@hazeljs/cli 0.2.0-beta.1

package/dist/commands/generate-crud.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCrud = generateCrud;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const controllerTemplate = `import { Controller, Get, Post, Put, Delete, Body, Param } from '@hazeljs/core';
+import { {{className}}Service } from './{{fileName}}.service';
+import { Create{{className}}Dto, Update{{className}}Dto } from './dto/{{fileName}}.dto';
+
+@Controller('/{{routePath}}')
+export class {{className}}Controller {
+  constructor(private {{camelName}}Service: {{className}}Service) {}
+
+  @Get()
+  findAll() {
+    return this.{{camelName}}Service.findAll();
+  }
+
+  @Get('/:id')
+  findOne(@Param('id') id: string) {
+    return this.{{camelName}}Service.findOne(id);
+  }
+
+  @Post()
+  create(@Body() createDto: Create{{className}}Dto) {
+    return this.{{camelName}}Service.create(createDto);
+  }
+
+  @Put('/:id')
+  update(@Param('id') id: string, @Body() updateDto: Update{{className}}Dto) {
+    return this.{{camelName}}Service.update(id, updateDto);
+  }
+
+  @Delete('/:id')
+  delete(@Param('id') id: string) {
+    return this.{{camelName}}Service.delete(id);
+  }
+}
+`;
+const serviceTemplate = `import { Injectable } from '@hazeljs/core';
+import { Create{{className}}Dto, Update{{className}}Dto } from './dto/{{fileName}}.dto';
+
+@Injectable()
+export class {{className}}Service {
+  private {{camelName}}s: any[] = [];
+
+  findAll() {
+    return this.{{camelName}}s;
+  }
+
+  findOne(id: string) {
+    const {{camelName}} = this.{{camelName}}s.find(item => item.id === id);
+    if (!{{camelName}}) {
+      throw new Error('{{className}} not found');
+    }
+    return {{camelName}};
+  }
+
+  create(createDto: Create{{className}}Dto) {
+    const {{camelName}} = {
+      id: Date.now().toString(),
+      ...createDto,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+    this.{{camelName}}s.push({{camelName}});
+    return {{camelName}};
+  }
+
+  update(id: string, updateDto: Update{{className}}Dto) {
+    const index = this.{{camelName}}s.findIndex(item => item.id === id);
+    if (index === -1) {
+      throw new Error('{{className}} not found');
+    }
+    this.{{camelName}}s[index] = {
+      ...this.{{camelName}}s[index],
+      ...updateDto,
+      updatedAt: new Date(),
+    };
+    return this.{{camelName}}s[index];
+  }
+
+  delete(id: string) {
+    const index = this.{{camelName}}s.findIndex(item => item.id === id);
+    if (index === -1) {
+      throw new Error('{{className}} not found');
+    }
+    const deleted = this.{{camelName}}s.splice(index, 1);
+    return deleted[0];
+  }
+}
+`;
+const dtoTemplate = `import { IsString, IsOptional, IsNotEmpty } from 'class-validator';
+
+export class Create{{className}}Dto {
+  @IsString()
+  @IsNotEmpty()
+  name: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+}
+
+export class Update{{className}}Dto {
+  @IsString()
+  @IsOptional()
+  name?: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+}
+`;
+const moduleTemplate = `import { HazelModule } from '@hazeljs/core';
+import { {{className}}Controller } from './{{fileName}}.controller';
+import { {{className}}Service } from './{{fileName}}.service';
+
+@HazelModule({
+  controllers: [{{className}}Controller],
+  providers: [{{className}}Service],
+})
+export class {{className}}Module {}
+`;
+function toPascalCase(str) {
+    return str
+        .split(/[-_]/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+function toKebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+function toCamelCase(str) {
+    const pascal = toPascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function renderTemplate(template, data) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => data[key] || '');
+}
+function generateCrud(command) {
+    command
+        .command('crud <name>')
+        .description('Generate a complete CRUD resource (controller, service, module, DTOs)')
+        .option('-p, --path <path>', 'Specify the path', 'src')
+        .option('-r, --route <route>', 'Specify the route path')
+        .action((name, options) => {
+        const className = toPascalCase(name);
+        const fileName = toKebabCase(name);
+        const camelName = toCamelCase(name);
+        const routePath = options.route || fileName;
+        const basePath = path_1.default.join(process.cwd(), options.path || 'src', fileName);
+        const data = {
+            className,
+            fileName,
+            camelName,
+            routePath,
+        };
+        try {
+            // Create directory
+            if (!fs_1.default.existsSync(basePath)) {
+                fs_1.default.mkdirSync(basePath, { recursive: true });
+            }
+            // Create DTO directory
+            const dtoPath = path_1.default.join(basePath, 'dto');
+            if (!fs_1.default.existsSync(dtoPath)) {
+                fs_1.default.mkdirSync(dtoPath, { recursive: true });
+            }
+            // Generate controller
+            const controllerPath = path_1.default.join(basePath, `${fileName}.controller.ts`);
+            fs_1.default.writeFileSync(controllerPath, renderTemplate(controllerTemplate, data));
+            console.log(chalk_1.default.green(`✓ Generated ${controllerPath}`));
+            // Generate service
+            const servicePath = path_1.default.join(basePath, `${fileName}.service.ts`);
+            fs_1.default.writeFileSync(servicePath, renderTemplate(serviceTemplate, data));
+            console.log(chalk_1.default.green(`✓ Generated ${servicePath}`));
+            // Generate DTOs
+            const dtoFilePath = path_1.default.join(dtoPath, `${fileName}.dto.ts`);
+            fs_1.default.writeFileSync(dtoFilePath, renderTemplate(dtoTemplate, data));
+            console.log(chalk_1.default.green(`✓ Generated ${dtoFilePath}`));
+            // Generate module
+            const modulePath = path_1.default.join(basePath, `${fileName}.module.ts`);
+            fs_1.default.writeFileSync(modulePath, renderTemplate(moduleTemplate, data));
+            console.log(chalk_1.default.green(`✓ Generated ${modulePath}`));
+            console.log(chalk_1.default.blue('\n📦 CRUD resource generated successfully!'));
+            console.log(chalk_1.default.gray(`\nNext steps:`));
+            console.log(chalk_1.default.gray(`1. Import ${className}Module in your app module`));
+            console.log(chalk_1.default.gray(`2. Customize the DTOs in ${dtoFilePath}`));
+            console.log(chalk_1.default.gray(`3. Implement your business logic in ${servicePath}`));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error generating CRUD resource:'), error);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/generate-dto.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateDto(program: Command): void;

package/dist/commands/generate-dto.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDto = generateDto;
+const generator_1 = require("../utils/generator");
+const CREATE_DTO_TEMPLATE = `import { IsString, IsOptional } from 'class-validator';
+
+export class Create{{className}}Dto {
+  @IsString()
+  name: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+}
+`;
+const UPDATE_DTO_TEMPLATE = `import { PartialType } from '@hazeljs/core';
+import { Create{{className}}Dto } from './create-{{fileName}}.dto';
+
+export class Update{{className}}Dto extends PartialType(Create{{className}}Dto) {}
+`;
+class DtoGenerator extends generator_1.Generator {
+    getDefaultTemplate() {
+        return CREATE_DTO_TEMPLATE;
+    }
+    async generate(options) {
+        // Generate create DTO
+        const createDtoOptions = {
+            ...options,
+            template: CREATE_DTO_TEMPLATE,
+            path: options.path ? `${options.path}/dto` : 'src/dto',
+        };
+        await super.generate(createDtoOptions);
+        // Generate update DTO
+        const updateDtoOptions = {
+            ...options,
+            template: UPDATE_DTO_TEMPLATE,
+            path: options.path ? `${options.path}/dto` : 'src/dto',
+        };
+        await super.generate(updateDtoOptions);
+    }
+}
+function generateDto(program) {
+    program
+        .command('dto <name>')
+        .description('Generate create and update DTOs')
+        .option('-p, --path <path>', 'Path where the DTOs should be generated')
+        .action(async (name, options) => {
+        const generator = new DtoGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate(finalOptions);
+    });
+}

package/dist/commands/generate-exception-filter.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateExceptionFilter(program: Command): void;

package/dist/commands/generate-exception-filter.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateExceptionFilter = generateExceptionFilter;
+const generator_1 = require("../utils/generator");
+const EXCEPTION_FILTER_TEMPLATE = `import { Catch, ExceptionFilter, ArgumentsHost, HttpError } from '@hazeljs/core';
+import logger from '@hazeljs/core';
+
+@Catch(HttpError)
+export class {{className}}ExceptionFilter implements ExceptionFilter<HttpError> {
+  catch(exception: HttpError, host: ArgumentsHost): void {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+
+    const status = exception.statusCode || 500;
+    const message = exception.message || 'Internal server error';
+
+    logger.error(\`[\${request.method}] \${request.url} - \${message} (\${status})\`);
+
+    response.status(status).json({
+      statusCode: status,
+      message,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      ...(exception.errors && { errors: exception.errors }),
+    });
+  }
+}
+`;
+class ExceptionFilterGenerator extends generator_1.Generator {
+    getDefaultTemplate() {
+        return EXCEPTION_FILTER_TEMPLATE;
+    }
+}
+function generateExceptionFilter(program) {
+    program
+        .command('filter <name>')
+        .description('Generate a new exception filter')
+        .alias('f')
+        .option('-p, --path <path>', 'Path where the filter should be generated')
+        .action(async (name, options) => {
+        const generator = new ExceptionFilterGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate(finalOptions);
+    });
+}

package/dist/commands/generate-guard.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateGuard(program: Command): void;

package/dist/commands/generate-guard.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGuard = generateGuard;
+const generator_1 = require("../utils/generator");
+const GUARD_TEMPLATE = `import { Injectable, CanActivate, ExecutionContext } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Guard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    // Add your guard logic here
+    return true;
+  }
+}
+`;
+class GuardGenerator extends generator_1.Generator {
+    getDefaultTemplate() {
+        return GUARD_TEMPLATE;
+    }
+}
+function generateGuard(program) {
+    program
+        .command('guard <name>')
+        .description('Generate a new guard')
+        .option('-p, --path <path>', 'Path where the guard should be generated')
+        .action(async (name, options) => {
+        const generator = new GuardGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate(finalOptions);
+    });
+}

package/dist/commands/generate-interceptor.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateInterceptor(program: Command): void;

package/dist/commands/generate-interceptor.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInterceptor = generateInterceptor;
+const generator_1 = require("../utils/generator");
+const INTERCEPTOR_TEMPLATE = `import { Injectable, Interceptor, ExecutionContext } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Interceptor implements Interceptor {
+  async intercept(context: ExecutionContext, next: () => Promise<unknown>): Promise<unknown> {
+    // Pre-processing logic here (before handler execution)
+    const result = await next();
+    // Post-processing logic here (after handler execution)
+    // Transform the response data here
+    return result;
+  }
+}
+`;
+class InterceptorGenerator extends generator_1.Generator {
+    getDefaultTemplate() {
+        return INTERCEPTOR_TEMPLATE;
+    }
+}
+function generateInterceptor(program) {
+    program
+        .command('interceptor <name>')
+        .description('Generate a new interceptor')
+        .option('-p, --path <path>', 'Path where the interceptor should be generated')
+        .action(async (name, options) => {
+        const generator = new InterceptorGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate(finalOptions);
+    });
+}

package/dist/commands/generate-middleware.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateMiddleware(command: Command): void;

package/dist/commands/generate-middleware.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMiddleware = generateMiddleware;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const middlewareTemplate = `import { Request, Response, NextFunction } from 'express';
+import { Injectable } from '@hazeljs/core';
+
+@Injectable()
+export class {{className}}Middleware {
+  use(req: Request, res: Response, next: NextFunction) {
+    // Add your middleware logic here
+    console.log(\`[{{className}}Middleware] \${req.method} \${req.path}\`);
+    
+    // Example: Add custom header
+    res.setHeader('X-{{className}}', 'true');
+    
+    // Continue to next middleware
+    next();
+  }
+}
+`;
+function toPascalCase(str) {
+    return str
+        .split(/[-_]/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+function toKebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+function renderTemplate(template, data) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => data[key] || '');
+}
+function generateMiddleware(command) {
+    command
+        .command('middleware <name>')
+        .alias('mw')
+        .description('Generate a middleware')
+        .option('-p, --path <path>', 'Specify the path', 'src/middleware')
+        .action((name, options) => {
+        const className = toPascalCase(name);
+        const fileName = toKebabCase(name);
+        const filePath = path_1.default.join(process.cwd(), options.path || 'src/middleware', `${fileName}.middleware.ts`);
+        const data = {
+            className,
+            fileName,
+        };
+        try {
+            // Create directory if it doesn't exist
+            const dir = path_1.default.dirname(filePath);
+            if (!fs_1.default.existsSync(dir)) {
+                fs_1.default.mkdirSync(dir, { recursive: true });
+            }
+            // Generate middleware
+            fs_1.default.writeFileSync(filePath, renderTemplate(middlewareTemplate, data));
+            console.log(chalk_1.default.green(`✓ Generated ${filePath}`));
+            console.log(chalk_1.default.gray('\nUsage:'));
+            console.log(chalk_1.default.gray(`import { ${className}Middleware } from './${options.path?.replace('src/', '') || 'middleware'}/${fileName}.middleware';`));
+            console.log(chalk_1.default.gray(`\n// In your module:`));
+            console.log(chalk_1.default.gray(`@HazelModule({`));
+            console.log(chalk_1.default.gray(`  providers: [${className}Middleware],`));
+            console.log(chalk_1.default.gray(`})`));
+            console.log(chalk_1.default.gray(`\n// Or apply globally in main.ts:`));
+            console.log(chalk_1.default.gray(`app.use(new ${className}Middleware().use);`));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error generating middleware:'), error);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/generate-module.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateModule(program: Command): void;

package/dist/commands/generate-module.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModule = generateModule;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const generator_1 = require("../utils/generator");
+const MODULE_TEMPLATE = `import { HazelModule } from '@hazeljs/core';
+import { {{className}}Controller } from './{{fileName}}.controller';
+import { {{className}}Service } from './{{fileName}}.service';
+
+@HazelModule({
+  controllers: [{{className}}Controller],
+  providers: [{{className}}Service],
+})
+export class {{className}}Module {}
+`;
+const CONTROLLER_TEMPLATE = `import { Controller, Get, Post, Body } from '../../core/decorators';
+import { {{className}}Service } from './{{fileName}}.service';
+import { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';
+
+@Controller('/{{fileName}}')
+export class {{className}}Controller {
+  constructor(private readonly {{fileName}}Service: {{className}}Service) {}
+
+  @Get()
+  findAll() {
+    return this.{{fileName}}Service.findAll();
+  }
+
+  @Post()
+  create(@Body() createDto: Create{{className}}Dto) {
+    return this.{{fileName}}Service.create(createDto);
+  }
+}
+`;
+const SERVICE_TEMPLATE = `import { Injectable } from '../../core/decorators';
+import { Create{{className}}Dto } from './dto/create-{{fileName}}.dto';
+
+@Injectable()
+export class {{className}}Service {
+  private items = [];
+
+  findAll() {
+    return this.items;
+  }
+
+  create(dto: Create{{className}}Dto) {
+    this.items.push(dto);
+    return dto;
+  }
+}
+`;
+const CREATE_DTO_TEMPLATE = `export class Create{{className}}Dto {
+  // Add your properties here
+  name: string;
+}
+`;
+const UPDATE_DTO_TEMPLATE = `export class Update{{className}}Dto {
+  // Add your properties here
+  name?: string;
+}
+`;
+class FullModuleGenerator extends generator_1.Generator {
+    async generate(options) {
+        const { name, path: customPath } = options;
+        const className = this.toPascalCase(name);
+        const fileName = this.toKebabCase(name);
+        const baseDir = path_1.default.join(process.cwd(), customPath || 'src', fileName);
+        // Create module directory and dto subdirectory
+        fs_1.default.mkdirSync(baseDir, { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(baseDir, 'dto'), { recursive: true });
+        // Generate files
+        fs_1.default.writeFileSync(path_1.default.join(baseDir, `${fileName}.module.ts`), this.render(MODULE_TEMPLATE, { className, fileName }));
+        fs_1.default.writeFileSync(path_1.default.join(baseDir, `${fileName}.controller.ts`), this.render(CONTROLLER_TEMPLATE, { className, fileName }));
+        fs_1.default.writeFileSync(path_1.default.join(baseDir, `${fileName}.service.ts`), this.render(SERVICE_TEMPLATE, { className, fileName }));
+        fs_1.default.writeFileSync(path_1.default.join(baseDir, 'dto', `create-${fileName}.dto.ts`), this.render(CREATE_DTO_TEMPLATE, { className, fileName }));
+        fs_1.default.writeFileSync(path_1.default.join(baseDir, 'dto', `update-${fileName}.dto.ts`), this.render(UPDATE_DTO_TEMPLATE, { className, fileName }));
+        console.log(`✓ Generated module in ${baseDir}`);
+    }
+    render(template, data) {
+        return template.replace(/{{(\w+)}}/g, (_, key) => data[key] || '');
+    }
+}
+function generateModule(program) {
+    program
+        .command('module <name>')
+        .description('Generate a new module (with controller, service, DTOs)')
+        .option('-p, --path <path>', 'Path where the module should be generated')
+        .action(async (name, options) => {
+        const generator = new FullModuleGenerator();
+        await generator.generate({ name, path: options.path });
+    });
+}

package/dist/commands/generate-pipe.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generatePipe(program: Command): void;

package/dist/commands/generate-pipe.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePipe = generatePipe;
+const generator_1 = require("../utils/generator");
+const PIPE_TEMPLATE = `import { PipeTransform, RequestContext } from '@hazeljs/core';
+
+export class {{className}}Pipe implements PipeTransform {
+  transform(value: unknown, context: RequestContext): unknown {
+    // Transform logic here
+    return value;
+  }
+}
+`;
+class PipeGenerator extends generator_1.Generator {
+    getDefaultTemplate() {
+        return PIPE_TEMPLATE;
+    }
+}
+function generatePipe(program) {
+    program
+        .command('pipe <name>')
+        .description('Generate a new pipe')
+        .option('-p, --path <path>', 'Path where the pipe should be generated')
+        .action(async (name, options) => {
+        const generator = new PipeGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate(finalOptions);
+    });
+}

package/dist/commands/generate-repository.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateRepository(program: Command): void;

package/dist/commands/generate-repository.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRepository = generateRepository;
+const generator_1 = require("../utils/generator");
+const REPOSITORY_TEMPLATE = `import { Injectable } from '@hazeljs/core';
+import { BaseRepository, PrismaService, PrismaModel } from '@hazeljs/prisma';
+
+@Injectable()
+export class {{className}}Repository extends BaseRepository<PrismaModel> {
+  constructor(prisma: PrismaService) {
+    // Replace 'modelName' with your actual Prisma model name
+    super(prisma.modelName as unknown as { findMany: () => Promise<PrismaModel[]>; findUnique: (args: { where: { id?: number } }) => Promise<PrismaModel | null>; create: (args: { data: unknown }) => Promise<PrismaModel>; update: (args: { where: { id?: number }; data: unknown }) => Promise<PrismaModel>; delete: (args: { where: { id?: number } }) => Promise<PrismaModel>; count: (args?: unknown) => Promise<number> });
+  }
+
+  // Add custom repository methods here
+}
+`;
+class RepositoryGenerator extends generator_1.Generator {
+    getDefaultTemplate() {
+        return REPOSITORY_TEMPLATE;
+    }
+}
+function generateRepository(program) {
+    program
+        .command('repository <name>')
+        .description('Generate a new Prisma repository')
+        .alias('repo')
+        .option('-p, --path <path>', 'Path where the repository should be generated')
+        .action(async (name, options) => {
+        const generator = new RepositoryGenerator();
+        const generatorOptions = {
+            name,
+            path: options.path,
+        };
+        const finalOptions = await generator.promptForOptions(generatorOptions);
+        await generator.generate(finalOptions);
+    });
+}

package/dist/commands/generate-serverless-handler.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function generateServerlessHandler(program: Command): void;