@xeno-js/cli 0.1.0

package/src/infrastructure/generators/core/bootstrap.generator.ts

@@ -0,0 +1,118 @@
+import path from 'node:path'
+
+import { type IFileService, type IGenerator } from '../../../domain'
+import { CORE_CONSTANTS, type CoreOptions } from '../../../shared'
+
+export class BootstrapGenerator implements IGenerator<CoreOptions> {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(projectPath: string, options: CoreOptions): Promise<void> {
+    // Costruisce in modo flessibile i nodi di configurazione
+    let builderNodes = `
+  const builder = new AppBuilder<MyRegistry>()
+    .addContext()
+    .addMiddlewares((opts) => {
+      // Add your options here
+    })
+    .addPipeline((opts) => {
+      // Add your options here
+    })`
+
+    if (options.database !== CORE_CONSTANTS.NONE) {
+      if (options.database === CORE_CONSTANTS.DRIZZLE) {
+        builderNodes += `
+        .addDb((opts, config) => {
+          opts.enableSqlLite = false
+          opts.connectionString = config.getOrThrow('DATABASE_URL');
+        })`
+      } else if (options.database === CORE_CONSTANTS.SQL_LITE) {
+        builderNodes += `
+        .addDb((opts, config) => {
+          opts.enableSqlLite = true;
+          opts.connectionString = config.getOrThrow('SQLITE_DATABASE_URL');
+        })`
+      }
+    }
+
+    if (options.redis) {
+      builderNodes += `
+    .addCache((opts, config) => {
+      const isDev = config.get('NODE_ENV') === 'development';
+      opts.inMemory = isDev;
+      opts.redis = !isDev ? {
+        host: config.getOrThrow('REDIS_HOST'),
+        port: config.getNumber('REDIS_PORT') ?? 6379,
+        username: config.get('REDIS_USERNAME') ?? '',
+        password: config.get('REDIS_PASSWORD') ?? '',
+        tls: config.getBoolean('REDIS_TLS') ?? false,
+        maxRetriesPerRequest: 3
+      } : undefined
+    })`
+    } else {
+      // Default in-memory cache if no redis selected but CQRS pipeline exists
+      builderNodes += `
+    .addCache((opts) => {
+      opts.inMemory = true;
+    })`
+    }
+
+    if (options.supabase) {
+      builderNodes += `
+    .addAuth((opts, config) => {
+      opts.url = config.getOrThrow('SUPABASE_URL');
+      opts.key = config.getOrThrow('SUPABASE_KEY');
+    })`
+    }
+
+    if (options.pino || options.sentry) {
+      const pinoConfig = options.pino
+        ? `opts.pino.config = !isDev ? { env: config.getOrThrow('NODE_ENV'), destination: 'stdout', prettyPrint: false } : undefined;`
+        : ''
+      const sentryConfig = options.sentry
+        ? `opts.sentry.config = !isDev ? { dsn: config.getOrThrow('SENTRY_DSN'), environment: config.getOrThrow('NODE_ENV') } : undefined;`
+        : ''
+
+      builderNodes += `
+    .addLogger((opts, config) => {
+      const isDev = config.get('NODE_ENV') === 'development';
+      opts.level = LOG_LEVEL.INFO;
+      opts.console = isDev;
+      ${pinoConfig}
+      ${sentryConfig}
+    })`
+    }
+
+    builderNodes += `
+    .addServices((opts, config) => {
+      // Register custom repositories and handlers here
+    });`
+
+    const content = `import type { IServiceContainer } from '@xeno-js/core';
+import { AppBuilder, LOG_LEVEL, Nullable, TOKENS } from '@xeno-js/core';
+import type { MyRegistry } from './registry';
+
+let containerPromise: Nullable<Promise<IServiceContainer<MyRegistry>>> = null;
+
+export async function bootstrap() {
+  if (!containerPromise) {
+    containerPromise = (async () => {
+      const builder = getContainer();
+      return await builder.build();
+    })().catch((err) => {
+      containerPromise = null;
+      throw err;
+    });
+  }
+  return containerPromise;
+}
+
+function getContainer() {
+${builderNodes}
+  return builder;
+}
+`
+
+    const filePath = path.join(projectPath, 'src', 'bootstrap.ts')
+    await this._fileService.writeFileRecursive(filePath, content)
+  }
+}

