Mastering Bun - The Modern Fullstack Development

Learn TypeScript basics by creating a sum function, defining types, and exporting and importing modules in Bun and Node, demonstrating module-based code in index.ts.

Learn to create a module by exporting a function and importing it across a project, using a sum example to show reusability in bun and node environments.

Export multiple functions from a module and import them in single line. Add prod function (a and b numbers, returns a plus b) and import sum and prod into index.ts.

Explore different ways to write import paths in Bun, including extensions and case variations. Learn about default and named import and export and how file name matching ensures execution.

Master default and named exports with practical examples of import syntax, showing that a module can have one default export and multiple named exports.

Compare commonjs and es modules in Bun and NodeJS, contrasting require-based cjs imports with es6 import/export, and learn when to use each in modern fullstack development.

Explore variables and data types in TypeScript and JavaScript, including var, let, and const, with type annotations and compiler checks that enforce typing concepts.

Explore the primitive number data type, including decimal, floating point, binary, hexadecimal, and octal values in JavaScript and TypeScript, with examples of let declarations and console logs.

Declare boolean variables in TypeScript and JavaScript using true and false in lowercase, log their values, inspect types with the type of operator, and apply negation with the exclamation mark.

Compare null, undefined, and void in JavaScript and TypeScript. Understand how undefined signifies an uninitialized variable, how null becomes an object, and how void marks no return value.

Explore the any data type in TypeScript, and learn how variables can hold any value, how default typing works, and how to explicitly declare let a: any.

Explore type annotation and type inference in TypeScript, showing how colon syntax fixes types, how inference assigns types from values, and how mismatched assignments trigger errors.

Explore string basics in TypeScript and JavaScript, including quoting options, escaping quotes, backticks for strings, and common escape sequences like newline, tab, and carriage return.

Explore handling Unicode values in string data, using slash u escapes to display characters like the copyright sign (00A9) and Unicode with curly brackets, including emoticons in the 1F600–1F64F range.

Master template literals in ES6 using backticks to embed expressions with ${}, enabling seamless interpolation. Preserve spaces and newlines without escapes for cleaner strings.

Introduce type aliases in TypeScript to define a custom address type with street, city, and pin, then use it in a function parameter and demonstrate union types.

Explore the never type in TypeScript, illustrating how functions that throw errors never return, distinguish never from void, and how undefined and null relate to each type.

Explore buffers in Bun for handling binary data with the global buffer object and array buffers, and learn encodings for file read and write.

Explore binary data basics and how zeros and ones encode transistor states, with eight bits forming a byte, while grasping decimal and hexadecimal bases and 0x prefixes.

Explore buffers as fixed-size memory containers that receive binary data and pass it on, using Bun’s NodeJS global buffer to create, write, and convert to utf eight strings.

Explore character sets like Unicode and ASCII, learn how binary translates to characters through UTF-8 encoding, and understand why specifying the character set matters.

Create array buffers by instantiating the array buffer class with a byte length. Then view the array buffer as Uint8Array, Uint16Array, or Uint32Array to see how element counts vary.

explore bun's built-in file handling with bun.file and bun.write for reading and writing, using native optimized APIs for minimal syntax, with directory operations not included in bun file.

Instantiate a lazily loaded bun.file object to access file properties like size and mime type, then read content via the text method using await to resolve the promise.

Learn to read json directly with the json method, converting file.json into an object and accessing properties like name and module.

Read file data in Bun using array buffer, buffer, and streams. Await the array buffer, convert it to a buffer with buffer.from, and read stream chunks with for await.

Learn how Bun's fs module watch reports changes and file names via a callback. See events on files or folders created, renamed, or deleted.

Discover how bun.right writes data to a file by specifying a path and content, including overwriting with a single call and appending using node fs appendFileSync.

Watch a file and constantly maintain a copy file with the exact content by reading the original on change and writing to copy.txt.

Learn to delete a file programmatically with node's fs.unlink and its sync variant, including asynchronous deletion via a callback and test.txt deletions with console messages.

Build a web server with Bun, handling requests and responses and understanding http/https, domains, and data formats like html and json used by web and mobile apps.

Create a bun.serve server with port 3000 and a fetch handler that receives the request and server, returning a 'hello, world' response.

Decode the request object by displaying it in the console to reveal the method, URL, and headers, including host details, user agent, and cookies.

Understand the server object by examining host name, port, and pending requests, then stop the server with a set timeout of three seconds to observe it go offline.

Explore how to configure server routes using Bun's req.url, handling root, product, and data paths with switch cases, and delivering content or json data for each url.

Parse urls with new URL(), read the pathname to define routes by path (for example /products), and use the URL object's origin, protocol, host, and port to simplify routing.

Learn how to send json responses from a Bun route by stringifying a product object, setting the response headers to application/json, and inspecting the network output.

Explore how browser requests default to get and carry data in the url query string, with Bun server and a rendered html form. See why post submits data instead.

Configure post method in a form to submit data to the /data route, handle the post request via a conditional route, and return a message with product name and price.

Decode posted multipart/form-data in bun by awaiting request.text, then parse the body with URLSearchParams to access fields like name and price.

Explore how to install express with bun, using bun add express at types/express, and prepare to build a server with express in subsequent lessons.

Create a server with Express by importing Express, initializing app, and setting port 3000, then start listening with app.listen and log server. Define a root route and request and response.

