└── README.md
/README.md:
--------------------------------------------------------------------------------
1 | # Programming_Resources
2 |
3 | An collection of all the amazing programming learning materials and resources online. Aim to create an one-stop station for fantastic onlien resources for coding and fun.
4 |
5 | ## Overview
6 | - [Programming Resources](#Programming_Resources)
7 | - [Markdown](#Markdown)
8 | - [Python](#Python)
9 | - [Web Development](#Web_Development)
10 | - [Helpful Readings](#Helpful_Readings)
11 | - [CSS Animation Guide](#CSS_Animation_Guide)
12 | - [Set up your web development environment](#Set_Up_Your_Web_Development_Environment)
13 | - [Set Up Your Supabase Backend](#Set_Up_Your_Supabase_Backend)
14 | - [Deploying Your Website](#Deploying_Your_Website)
15 |
16 | ## Markdown
17 | This Document is written in Markdown and it's a super important language and tool to use in programming, so I want to start with Markdown.
18 |
19 | Markdown is a plain text formatting syntax aimed at making writing for the internet easier. The philosophy behind Markdown is that plain text documents should be readable without tags mussing everything up, but there should still be ways to add text modifiers like lists, bold, italics, etc. It is an alternative to WYSIWYG (what you see is what you get) editors, which use rich text that later gets converted to proper HTML.
20 |
21 | Here are some resources for more info on Markdown, including what is it, why important and how to use it:
22 |
23 | * [:earth_americas: What is Markdown, and why should you use it?](https://www.ultraedit.com/company/blog/community/what-is-markdown-why-use-it.html)
24 | * [:earth_americas: Basic Syntax](https://www.markdownguide.org/basic-syntax/)
25 | * [:octocat: Markdown Cheatsheet](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#lines) - :star2: 54.1K - :fork_and_knife: 10.4K
26 |
27 | ## Python
28 | As the saying goes, the master teaches the trade, but apprenticers skill is self-made.With Python's popularity, more and more people want to learn Python, and want to learn it systematically. Here we will share the experience of several free learning materials on :octocat:Github for students to learn.
29 |
30 | * [:octocat: Learn-python3](https://github.com/jerry-git/learn-python3) - :star2: 4.5K - :fork_and_knife: 1.3K
31 |
32 | Resources for learning and teaching beginner to intermediate-level Python 3.
33 |
34 | - The contents of this repo are very well structured and in Jupyter Notebooks.
35 | - The beginner folder inside the notebooks folder contains 19 introductory topics such as strings, conditionals, classes, exceptions, and so, to get you started. We recommend taking a look at the repo for the full list.
36 | - The rest of the advanced topics are provided in the intermediate folder, such as writing idiomatic Python, a few other general topics, and some best practices to help you avoid writing disastrous and inefficient code.
37 |
38 |
39 | * [:octocat: Learn-python](https://github.com/trekhleb/learn-python) - :star2: 11.7K - :fork_and_knife: 1.9K
40 |
41 | Similar to learn-python3, learn-python repository also serves as a handy collection of Python resources for beginners and intermediate learners.
42 |
43 | - The repository uses a collection of Python scripts to cover individual topics in Python, such as operators, data types, classes, modules, and much more, with precise explanations and accompanying examples.
44 | - There’s also a small section explaining how to use this repository to help you make the most out of this repo.
45 | - Oleksii calls the repo a playground and a cheat sheet as during the learning phase, learners will often return to the repo to experiment with the code examples for a closer hands-on feel. Once you feel comfortable writing your own Python code, you can use the mentioned linting tools, like pylint, to clean the code while the necessary testing is handled by pytest.
46 |
47 |
48 | * [:octocat: Awesome-python](https://github.com/vinta/awesome-python) - :star2: 113K - :fork_and_knife: 20.5K
49 |
50 | A thoughtful yet enormous collection of Python frameworks, libraries, tools, and other handy resources.
51 |
52 | - The repo has listed over 90 different categories for individual projects or topics including admin panels, data validations, computer vision, algorithms and design patterns, ChatOps tools, and so much more.
53 | - Provides links to useful books, newsletters, podcasts, and web series dedicated to making Python easier for everyone.
54 |
55 |
56 | * [:octocat: Project-Based Learning](https://github.com/tuvtran/project-based-learning#python) - :star2: 61.3K - :fork_and_knife: 9.3K
57 |
58 | Packed with tutorials for various programming languages with a specific focus on being project-oriented.
59 |
60 | - A huge list of over 20 programming languages, we’ll be focussing only on Python for this write-up but feel free to check the projects from other programming languages.
61 | - Includes tons of tutorials for building a host of projects from web scrapers, bots, and web applications to building Data Science, Machine Learning, and Deep Learning solutions.
62 |
63 |
64 | * [:octocat: Python-programming-exercises](https://github.com/zhiwehu/Python-programming-exercises) - :star2: 18.3K - :fork_and_knife: 6.1K
65 |
66 | Has more than 100 Python programming challenges that cater to new developers, intermediate developers, as well as veteran professionals.
67 |
68 | - Jeffrey also has a website that teaches you foundational Python in the form of comics, which you can also use, but unless you know Chinese, you would be hard-pressed to understand it.
69 | - It comes with the required hints and the solution, but try not to scroll too far down, or else you’ll stumble upon the answer.
70 |
71 |
72 | * [:octocat: full-speed-python](https://github.com/joaoventura/full-speed-python) - :star2: 3.5K - :fork_and_knife: 541
73 |
74 | Essentially a book that covers the fundamentals of Python along with more advanced topics with a significant emphasis on practical learning.
75 |
76 | - After explaining each topic, João tries to solidify the understanding of the concepts by presenting his readers with sufficient exercises. These exercises play a crucial role in bringing Python learners up to speed with Python’s syntax in a short period.
77 | - Once you start following this approach, you’ll be able to cover the entirety of this Python book within a month or two, tops. The repo contains the files you will need to build the book for yourself, or you can simply download the book from his repo, the download links are available there.
78 |
79 |
80 | * [:octocat: Coding-problems](https://github.com/MTrajK/coding-problems) - :star2: 2.3K - :fork_and_knife: 469
81 |
82 | Contains an updated collection of solutions to numerous coding and algorithmic problems that new programmers face while learning data structures and algorithms.
83 |
84 | - Meto has covered the solutions for problems from various topics and has categorized them into arrays, linked lists, dynamic programming, math, and a few more categories.
85 | - The author has structured the problems perfectly to make it easier for individuals to analyze the problem and its solution. But of course, that’s not the only thing you’ll find in his repo. You’ll also find some valuable resources like online courses(MOOCs), books, training websites, YouTube channels, and a bunch of other resources that cover Python and solutions to a host of problems developers encounter while working with Python.
86 |
87 |
88 | * [:octocat: The Algorithms](https://github.com/TheAlgorithms/Python) - :star2: 128K - :fork_and_knife: 33.9K
89 |
90 | The Algorithms/Python repo is one of the most starred and forked Python GitHub repo on and there’s a good reason behind its popularity.
91 |
92 | - Their repo contains algorithms and their implementation for over 35 categories of topics in Python, such as data structures, computer vision, linear algebra, neural networks, sorts, strings, to name a few. Do keep in mind that understanding these algorithms requires at least a beginner-level knowledge of Python, making this repo more suited to intermediate and advanced developers.
93 | - Not only Python, but their repo is also home to a similarly vast collection of algorithms for Java, C, C++, JavaScript, Ruby, and a few other programming languages. Regardless of your experience with Python, we recommend starring this repo to have all those algorithms readily available for when you need them. Being open-sourced also gives you the freedom to contribute to the repo in expanding its collection if you wish to.
94 |
95 |
96 | * [:octocat: python_reference](https://github.com/rasbt/python_reference) - :star2: 3.1K - :fork_and_knife: 847
97 |
98 | A collection of various Python topics for intermediate developers.
99 |
100 | - If you have already mastered the basics of Python, then this repo might be suitable for you to help you understand a host of advanced topics. The repo provides Jupyter Notebooks for various topics, such as useful regular expressions, Cython with and without IPython, and many more like it, while giving you the flexibility to edit and run the code as you wish.
101 |
102 |
103 | * [:octocat: Practical Python](https://github.com/dabeaz-course/practical-python) - :star2: 7.7K - :fork_and_knife: 4.2K
104 |
105 | The material you see here is the heart of an instructor-led Python training course used for corporate training and professional development. It has been in continual development since 2007 and battle tested in real-world classrooms.This includes the completion of approximately 130 hands-on coding exercises.
106 |
107 | - The goal of this course is to cover foundational aspects of Python programming with an emphasis on script writing, data manipulation, and program organization. By the end of this course, students should be able to start writing useful Python programs on their own or be able to understand and modify Python code written by their coworkers.
108 |
109 |
110 | * [:octocat: Useful Python Snippets](https://github.com/crazyguitar/pysheeet) - :star2: 7K - :fork_and_knife: 1K
111 |
112 | Pysheeet was created with intention of collecting python code snippets for reducing coding hours and making life easier and faster.
113 |
114 |
115 | ## Web_Development
116 | ### Helpful_Readings
117 | * [:book:[HTML] Web accessibility with HTML](https://developer.mozilla.org/en-US/docs/Learn/Accessibility/HTML)
118 | * [:book:[HTML] Including metadata in the head tag](https://developer.mozilla.org/en-US/docs/Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML)
119 | * [:book:[HTML] Semantic tag for structuring a page by function](https://developer.mozilla.org/en-US/docs/Learn/HTML/Introduction_to_HTML/Document_and_website_structure)
120 | * [:book:[HTML] Embedding images into HTML](https://developer.mozilla.org/en-US/docs/Learn/HTML/Multimedia_and_embedding/Images_in_HTML)
121 | * [:book:[HTML] Using SVGs](https://developer.mozilla.org/en-US/docs/Learn/HTML/Multimedia_and_embedding/Adding_vector_graphics_to_the_Web)
122 | * [:book:[HTML] Overview of Developer Tools](https://developer.chrome.com/docs/devtools/dom/)
123 | * [:book:[CSS] Overview of CSS Concepts](https://www.taniarascia.com/overview-of-css-concepts/)
124 | * [:book:[CSS] The Box Model](https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/The_box_model)
125 | * [:book:[CSS] Guide to Flexbox](https://css-tricks.com/snippets/css/a-guide-to-flexbox/)
126 | * [:book:[CSS] Creating a Complex Layout with CSS Grid](https://www.joshwcomeau.com/css/full-bleed/)
127 | * [:book:[CSS] CSS Common Layout Cookbook](https://developer.mozilla.org/en-US/docs/Web/CSS/Layout_cookbook)
128 | * [:book:[REACT] Hello World](https://reactjs.org/docs/hello-world.html)
129 | * [:book:[REACT] Intro to JSX](https://reactjs.org/docs/introducing-jsx.html)
130 | * [:book:[REACT] Rendering Elements](https://reactjs.org/docs/rendering-elements.html)
131 | * [:book:[REACT] Components and Props](https://reactjs.org/docs/components-and-props.html)
132 | * [:book:[REACT] State and Lifecycle](https://reactjs.org/docs/state-and-lifecycle.html)
133 | * [:book:[REACT] Introducing Hooks](https://reactjs.org/docs/hooks-intro.html)
134 | * [:book:[REACT] useState Hook](https://reactjs.org/docs/hooks-state.html)
135 | * [:book:[REACT] Handling Events](https://reactjs.org/docs/handling-events.html)
136 | * [:book:[REACT] Conditional Rendering](https://reactjs.org/docs/conditional-rendering.html)
137 | * [:book:[REACT] Lists and Keys](https://reactjs.org/docs/lists-and-keys.html)
138 | * [:book:[REACT] useEffect Hook](https://reactjs.org/docs/hooks-effect.html)
139 | * [:book:[BACKEND] Row Level Security](https://supabase.io/docs/learn/auth-deep-dive/auth-row-level-security)
140 | * [:book:[BACKEND] Supabase + Next.js Demo Tutorial](https://supabase.io/docs/guides/with-nextjs)
141 | * [:book:[BACKEND] Data Fetching in NextJS](https://nextjs.org/docs/basic-features/data-fetching)
142 | * [:book:[BACKEND] Async/Await Syntax](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Asynchronous/Async_await)
143 |
144 | ### CSS_Animation_Guide
145 | CSS animations are a relatively simple way to add polish and delight to your web apps. Animation is becoming increasingly common as a way to signify that elements are interactive, and they can also be used to create games or interactive experiences. Through this guide we'll learn some of the tools we can use to add animations to our site. While following along with the material, I encourage you to tinker with real code in the animation sandbox.
146 |
147 | **→ Sandbox Code:** [https://codesandbox.io/s/suspicious-matan-342yy?file=/index.html]
148 |
149 | #### Hover States
150 | It's common to add an animation when a user hovers over an interactive element like a button or link. You can do this by using the `:hover` pseudo selector.
151 |
152 | ```html
153 | .box {
154 | color: blue;
155 | }
156 |
157 | .box:hover {
158 | /* Change the box color when mouse hovers over element */
159 | color: red;
160 | }
161 | ```
162 |
163 | ##### Hover Flicker
164 | If you're animating any `transform` properties (as we'll do below) you can sometimes see what's called a hover "death flicker" because the element transforms out from under the mouse area, stopping the hover animation. You can fix this by wrapping the element you want to transform in a containing element and using that containing element to detect hover, while still applying the styles to the child element.
165 |
166 | ```html
167 | .wrapper:hover .box {
168 | /*
169 | Transform box only when wrapper is hovered,
170 | so hover area won't rotate out from under the mouse
171 | */
172 | transform: rotate(20deg);
173 | }
174 |
175 | /* HTML for this approach */
176 |
179 | ```
180 |
181 | #### CSS Transforms
182 | Allow you to reposition elements without triggering a re-render. Values are relative to the elements original expected position and do not affect the layout or other elements. Most commonly used values are `translate(xValue, yValue)` `scale()` and `rotate()`
183 |
184 | ```html
185 | .box {
186 | transform: translate(10px) rotate(20deg) scale(1.5);
187 | }
188 | ```
189 |
190 | #### Transition
191 | Changing something on hover is great, but it's not really animated if it's instantaneous. We want our property to gradually change into the desired new value, like things do in nature, not just teleport there. CSS handles this automatically with the `transition` property.
192 |
193 | ***A note about performance**: Transition works best with properties like `transform` and `opacity` and these values should be used whenever possible. Other properties that affect layout like width, padding, etc will cause multiple re-renders of the element and could result in a laggy performance.
194 |
195 | It requires two values: the property (or properties) to transition, and the duration of the transition.
196 |
197 | The transition property added on the hover state controls the beginning transition, or the transition from the default value to the hover value. The transition property on the normal element controls the exit transition, or the transition from the hover state back to the default.
198 |
199 | Many times you'll want these two transitions to be different when implementing action driven animation. [This is a great blog post to learn more about motion design](https://tobiasahlin.com/blog/meaningful-motion-w-action-driven-animation/).
200 |
201 | ```html
202 | .box {
203 | /* hover -> default */
204 | transition: transform 400ms;
205 | }
206 |
207 | .wrapper:hover .box {
208 | /* default -> hover */
209 | transition: transform 200ms;
210 | transform: rotate(20deg);
211 | }
212 | ```
213 |
214 | ##### Transition Timing Functions
215 | The default transition timing function is `ease` . This controls the rate at which the change from one value to the next occurs. You can specify a different timing function in the short-hand for transition.
216 |
217 | ```html
218 | .wrapper:hover .box {
219 | transition: transform 200ms ease-in;
220 | transform: rotate(20deg);
221 | }
222 | ```
223 |
224 | Play around with the other timing functions `linear` `ease-in` `ease-out` and `ease-in-out`
225 | You can also define your own timing function with `cubic-bezier()` which is often used to create spring-like animations. This is outside of the scope of this class but you can learn more in [this blog post about CSS Bezier Functions](https://css-tricks.com/advanced-css-animation-using-cubic-bezier/).
226 |
227 | #### Custom Keyframe Animations
228 | Sometimes you want a multi-step animation or for something to happen on the page load or with a dynamically added class name in React. For that you can define your own animations with CSS `@keyframes`.
229 |
230 | This allows you to define a series of steps, give them a name, and then apply that animation wherever you want in your CSS. The following code creates a custom animation called `fade-in` that starts with an elements opacity at 0 and ends with an element's opacity at 1.
231 |
232 | ```html
233 | @keyframes fade-in {
234 | 0% {
235 | opacity: 0;
236 | }
237 | 100% {
238 | opacity: 1;
239 | }
240 | }
241 | ```
242 |
243 | Try adding as many steps at different % times and as many other animated properties as you want.
244 |
245 | You can apply this animation to an element with the `animation` property. Again, it requires the name of our keyframe animation and a duration.
246 |
247 | ```html
248 | .box {
249 | animation: fade-in 100ms;
250 | }
251 | ```
252 |
253 | #### Animation Delay
254 | You can specify the amount of time you want an animation to wait before running.
255 |
256 | ```html
257 | .box {
258 | animation: fade-in 100ms;
259 | /* Wait 2 seconds before triggering the animation */
260 | animation-delay: 2s;
261 | }
262 | ```
263 |
264 | (You can do the same thing on transitions with `transition-delay` )
265 |
266 | #### Animation Fill Modes
267 | When there's a delay on an animation, most of the time you want the animation to be in it's starting state until the animation, then remain in its ending state. For some weird asf reason, this is not the default behavior. You can change this by using `animation-fill-mode` which [has a lot of different values](https://developer.mozilla.org/en-US/docs/Web/CSS/animation-fill-mode), but `both` is the most commonly used one that preserves the starting and ending visual state.
268 |
269 | ```html
270 | /* Slap this on whenever you use an animation */
271 | animation-fill-mode: both;
272 | ```
273 |
274 | ### Set_Up_Your_Web_Development_Environment
275 | #### Software Pre-Requisites
276 | 1. Download and install [Visual Studio Code](https://code.visualstudio.com/) (text editor like Atom, with terminal built in)
277 | 2. Create a [GitHub Account](https://github.com/)
278 | 3. Create a [Netlify Account](https://www.netlify.com/) (this is a free, automated CI/CD deploy and hosting platform - it’s phenomenal)
279 | 4. Create a [CodeSandbox Account](https://codesandbox.io/) (It is a browser based Javascript/HTML/CSS development environment)
280 | 5. Download and Install [Node.js](https://nodejs.org/en/download/) (a javascript framework for backend code, comes with package manager `npm` CLI utility)
281 |
282 | If creating a **static site**, just create a new directory and an HTML and CSS file.
283 |
284 | ```bash
285 | mkdir PROJECT_NAME
286 | touch index.html
287 | touch styles.css
288 | ```
289 |
290 | I'd recommend using Josh Comeau's [HTML Starter Template](https://www.joshwcomeau.com/snippets/html/html-skeleton/) and [CSS Reset](https://www.joshwcomeau.com/css/custom-css-reset/#introduction). Just copy and paste from the links into your newly made `index.html` and `styles.css` respectively.
291 |
292 | If creating an application, set up your project with NextJS boilerplate.
293 |
294 | ```bash
295 | // with styled-components
296 | npx create-next-app --example with-styled-components NAME_OF_PROJECT
297 |
298 | // with tailwindcss
299 | npx create-next-app -e with-tailwindcss NAME_OF_PROJECT
300 |
301 | // just plain ol' nextjs
302 | npx create-next-app NAME_OF_PROJECT
303 | ```
304 |
305 | Follow documentation on getting set up with [a plain NextJS app](https://nextjs.org/docs/getting-started) and with an [app with TailwindCSS](https://tailwindcss.com/docs/guides/nextjs).
306 |
307 | Then change into your project directory and start your server
308 |
309 | ```bash
310 | cd ./NAME_OF_PROJECT
311 | npm run dev
312 | ```
313 |
314 | ### Set_Up_Your_Supabase_Backend
315 | To add a backend to our application, we will be using [Supabase](https://supabase.com/). This is an open source alternative to Google's firebase that provides a lot of backend features out of the box for free. In this application, we will be using their database and authentication.
316 |
317 | Take a deep breath, this might seem overwhelming at first. It will all be ok! 🙏
318 |
319 | #### Environment Variables
320 | You'll need to store two environment variables for reference in your project, your supabase url and your anon key. Both of these are designed to be public, so it's ok that they'll appear in your client. Adding row level security to our table (more on this below) will prevent people from accessing restricted data.
321 |
322 | 1. Find the url & keys inside your Supabase Settings > API
323 | 2. Create a `.env.local` file in the root of your project directory and add these two variables.
324 | ```javascript
325 | NEXT_PUBLIC_SUPABASE_URL=https://SOME_URL.supabase.co
326 | NEXT_PUBLIC_SUPABASE_ANON_KEY=SOME_STRING_OF_CHARS
327 | ```
328 | 3. Go to your Netlify project > Deployment > Deploy Settings and add the above variables as deployment environment variables as well. Make sure the names match.
329 |
330 | Now both your local and production environments should be able to access these variables and use them to make requests to Supabase.
331 |
332 | #### Supabase Client Object
333 | Our front-end needs to authenticate to Supabase to make any API calls. To do this, we will create a utility supabase client object that we can then import into any components that need to make API calls.
334 | We'll create a new directory called `utils` and put a new` supabaseClient.js` file in it to store our client object.
335 |
336 | ```javascript
337 | // utils/supabaseClient.js
338 | import { createClient } from '@supabase/supabase-js'
339 |
340 | const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL
341 | const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY
342 |
343 | export const supabase = createClient(supabaseUrl, supabaseAnonKey)
344 | ```
345 |
346 | This takes the environment variables we set up earlier and injects them into our client code so that we can use the object `subabase` to make API requests to our backend. You can now import it into any component that needs it.
347 |
348 | ```javascript
349 | import { supabase } from '../utils/supabaseClient'
350 |
351 | // fetch data function example
352 | const fetchDataFromSupabase = async () => {
353 | let { data, error } = await supabase
354 | .from('TABLE_NAME')
355 | .select('COLUMN, ANOTHER_COLUMN')
356 | if (error) setError(error.message)
357 | else {
358 | setData(data)
359 | setLoading(false)
360 | }
361 | }
362 | ```
363 |
364 | The above data fetching code could be run on the client, or in `getStaticProps` or `getServerSideProps` depending on the use case. Since we will have row level security (more on this below) and want to limit the data that people can see, we need to run it on the client so it only runs after a user is authenticated (again, more on this below).
365 |
366 | #### Authentication
367 | If you want to, you can build out your own UI and Authentication logic for your app. If you want to save a lot of time, you can use Supabase's pre-built solution and sacrifice some customization.
368 |
369 | [](https://ui.supabase.io/components/auth)
370 |
371 | To use this, you'll need to install the SupabaseUI library
372 |
373 | ```javascript
374 | npm install @supabase/ui
375 | ```
376 |
377 | and then import it into your `_app.js` and `index.js`files.
378 |
379 | ```javascript
380 | import { Auth } from '@supabase/ui'
381 | ```
382 |
383 | The Auth package not only gives you a pre-built UI and functions for logging in and out, but also a User Context Component that allows you to access the current user from anywhere in your application. We will learn more about Context later in this course, for now just wrap your code in `_app.js` like this.
384 |
385 | ```javascript
386 | // _app.js
387 | import 'tailwindcss/tailwind.css'
388 | import { supabase } from '../utils/supabaseClient'
389 | import { Auth } from '@supabase/ui'
390 |
391 | function MyApp({ Component, pageProps }) {
392 | return (
393 | {/* I'm the new part! I send a user object to all components */}
394 |
395 |
396 |
397 | )
398 | }
399 |
400 | export default MyApp
401 | ```
402 |
403 | Then, you can access the current user from another component like this:
404 |
405 | ```javascript
406 | // gets the user object from Context
407 | const { user } = Auth.useUser()
408 | ```
409 |
410 | #### Database Setup
411 | 1. Go to the SQL Editor in your Supabase project and run the following query to create your database.
412 |
413 | ```sql
414 | create table public.gratitudes (
415 | id uuid references auth.users not null,
416 | entry text,
417 | date_insert_ts timestamp default now(),
418 |
419 | primary key (id, date_insert_ts) -- each row unique to user and time inserted
420 | );
421 | ```
422 |
423 | 2. Then for this application, we want to only allow users to query data that corresponds to their user id. There are a lot of different ways to implement this, but PostgresQL gives us a pretty simple way: row-level security roles. This allows us to write some SQL roles that will automatically filter out data that does not include the user's ID.
424 |
425 | ```sql
426 | alter table public.gratitudes enable row level security;
427 |
428 | create policy "Gratitudes are viewable by users who created them."
429 | on gratitudes for select
430 | using ( auth.uid() = id );
431 |
432 | create policy "Users can insert their own gratitudes."
433 | on gratitudes for insert
434 | with check ( auth.uid() = id );
435 | ```
436 |
437 | The actual functionality behind SQL policies is outside of the scope of this course, but you can read more in the [Supabase documentation on row level security](https://supabase.com/docs/learn/auth-deep-dive/auth-row-level-security).
438 |
439 | ### Deploying_Your_Website
440 | We'll be deploying our sites on Netlify, a wonderful tool that offers free hosting, continuous integration and continuous deployment, and a whole host of other perks.
441 |
442 | Since your apps are built with NextJS, Netlify will **automatically** detect this when you add a new project and should set up most of the integrations for you via the [next-on-netlify essential build plug-in.](https://github.com/netlify/netlify-plugin-nextjs/tree/v3#readme) You shouldn't need to do anything to get this set up with a new site.
443 |
444 | You can read more about the detailed features of NextJS on Netlify in the [official documentation](https://docs.netlify.com/configure-builds/common-configurations/next-js/?_ga=2.40143586.1188718911.1639016182-259392666.1629061964).
445 |
446 | However, you will need to set up ENV variables for all of your API keys if you're using Supabase or a third party API. Follow the instructions below.
447 |
448 | 1. Upload your entire root directory to GitHub. This includes everything created automatically when you ran `create-next-app` to start developing. It should've created a `.gitignore` file for you, so you don't need to change anything there. The `node_modules` and `.next` directories should be ignored and not uploaded.
449 | 2. Log in to your Netlify account and click the "New Site from Git" button.
450 | 
451 | Find your repository and step through the connection process. This will attempt to create an initial deploy from your repository. **Use the default settings** created by Netlify after you select your repository, you should only change something if you've deliberately done something different.
452 | 3. Your first build will probably fail, because you haven't added your ENV variables to a production environment. Click on your added site and navigate to `Site settings` > `Build & deploy` > `Enivronment`
453 | Add any environment variables you use in your project, and make sure the names are consistent with what you reference in your code.
454 | *(if you're not using any variables, you can skip this step)*
455 | 
456 | 4. If using Supabase Auth, go to your Supabase Console and navigate to` Settings` > `Auth settings` > `General` > `Site URL` and add whatever your URL through Netlify is. This will allow links emailed out to users to redirect to the appropriate domain name for your site.
457 | 5. Navigate to `Deploys` and click `Trigger deploy` > `Deploy site` to force a re-deploy, and you should be good to go! 🤞
458 | 
459 | 6. Verify that your site is working correctly by clicking on the netlify link in your site details. If something goes wrong, it has probably happened to other people, so don't fret. Check the deploy log, search for your errors, and see how other people solved it. I'll add to the troubleshooting section below as other students run into errors, so check that first!
460 | 7. If you want to get ✨ fancy ✨, Netlify provides a bunch of additional useful features out of the box like [automatic form submission collection](https://www.netlify.com/blog/2017/07/20/how-to-integrate-netlifys-form-handling-in-a-react-app/), [asset optimization](https://docs.netlify.com/site-deploys/post-processing/), [build plug-ins](https://www.netlify.com/products/build/plugins/), and even things like [split testing](https://docs.netlify.com/site-deploys/split-testing/)!
461 |
462 | #### Troubleshooting
463 |
464 | My site deploys, but I get a 404 error when trying to route to the home page.
465 |
466 | - This typically happens because you don't have an `index.js` file in the `pages` directory of your app. (or if it is just a static site, no `index.html` page)
467 | - If you do have an index.js , make sure something is rendered in all cases.
468 | - If you're using the next/link package, make sure you have a lowercase "link" in your import statement.
469 |
470 |
471 |
472 |
473 | My site deploys, but my login doesn't work or gives a 404 error.
474 |
475 | - You probably did not complete step #4. Make sure your deployed netlify domain is listed as the site URL and everything is spelled correctly.
476 |
477 |
478 |
479 |
480 | "Waiting for other deploys from your team to complete" in the deploy log
481 |
482 | - This just means you have another deploy that's currently running. Once that deploy finishes, it will attempt to run your most recent deploy. You can check the status of deploys by navigating to Deploys and looking at the list of deploys + their status code.
483 |
484 |
485 |
486 |
487 | My build has been running for basically 10,000 hours
488 |
489 | - Make sure you are using the default settings created by Netlify, as mentioned in step 2. Your build command should be next build (not npm run dev , that is the command to start the local development server, not the build command, so it will run continuously)
490 |
491 |
--------------------------------------------------------------------------------