package/src/infrastructure/generators/core/command/cqrs.generator.ts

@@ -0,0 +1,63 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import type { IFileService } from '../../../../domain'
+import { COMMAND_CONSTANTS, Guards, StringUtils } from '../../../../shared'
+
+export class CqrsGenerator {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(
+    targetDir: string,
+    name: string,
+    type: 'command' | 'query',
+    outputPath?: string,
+  ): Promise<void> {
+    const pascalName = StringUtils.pascalCase(name)
+    const tokenPrefix = StringUtils.splitCamelCaseWithUnderscore(pascalName).toUpperCase()
+    const lowerName = name.toLowerCase()
+    const destinationFolder = outputPath ?? lowerName
+    const componentDir = path.join(targetDir, 'src', destinationFolder)
+
+    let hasZod = false
+    let hasDrizzle = false
+
+    try {
+      const pkgJsonStr = await fs.readFile(path.join(targetDir, 'package.json'), 'utf8')
+      const pkgJson = JSON.parse(pkgJsonStr) as {
+        dependencies?: Record<string, string>
+        devDependencies?: Record<string, string>
+      }
+      const deps = { ...(pkgJson.dependencies ?? {}), ...(pkgJson.devDependencies ?? {}) }
+      hasZod = !!Guards.isDefined(deps['zod'])
+      hasDrizzle = !!Guards.isDefined(deps['drizzle-orm'])
+    } catch (error) {
+      console.warn(
+        '  Warning: Could not read package.json. Assuming Zod and Drizzle are not installed.',
+        error,
+      )
+    }
+
+    switch (type) {
+      case COMMAND_CONSTANTS.COMMAND: {
+        const { GenerateCommandCoreGenerator } = await import('./generate-command.generator.js')
+        const generator = new GenerateCommandCoreGenerator(this._fileService)
+        return generator.generate(
+          pascalName,
+          lowerName,
+          tokenPrefix,
+          componentDir,
+          hasZod,
+          hasDrizzle,
+        )
+      }
+      case COMMAND_CONSTANTS.QUERY: {
+        const { GenerateQueryCoreGenerator } = await import('./generate-query.generator.js')
+        const generatorQuery = new GenerateQueryCoreGenerator(this._fileService)
+        return generatorQuery.generate(pascalName, lowerName, tokenPrefix, componentDir, hasZod)
+      }
+      default:
+        throw new Error(`Unsupported generator type: '${String(type)}'. Use 'command' or 'query'.`)
+    }
+  }
+}

package/src/infrastructure/generators/core/command/generate-command.generator.ts

