@zintrust/core 0.1.0

package/src/cli/scaffolding/ResponseFactoryGenerator.js

@@ -0,0 +1,321 @@
+/**
+ * Response Factory Generator - Phase 7
+ * Generates response/output DTO factories with built-in validation
+ */
+import { FileGenerator } from '../scaffolding/FileGenerator';
+import { Logger } from '../../config/logger';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { fsPromises as fs } from '../../node-singletons/fs';
+import * as path from 'node:path';
+/**
+ * Validate response factory options
+ */
+export async function validateOptions(options) {
+    if (options.factoryName.trim() === '') {
+        throw ErrorFactory.createCliError('Response factory name is required');
+    }
+    if (options.responseName.trim() === '') {
+        throw ErrorFactory.createCliError('Response name is required');
+    }
+    if (options.factoriesPath === '') {
+        throw ErrorFactory.createCliError('Factories path is required');
+    }
+    // Verify factory path exists
+    const pathExists = await fs
+        .access(options.factoriesPath)
+        .then(() => true)
+        .catch(() => false);
+    if (!pathExists) {
+        throw ErrorFactory.createCliError(`Factories directory not found: ${options.factoriesPath}`);
+    }
+}
+/**
+ * Generate response factory
+ */
+export async function generate(options) {
+    try {
+        await validateOptions(options);
+        const factoryPath = path.join(options.factoriesPath, `${options.factoryName}.ts`);
+        const factoryCode = generateFactoryCode(options);
+        // Write factory file
+        FileGenerator.writeFile(factoryPath, factoryCode);
+        Logger.info(`✅ Generated response factory: ${options.factoryName}`);
+        // Generate response DTO if requested
+        let responsePath;
+        if (options.responsesPath !== undefined) {
+            responsePath = await generateResponseDTO(options);
+        }
+        return {
+            success: true,
+            factoryPath,
+            responsePath,
+            message: `Response factory '${options.factoryName}' generated successfully`,
+        };
+    }
+    catch (err) {
+        ErrorFactory.createTryCatchError('Response factory generation failed', err);
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            success: false,
+            factoryPath: '',
+            message: `Failed to generate response factory: ${message}`,
+        };
+    }
+}
+/**
+ * Generate factory methods (times, setState, make, makeMany, get, first)
+ */
+function generateFactoryMethods() {
+    return `      /**
+       * Generate multiple responses
+       */
+      times(count: number) {
+        recordCount = count;
+        return factory;
+      },
+
+      /**
+       * Set response state (success, error, partial)
+       */
+      setState(state: 'success' | 'error' | 'partial') {
+        responseState = state;
+        return factory;
+      },
+
+      /**
+       * Generate single response
+       */
+      make() {
+        return factory.generateResponse();
+      },
+
+      /**
+       * Generate multiple responses
+       */
+      makeMany() {
+        return Array.from({ length: recordCount }, () => factory.generateResponse());
+      },
+
+      /**
+       * Alias for makeMany()
+       */
+      get() {
+        return factory.makeMany();
+      },
+
+      /**
+       * Get first response
+       */
+      first() {
+        return factory.make();
+      },`;
+}
+/**
+ * Generate response generation method
+ */
+function generateResponseMethod(responseName, fields, responseType) {
+    return `      /**
+       * Generate response with state handling
+       */
+      generateResponse() {
+        const data: Record<string, unknown> = {
+${generateFieldAssignments(fields, responseType)}
+        };
+
+        // Apply state transformations
+        if (responseState === 'error') {
+          data.status = 'error';
+          data.errors = ['An error occurred'];
+        } else if (responseState === 'partial') {
+          // Set some fields to null/undefined for partial response testing
+          ${generatePartialFields(fields)}
+        }
+
+        return ${responseName}.create(data);
+      },`;
+}
+/**
+ * Generate response factory code
+ */
+function generateFactoryCode(options) {
+    const { factoryName, responseName, fields = [], responseType = 'success' } = options;
+    const helperMethods = generateHelperMethods(fields);
+    const dtoImport = options.responsesPath === undefined
+        ? `export const ${responseName} = {
+  create(data: Record<string, unknown> = {}) {
+    return { ...data };
+  }
+};`
+        : `import { ${responseName} } from '@app/Responses/${responseName}';`;
+    return `/**
+ * ${factoryName} - Response Factory
+ * Generates ${responseName} response instances for testing
+ *
+ * Response Type: ${responseType}
+ */
+
+import { faker } from '@faker-js/faker';
+
+${dtoImport}
+
+/**
+ * ${factoryName} - Generates response test data
+ */
+export const ${factoryName} = Object.freeze({
+  /**
+   * Create a new factory instance
+   */
+  new() {
+    let recordCount = 1;
+    let responseState = 'success';
+
+    const factory = {
+${generateFactoryMethods()}
+
+${generateResponseMethod(responseName, fields, responseType)}
+
+${helperMethods}
+    };
+
+    return factory;
+  }
+});
+
+export default ${factoryName};
+`;
+}
+/**
+ * Generate response DTO code
+ */
+async function generateResponseDTO(options) {
+    if (options.responsesPath === undefined) {
+        throw ErrorFactory.createCliError('Responses path is required');
+    }
+    const dtoPath = path.join(options.responsesPath, `${options.responseName}.ts`);
+    const dtoCode = `/**
+ * ${options.responseName} - Response DTO
+ * Serializes and validates API response data
+ *
+ * Type: ${options.responseType}
+ */
+
+export const ${options.responseName} = Object.freeze({
+  create(data: Record<string, unknown> = {}) {
+    const response = {
+      ...data,
+
+      /**
+       * Serialize to JSON
+       */
+      toJSON() {
+        const d = response as any;
+        return {
+${(options.fields ?? []).map((f) => `          ${f.name}: d.${f.name}`).join(',\n')}
+        };
+      },
+
+      /**
+       * Validate response
+       */
+      validate(): string[] {
+        const errors: string[] = [];
+        const d = response as any;
+
+${(options.fields ?? [])
+        .filter((f) => f.required === true)
+        .map((f) => `        if (d.${f.name} === undefined || d.${f.name} === null) {
+          errors.push('${f.name} is required');
+        }`)
+        .join('\n')}
+
+        return errors;
+      },
+    };
+
+    return response;
+  }
+};
+
+export default ${options.responseName};
+`;
+    FileGenerator.writeFile(dtoPath, dtoCode);
+    Logger.info(`✅ Generated response DTO: ${options.responseName}`);
+    return dtoPath;
+}
+/**
+ * Generate field assignments for the factory
+ */
+function generateFieldAssignments(fields, responseType) {
+    const assignments = fields.map((field) => {
+        let value = 'faker.lorem.word()';
+        if (field.type === 'email')
+            value = 'faker.internet.email()';
+        else if (field.type === 'number')
+            value = 'faker.number.int({ min: 1, max: 1000 })';
+        else if (field.type === 'boolean')
+            value = 'faker.datatype.boolean()';
+        else if (field.type === 'uuid')
+            value = 'faker.string.uuid()';
+        else if (field.type === 'date')
+            value = 'faker.date.recent().toISOString()';
+        else if (field.type === 'json')
+            value = '{ key: faker.lorem.word() }';
+        if (field.array === true) {
+            value = `Array.from({ length: 3 }, () => ${value})`;
+        }
+        return `          ${field.name}: ${value},`;
+    });
+    if (responseType === 'paginated') {
+        // Provide a minimal, predictable pagination shape for tests and examples.
+        if (!fields.some((f) => f.name === 'pagination')) {
+            assignments.push('          pagination: { page: 1, limit: 10, total: 100 },');
+        }
+        if (!fields.some((f) => f.name === 'items')) {
+            assignments.push('          items: [],');
+        }
+    }
+    if (responseType === 'success' && !fields.some((f) => f.name === 'status')) {
+        assignments.push("          status: 'success',");
+    }
+    return assignments.join('\n');
+}
+/**
+ * Generate partial field modifications
+ */
+function generatePartialFields(fields) {
+    return fields
+        .filter((f) => (f.required ?? false) !== true)
+        .map((f) => `data.${f.name} = null;`)
+        .join('\n          ');
+}
+/**
+ * Generate helper methods for the factory
+ */
+function generateHelperMethods(fields) {
+    return fields
+        .map((field) => `
+      /**
+       * Set ${field.name}
+       */
+      with${capitalizeType(field.name)}(value: any) {
+        return factory.generateResponse().then((res: any) => {
+          res.${field.name} = value;
+          return res;
+        });
+      },`)
+        .join('\n');
+}
+/**
+ * Capitalize type name
+ */
+function capitalizeType(type) {
+    return type.charAt(0).toUpperCase() + type.slice(1);
+}
+/**
+ * Response Factory Generator - Phase 7
+ * Generates response/output DTO factories with built-in validation
+ */
+export const ResponseFactoryGenerator = Object.freeze({
+    validateOptions,
+    generate,
+});

