@hazeljs/cli 0.5.4 → 0.6.0

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

@@ -1,43 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const commander_1 = require("commander");
-const generate_exception_filter_1 = require("./generate-exception-filter");
-jest.mock('fs');
-describe('generateExceptionFilter', () => {
-    const mockFs = fs_1.default;
-    let program;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.writeFileSync.mockImplementation(() => { });
-        jest.spyOn(console, 'log').mockImplementation();
-        program = new commander_1.Command();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it('should register the filter command with alias', () => {
-        (0, generate_exception_filter_1.generateExceptionFilter)(program);
-        const cmd = program.commands.find(c => c.name() === 'filter');
-        expect(cmd).toBeDefined();
-        expect(cmd?.alias()).toBe('f');
-    });
-    it('should generate a filter file with correct suffix', async () => {
-        (0, generate_exception_filter_1.generateExceptionFilter)(program);
-        await program.parseAsync(['node', 'test', 'filter', 'http']);
-        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('http.filter.ts'), expect.stringContaining('HttpExceptionFilter'));
-    });
-    it('should import correctly from @hazeljs/core', async () => {
-        (0, generate_exception_filter_1.generateExceptionFilter)(program);
-        await program.parseAsync(['node', 'test', 'filter', 'http']);
-        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
-        expect(writtenContent).toContain("from '@hazeljs/core'");
-        expect(writtenContent).toContain('Catch');
-        expect(writtenContent).toContain('logger');
-        expect(writtenContent).not.toContain("import logger from");
-    });
-});

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runGuard(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateGuard(program: Command): void;

package/dist/commands/generate-guard.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runGuard = runGuard;
-exports.generateGuard = generateGuard;
-const generator_1 = require("../utils/generator");
-const GUARD_TEMPLATE = `import { Injectable, type CanActivate, type 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 {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'guard';
-    }
-    getDefaultTemplate() {
-        return GUARD_TEMPLATE;
-    }
-}
-async function runGuard(name, options) {
-    const generator = new GuardGenerator();
-    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
-}
-function generateGuard(program) {
-    program
-        .command('guard <name>')
-        .description('Generate a new guard')
-        .alias('gu')
-        .option('-p, --path <path>', 'Path where the guard should be generated')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runGuard(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

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

@@ -1 +0,0 @@
-export {};

package/dist/commands/generate-guard.test.js

@@ -1,41 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const commander_1 = require("commander");
-const generate_guard_1 = require("./generate-guard");
-jest.mock('fs');
-describe('generateGuard', () => {
-    const mockFs = fs_1.default;
-    let program;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.writeFileSync.mockImplementation(() => { });
-        jest.spyOn(console, 'log').mockImplementation();
-        program = new commander_1.Command();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it('should register the guard command with alias', () => {
-        (0, generate_guard_1.generateGuard)(program);
-        const cmd = program.commands.find(c => c.name() === 'guard');
-        expect(cmd).toBeDefined();
-        expect(cmd?.alias()).toBe('gu');
-    });
-    it('should generate a guard file with correct suffix', async () => {
-        (0, generate_guard_1.generateGuard)(program);
-        await program.parseAsync(['node', 'test', 'guard', 'auth']);
-        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('auth.guard.ts'), expect.stringContaining('AuthGuard'));
-    });
-    it('should include CanActivate interface', async () => {
-        (0, generate_guard_1.generateGuard)(program);
-        await program.parseAsync(['node', 'test', 'guard', 'auth']);
-        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
-        expect(writtenContent).toContain('CanActivate');
-        expect(writtenContent).toContain('canActivate');
-    });
-});

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runInterceptor(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateInterceptor(program: Command): void;

package/dist/commands/generate-interceptor.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runInterceptor = runInterceptor;
-exports.generateInterceptor = generateInterceptor;
-const generator_1 = require("../utils/generator");
-const INTERCEPTOR_TEMPLATE = `import { Injectable, Interceptor, type 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)
-    return result;
-  }
-}
-`;
-class InterceptorGenerator extends generator_1.Generator {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'interceptor';
-    }
-    getDefaultTemplate() {
-        return INTERCEPTOR_TEMPLATE;
-    }
-}
-async function runInterceptor(name, options) {
-    const generator = new InterceptorGenerator();
-    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
-}
-function generateInterceptor(program) {
-    program
-        .command('interceptor <name>')
-        .description('Generate a new interceptor')
-        .alias('i')
-        .option('-p, --path <path>', 'Path where the interceptor should be generated')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runInterceptor(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

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

@@ -1 +0,0 @@
-export {};

package/dist/commands/generate-interceptor.test.js

@@ -1,41 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const commander_1 = require("commander");
-const generate_interceptor_1 = require("./generate-interceptor");
-jest.mock('fs');
-describe('generateInterceptor', () => {
-    const mockFs = fs_1.default;
-    let program;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.writeFileSync.mockImplementation(() => { });
-        jest.spyOn(console, 'log').mockImplementation();
-        program = new commander_1.Command();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it('should register the interceptor command with alias', () => {
-        (0, generate_interceptor_1.generateInterceptor)(program);
-        const cmd = program.commands.find(c => c.name() === 'interceptor');
-        expect(cmd).toBeDefined();
-        expect(cmd?.alias()).toBe('i');
-    });
-    it('should generate an interceptor file with correct suffix', async () => {
-        (0, generate_interceptor_1.generateInterceptor)(program);
-        await program.parseAsync(['node', 'test', 'interceptor', 'logging']);
-        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('logging.interceptor.ts'), expect.stringContaining('LoggingInterceptor'));
-    });
-    it('should implement the Interceptor interface', async () => {
-        (0, generate_interceptor_1.generateInterceptor)(program);
-        await program.parseAsync(['node', 'test', 'interceptor', 'logging']);
-        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
-        expect(writtenContent).toContain('implements Interceptor');
-        expect(writtenContent).toContain('intercept');
-    });
-});

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runMiddleware(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateMiddleware(command: Command): void;

package/dist/commands/generate-middleware.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runMiddleware = runMiddleware;
-exports.generateMiddleware = generateMiddleware;
-const generator_1 = require("../utils/generator");
-const MIDDLEWARE_TEMPLATE = `import { Injectable, type MiddlewareHandler, type Request, type Response, type NextFunction } from '@hazeljs/core';
-
-@Injectable()
-export class {{className}}Middleware implements MiddlewareHandler {
-  use(req: Request, res: Response, next: NextFunction) {
-    // Add your middleware logic here
-    console.log(\`[{{className}}Middleware] \${req.method} \${req.url}\`);
-    
-    // Continue to next middleware
-    next();
-  }
-}
-`;
-class MiddlewareGenerator extends generator_1.Generator {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'middleware';
-    }
-    getDefaultTemplate() {
-        return MIDDLEWARE_TEMPLATE;
-    }
-}
-async function runMiddleware(name, options) {
-    const generator = new MiddlewareGenerator();
-    const result = await generator.generate({ name, path: options.path, dryRun: options.dryRun });
-    result.nextSteps = result.nextSteps ?? [];
-    result.nextSteps.push('Import the middleware in your module or apply it globally.');
-    return result;
-}
-function generateMiddleware(command) {
-    command
-        .command('middleware <name>')
-        .alias('mw')
-        .description('Generate a middleware')
-        .option('-p, --path <path>', 'Specify the path', 'src/middleware')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runMiddleware(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

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

@@ -1 +0,0 @@
-export {};

package/dist/commands/generate-middleware.test.js

@@ -1,41 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const commander_1 = require("commander");
-const generate_middleware_1 = require("./generate-middleware");
-jest.mock('fs');
-describe('generateMiddleware', () => {
-    const mockFs = fs_1.default;
-    let program;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.writeFileSync.mockImplementation(() => { });
-        jest.spyOn(console, 'log').mockImplementation();
-        program = new commander_1.Command();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it('should register the middleware command with alias', () => {
-        (0, generate_middleware_1.generateMiddleware)(program);
-        const cmd = program.commands.find(c => c.name() === 'middleware');
-        expect(cmd).toBeDefined();
-        expect(cmd?.alias()).toBe('mw');
-    });
-    it('should generate a middleware file with correct suffix', async () => {
-        (0, generate_middleware_1.generateMiddleware)(program);
-        await program.parseAsync(['node', 'test', 'middleware', 'logger']);
-        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('logger.middleware.ts'), expect.stringContaining('LoggerMiddleware'));
-    });
-    it('should import from @hazeljs/core not express', async () => {
-        (0, generate_middleware_1.generateMiddleware)(program);
-        await program.parseAsync(['node', 'test', 'middleware', 'logger']);
-        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
-        expect(writtenContent).toContain("from '@hazeljs/core'");
-        expect(writtenContent).not.toContain("from 'express'");
-    });
-});

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runPipe(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generatePipe(program: Command): void;

package/dist/commands/generate-pipe.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runPipe = runPipe;
-exports.generatePipe = generatePipe;
-const generator_1 = require("../utils/generator");
-const PIPE_TEMPLATE = `import { type PipeTransform, type 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 {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'pipe';
-    }
-    getDefaultTemplate() {
-        return PIPE_TEMPLATE;
-    }
-}
-async function runPipe(name, options) {
-    const generator = new PipeGenerator();
-    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
-}
-function generatePipe(program) {
-    program
-        .command('pipe <name>')
-        .description('Generate a new pipe')
-        .option('-p, --path <path>', 'Path where the pipe should be generated')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runPipe(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

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

@@ -1 +0,0 @@
-export {};

package/dist/commands/generate-pipe.test.js

@@ -1,35 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const commander_1 = require("commander");
-const generate_pipe_1 = require("./generate-pipe");
-jest.mock('fs');
-describe('generatePipe', () => {
-    const mockFs = fs_1.default;
-    let program;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.writeFileSync.mockImplementation(() => { });
-        jest.spyOn(console, 'log').mockImplementation();
-        program = new commander_1.Command();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it('should generate a pipe file with correct suffix', async () => {
-        (0, generate_pipe_1.generatePipe)(program);
-        await program.parseAsync(['node', 'test', 'pipe', 'validation']);
-        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('validation.pipe.ts'), expect.stringContaining('ValidationPipe'));
-    });
-    it('should implement PipeTransform interface', async () => {
-        (0, generate_pipe_1.generatePipe)(program);
-        await program.parseAsync(['node', 'test', 'pipe', 'validation']);
-        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
-        expect(writtenContent).toContain('PipeTransform');
-        expect(writtenContent).toContain('transform');
-    });
-});

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runRag(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateRag(command: Command): void;

package/dist/commands/generate-rag.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runRag = runRag;
-exports.generateRag = generateRag;
-const generator_1 = require("../utils/generator");
-const RAG_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
-import { RAGPipeline, MemoryVectorStore } from '@hazeljs/rag';
-
-@Service()
-export class {{className}}RagService {
-  private pipeline: RAGPipeline;
-
-  constructor() {
-    // Initialize with a memory vector store (swap for Pinecone, Qdrant, etc. in production)
-    const vectorStore = new MemoryVectorStore();
-
-    this.pipeline = new RAGPipeline({
-      vectorStore,
-      topK: 5,
-    });
-  }
-
-  async addDocument(content: string, metadata?: Record<string, unknown>) {
-    // Add a document to the vector store for retrieval
-    await this.pipeline.addDocument({
-      content,
-      metadata: metadata || {},
-    });
-  }
-
-  async query(question: string) {
-    // Retrieve relevant documents and generate a response
-    const results = await this.pipeline.query(question);
-    return results;
-  }
-}
-`;
-class RagServiceGenerator extends generator_1.Generator {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'rag';
-    }
-    getDefaultTemplate() {
-        return RAG_SERVICE_TEMPLATE;
-    }
-}
-async function runRag(name, options) {
-    const generator = new RagServiceGenerator();
-    const result = await generator.generate({ name, path: options.path, dryRun: options.dryRun });
-    result.nextSteps = [
-        'npm install @hazeljs/rag',
-        'Register this service as a provider in your module',
-        'Configure your embedding provider and vector store',
-    ];
-    return result;
-}
-function generateRag(command) {
-    command
-        .command('rag <name>')
-        .description('Generate a RAG (Retrieval-Augmented Generation) service')
-        .option('-p, --path <path>', 'Specify the path')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runRag(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

package/dist/commands/generate-rag.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/generate-rag.test.js

@@ -1,35 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const commander_1 = require("commander");
-const generate_rag_1 = require("./generate-rag");
-jest.mock('fs');
-describe('generateRag', () => {
-    const mockFs = fs_1.default;
-    let program;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.writeFileSync.mockImplementation(() => { });
-        jest.spyOn(console, 'log').mockImplementation();
-        program = new commander_1.Command();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it('should generate a RAG service file', async () => {
-        (0, generate_rag_1.generateRag)(program);
-        await program.parseAsync(['node', 'test', 'rag', 'knowledge']);
-        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('knowledge.rag.ts'), expect.stringContaining('KnowledgeRagService'));
-    });
-    it('should import from @hazeljs/rag', async () => {
-        (0, generate_rag_1.generateRag)(program);
-        await program.parseAsync(['node', 'test', 'rag', 'knowledge']);
-        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
-        expect(writtenContent).toContain("from '@hazeljs/rag'");
-        expect(writtenContent).toContain('RAGPipeline');
-    });
-});

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runRepository(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateRepository(program: Command): void;

package/dist/commands/generate-repository.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runRepository = runRepository;
-exports.generateRepository = generateRepository;
-const generator_1 = require("../utils/generator");
-const REPOSITORY_TEMPLATE = `import { Repository, BaseRepository, PrismaService } from '@hazeljs/prisma';
-
-// @Repository implies @Injectable() — no need for both decorators
-@Repository({ model: '{{modelName}}' })
-export class {{className}}Repository extends BaseRepository<any> {
-  constructor(prisma: PrismaService) {
-    super(prisma, '{{modelName}}');
-  }
-
-  // Add custom repository methods here
-  async findByName(name: string) {
-    return this.findMany({ where: { name } });
-  }
-}
-`;
-class RepositoryGenerator extends generator_1.Generator {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'repository';
-    }
-    getDefaultTemplate() {
-        return REPOSITORY_TEMPLATE;
-    }
-}
-async function runRepository(name, options) {
-    const generator = new RepositoryGenerator();
-    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
-}
-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')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runRepository(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

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

@@ -1 +0,0 @@
-export {};

package/dist/commands/generate-repository.test.js

@@ -1,41 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const commander_1 = require("commander");
-const generate_repository_1 = require("./generate-repository");
-jest.mock('fs');
-describe('generateRepository', () => {
-    const mockFs = fs_1.default;
-    let program;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.writeFileSync.mockImplementation(() => { });
-        jest.spyOn(console, 'log').mockImplementation();
-        program = new commander_1.Command();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it('should register the repository command with alias', () => {
-        (0, generate_repository_1.generateRepository)(program);
-        const cmd = program.commands.find(c => c.name() === 'repository');
-        expect(cmd).toBeDefined();
-        expect(cmd?.alias()).toBe('repo');
-    });
-    it('should generate a repository file with correct suffix', async () => {
-        (0, generate_repository_1.generateRepository)(program);
-        await program.parseAsync(['node', 'test', 'repository', 'user']);
-        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('user.repository.ts'), expect.stringContaining('UserRepository'));
-    });
-    it('should import from @hazeljs/prisma', async () => {
-        (0, generate_repository_1.generateRepository)(program);
-        await program.parseAsync(['node', 'test', 'repository', 'user']);
-        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
-        expect(writtenContent).toContain("from '@hazeljs/prisma'");
-        expect(writtenContent).toContain('BaseRepository');
-    });
-});

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runServerlessHandler(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateServerlessHandler(program: Command): void;