@@ -0,0 +1,191 @@
+import path from 'node:path'
+
+import type { IFileService } from '../../../../domain'
+
+export class GenerateCommandCoreGenerator {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(
+    pascalName: string,
+    lowerName: string,
+    tokenPrefix: string,
+    componentDir: string,
+    hasZod: boolean,
+    hasDrizzle: boolean,
+  ): Promise<void> {
+    // 1. Command
+    const commandContent = `import { Command } from '@xeno-js/core';
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ * Please replace <any> with your specific payload and response types.
+ */
+export class ${pascalName}Command extends Command<any> {
+    constructor(public readonly payload: any) {
+        super('${tokenPrefix}_COMMAND_HANDLER');
+    }
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.command.ts`),
+      commandContent,
+    )
+
+    // 2. Handler
+    const handlerContent = `import type { IFactory, ResultType, UserContext } from '@xeno-js/core';
+import { AppError, BaseHandler, Result } from '@xeno-js/core';
+import { ${pascalName}Command } from './${lowerName}.command';
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ * Please replace <any> with your specific response type.
+ */
+export class ${pascalName}Handler extends BaseHandler<${pascalName}Command, any> {
+    constructor(
+        identityFactory: IFactory<void, UserContext>
+    ) {
+        super(identityFactory);
+    }
+
+    public async executeAsync(request: ${pascalName}Command, singal: AbortSignal): Promise<ResultType<any>> {
+        // TODO: Implement your business logic here
+
+        return Result.ok();
+    }
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.handler.ts`),
+      handlerContent,
+    )
+
+    // 3. Controller
+    const controllerContent = `import type { IContextAccessor, IMediator, RequestContext, ResponseDto } from '@xeno-js/core';
+import { BaseController } from '@xeno-js/core';
+import { ${pascalName}Command } from './${lowerName}.command';
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ * Please replace <any, any> with your specific request and response types.
+ */
+export class ${pascalName}Controller extends BaseController<any, any> {
+    constructor(
+        requestContext: IContextAccessor<RequestContext>,
+        mediator: IMediator,
+    ) {
+        super(requestContext, mediator);
+    }
+
+    public async handle(request: any): Promise<ResponseDto<any>> {
+        const cmd = new ${pascalName}Command(request);
+        const result = await this._send(cmd);
+
+        if (!result.isOk()) {
+            return this.fail(result.getErrorOrThrow(), 'Error during ${pascalName} operation');
+        }
+
+        return this.ok(result.getValueOrThrow());
+    }
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.controller.ts`),
+      controllerContent,
+    )
+
+    // 4. Entity
+    const entityContent = `import { Entity } from '@xeno-js/core';
+
+export interface ${pascalName}Props {
+    // TODO: Define your entity properties
+}
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ * Adjust the properties and types according to your domain logic.
+ */
+export class ${pascalName} extends Entity<${pascalName}Props> {
+    private constructor(props: ${pascalName}Props, id?: string) {
+        super(props, id);
+    }
+
+    static create(props: ${pascalName}Props, id?: string): ${pascalName} {
+        return new ${pascalName}(props, id);
+    }
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.entity.ts`),
+      entityContent,
+    )
+
+    // 5. Schema Zod (Condizionale)
+    if (hasZod) {
+      const zodContent = `import { z } from 'zod';
+import { ZodUtils } from '@xeno-js/core';
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ * Define the actual Zod validation schema for your command payload.
+ */
+export const ${pascalName}Schema = ZodUtils.createCommandSchema({
+    payload: z.any() // TODO: Update with strict validation
+});
+`
+      await this._fileService.writeFileRecursive(
+        path.join(componentDir, `${lowerName}.schema-zod.ts`),
+        zodContent,
+      )
+    }
+
+    // 6. Schema DB (Condizionale)
+    if (hasDrizzle) {
+      const dbContent = `import { pgTable, text, timestamp } from 'drizzle-orm/pg-core';
+// Note: If you are using SQLite, change the import to 'drizzle-orm/sqlite-core' and update the table definition.
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ * Update the schema definition with your actual database columns.
+ */
+export const ${lowerName}s = pgTable('${lowerName}s', {
+    id: text('id').primaryKey(),
+    createdAt: timestamp('created_at').defaultNow(),
+    updatedAt: timestamp('updated_at').defaultNow().$onUpdate(() => new Date()),
+});
+
+export type ${pascalName}Dto = typeof ${lowerName}s.$inferSelect;
+export type New${pascalName}Dto = typeof ${lowerName}s.$inferInsert;
+`
+      await this._fileService.writeFileRecursive(
+        path.join(componentDir, `${lowerName}.schema-db.ts`),
+        dbContent,
+      )
+    }
+
+    // 7. Module
+    const moduleContent = `import type { IServiceContainer, IConfigurationService } from '@xeno-js/core';
+import { TOKENS } from '@xeno-js/core';
+import { ${pascalName}Controller } from './${lowerName}.controller';
+import { ${pascalName}Handler } from './${lowerName}.handler';
+
+export const ${pascalName}Module = Object.freeze({
+    register(opts: IServiceContainer<any>, _config: IConfigurationService): void {
+        opts.addTransient('${tokenPrefix}_COMMAND_CONTROLLER', (c) => new ${pascalName}Controller(c.resolve(TOKENS.REQUEST_CONTEXT), c.resolve(TOKENS.MEDIATOR)));
+        opts.addScoped('${tokenPrefix}_COMMAND_HANDLER', (c) => new ${pascalName}Handler(c.resolve(TOKENS.USER_CONTEXT_FACTORY)));
+
+        /*
+         * ⚠️ WARNING: ACTION REQUIRED ⚠️
+         * Please copy and paste the following tokens to your MyRegistry interface (usually in src/registry.ts):
+         *
+         * ${tokenPrefix}_COMMAND_CONTROLLER: IController<any, any>;
+         * ${tokenPrefix}_COMMAND_HANDLER: IHandler<${pascalName}Command, any>;
+         */
+    }
+} as const);
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.module.ts`),
+      moduleContent,
+    )
+  }
+}