Explore how Express.js handles get requests using app.get, including the request and response objects in TypeScript, and inspect headers, host, cookies, protocol, hostname, and ip to understand request details.

Learn to respond to requests using the response object, send data with res.send, and write html using an h1 tag, then end the response in a bun server.

Discover how response headers and content-type determine how the client renders data, with practical examples sending html versus json by setting the appropriate header.

Define routes with bun using app.get and a URL, simplifying get requests and creating a /products route, unlike conditional routing in classic server code.

Discover how wildcard characters empower routing in Bun. Use ? for optional characters, + for one or more repeats, and * for flexible in-between text, with practical route examples.

Discover how URL parameters work in Express.js by defining a route like /user/:userId/:username, accessing values with request.params, and displaying them as an object literal.

Master handling post requests with Express by configuring app.post('/data'), sending HTML content by reading an HTML file, and understanding how form method and default get behavior affect routing.

Learn how to access post data by using Express URL-encoded middleware, attaching it with app.use, and displaying request.body in a post route at /data.

Learn how to implement modular routing in express using express.Router to create a separate users routing module, mount it with app.use('/users', userRoutes), and improve readability and separation of concerns.

Learn how Postman acts as a fake client to send get, post, put, patch, and delete requests to an API, and install the app online or on your device.

Use postman to make get or post requests to the server's root route and view the responses. Configure parameters and headers to customize requests, enabling rest api development and mocking.

Learn put, patch, and delete requests: put overwrites data, patch updates specific fields, and delete removes resources. Implement these with app.patch, app.put, and app.delete routes and test with Postman.

Learn to serve html and image files with the response send file method by resolving absolute paths via import.meta, bun add path, and path.join for dynamic, cross-platform file serving.

Learn to serve static files with express by using express.static, configuring a public folder for html, css, and images, and compare sendFile with static for folder-wide delivery.

Explore Alicia with bun, a lightweight server-side framework that boosts performance, enables server side rendering, and generates boilerplate code while providing an inbuilt API testing module.

Create an Alicia server project with bun create Alicia, explore the boilerplate, and run via bun dev. Compare Alicia's get and listen patterns to express, using app.get and app.listen.

Master the context object, as the get method passes a request context to a callback, exposing the request method, URL, headers, cookies, and query for security and authentication tasks.

Learn to send a client response in bun using elysia by returning the value from the callback, implementing the Burnshaw method, with no response class needed.

Configure routes in Alicia using get, post, put, patch, and delete methods with cleaner syntax for route configuration, including a /products get route and various method responses.

The .all() route handler acts as a catch-all for all request types at a url, providing a response while preserving the priority of specific get, post, put, and delete routes.

Learn to use url parameters to receive user id and username as structured values in a bun route, accessing them through context.params and displaying them.

Learn to group routes with a common prefix using the group function, simplifying route declarations and improving code clarity, while configuring get, post, and put handlers via the app callback.

Apply a common url prefix to all routes by using the prefix option in the Alicia class constructor, making slash user the default for every route.

Explore plugins as logical components that improve architecture through separation of concerns, enabling reusable, component-based code. Implement a products plugin to manage group routes and keep the main app clean.

Create a functional callback plugin for Bun by passing a callback that receives the app instance via use, returning app.Group, and note that new instances may offer better type inference.

Master the bun workflow to send HTML and JSX using the Alicia js HTML plugin, install and configure it, and render HTML without manual headers.

Learn to send JSX as a response with the Alicia JSX HTML plugin, render HTML inside JavaScript for dynamic output, and configure tsconfig and .tsx to map a products array.

Learn how to serve static files in bun by using the Alicia js static plugin to deliver html css and images from a public assets folder.

Explore the basics of SQLite, a lightweight, serverless database used in mobile apps, and see how Bun enhances performance, with benchmarked queries per second.

Create a SQLite database in bun by importing the database class from bun sqlite, instantiating it with a name, and using options like create: false or readOnly.

Use the db.run method to execute sqlite queries, such as creating a products table. Define id integer primary key autoincrement, name text, and price number; insert into products Apple 50.

Learn to fetch data from a SQLite database by switching from db.run to the query method, then retrieve results with get, all, or values.

Learn to pass user defined values in SQLite queries with bind parameters, using question marks or colon named placeholders, and apply these to create, read, update, and delete operations.

Learn to build a Bun-based Alicia app with SQLite-backed CRUD operations, wiring HTML pages for add, edit, and delete product flows from boilerplate to a functional app.

Configure the home route in bun, serve html from public with bun file, and enable html and static plugins to render the page and deliver assets.

Configure add and edit routes in bun using a views path constant and metadata, then render the add, edit, and home page and prepare for SQLite database setup.

Learn how to set up a bun sqlite database in a src/db.ts file, create a products database class, initialize a products table, and enable CRUD operations via a decorator-based context.

Create an api to add products by implementing a add product method in the products database class, exposing a post route that saves data and redirects to the home page.

Fetch all products from the database via a Bun API route, then render product cards dynamically on the client using a script that maps products to HTML.

Learn to update product data by wiring an edit button to an edit route, posting changes, and updating the database (name, price, image) where the id matches.

Delete a product by id via a delete button using URL parameters, route /delete/:id, and a database delete from products where id equals the parsed id, then redirect home.