package/src/cli/scaffolding/RouteGenerator.d.ts

@@ -0,0 +1,66 @@
+/**
+ * RouteGenerator - Generate route files
+ * Creates route definitions with middleware and parameters
+ */
+export type RouteMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'resource';
+export interface RouteDefinition {
+    method: RouteMethod;
+    path: string;
+    controller: string;
+    action?: string;
+    middleware?: string[];
+    params?: string[];
+}
+export interface RouteOptions {
+    routesPath: string;
+    groupName?: string;
+    prefix?: string;
+    middleware?: string[];
+    routes: RouteDefinition[];
+    namespace?: string;
+}
+export interface RouteGeneratorResult {
+    success: boolean;
+    routeFile: string;
+    routeCount: number;
+    message: string;
+}
+/**
+ * Validate route options
+ */
+export declare function validateOptions(options: RouteOptions): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Generate route file
+ */
+export declare function generateRoutes(options: RouteOptions): Promise<RouteGeneratorResult>;
+/**
+ * Generate common API routes (User CRUD example)
+ */
+export declare function getUserApiRoutes(): RouteDefinition[];
+/**
+ * Generate common auth routes
+ */
+export declare function getAuthRoutes(): RouteDefinition[];
+/**
+ * Generate common admin routes
+ */
+export declare function getAdminRoutes(): RouteDefinition[];
+/**
+ * Get common HTTP methods
+ */
+export declare function getCommonMethods(): RouteMethod[];
+/**
+ * RouteGenerator creates route definitions
+ */
+export declare const RouteGenerator: Readonly<{
+    validateOptions: typeof validateOptions;
+    generateRoutes: typeof generateRoutes;
+    getUserApiRoutes: typeof getUserApiRoutes;
+    getAuthRoutes: typeof getAuthRoutes;
+    getAdminRoutes: typeof getAdminRoutes;
+    getCommonMethods: typeof getCommonMethods;
+}>;
+//# sourceMappingURL=RouteGenerator.d.ts.map