package/src/infrastructure/generators/core/command/generate-query.generator.ts

@@ -0,0 +1,150 @@
+import path from 'node:path'
+
+import type { IFileService } from '../../../../domain'
+
+export class GenerateQueryCoreGenerator {
+  constructor(private readonly _fileService: IFileService) {}
+
+  public async generate(
+    pascalName: string,
+    lowerName: string,
+    tokenPrefix: string,
+    componentDir: string,
+    hasZod: boolean,
+  ): Promise<void> {
+    const queryContent = `import { BaseQuery } from '@xeno-js/core';
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ * Please replace <any> with your specific payload and response types.
+ */
+export class ${pascalName}Query extends BaseQuery<any> {
+    constructor(public readonly payload: any) {
+        super(
+            '${tokenPrefix}_QUERY_HANDLER', 
+            // Default cache options:
+            {
+                ttl: 60,
+                cacheKey: \`${lowerName}:\${JSON.stringify(payload)}\`,
+                bypassCache: false,
+                consistentRead: false
+                isUserScoped: false,
+            }
+        );
+    }
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.query.ts`),
+      queryContent,
+    )
+
+    // 2. Handler
+    const handlerContent = `import type { IFactory, ResultType, UserContext } from '@xeno-js/core';
+import { AppError, BaseHandler, Result } from '@xeno-js/core';
+import { ${pascalName}Query } from './${lowerName}.query';
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ * Please replace <any> with your specific response type.
+ */
+export class ${pascalName}Handler extends BaseHandler<${pascalName}Query, any> {
+    constructor(
+        identityFactory: IFactory<void, UserContext>
+        // TODO: Inject your ReadDao or DataSource here
+    ) {
+        super(identityFactory);
+    }
+
+    public async executeAsync(request: ${pascalName}Query, singal: AbortSignal): Promise<ResultType<any>> {
+        // TODO: Implement your query logic here
+
+        return Result.ok();
+    }
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.handler.ts`),
+      handlerContent,
+    )
+
+    // 3. Controller
+    const controllerContent = `import type { IContextAccessor, IMediator, RequestContext, ResponseDto } from '@xeno-js/core';
+import { BaseController } from '@xeno-js/core';
+import { ${pascalName}Query } from './${lowerName}.query';
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ * Please replace <any, any> with your specific request and response types.
+ */
+export class ${pascalName}Controller extends BaseController<any, any> {
+    constructor(
+        requestContext: IContextAccessor<RequestContext>,
+        mediator: IMediator,
+    ) {
+        super(requestContext, mediator);
+    }
+
+    public async handle(request: any): Promise<ResponseDto<any>> {
+        const query = new ${pascalName}Query(request);
+        const result = await this._query(query);
+
+        if (!result.isOk()) {
+            return this.fail(result.getErrorOrThrow(), 'Error during ${pascalName} operation');
+        }
+
+        return this.ok(result.getValueOrThrow());
+    }
+}
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.controller.ts`),
+      controllerContent,
+    )
+
+    // 4. Schema Zod
+    if (hasZod) {
+      const zodContent = `import { z } from 'zod';
+import { ZodUtils } from '@xeno-js/core';
+
+/*
+ * ⚠️ WARNING: ACTION REQUIRED ⚠️
+ * Define the actual Zod validation schema for your query payload.
+ */
+export const ${pascalName}Schema = ZodUtils.createQuerySchema({
+    payload: z.any() // TODO: Update with strict validation
+});
+`
+      await this._fileService.writeFileRecursive(
+        path.join(componentDir, `${lowerName}.schema-zod.ts`),
+        zodContent,
+      )
+    }
+
+    // 5. Module
+    const moduleContent = `import type { IServiceContainer, IConfigurationService } from '@xeno-js/core';
+import { TOKENS } from '@xeno-js/core';
+import { ${pascalName}Controller } from './${lowerName}.controller';
+import { ${pascalName}Handler } from './${lowerName}.handler';
+
+export const ${pascalName}Module = Object.freeze({
+    register(opts: IServiceContainer<any>, _config: IConfigurationService): void {
+        opts.addTransient('${tokenPrefix}_QUERY_CONTROLLER', (c) => new ${pascalName}Controller(c.resolve(TOKENS.REQUEST_CONTEXT), c.resolve(TOKENS.MEDIATOR)));
+        opts.addScoped('${tokenPrefix}_QUERY_HANDLER', (c) => new ${pascalName}Handler(c.resolve(TOKENS.USER_CONTEXT_FACTORY)));
+
+        /*
+         * ⚠️ WARNING: ACTION REQUIRED ⚠️
+         * Please copy and paste the following tokens to your MyRegistry interface (usually in src/registry.ts):
+         *
+         * ${tokenPrefix}_QUERY_CONTROLLER: IController<any, any>;
+         * ${tokenPrefix}_QUERY_HANDLER: IHandler<${pascalName}Query, any>;
+         */
+    }
+} as const);
+`
+    await this._fileService.writeFileRecursive(
+      path.join(componentDir, `${lowerName}.module.ts`),
+      moduleContent,
+    )
+  }
+}

