jcc-express-mvc 1.9.7 → 1.9.8

package/final-documentation/Architecture Concept/Request-Lifecycle.md

@@ -59,7 +59,7 @@ Think of the stack as: framework defaults → your kernel `middlewares` (for exa
 
 One of the most important bootstrap steps is loading service providers. Providers register bindings on the container (`register`) and run extra setup once registrations exist (`boot`).
 
-In `ApplicationBuilder.withProviders()`, the framework prepends `DatabaseServiceProvider`, registers your list from `bootstrap/providers.ts` (and may place `AuthServiceProvider` early), then appends `QueueServiceProvider`. That order matters so the database, auth, and queue subsystems are available where other code expects them.
+During application bootstrap, the framework prepends `DatabaseServiceProvider`, registers your list from `bootstrap/providers.ts` (and may place `AuthServiceProvider` early), then appends `QueueServiceProvider`. That order matters so the database, auth, and queue subsystems are available where other code expects them.
 
 Your own providers live under `app/Providers/` (for example `AppServiceProvider`) and are listed in `bootstrap/providers.ts`. Use `AppServiceProvider` (or additional providers) for container bindings, config-driven setup, and small bootstrap tasks—same idea as Laravel’s `AppServiceProvider`.
 
@@ -92,7 +92,7 @@ If the request fails a guard (for example user not authenticated), middleware ca
 
 If the request passes all matched middleware, your route or controller runs and produces the response (JSON, Blade, Inertia, redirect, …).
 
-Reference — framework middleware order (before kernel entries), from `jcc-express-mvc/lib/Middleware`:
+Reference — default framework middleware order (before kernel entries):
 
 1. `express.json()`
 2. `express.urlencoded({ extended: false })`
@@ -117,7 +117,7 @@ When your controller or closure finishes—by calling `res.send`, `res.json`, `r
 
 The framework listens for `finish` on the response and clears the per-request `request` / `response` / `next` bindings on the container so the next request does not leak state.
 
-If an error is passed to `next(error)` or thrown without being caught, `AppErrorHandler` maps it to an HTTP response (status and body) according to framework rules.
+If an error is passed to `next(error)` or thrown without being caught, the framework error handler maps it to an HTTP response (status and body). See [Error handling](../The%20Basics/Error-handling.md).
 
 ---
 
@@ -132,6 +132,6 @@ Your `bootstrap/providers.ts` list is the counterpart to Laravel’s provider li
 ## Where to customize (quick reference)
 
 - Global HTTP middleware — `app/Http/kernel.ts` → `middlewares` and `middlewareAliases`.
-- Default Express stack — `jcc-express-mvc/lib/Middleware` + `app/Config` (CORS, rate limit, engine).
+- Default Express stack — framework global middleware + `app/Config` (CORS, rate limit, engine).
 - Routes and API prefixes — `route/*.ts` and `bootstrap/app.ts` → `withRouting`.
 - Container bindings and boot logic — `app/Providers/*` and `bootstrap/providers.ts`.

package/final-documentation/Architecture Concept/Service-Container.md

@@ -84,15 +84,15 @@ If resolution fails, you may need an explicit `bind` for that type or pass param
 
 ---
 
-## Controllers and `callControllerMethod`
+## Controllers and method injection
 
-For controller actions, the framework can `callControllerMethod`, which reads `inject:method:deps` metadata and resolves FormRequest, models, route parameters, etc. Plain routes that use `(req, res) =>` do not need this—you still benefit from `view()` / `inertia()` because they read `response` from the container after it is bound.
+For controller actions, the framework resolves method parameters from container metadata: FormRequest classes, models, route parameters, and services. Plain routes that use `(req, res) =>` do not need this—you still benefit from `view()` / `inertia()` because they read `response` from the container after it is bound.
 
 ---
 
 ## Global `app` and helpers
 
-After `globalHelpers(app)` runs (during `ApplicationBuilder.create()`), `globalThis.app` is the Application instance. Helpers like `env()`, `view()`, `inertia()` use the container under the hood (for example `response` from `app.resolve("response")`).
+After the application boots, `globalThis.app` is the Application instance. Helpers like `env()`, `view()`, and `inertia()` use the container under the hood (for example `response` from `app.resolve("response")`).
 
 Prefer constructor injection or explicit `app.resolve()` in providers and long-lived services; use globals where the framework already does (routes, Blade/Inertia helpers).
 
@@ -100,7 +100,7 @@ Prefer constructor injection or explicit `app.resolve()` in providers and long-l
 
 ## Comparison to Laravel (mental model)
 
-- Container class — Laravel: `Illuminate\Container\Container`. JCC: `jcc-express-mvc/lib/Container`.
+- Container — Laravel: `Illuminate\Container\Container`. JCC: the framework service container (resolved via `app.resolve()` / `app.make()`).
 - Application — Laravel’s `Application` extends the container. JCC: `Application` → `ExpressApplication` → `Container`.
 - Registering services — Laravel: `AppServiceProvider::register`. JCC: same idea in `app/Providers/*` → `register()`.
 - Resolving — Laravel: `app()`, `resolve()`. JCC: `app.resolve()`, `app.make()`.

package/final-documentation/Architecture Concept/Service-Provider.md

@@ -15,7 +15,7 @@ A provider connects the framework to your app:
 - Register container bindings (`bind`, `singleton`, `instance`) so other code can `resolve` them.
 - Boot behavior that depends on those bindings (routes are not registered here—`RouteServiceProvider` loads route files during `app.run()`, but your `boot()` can use `Gate`, events, or other services already on the container).
 
-The abstract base class lives in `jcc-express-mvc` (`ServiceProvider`). Extend it from `jcc-express-mvc/Core/Provider` (re-export) or the underlying `lib/Providers/ServiceProvider`.
+The abstract base class is **`ServiceProvider`**. Extend it from `jcc-express-mvc/Core/Provider`.
 
 ---
 
@@ -28,14 +28,17 @@ The abstract base class lives in `jcc-express-mvc` (`ServiceProvider`). Extend i
 
 ---
 
-## Registration order (`ApplicationBuilder`)
+## Registration order (bootstrap)
 
-In `withProviders()`, the builder does not use your array alone. It builds this chain:
+During `withProviders()`, the application builder does not use your array alone. It builds this chain:
 
-1. `DatabaseServiceProvider` — Knex / Sequelize / Mongoose setup (skipped when `DB_ORM=prisma`).
-2. `PrismaServiceProvider` — Prisma client singleton and graceful `$disconnect`.
-2. Your providers from `bootstrap/providers.ts` — If `AuthServiceProvider` (framework) is in the list but not first, the builder moves it to the front of your list so auth is set up early.
-3. `QueueServiceProvider` — Always last in the chain.
+1. `LogServiceProvider`
+2. `DatabaseServiceProvider` — Knex / Sequelize / Mongoose setup (skipped when `DB_ORM=prisma` or `DB_ORM=typeorm`).
+3. `PrismaServiceProvider` — Prisma client singleton and graceful `$disconnect` (when configured).
+4. `TypeORMServiceProvider` — TypeORM `DataSource` singleton and graceful shutdown (when configured).
+5. `SessionServiceProvider`, `CacheServiceProvider`
+6. Your providers from `bootstrap/providers.ts` — If `AuthServiceProvider` (framework) is in the list but not first, the builder moves it to the front of your list so auth is set up early.
+7. `QueueServiceProvider` — Always last in the chain.
 
 That order matters when one provider’s `register()` assumes another binding already exists.
 
@@ -100,6 +103,7 @@ export const providers = [AppServiceProvider];
 
 - `DatabaseServiceProvider` — Database / ORM wiring; runs before your list.
 - `PrismaServiceProvider` — Registers `database.prisma.service` when configured.
+- `TypeORMServiceProvider` — Registers `database.typeorm.dataSource` when configured.
 - `AuthServiceProvider` (when included) — Intended to run early among your providers.
 - `QueueServiceProvider` — Queue binding; runs after your list.
 - `RouteServiceProvider` — Not in your `bootstrap/providers.ts` list by default; it is registered as a singleton on `Application` and `loadRoutes()` is invoked from `app.run()` to load `route/web`, `route/api`, etc.

package/final-documentation/Database/Database-Introduction.md

@@ -8,6 +8,7 @@ Almost every real application needs a database. JCC Express MVC keeps this flexi
 - **Sequelize** as an alternative SQL ORM
 - **Mongoose** for MongoDB document workflows
 - **Prisma** for schema-first SQL with generated client and migrations
+- **TypeORM** for decorator-based entities and `DataSource` repositories
 
 In practice, most projects start with the default JCC stack, then switch ORM mode only when needed.
 
@@ -26,6 +27,8 @@ For document databases, use `DB_ORM=mongoose` with your Mongo connection setting
 
 For Prisma, use `DB_ORM=prisma` and configure `DATABASE_URL` plus `database.prisma.service` — see [Prisma](./Prisma.md).
 
+For TypeORM, use `DB_ORM=typeorm` and configure `database.typeorm.dataSource` — see [TypeORM](./TypeORM.md).
+
 ---
 
 ## Configuration
@@ -42,12 +45,13 @@ Minimal shape from `app/Config/database.ts`:
 export const database = {
   orm: config.get("DB_ORM", "jcc"),
   prisma: { service: PrismaService },
+  typeorm: { dataSource: TypeORMDataSource },
   sequelize: { /* ... */ },
   mongoose: { /* ... */ },
 };
 ```
 
-See [Prisma](./Prisma.md) for the full Prisma setup.
+See [Prisma](./Prisma.md) and [TypeORM](./TypeORM.md) for full setup.
 
 ---
 
@@ -74,6 +78,8 @@ The provider layer uses your env/config to decide connection behavior:
 - `DB_ORM=jcc` -> JCC/Knex SQL flow
 - `DB_ORM=sequelize` -> Sequelize connection path
 - `DB_ORM=mongoose` -> Mongoose connection path
+- `DB_ORM=prisma` -> Prisma client path (see [Prisma](./Prisma.md))
+- `DB_ORM=typeorm` -> TypeORM DataSource path (see [TypeORM](./TypeORM.md))
 
 Keep `DB_ORM` and `DB_CONNECTION` consistent (for example, do not pair `DB_ORM=mongoose` with SQL-only assumptions in your app code).
 

package/final-documentation/Database/Migrations.md

@@ -135,12 +135,7 @@ Common schema helpers seen in the current codebase:
 
 ---
 
-## Full migration API (current source)
-
-This list is taken from the current implementation in:
-
-- `jcc-express-mvc/lib/Jcc-eloquent/lib/Schema/index.ts`
-- `jcc-express-mvc/lib/Jcc-eloquent/lib/Schema/BluePrint/index.ts`
+## Full migration API
 
 ### `Schema` methods
 

package/final-documentation/Database/Prisma.md

@@ -129,8 +129,8 @@ The framework only injects an adapter when you set `database.prisma.adapter` or
 
 ```typescript
 import { PrismaClient } from "generated/prisma/client";