package/src/cli/scaffolding/RouteGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouteGenerator.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/RouteGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEnF,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,WAAW,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAqB3F;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA2CzF;AA+HD;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,EAAE,CAsCpD;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,eAAe,EAAE,CA6BjD;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,eAAe,EAAE,CA+BlD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,WAAW,EAAE,CAEhD;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;EAOzB,CAAC"}

package/src/cli/scaffolding/RouteGenerator.js

@@ -0,0 +1,306 @@
+/**
+ * RouteGenerator - Generate route files
+ * Creates route definitions with middleware and parameters
+ */
+import { FileGenerator } from '../scaffolding/FileGenerator';
+import { Logger } from '../../config/logger';
+import * as path from 'node:path';
+/**
+ * Validate route options
+ */
+export function validateOptions(options) {
+    const errors = [];
+    if (options.routesPath === '' || !FileGenerator.directoryExists(options.routesPath)) {
+        errors.push(`Routes directory does not exist: ${options.routesPath}`);
+    }
+    if (options.routes.length === 0) {
+        errors.push(`No routes provided`);
+    }
+    const validMethods = ['get', 'post', 'put', 'patch', 'delete', 'resource'];
+    const invalidRoutes = options.routes.filter((r) => !validMethods.includes(r.method));
+    if (invalidRoutes.length > 0) {
+        errors.push(`Invalid route methods. Supported: ${validMethods.join(', ')}`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Generate route file
+ */
+export async function generateRoutes(options) {
+    const validation = validateOptions(options);
+    if (!validation.valid) {
+        return {
+            success: false,
+            routeFile: '',
+            routeCount: 0,
+            message: `Validation failed: ${validation.errors.join(', ')}`,
+        };
+    }
+    try {
+        const routeContent = buildRouteWrapper(options);
+        const groupName = options.groupName ?? 'routes';
+        const routeFile = path.join(options.routesPath, `${groupName}.ts`);
+        const created = FileGenerator.writeFile(routeFile, routeContent);
+        if (!created) {
+            return {
+                success: false,
+                routeFile,
+                routeCount: 0,
+                message: `Failed to create route file`,
+            };
+        }
+        Logger.info(`✅ Generated routes: ${routeFile} (${options.routes.length} routes)`);
+        return {
+            success: true,
+            routeFile,
+            routeCount: options.routes.length,
+            message: `Routes created successfully`,
+        };
+    }
+    catch (error) {
+        Logger.error('Route generation failed', error);
+        return {
+            success: false,
+            routeFile: '',
+            routeCount: 0,
+            message: `Error: ${error.message}`,
+        };
+    }
+}
+/**
+ * Build route wrapper TypeScript code
+ */
+function buildRouteWrapper(options) {
+    const imports = buildImports(options);
+    const routeRegistration = buildRouteRegistration(options);
+    return `/**
+ * Routes
+ * Auto-generated route definitions
+ */
+
+${imports}
+
+export function registerRoutes(router: Router): void {
+${routeRegistration}
+}
+`;
+}
+/**
+ * Build import statements
+ */
+function buildImports(options) {
+    const imports = ['import { Router } from "../../routing/Router";'];
+    // Collect unique controllers
+    const controllers = new Set();
+    for (const route of options.routes) {
+        controllers.add(route.controller);
+    }
+    // Add controller imports
+    for (const controller of controllers) {
+        imports.push(`import { ${controller} } from '@app/Controllers/${controller}';`);
+    }
+    return imports.join('\n');
+}
+/**
+ * Build route registration code
+ */
+function buildRouteRegistration(options) {
+    let code = '';
+    // Add group if prefix or middleware provided
+    if (options.prefix !== undefined || options.middleware !== undefined) {
+        code += `  router.group({`;
+        const groupOptions = [];
+        if (options.prefix !== undefined) {
+            groupOptions.push(`    prefix: '${options.prefix}'`);
+        }
+        if (options.middleware !== undefined && options.middleware.length > 0) {
+            const middleware = options.middleware.map((m) => `'${m}'`).join(', ');
+            groupOptions.push(`    middleware: [${middleware}]`);
+        }
+        code += groupOptions.join(',\n') + '\n';
+        code += `  }, (r) => {\n`;
+        // Add routes inside group
+        for (const route of options.routes) {
+            code += buildRouteCode(route, 'r');
+        }
+        code += `  });\n`;
+    }
+    else {
+        // Add routes directly
+        for (const route of options.routes) {
+            code += buildRouteCode(route, 'router');
+        }
+    }
+    return code;
+}
+/**
+ * Build single route code
+ */
+function buildRouteCode(route, router) {
+    if (route.method === 'resource') {
+        return buildResourceRoute(route, router);
+    }
+    else {
+        return buildMethodRoute(route, router);
+    }
+}
+/**
+ * Build standard method route (GET, POST, etc.)
+ */
+function buildMethodRoute(route, router) {
+    const method = route.method;
+    const path = route.path;
+    const controller = route.controller;
+    const action = route.action ?? 'handle';
+    const middleware = route.middleware === undefined
+        ? ''
+        : (() => {
+            const middlewareList = route.middleware.map((m) => `'${m}'`).join(', ');
+            return `, { middleware: [${middlewareList}] }`;
+        })();
+    return `    ${router}.${method}('${path}', [${controller}, '${action}']${middleware});\n`;
+}
+/**
+ * Build resource route (RESTful CRUD)
+ */
+function buildResourceRoute(route, router) {
+    const path = route.path;
+    const controller = route.controller;
+    const middleware = route.middleware === undefined
+        ? ''
+        : (() => {
+            const middlewareList = route.middleware.map((m) => `'${m}'`).join(', ');
+            return `, { middleware: [${middlewareList}] }`;
+        })();
+    return `    ${router}.resource('${path}', ${controller}${middleware});\n`;
+}
+/**
+ * Generate common API routes (User CRUD example)
+ */
+export function getUserApiRoutes() {
+    return [
+        {
+            method: 'get',
+            path: '/users',
+            controller: 'UserController',
+            action: 'index',
+            middleware: ['auth'],
+        },
+        {
+            method: 'post',
+            path: '/users',
+            controller: 'UserController',
+            action: 'store',
+            middleware: ['auth'],
+        },
+        {
+            method: 'get',
+            path: '/users/:id',
+            controller: 'UserController',
+            action: 'show',
+            middleware: ['auth'],
+        },
+        {
+            method: 'put',
+            path: '/users/:id',
+            controller: 'UserController',
+            action: 'update',
+            middleware: ['auth'],
+        },
+        {
+            method: 'delete',
+            path: '/users/:id',
+            controller: 'UserController',
+            action: 'destroy',
+            middleware: ['auth'],
+        },
+    ];
+}
+/**
+ * Generate common auth routes
+ */
+export function getAuthRoutes() {
+    return [
+        {
+            method: 'post',
+            path: '/auth/login',
+            controller: 'AuthController',
+            action: 'login',
+        },
+        {
+            method: 'post',
+            path: '/auth/register',
+            controller: 'AuthController',
+            action: 'register',
+        },
+        {
+            method: 'post',
+            path: '/auth/logout',
+            controller: 'AuthController',
+            action: 'logout',
+            middleware: ['auth'],
+        },
+        {
+            method: 'post',
+            path: '/auth/refresh',
+            controller: 'AuthController',
+            action: 'refresh',
+            middleware: ['auth'],
+        },
+    ];
+}
+/**
+ * Generate common admin routes
+ */
+export function getAdminRoutes() {
+    return [
+        {
+            method: 'get',
+            path: '/dashboard',
+            controller: 'AdminController',
+            action: 'dashboard',
+            middleware: ['auth', 'admin'],
+        },
+        {
+            method: 'get',
+            path: '/users',
+            controller: 'AdminController',
+            action: 'users',
+            middleware: ['auth', 'admin'],
+        },
+        {
+            method: 'get',
+            path: '/analytics',
+            controller: 'AdminController',
+            action: 'analytics',
+            middleware: ['auth', 'admin'],
+        },
+        {
+            method: 'get',
+            path: '/logs',
+            controller: 'AdminController',
+            action: 'logs',
+            middleware: ['auth', 'admin'],
+        },
+    ];
+}
+/**
+ * Get common HTTP methods
+ */
+export function getCommonMethods() {
+    return ['get', 'post', 'put', 'patch', 'delete', 'resource'];
+}
+/**
+ * RouteGenerator creates route definitions
+ */
+export const RouteGenerator = Object.freeze({
+    validateOptions,
+    generateRoutes,
+    getUserApiRoutes,
+    getAuthRoutes,
+    getAdminRoutes,
+    getCommonMethods,
+});