package/src/infrastructure/generators/core/drizzle-sql-lite.generator.ts

@@ -0,0 +1,76 @@
+import path from 'node:path'
+
+import type { IFileService, IGenerator } from '../../../domain'
+import { type CoreOptions } from '../../../shared'
+
+/**
+ * @class DrizzleSqlLiteGenerator
+ * @description Generates a Drizzle configuration file (drizzle.config.ts) and a
+ * SQLite schema example (src/infrastructure/db/sqlite-schema.ts) when the user
+ * opts to use SQLite/libSQL instead of Postgres.
+ */
+export class DrizzleSqlLiteGenerator implements IGenerator<CoreOptions> {
+  constructor(private readonly _fileService: IFileService) {}
+
+  async generate(projectPath: string, _options: CoreOptions): Promise<void> {
+    const configContent = this.composeDrizzleConfig()
+    const filePath = path.join(projectPath, 'drizzle.config.ts')
+    await this._fileService.writeFileRecursive(filePath, configContent)
+
+    const schemaPath = path.join(projectPath, 'src', 'schema.ts')
+    const schemaContent = this.composeSchema()
+    await this._fileService.writeFileRecursive(schemaPath, schemaContent)
+  }
+
+  private composeDrizzleConfig(): string {
+    return `import 'dotenv/config';
+import { defineConfig } from 'drizzle-kit';
+
+/**
+ * Drizzle Kit configuration for SQLite / libSQL.
+ * Uses environment variable SQLITE_DATABASE_URL to locate the database.
+ */
+export default defineConfig({
+  schema: './src/schema.ts',
+  out: './drizzle',
+  dialect: 'sqlite',
+  dbCredentials: {
+    url: process.env.SQLITE_DATABASE_URL!,
+  },
+  verbose: true,
+  strict: true,
+});
+`
+  }
+
+  private composeSchema(): string {
+    return `import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core';
+
+ /**
+  * Example SQLite schema using Drizzle's libsql primitives.
+  * Place your application tables here (this file is scaffolded by the CLI when
+  * the user opts into SQLite support).
+  */
+ export const usersTable = sqliteTable('users', {
+   id: integer('id').primaryKey().notNull(),
+   name: text('name').notNull(),
+   description: text('description'),
+ });
+
+/**
+ * Types inferred from the schema.
+ * - UserDto: Represents the shape of the data retrieved from the database ($inferSelect).
+ * - NewUserDto: Represents the shape of the data required to insert a new record ($inferInsert).
+ */
+export type UserDto = typeof usersTable.$inferSelect;
+export type NewUserDto = typeof usersTable.$inferInsert;
+
+/**
+ * Centralized Database Schema dictionary.
+ */
+export type SqliteSchema = {
+  users: typeof usersTable;
+};
+`
+  }
+}

