@xeno-js/cli 0.1.0

package/dist/infrastructure/generators/core/bootstrap.generator.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BootstrapGenerator = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const shared_1 = require("../../../shared");
+class BootstrapGenerator {
+    _fileService;
+    constructor(_fileService) {
+        this._fileService = _fileService;
+    }
+    async generate(projectPath, options) {
+        // 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 !== shared_1.CORE_CONSTANTS.NONE) {
+            if (options.database === shared_1.CORE_CONSTANTS.DRIZZLE) {
+                builderNodes += `
+        .addDb((opts, config) => {
+          opts.enableSqlLite = false
+          opts.connectionString = config.getOrThrow('DATABASE_URL');
+        })`;
+            }
+            else if (options.database === shared_1.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 = node_path_1.default.join(projectPath, 'src', 'bootstrap.ts');
+        await this._fileService.writeFileRecursive(filePath, content);
+    }
+}
+exports.BootstrapGenerator = BootstrapGenerator;

package/dist/infrastructure/generators/core/command/cqrs.generator.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CqrsGenerator = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const shared_1 = require("../../../../shared");
+class CqrsGenerator {
+    _fileService;
+    constructor(_fileService) {
+        this._fileService = _fileService;
+    }
+    async generate(targetDir, name, type, outputPath) {
+        const pascalName = shared_1.StringUtils.pascalCase(name);
+        const tokenPrefix = shared_1.StringUtils.splitCamelCaseWithUnderscore(pascalName).toUpperCase();
+        const lowerName = name.toLowerCase();
+        const destinationFolder = outputPath ?? lowerName;
+        const componentDir = node_path_1.default.join(targetDir, 'src', destinationFolder);
+        let hasZod = false;
+        let hasDrizzle = false;
+        try {
+            const pkgJsonStr = await promises_1.default.readFile(node_path_1.default.join(targetDir, 'package.json'), 'utf8');
+            const pkgJson = JSON.parse(pkgJsonStr);
+            const deps = { ...(pkgJson.dependencies ?? {}), ...(pkgJson.devDependencies ?? {}) };
+            hasZod = !!shared_1.Guards.isDefined(deps['zod']);
+            hasDrizzle = !!shared_1.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 shared_1.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 shared_1.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'.`);
+        }
+    }
+}
+exports.CqrsGenerator = CqrsGenerator;

package/dist/infrastructure/generators/core/command/generate-command.generator.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateCommandCoreGenerator = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+class GenerateCommandCoreGenerator {
+    _fileService;
+    constructor(_fileService) {
+        this._fileService = _fileService;
+    }
+    async generate(pascalName, lowerName, tokenPrefix, componentDir, hasZod, hasDrizzle) {
+        // 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(node_path_1.default.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(node_path_1.default.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(node_path_1.default.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(node_path_1.default.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(node_path_1.default.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(node_path_1.default.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(node_path_1.default.join(componentDir, `${lowerName}.module.ts`), moduleContent);
+    }
+}
+exports.GenerateCommandCoreGenerator = GenerateCommandCoreGenerator;

package/dist/infrastructure/generators/core/command/generate-query.generator.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateQueryCoreGenerator = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+class GenerateQueryCoreGenerator {
+    _fileService;
+    constructor(_fileService) {
+        this._fileService = _fileService;
+    }
+    async generate(pascalName, lowerName, tokenPrefix, componentDir, hasZod) {
+        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(node_path_1.default.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(node_path_1.default.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(node_path_1.default.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(node_path_1.default.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(node_path_1.default.join(componentDir, `${lowerName}.module.ts`), moduleContent);
+    }
+}
+exports.GenerateQueryCoreGenerator = GenerateQueryCoreGenerator;

package/dist/infrastructure/generators/core/drizzle-sql-lite.generator.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrizzleSqlLiteGenerator = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * @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.
+ */
+class DrizzleSqlLiteGenerator {
+    _fileService;
+    constructor(_fileService) {
+        this._fileService = _fileService;
+    }
+    async generate(projectPath, _options) {
+        const configContent = this.composeDrizzleConfig();
+        const filePath = node_path_1.default.join(projectPath, 'drizzle.config.ts');
+        await this._fileService.writeFileRecursive(filePath, configContent);
+        const schemaPath = node_path_1.default.join(projectPath, 'src', 'schema.ts');
+        const schemaContent = this.composeSchema();
+        await this._fileService.writeFileRecursive(schemaPath, schemaContent);
+    }
+    composeDrizzleConfig() {
+        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,
+});
+`;
+    }
+    composeSchema() {
+        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;
+};
+`;
+    }
+}
+exports.DrizzleSqlLiteGenerator = DrizzleSqlLiteGenerator;

package/dist/infrastructure/generators/core/drizzle.generator.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrizzleGenerator = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * @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
+ */
+class DrizzleGenerator {
+    _fileService;
+    constructor(_fileService) {
+        this._fileService = _fileService;
+    }
+    async generate(projectPath, _options) {
+        const configContent = this.composeDrizzleConfig();
+        const filePath = node_path_1.default.join(projectPath, 'drizzle.config.ts');
+        await this._fileService.writeFileRecursive(filePath, configContent);
+        const schemaContent = this.composeSchema();
+        await this._fileService.writeFileRecursive(node_path_1.default.join(projectPath, 'src', 'schema.ts'), schemaContent);
+    }
+    composeDrizzleConfig() {
+        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,
+});
+`;
+    }
+    composeSchema() {
+        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;
+};
+`;
+    }
+}
+exports.DrizzleGenerator = DrizzleGenerator;