@venizia/ignis-docs 0.0.1-8 → 0.0.1-9

package/wiki/get-started/building-a-crud-api.md

@@ -134,12 +134,10 @@ export type TTodo = TTableObject<TTodoSchema>;
 
 // 4. Create the Entity class, decorated with @model
 @model({ type: 'entity' })
-export class Todo extends BaseEntity<TTodoSchema> {
-  static readonly TABLE_NAME = 'Todo';
-
-  constructor() {
-    super({ name: Todo.TABLE_NAME, schema: todoTable });
-  }
+export class Todo extends BaseEntity<typeof Todo.schema> {
+  static override schema = todoTable;
+  static override relations = () => todoRelations.definitions;
+  static override TABLE_NAME = 'Todo';
 }
 ```
 
@@ -203,7 +201,6 @@ Create `src/datasources/postgres.datasource.ts`:
 
 ```typescript
 // src/datasources/postgres.datasource.ts
-import { Todo, todoRelations, todoTable } from '@/models/todo.model';
 import {
   BaseDataSource,
   datasource,
@@ -214,61 +211,61 @@ import { drizzle } from 'drizzle-orm/node-postgres';
 import { Pool } from 'pg';
 
 interface IDSConfigs {
-  connection: {
-    host?: string;
-    port?: number;
-    user?: string;
-    password?: string;
-    database?: string;
-  };
+  host: string;
+  port: number;
+  database: string;
+  user: string;
+  password: string;
 }
 
-@datasource()
+/**
+ * PostgresDataSource with auto-discovery support.
+ *
+ * How it works:
+ * 1. @repository decorator binds model to datasource
+ * 2. When configure() is called, getSchema() auto-discovers all bound models
+ * 3. Drizzle is initialized with the auto-discovered schema
+ */
+@datasource({ driver: 'node-postgres' })
 export class PostgresDataSource extends BaseDataSource<TNodePostgresConnector, IDSConfigs> {
   constructor() {
     super({
       name: PostgresDataSource.name,
-      driver: 'node-postgres',
+      // Driver is read from @datasource decorator - no need to pass here!
       config: {
-        connection: {
-          host: process.env.APP_ENV_POSTGRES_HOST,
-          port: +(process.env.APP_ENV_POSTGRES_PORT ?? 5432),
-          user: process.env.APP_ENV_POSTGRES_USERNAME,
-          password: process.env.APP_ENV_POSTGRES_PASSWORD,
-          database: process.env.APP_ENV_POSTGRES_DATABASE,
-        },
+        host: process.env.APP_ENV_POSTGRES_HOST ?? 'localhost',
+        port: +(process.env.APP_ENV_POSTGRES_PORT ?? 5432),
+        database: process.env.APP_ENV_POSTGRES_DATABASE ?? 'todo_db',
+        user: process.env.APP_ENV_POSTGRES_USERNAME ?? 'postgres',
+        password: process.env.APP_ENV_POSTGRES_PASSWORD ?? '',
       },
-      // Register all your models and their relations here
-      schema: Object.assign(
-        {},
-        { [Todo.TABLE_NAME]: todoTable },
-        todoRelations.relations,
-      ),
+      // NO schema property - auto-discovered from @repository bindings!
     });
   }
 
   override configure(): ValueOrPromise<void> {
-    this.connector = drizzle({
-      client: new Pool(this.settings.connection),
-      schema: this.schema,
-    });
-  }
-
-  override async connect(): Promise<TNodePostgresConnector | undefined> {
-    await (this.connector.client as Pool).connect();
-    return this.connector;
-  }
-
-  override async disconnect(): Promise<void> {
-    await (this.connector.client as Pool).end();
+    // getSchema() auto-discovers models from @repository bindings
+    const schema = this.getSchema();
+
+    // Log discovered schema for debugging
+    const schemaKeys = Object.keys(schema);
+    this.logger.debug(
+      '[configure] Auto-discovered schema | Schema + Relations (%s): %o',
+      schemaKeys.length,
+      schemaKeys,
+    );
+
+    const client = new Pool(this.settings);
+    this.connector = drizzle({ client, schema });
   }
 }
 ```
 
 **Key Points:**
-- Registers `todoTable` and `todoRelations` in the schema
+- Schema is auto-discovered from `@repository` decorators - no manual registration needed
+- Uses `getSchema()` for lazy schema resolution (resolves when all models are loaded)
 - Uses environment variables for connection config
-- Implements connection lifecycle methods
+- Implements connection lifecycle methods (`connect()`, `disconnect()`)
 
 > **Deep Dive:** See [DataSources Reference](../references/base/datasources.md) for advanced configuration and multiple database support.
 
@@ -280,26 +277,15 @@ Create `src/repositories/todo.repository.ts`:
 
 ```typescript
 // src/repositories/todo.repository.ts
-import { Todo, todoRelations, TTodoSchema } from '@/models/todo.model';
-import {
-  DefaultCRUDRepository,
-  IDataSource,
-  inject,
-  repository,
-} from '@venizia/ignis';
-
-@repository()
-export class TodoRepository extends DefaultCRUDRepository<TTodoSchema> {
-  constructor(
-    @inject({ key: 'datasources.PostgresDataSource' })
-    dataSource: IDataSource,
-  ) {
-    super({
-      dataSource,
-      entityClass: Todo,
-      relations: todoRelations.definitions,
-    });
-  }
+import { Todo } from '@/models/todo.model';
+import { PostgresDataSource } from '@/datasources/postgres.datasource';
+import { DefaultCRUDRepository, repository } from '@venizia/ignis';
+
+// Both 'model' and 'dataSource' are required for schema auto-discovery
+@repository({ model: Todo, dataSource: PostgresDataSource })
+export class TodoRepository extends DefaultCRUDRepository<typeof Todo.schema> {
+  // No constructor needed! DataSource and relations are auto-resolved
+  // from the @repository decorator and entity's static properties
 }
 ```
 
@@ -358,15 +344,15 @@ export class TodoController extends _Controller {
 **Auto-generated Endpoints:**
 | Method | Path | Description |
 |--------|------|-------------|
-| GET | `/todos` | List all todos |
-| GET | `/todos/:id` | Get todo by ID |
-| GET | `/todos/find-one` | Find one todo by filter |
-| GET | `/todos/count` | Count todos |
-| POST | `/todos` | Create todo |
-| PATCH | `/todos/:id` | Update todo by ID |
-| PATCH | `/todos` | Update multiple todos |
-| DELETE | `/todos/:id` | Delete todo by ID |
-| DELETE | `/todos` | Delete multiple todos |
+| GET | `/todos` | List all todos (find) |
+| GET | `/todos/:id` | Get todo by ID (findById) |
+| GET | `/todos/find-one` | Find one todo by filter (findOne) |
+| GET | `/todos/count` | Count todos (count) |
+| POST | `/todos` | Create todo (create) |
+| PATCH | `/todos/:id` | Update todo by ID (updateById) |
+| PATCH | `/todos` | Update multiple todos by filter (updateBy) |
+| DELETE | `/todos/:id` | Delete todo by ID (deleteById) |
+| DELETE | `/todos` | Delete multiple todos by filter (deleteBy) |
 
 > **Deep Dive:** See [ControllerFactory Reference](../references/base/controllers.md#controllerfactory) for customization options.
 
@@ -639,8 +625,7 @@ Now that you've built the Todo API, try building a **User** feature on your own!
 
 **Challenge checklist:**
 - [ ] Create `src/models/user.model.ts`
-- [ ] Update `PostgresDataSource` to include User schema
-- [ ] Create `src/repositories/user.repository.ts`
+- [ ] Create `src/repositories/user.repository.ts` (this auto-registers User with PostgresDataSource)
 - [ ] Create `src/controllers/user.controller.ts`
 - [ ] Register repository and controller in `application.ts`
 - [ ] Run migration: `bun run migrate:dev`

package/wiki/get-started/core-concepts/controllers.md

@@ -9,7 +9,7 @@ Controllers handle HTTP requests and return responses - they're your API endpoin
 Extend `BaseController` and use decorators to define routes:
 
 ```typescript
-import { BaseController, controller, get, jsonResponse, z } from '@venizia/ignis';
+import { BaseController, controller, get, jsonResponse, z, HTTP } from '@venizia/ignis';
 import { Context } from 'hono';
 
 @controller({ path: '/users' })
@@ -29,7 +29,7 @@ export class UserController extends BaseController {
     },
   })
   getAllUsers(c: Context) {
-    return c.json([{ id: '1', name: 'John Doe' }]);
+    return c.json([{ id: '1', name: 'John Doe' }], HTTP.ResultCodes.RS_2.Ok);
   }
 }
 ```
@@ -177,7 +177,7 @@ const GetUsersRoute = {
 this.defineRoute({
   configs: GetUsersRoute,
   handler: (c: TRouteContext<typeof GetUsersRoute>) => { // Return type is automatically inferred
-    return c.json([{ id: 1, name: 'John Doe' }]);
+    return c.json([{ id: 1, name: 'John Doe' }], HTTP.ResultCodes.RS_2.Ok);
   },
 });
 ```