package/src/infrastructure/generators/core/drizzle.generator.ts

@@ -0,0 +1,86 @@
+import path from 'node:path'
+
+import type { IFileService, IGenerator } from '../../../domain'
+import { type CoreOptions } from '../../../shared'
+
+/**
+ * @class DrizzleGenerator
+ * @description Generates the Drizzle configuration file (drizzle.config.ts) and a basic schema file (src/schema.ts) for database scaffolding.
+ * The generator is only invoked if the user has opted to include database support in their project.
+ *
+ * @author Xeno
+ * @version 1.0.0
+ * @license ISC
+ * @since 2025-09-30
+ * @link https://github.com/xeno-js/xeno-js
+ */
+export class DrizzleGenerator implements IGenerator<CoreOptions> {
+  constructor(private readonly _fileService: IFileService) {}
+
+  async generate(projectPath: string, _options: CoreOptions): Promise<void> {
+    const configContent = this.composeDrizzleConfig()
+    const filePath = path.join(projectPath, 'drizzle.config.ts')
+    await this._fileService.writeFileRecursive(filePath, configContent)
+
+    const schemaContent = this.composeSchema()
+    await this._fileService.writeFileRecursive(
+      path.join(projectPath, 'src', 'schema.ts'),
+      schemaContent,
+    )
+  }
+
+  private composeDrizzleConfig(): string {
+    return `import 'dotenv/config';
+import { defineConfig } from 'drizzle-kit';
+
+/**
+ * Drizzle Kit configuration file.
+ * Defines the schema location, migration output directory, and database connection.
+ */
+export default defineConfig({
+  schema: './src/schema.ts',
+  out: './drizzle',
+  dialect: 'postgresql',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+  verbose: true,
+  strict: true,
+});
+`
+  }
+
+  private composeSchema(): string {
+    return `import { boolean, pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+
+/**
+ * @description Define your database tables here.
+ * The 'usersTable' serves as a baseline example. 
+ * You can add more tables, relations, and indexes according to your domain requirements.
+ */
+export const usersTable = pgTable('users', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  email: text('email').notNull().unique(),
+  isDeleted: boolean('is_deleted').notNull().default(false),
+  deletedAt: timestamp('deleted_at'),
+  createdAt: timestamp('created_at').defaultNow(),
+});
+
+/**
+ * Types inferred from the schema.
+ * - UserDto: Represents the shape of the data retrieved from the database ($inferSelect).
+ * - NewUserDto: Represents the shape of the data required to insert a new record ($inferInsert).
+ */
+export type UserDto = typeof usersTable.$inferSelect;
+export type NewUserDto = typeof usersTable.$inferInsert;
+
+/**
+ * Centralized Database Schema dictionary.
+ */
+export type DbSchema = {
+  users: typeof usersTable;
+};
+`
+  }
+}