-import { createMariaDbAdapter } from "@framework/lib/Database/Drivers/Prisma/adapters/mariadb";
-import type { PrismaClientOptions } from "@framework/lib/Database/Drivers/Prisma/types";
+import { createMariaDbAdapter } from "jcc-express-mvc/lib/Database/Drivers/Prisma/adapters/mariadb";
+import type { PrismaClientOptions } from "jcc-express-mvc/lib/Database/Drivers/Prisma/types";
 
 export class PrismaService extends PrismaClient {
   constructor(options?: PrismaClientOptions) {
@@ -160,7 +160,8 @@ PRISMA_ADAPTER=postgres
 **3. `database.prisma.adapter` in app config:**
 
 ```typescript
-import { createPostgresAdapter } from "jcc-express-mvc/lib/Database/Drivers/Prisma/adapters/postgres";
+import { createPostgresAdapter } from "jcc-express-mvc/lib/Database/Drivers/Prisma/adapters/
+postgres";
 
 export const database = {
   prisma: {
@@ -188,17 +189,16 @@ prisma: {
 
 ## Framework adapter helpers
 
+Built-in adapter factories:
+
 | Export                      | Use                                                 |
 | --------------------------- | --------------------------------------------------- |
-| `resolvePrismaAdapter(app)` | Used by `PrismaServiceProvider`                     |
 | `createPrismaAdapter(name)` | Build adapter for a named driver (`PRISMA_ADAPTER`) |
 | `createMariaDbAdapter()`    | MySQL / MariaDB                                     |
 | `createPostgresAdapter()`   | PostgreSQL                                          |
 | `createSqliteAdapter()`     | SQLite file                                         |
 | `createLibSqlAdapter()`     | LibSQL / Turso                                      |
 
-Import from `jcc-express-mvc/lib/Database` or `jcc-express-mvc/lib/Database/Drivers/Prisma/connection`.
-
 The framework registers `PrismaService` as a **singleton** and aliases `prisma` and `database.connection`.
 
 ---
@@ -262,9 +262,12 @@ Equivalent npm scripts: `prisma:generate`, `prisma:migrate`, `prisma:studio`.
 | `PrismaServiceProvider` | `jcc-express-mvc/lib/Database/PrismaServiceProvider.ts`      |
 | `Database` resolver     | `jcc-express-mvc/lib/Database/Database.ts` (`DB_ORM=prisma`) |
 
-`PrismaDriver` implements the same `DatabaseDriver` interface as `KnexDriver`, `SequelizeDriver`, and `MongooseDriver` (`connect`, `getConnection`, `disconnect`). Adapter selection lives under `Drivers/Prisma/`.
+When `DB_ORM=prisma` (or when `database.prisma.service` is set in `app/Config/database.ts`):
 
-When `DB_ORM=prisma`, `DatabaseServiceProvider` skips Knex/Sequelize/Mongoose setup so only Prisma owns the connection.
+- Your `PrismaService` class is registered as a **singleton**.
+- The client is available via constructor injection, `app.resolve("prisma")`, or the global `prisma()` helper.
+- Knex / Sequelize / Mongoose setup is skipped so Prisma owns the database connection.
+- The client disconnects gracefully on shutdown.
 
 ---
 

package/final-documentation/Database/Query-Builder.md

@@ -2,7 +2,7 @@
 
 ## Introduction
 
-JCC Express MVC provides a fluent query builder through `DB.table(...)` and `DB.query()` (`jcc-express-mvc/lib/Jcc-eloquent/lib/Builder.ts`).
+JCC Express MVC provides a fluent query builder through `DB.table(...)` and `DB.query()`.
 
 Use it for composable SQL queries without writing full raw SQL for every operation.
 

package/final-documentation/Database/Seeding.md

@@ -23,7 +23,7 @@ This creates a new seeder class in `database/seeders`.
 Typical seeder pattern:
 
 ```typescript
-import { DB } from "jcc-express-mvc/lib/Jcc-eloquent";
+import { DB } from "jcc-express-mvc/Eloquent";
 
 export class UserSeeder {
   async run() {

package/final-documentation/Database/Sequelize.md

@@ -2,19 +2,19 @@
 
 ## Introduction
 
-JCC Express MVC supports Sequelize as an alternative ORM path through `DatabaseServiceProvider` and `SequelizeDriver`.
+JCC Express MVC supports [Sequelize](https://sequelize.org/) as an alternative SQL ORM when `DB_ORM=sequelize`. Models live in `app/Models/` and use Sequelize's class + `Model.init(...)` pattern — not JCC Eloquent's `Model` from `jcc-express-mvc/Eloquent`.
 
-When enabled, the framework resolves a Sequelize connection and aliases it as:
+When enabled, the framework registers the connection as:
 
 - `database.connection`
 - `sequelize`
 
+Resolve it with `app.resolve("sequelize")` or the global `app` helper during bootstrap.
+
 ---
 
 ## Enable Sequelize
 
-Set env/config to use Sequelize:
-
 ```env
 DB_ORM=sequelize
 DB_CONNECTION=mysql
@@ -25,7 +25,7 @@ DB_USERNAME=root
 DB_PASSWORD=secret
 ```
 
-`app/Config/database.ts` already contains the expected `sequelize` block:
+`app/Config/database.ts` includes the expected `sequelize` block:
 
 ```typescript
 sequelize: {
@@ -38,49 +38,111 @@ sequelize: {
 }
 ```
 
+`sync.alter` updates tables to match your models in development. Keep `sync.force` and `dropTables` disabled in production unless you intentionally reset schema.
+
 ---
 
 ## Required packages
 
-Install Sequelize and a SQL driver package:
-
 ```bash
 npm install sequelize mysql2
 ```
 
-For PostgreSQL or SQLite, install the matching dialect package(s).
+For PostgreSQL or SQLite, install the matching dialect driver (`pg`, `better-sqlite3`, etc.).
 
 ---
 
-## Generate models (recommended)
+## Generate models
 
-Do not manually create model files for this flow. Use ArtisanNode:
+With `DB_ORM=sequelize`, ArtisanNode scaffolds Sequelize models:
 
 ```bash
 bun artisanNode make:model User
+bun artisanNode make:model Post
 ```
 
-`SequelizeDriver` auto-loads models from `app/Models`, so generated model files are discovered at connect time.
+Files are created in `app/Models/`. On connect, the framework loads every `.ts` / `.js` file in that folder, registers models, and runs `static associate` on each class that defines it.
 
 ---
 
-## Sequelize model example
+## Model file structure
+
+Each Sequelize model file should:
+
+1. Import `Model`, `DataTypes`, and `Sequelize` from the **`sequelize`** package.
+2. Resolve the shared connection with `app.resolve<Sequelize>("sequelize")`.
+3. Extend Sequelize's `Model` class and `declare` typed attributes.
+4. Define `static associate(models)` for relationships (optional).
+5. Call `ModelName.init(attributes, options)` at the bottom of the file.
+6. **Export a class whose name matches the filename** (e.g. `Test.ts` exports `class Test`) so autoloading can register it.
 
-In Sequelize mode, model files in `app/Models` should follow Sequelize's `Model.init(...)` pattern:
+Example (`app/Models/Test.ts`):
 
 ```typescript
-import { DataTypes, Model } from "sequelize";
+import { Model, DataTypes, Sequelize } from "sequelize";
 
-// Make sure this resolves to your registered Sequelize instance.
-const sequelize = app.resolve("sequelize");
+const sequelize = app.resolve<Sequelize>("sequelize");
+
+export class Test extends Model {
+  declare id: number;
+
+  /**
+   * Define relationships between models
+   * @param models - Record of all loaded model classes
+   */
+  static associate(models: any) {
+    //
+  }
+}
+
+Test.init(
+  {
+    id: {
+      type: DataTypes.INTEGER,
+      primaryKey: true,
+      autoIncrement: true,
+    },
+  },
+  {
+    sequelize,
+    tableName: "tests",
+    timestamps: true,
+    modelName: "Test",
+  }
+);
+```
+
+### `Model.init` options
+
+| Option       | Purpose                                                    |
+| ------------ | ---------------------------------------------------------- |
+| `sequelize`  | Shared connection from `app.resolve("sequelize")`          |
+| `tableName`  | Database table name                                        |
+| `modelName`  | Sequelize model name (used for route model binding suffix) |
+| `timestamps` | When `true`, Sequelize manages `createdAt` / `updatedAt`   |
+
+Add columns in the first argument to `init` using `DataTypes` (`STRING`, `TEXT`, `BOOLEAN`, `DATE`, `JSON`, etc.).
+
+---
+
+## Full example: User model
+
+```typescript
+import { Model, DataTypes, Sequelize } from "sequelize";
+
+const sequelize = app.resolve<Sequelize>("sequelize");
 
 export class User extends Model {
-  declare id?: number;
-  declare name?: string;
-  declare email?: string;
-  declare password?: string;
-  declare createdAt?: Date;
-  declare updatedAt?: Date;
+  declare id: number;
+  declare name: string;
+  declare email: string;
+  declare password: string;
+  declare createdAt: Date;
+  declare updatedAt: Date;
+
+  static associate(models: any) {
+    User.hasMany(models.Post, { foreignKey: "userId", as: "posts" });
+  }
 }
 
 User.init(
@@ -94,54 +156,167 @@ User.init(
       type: DataTypes.STRING,
       allowNull: false,
     },
+    email: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      unique: true,
+    },
+    password: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
   },
   {
     sequelize,
     tableName: "users",
     timestamps: true,
     modelName: "User",
+  }
+);
+```
+
+---
+
+## Relationships (`associate`)
+
+After all models in `app/Models/` are loaded, the framework calls `static associate(models)` on each model. The `models` argument is a map of loaded classes keyed by filename (`User`, `Post`, etc.).
+
+```typescript
+// app/Models/Post.ts
+import { Model, DataTypes, Sequelize } from "sequelize";
+
+const sequelize = app.resolve<Sequelize>("sequelize");
+
+export class Post extends Model {
+  declare id: number;
+  declare title: string;
+  declare body: string;
+  declare userId: number;
+
+  static associate(models: any) {
+    Post.belongsTo(models.User, { foreignKey: "userId", as: "author" });
+  }
+}
+
+Post.init(
+  {
+    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true },
+    title: { type: DataTypes.STRING, allowNull: false },
+    body: { type: DataTypes.TEXT },
+    userId: { type: DataTypes.INTEGER, allowNull: false },
   },
+  {
+    sequelize,
+    tableName: "posts",
+    timestamps: true,
+    modelName: "Post",
+  }
 );
 ```
 
+Models are loaded in **filename sort order**. Define foreign keys on child models and wire `associate` after both sides exist — parent models that appear earlier in the alphabet are available when `associate` runs on child models.
+
+---
+
+## Using models in controllers
+
+Import the model class from `app/Models/`:
+
+```typescript
+import { User } from "@/Models/User";
+
+// List
+const users = await User.findAll();
+
+// Find by primary key
+const user = await User.findByPk(1);
+
+// Create
+const created = await User.create({
+  name: "Jane",
+  email: "jane@example.com",
+  password: "secret",
+});
+
+// Update
+await user.update({ name: "Jane Doe" });
+
+// Delete
+await user.destroy();
+
+// Eager load
+const withPosts = await User.findByPk(1, { include: ["posts"] });
+```
+
+Use standard Sequelize query APIs on the model class and instances.
+
 ---
 
-## What the driver does on connect
+## Route model binding
 
-From `SequelizeDriver`:
+When `DB_ORM=sequelize`, implicit binding resolves models with `findByPk` from the route parameter (e.g. `{user}` → `User.findByPk(id)`). See [Routing](../The%20Basics/Routing.md#route-model-binding).
 
-- creates Sequelize instance with your config
-- calls `authenticate()`
-- auto-loads model files from `app/Models`
-- runs `sequelize.sync(config.sync)`
-- optionally drops tables when `dropTables` is enabled
+```typescript
+Route.get("/users/{user}", [UsersController, "show"]);
+```
+
+```typescript
+import { Inject, Method } from "jcc-express-mvc/Core/Dependency";
+import { User } from "@/Models/User";
+
+@Inject()
+export class UsersController {
+  @Method({ params: ["user"] })
+  async show(user: User) {
+    return user;
+  }
+}
+```
+
+Column binding (`{email$user}`) uses Sequelize `findOne({ where: { email } })`.
 
 ---
 
 ## Access the Sequelize connection
 
-To get the Sequelize instance:
+For raw queries or transactions outside model classes:
 
 ```typescript
 const sequelize = app.resolve("sequelize");
-```
 
-The connection is registered as a singleton by `DatabaseServiceProvider`.
+await sequelize.transaction(async (t) => {
+  // ...
+});
+```
 
 ---
 
-## Notes
+## What happens on connect
 
-- Sequelize setup is selected by `DB_ORM=sequelize`.
-- Model loading scans `app/Models` for `.ts` / `.js` files.
-- Keep `sync.force` / `dropTables` disabled in production unless intentionally resetting schema.
+When `DB_ORM=sequelize`, the framework:
+
+1. Creates the Sequelize instance from `app/Config/database.ts`.
+2. Authenticates against the database.
+3. Requires every model file in `app/Models/` and collects exported classes.
+4. Calls `associate(models)` on each model that defines it.
+5. Runs `sequelize.sync(...)` using your `sync` config.
 
 ---
 
 ## Summary
 
-- Set `DB_ORM=sequelize`.
-- Configure `app/Config/database.ts` -> `sequelize`.
-- Install required npm packages.
-- Generate models with `bun artisanNode make:model User`.
-- Resolve connection via `app.resolve("sequelize")`.
+- Set `DB_ORM=sequelize` and configure `database.sequelize` in app config.
+- Models live in `app/Models/` — use `sequelize`'s `Model` + `Model.init`, not JCC Eloquent.
+- Resolve the connection with `app.resolve<Sequelize>("sequelize")` in each model file.
+- Define relationships in `static associate(models)`.
+- Generate scaffolds with `bun artisanNode make:model <Name>`.
+- Query with Sequelize APIs (`findAll`, `findByPk`, `create`, etc.).
+
+---
+
+## Related
+
+- [Database Introduction](./Database-Introduction.md)
+- [Configuration](../Getting-Started/Configuration.md)
+- [Routing](../The%20Basics/Routing.md)
+- [Artisan Node](../The%20Basics/Artisan-Node.md)

package/final-documentation/Database/Transactions.md

@@ -14,7 +14,7 @@ JCC Express MVC supports transactions through:
 ## Basic transaction usage
 
 ```typescript
-import { DB } from "jcc-express-mvc/lib/Jcc-eloquent";
+import { DB } from "jcc-express-mvc/Eloquent";
 
 await DB.transaction(async () => {
   await DB.table("wallets").where("id", 1).decrement("balance", 100);