Deno - The Practical Guide (MVC, SQL, NoSQL, REST API)

Explore using the web API and the Dyno Namespace API, combine standard library and third-party modules, and apply the program lifecycle for setup and cleanup while building simple programs.

explore the Deno web API with built-in runtime docs, and implement a simple TypeScript example demonstrating set time out and set interval that logs hello and stops after five.

Learn to use Deno's namespace API to read files both asynchronously and synchronously, view function documentation, and inspect file metadata without imports.

Learn how Deno lifecycle events manage setup and cleanup with load and unload listeners, and when to use asynchronous versus synchronous functions.

Explore the Deno standard library, its modules, and how it differs from the runtime and random APIs. Learn imports, instability, and building a simple web server with standard library modules.

Explore the Deno standard library and its modules, learn to avoid external dependencies and pin versions, and build a simple web server using the http module.

Create a simple web server with Deno's standard library, handling http requests, returning dynamic responses, and setting headers to render html content, with proper permission, versioning notes, and port 8000.

Explore third party modules in Deno by browsing a list, using search to find topics, and reviewing readmes and GitHub repos to assess popularity (more than 45,000 stars) and usage.

Explore the Oak framework in Deno, including middleware, routing with a router, and the application class that wraps standard library functions, plus use and listen methods to start the server.

Learn to build a web app with a single middleware function, create and run a minimal server, inspect request data, set headers, and route content using middleware.

Learn to use Denon to automatically restart a Deno server when code changes, avoiding manual reruns and speeding up development.

Set up a Deno router to handle requests for specific paths, register routes as middleware with http methods and path parameters, and start the server to listen on a port.

Store first and last names in cookies on the client side, then retrieve them on a follow-up page to display a personalized welcome.

Learn to build web apps with a template engine, populate views, and separate layouts into header and footer. Serve static content like css files and gracefully handle missing images.

Learn how a template engine creates dynamic email pages by replacing variables in static template files at runtime, transforming templates into html emails without changing code.

Import and configure the ejs template engine in a deno app, create a separate view file, and render templates with dynamic data for a welcoming, form submission flow.

Process form submission to capture the first name from the request body and render it on an info page, then display a string array with an ejs for loop.

Learn to handle not-found pages in a Deno app by adding an Oak middleware that detects missing routes and renders a custom 404 page.

Learn to process form input in a Deno app, validate data with a validation module, use built-in rules, display and customize error messages, and create custom validation rules.

Learn to handle form submissions in Deno mvc by enabling a route to accept post requests, parse the body, and apply the first validation rule requiring username and email.

Explore multiple validation rules in Deno, from required to is email and between 5 to 10 characters, and compare first errors versus flattened error messages for browser display.

Display validation errors in the browser with EJS by converting error objects with Object.values into an array and iterating to render bullet-point messages on the form.

Configure custom error messages for form validation in deno using the fashion library. Learn to replace default prompts with specific messages for username and email for required and invalid inputs.

Learn to create a custom validation rule in Rails, enforcing a numeric value between 18 and 60 with a custom error message, including file setup and imports.

Learn how modules work and how import maps manage dependencies. Centralize utilities in one place and structure the project for easy deployment.

Explore how deno's module system caches modules in a global directory, reusing them across projects, with a configurable environment variable and a reload option to re-download specific or all modules.

Learn to manage deno dependencies by importing and exporting external modules in a central file, then re-exporting them for use elsewhere in the project.

Explore managing deno dependencies using import maps, aliasing modules for concise imports and centralized updates, then run with the unstable import maps flag.

Debug your dinner program by using breakpoints, the Chrome DevTools debugger, and source maps to inspect first name, last name, and the full name as you submit the form.

Learn to work with secure databases using SQL and NoSQL concepts, explore the MVC pattern, set up PostgreSQL connection, and perform core CRUD operations: insert, read, update, and delete data.

Differentiate relational databases from non-relational ones by examining SQL's structured query language, predefined schemas, and data in related tables; contrast NoSQL's flexible collections and dynamic schemas with no joins.

Explore the mvc model, where model handles data and database operations, the view handles presentation and web pages, and the controller connects them to control the program flow.

Install and configure a PostgreSQL database on your local machine to support your teen application. Compare Windows, Mac, and Postgres.app installation options and understand local versus remote connection strings.

Create a books table in the local database, define four columns with a primary key and a numeric price, save the schema, and prepare a data-driven app.

Create and organize the views for listing all books and a single book, with forms for adding, updating, and deleting, using a dedicated views folder and two view files.

Create a static, async model class named group to manage books data with create, find all, find by id, update, and delete methods, then import it into the controller.

Connect to PostgreSQL in Deno using the Posterous driver. Handle form submission through a controller to insert a new book with title, author, and price.

Retrieve all books by selecting all from books in the model, return the results to the controller, then render the data in the view's table.

Update a book record by submitting a form with id (primary key), title, author, and price; invoke the update function and redirect to the updated book.

Delete a book record from the database using an mvc flow: submit the delete form, pass the book id to the controller and model, then delete and redirect.

Learn to set up Goodbee, use Mongu debate class to create our database, and modify an existing collection; insert, retrieve, find by IP, update, and delete documents.

Set up MongoDB Atlas cloud with a free cluster, create a read-write user, and enable IP access. Connect from your app to auto-create databases and collections as needed.

Prepare your codebase for a MongoDB-backed app by refactoring controllers, removing PostgreSQL specifics, and aligning models, routes, and forms for a seamless migration.

Connect to a MongoDB Atlas database from a Deno app using the official MongoDB driver and insert a single document with insertOne.

Retrieve all book documents from the books collection via the controller, store them in a books array, and render id, title, author, and price in the view.

Find a single book by id in a Deno mvc app by extracting the id parameter, querying the model, and rendering the book’s title and price in the view.

Update a book document in the database via a form; pass the book id, then controller and model apply new title and price and redirect to the single book page.

Implement a delete workflow by submitting a form with a hidden book id, triggering a controller to delete the document from the database and redirecting users to the main page.

build a rest api that serves json for a spa or mobile app, performing create, read, update, and delete operations with routers and no templates.

Understand how an api enables app communication, focusing on rest api, endpoints, and methods. See how json data moves between client and server to perform post, put, and patch operations.

Rename and refactor existing code to build an API in deno, removing server-side rendered views and templates, and preparing routers for API endpoints in the next video.

Create routers for a Deno rest api by wiring controller functions to post create, read all, read one, and update document operations, with an api prefix to distinguish the endpoints.

Insert data via a REST API by sending JSON to the controller, map title and price, insert a document into the books collection, and return a JSON success or error.

Retrieve all documents from a collection via the model and controller, then return the data as json to the client, with success and error handling.

Learn how to find a document by id in a REST API using a controller and model, handle found and not found cases, and return structured JSON data.

Update a document in a collection via REST API by retrieving id from URL, extracting title and price from JSON, sending to model, and returning success or not found.

Delete a document by id via the api, using the controller to fetch it and the model to delete it, and return success if deletion occurred, else not found.