@@ -187,7 +187,7 @@ this.defineRoute({
 This method offers a fluent API for defining routes, similar to `defineRoute`, but structured for chaining. It also benefits from `TRouteContext` for type safety.
 
 ```typescript
-import { jsonResponse, z, TRouteContext } from '@venizia/ignis';
+import { jsonResponse, z, TRouteContext, HTTP } from '@venizia/ignis';
 
 // ... inside the binding() method
 
@@ -205,7 +205,7 @@ this.bindRoute({
 }).to({
   handler: (c: TRouteContext<typeof GetUserByIdRoute>) => { // Return type is automatically inferred
     const { id } = c.req.param();
-    return c.json({ id: id, name: 'John Doe' });
+    return c.json({ id: id, name: 'John Doe' }, HTTP.ResultCodes.RS_2.Ok);
   },
 });
 ```
@@ -255,17 +255,17 @@ export class ConfigurationController extends _Controller {
 ```
 The `ControllerFactory.defineCrudController` method automatically sets up the following routes based on your entity schema:
 
-| Name | Method | Path | Description |
+| Route Name | Method | Path | Description |
 | :--- | :--- | :--- | :--- |
 | `count` | `GET` | `/count` | Get the number of records matching a filter. |
 | `find` | `GET` | `/` | Retrieve all records matching a filter. |
 | `findById` | `GET` | `/:id` | Retrieve a single record by its ID. |
 | `findOne` | `GET` | `/find-one` | Retrieve a single record matching a filter. |
 | `create` | `POST` | `/` | Create a new record. |
-| `updateById` | `PATCH` | `/:id` | Update a record by its ID. |
-| `updateAll` | `PATCH` | `/` | Update multiple records matching a filter. |
-| `deleteById` | `DELETE` | `/:id` | Delete a record by its ID. |
-| `deleteAll` | `DELETE` | `/` | Delete multiple records matching a filter. |
+| `updateById` | `PATCH` | `/:id` | Update a single record by its ID. |
+| `updateBy` | `PATCH` | `/` | Update multiple records matching a `where` filter. |
+| `deleteById` | `DELETE` | `/:id` | Delete a single record by its ID. |
+| `deleteBy` | `DELETE` | `/` | Delete multiple records matching a `where` filter. |
 
 :::info Customization
 The `ControllerFactory` is highly customizable. You can override the Zod schemas for any of the generated routes to add, remove, or modify fields for request validation and response shapes. You can also configure other behaviors, like making delete operations return the deleted records.
@@ -368,7 +368,7 @@ When you define Zod schemas in your route's `request` configuration (whether wit
 
 ```typescript
 import { z } from '@hono/zod-openapi';
-import { jsonContent, put } from '@venizia/ignis';
+import { jsonContent, put, HTTP } from '@venizia/ignis';
 
 // ... inside a controller class
 
@@ -397,7 +397,7 @@ updateUser(c: Context) {
     console.log('Notification is enabled.');
   }
 
-  return c.json({ success: true, id, ...userUpdateData });
+  return c.json({ success: true, id, ...userUpdateData }, HTTP.ResultCodes.RS_2.Ok);
 }
 ```
 
@@ -405,7 +405,7 @@ Using `c.req.valid()` is the recommended way to access request data as it ensure
 
 ```typescript
 import { z } from '@hono/zod-openapi';
-import { jsonContent, put, TRouteContext } from '@venizia/ignis';
+import { jsonContent, put, TRouteContext, HTTP } from '@venizia/ignis';
 
 // ... inside a controller class
 
@@ -434,7 +434,7 @@ updateUser(c: TRouteContext<typeof updateUserConfig>) {
     console.log('Notification is enabled.');
   }
 
-  return c.json({ success: true, id, ...userUpdateData });
+  return c.json({ success: true, id, ...userUpdateData }, HTTP.ResultCodes.RS_2.Ok);
 }
 ```
 

package/wiki/get-started/core-concepts/persistent.md

@@ -45,12 +45,10 @@ export type TUser = TTableObject<TUserSchema>;
 
 // 4. Create the Entity class, decorated with @model
 @model({ type: 'entity' })
-export class User extends BaseEntity<TUserSchema> {
-  static readonly TABLE_NAME = User.name;
-
-  constructor() {
-    super({ name: User.name, schema: userTable });
-  }
+export class User extends BaseEntity<typeof User.schema> {
+  static override schema = userTable;
+  static override relations = () => userRelations.definitions;
+  static override TABLE_NAME = 'User';
 }
 ```
 
@@ -158,12 +156,10 @@ export type TPostSchema = typeof postTable;
 export type TPost = TTableObject<TPostSchema>;
 
 @model({ type: 'entity' })
-export class Post extends BaseEntity<TPostSchema> {
-  static readonly TABLE_NAME = 'Post';
-
-  constructor() {
-    super({ name: Post.TABLE_NAME, schema: postTable });
-  }
+export class Post extends BaseEntity<typeof Post.schema> {
+  static override schema = postTable;
+  static override relations = () => postRelations.definitions;
+  static override TABLE_NAME = 'Post';
 }
 ```
 
@@ -286,12 +282,10 @@ export type TConfigurationSchema = typeof configurationTable;
 export type TConfiguration = TTableObject<TConfigurationSchema>;
 
 @model({ type: 'entity' })
-export class Configuration extends BaseEntity<TConfigurationSchema> {
-  static readonly TABLE_NAME = Configuration.name;
-
-  constructor() {
-    super({ name: Configuration.TABLE_NAME, schema: configurationTable });
-  }
+export class Configuration extends BaseEntity<typeof Configuration.schema> {
+  static override schema = configurationTable;
+  static override relations = () => configurationRelations.definitions;
+  static override TABLE_NAME = 'Configuration';
 }
 ```
 **Key Concepts:**
@@ -309,34 +303,14 @@ A DataSource is a class responsible for managing the connection to your database
 
 ### Creating and Configuring a DataSource
 
-A `DataSource` must be decorated with `@datasource`. **The most critical part** is correctly merging your table schemas and relations into a single object that Drizzle ORM can understand.
-
-#### ⚠️ Understanding Schema Merging (CRITICAL CONCEPT)
-
-This is one of the most important concepts in Ignis. If you don't get this right, your relations won't work.
-
-**The Problem:**
-Drizzle ORM needs to know about:
-1. Your table structures (e.g., `userTable`, `configurationTable`)
-2. The relationships between them (e.g., "Configuration belongs to User")
+A `DataSource` must be decorated with `@datasource`. The framework now supports **schema auto-discovery**, which means you no longer need to manually merge tables and relations!
 
-**The Solution:**
-You must merge both into a single `schema` object in your DataSource constructor.
+### Pattern 1: Auto-Discovery (Recommended)
 
-#### Step-by-Step Example
-
-Let's say you have two models: `User` and `Configuration`. Here's how to set up the DataSource:
+With auto-discovery, the schema is automatically built from your `@repository` decorators:
 
 ```typescript
 // src/datasources/postgres.datasource.ts
-import {
-  Configuration,
-  configurationTable,        // The table structure
-  configurationRelations,    // The relationships
-  User,
-  userTable,                 // The table structure
-  userRelations,             // The relationships
-} from '@/models/entities';
 import {
   BaseDataSource,
   datasource,
@@ -346,7 +320,6 @@ import {
 import { drizzle } from 'drizzle-orm/node-postgres';
 import { Pool } from 'pg';
 
-// Configuration interface for database connection
 interface IDSConfigs {
   connection: {
     host?: string;
@@ -357,12 +330,11 @@ interface IDSConfigs {
   };
 }
 
-@datasource()
+@datasource({ driver: 'node-postgres' })
 export class PostgresDataSource extends BaseDataSource<TNodePostgresConnector, IDSConfigs> {
   constructor() {
     super({
       name: PostgresDataSource.name,
-      driver: 'node-postgres',
       config: {
         connection: {
           host: process.env.APP_ENV_POSTGRES_HOST,
@@ -372,27 +344,14 @@ export class PostgresDataSource extends BaseDataSource<TNodePostgresConnector, I
           database: process.env.APP_ENV_POSTGRES_DATABASE,
         },
       },
-
-      // 🔥 CRITICAL: This is where you merge tables and relations
-      schema: Object.assign(
-        {},
-        // Step 1: Add your table schemas
-        {
-          [User.TABLE_NAME]: userTable,
-          [Configuration.TABLE_NAME]: configurationTable,
-        },
-        // Step 2: Spread the relations objects
-        userRelations.relations,
-        configurationRelations.relations,
-      ),
+      // No schema needed - auto-discovered from @repository decorators!
     });
   }
 
   override configure(): ValueOrPromise<void> {
-    // Pass the merged schema to Drizzle
     this.connector = drizzle({
       client: new Pool(this.settings.connection),
-      schema: this.schema, // This now contains both tables AND relations
+      schema: this.schema, // Auto-discovered schema
     });
   }
 
@@ -407,34 +366,24 @@ export class PostgresDataSource extends BaseDataSource<TNodePostgresConnector, I
 }
 ```
 
-#### Why This Pattern?
-
-**Without the relations merged in:**
-```typescript
-// ❌ WRONG - Relations won't work!
-schema: {
-  [User.TABLE_NAME]: userTable,
-  [Configuration.TABLE_NAME]: configurationTable,
-}
-```
+**How auto-discovery works:**
 
-**Result:** Your repository's `include` queries will fail. You won't be able to fetch related data.
+When you define repositories with both `model` and `dataSource`:
 
-**With tables and relations merged:**
 ```typescript
-// ✅ CORRECT - Relations work perfectly!
-schema: Object.assign(
-  {},
-  {
-    [User.TABLE_NAME]: userTable,
-    [Configuration.TABLE_NAME]: configurationTable,
-  },
-  userRelations.relations,
-  configurationRelations.relations,
-)
+@repository({ model: User, dataSource: PostgresDataSource })
+export class UserRepository extends DefaultCRUDRepository<typeof User.schema> {}
+
+@repository({ model: Configuration, dataSource: PostgresDataSource })
+export class ConfigurationRepository extends DefaultCRUDRepository<typeof Configuration.schema> {}
 ```
 
-**Result:** You can now do:
+The framework automatically:
+1. Registers each model-datasource binding
+2. Builds the combined schema (tables + relations) when `getSchema()` is called
+3. Makes all registered models available for relational queries
+
+**Result:** You can use `include` queries without any manual schema configuration:
 ```typescript
 const config = await configRepo.findOne({
   filter: {
@@ -445,53 +394,55 @@ const config = await configRepo.findOne({
 console.log(config.creator.name); // Access related User data
 ```
 
-#### Adding New Models to Your DataSource
-
-Every time you create a new model, you need to:
+### Pattern 2: Manual Schema (Full Control)
 
-1. Import its table and relations
-2. Add them to the schema object
+If you need explicit control over the schema, you can still provide it manually:
 
-**Example - Adding a `Post` model:**
 ```typescript
 import {
-  Post,
-  postTable,
-  postRelations,
-  // ... other models
+  Configuration, configurationTable, configurationRelations,
+  User, userTable, userRelations,
 } from '@/models/entities';
 
-// In your constructor:
-schema: Object.assign(
-  {},
-  {
-    [User.TABLE_NAME]: userTable,
-    [Configuration.TABLE_NAME]: configurationTable,
-    [Post.TABLE_NAME]: postTable, // Add the table
-  },
-  userRelations.relations,
-  configurationRelations.relations,
-  postRelations.relations, // Add the relations
-),
+@datasource({ driver: 'node-postgres' })
+export class PostgresDataSource extends BaseDataSource<TNodePostgresConnector, IDSConfigs> {
+  constructor() {
+    super({
+      name: PostgresDataSource.name,
+      config: { /* ... */ },
+      // Manually merge tables and relations using spread syntax
+      schema: {
+        [User.TABLE_NAME]: userTable,
+        [Configuration.TABLE_NAME]: configurationTable,
+        ...userRelations.relations,
+        ...configurationRelations.relations,
+      },
+    });
+  }
+
+  override configure(): ValueOrPromise<void> {
+    this.connector = drizzle({
+      client: new Pool(this.settings.connection),
+      schema: this.schema,
+    });
+  }
+}
 ```
 
-**Pro tip:** As your app grows, consider using a helper function to reduce boilerplate:
+### @datasource Decorator
 
 ```typescript
-function buildSchema(models: Array<{ table: any; relations: any; name: string }>) {
-  const tables = models.reduce((acc, m) => ({ ...acc, [m.name]: m.table }), {});
-  const relations = models.map(m => m.relations.relations);
-  return Object.assign({}, tables, ...relations);
-}
-
-// Usage:
-schema: buildSchema([
-  { name: User.TABLE_NAME, table: userTable, relations: userRelations },
-  { name: Configuration.TABLE_NAME, table: configurationTable, relations: configurationRelations },
-  { name: Post.TABLE_NAME, table: postTable, relations: postRelations },
-])
+@datasource({
+  driver: 'node-postgres',    // Required - database driver
+  autoDiscovery?: true        // Optional - defaults to true
+})
 ```
 
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `driver` | `TDataSourceDriver` | - | Database driver name |
+| `autoDiscovery` | `boolean` | `true` | Enable/disable schema auto-discovery |
+
 ### Registering a DataSource
 
 Finally, register your `DataSource` with the application in `src/application.ts`.
@@ -520,29 +471,58 @@ Repositories abstract the data access logic. They use the configured `DataSource
 
 ### Creating a Repository
 
-A repository extends `DefaultCRUDRepository` (for full read/write operations), is decorated with `@repository`, and injects the `DataSource`.
+A repository extends `DefaultCRUDRepository` (for full read/write operations) and is decorated with `@repository`.
+
+**IMPORTANT:** Both `model` AND `dataSource` are required in `@repository` for schema auto-discovery. Without both, the model won't be registered and relational queries will fail.
+
+#### Pattern 1: Zero Boilerplate (Recommended)
+
+The simplest approach - dataSource is auto-injected from metadata:
 
 ```typescript
 // src/repositories/configuration.repository.ts
-import {
-  Configuration,
-  configurationRelations, // Import configurationRelations
-  TConfigurationSchema,
-} from '@/models/entities';
-import { IDataSource, inject, repository, DefaultCRUDRepository } from '@venizia/ignis';
+import { Configuration, TConfigurationSchema } from '@/models/entities';
+import { PostgresDataSource } from '@/datasources';
+import { repository, DefaultCRUDRepository } from '@venizia/ignis';
 
-// Decorator to mark this class as a repository for DI
-@repository({})
+@repository({ model: Configuration, dataSource: PostgresDataSource })
 export class ConfigurationRepository extends DefaultCRUDRepository<TConfigurationSchema> {
+  // No constructor needed - datasource auto-injected!
+
+  // Add custom methods as needed
+  async findByCode(code: string) {
+    return this.findOne({ filter: { where: { code } } });
+  }
+}
+```
+
+#### Pattern 2: Explicit @inject
+
+When you need constructor control (e.g., for read-only repositories or custom initialization):
+
+```typescript
+// src/repositories/user.repository.ts
+import { User } from '@/models/entities';
+import { PostgresDataSource } from '@/datasources';
+import { inject, repository, ReadableRepository } from '@venizia/ignis';
+
+@repository({ model: User, dataSource: PostgresDataSource })
+export class UserRepository extends ReadableRepository<typeof User.schema> {
   constructor(
-    // Inject the configured datasource
-    @inject({ key: 'datasources.PostgresDataSource' }) dataSource: IDataSource,
+    @inject({ key: 'datasources.PostgresDataSource' })
+    dataSource: PostgresDataSource,  // Must be concrete DataSource type, NOT 'any'
   ) {
-    // Pass the datasource, the model's Entity class, AND the relations definitions to the super constructor
-    super({ dataSource, entityClass: Configuration, relations: configurationRelations.definitions });
+    super(dataSource);
+  }
+
+  async findByRealm(realm: string) {
+    return this.findOne({ filter: { where: { realm } } });
   }
 }
 ```
+
+**Note:** When `@inject` is at param index 0, auto-injection is skipped (your `@inject` takes precedence).
+
 You would then register this repository in your `application.ts`: `this.repository(ConfigurationRepository);`
 
 ### Querying Data

package/wiki/get-started/quickstart.md

@@ -265,7 +265,7 @@ export class HelloController extends BaseController {
   })
   sayHello(c: Context) {
     // This looks just like Hono! Because it IS Hono under the hood.
-    return c.json({ message: 'Hello, World!' });
+    return c.json({ message: 'Hello, World!' }, HTTP.ResultCodes.RS_2.Ok);
   }
 
   // You can add more routes here: