@zintrust/core 0.1.28 → 0.1.29

package/src/cli/scaffolding/SeederGenerator.js

@@ -0,0 +1,334 @@
+/**
+ * Seeder Generator - Phase 6.2
+ * Generates database seeders for populating development/staging databases
+ * Uses factory generators for consistent data generation
+ */
+import { FileGenerator } from '../scaffolding/FileGenerator.js';
+import { CommonUtils } from '../../common/index.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { fsPromises as fs } from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+/**
+ * Seeder Generator - Creates database seeders using factory classes
+ * Enables rapid database population for development and staging
+ */
+/**
+ * Validate seeder options
+ */
+export async function validateOptions(options) {
+    if (options.seederName === undefined || options.seederName.trim() === '') {
+        throw ErrorFactory.createCliError('Seeder name is required');
+    }
+    if (!options.seederName.endsWith('Seeder')) {
+        throw ErrorFactory.createCliError('Seeder name must end with "Seeder" (e.g., UserSeeder)');
+    }
+    if (!/^[A-Z][a-zA-Z\d]*Seeder$/.test(options.seederName)) {
+        throw ErrorFactory.createCliError('Seeder name must be PascalCase ending with "Seeder"');
+    }
+    if (options.modelName === undefined || options.modelName.trim() === '') {
+        throw ErrorFactory.createCliError('Model name is required');
+    }
+    if (!/^[A-Z][a-zA-Z\d]*$/.test(options.modelName)) {
+        throw ErrorFactory.createCliError('Model name must be PascalCase (e.g., User, Post)');
+    }
+    if (options.count !== undefined && (options.count < 1 || options.count > 100000)) {
+        throw ErrorFactory.createCliError('Count must be between 1 and 100000');
+    }
+    await assertDirectoryExists(options.seedersPath, 'Seeders path');
+}
+/**
+ * Generate a database seeder
+ */
+export async function generateSeeder(options) {
+    try {
+        await validateOptions(options);
+        const seederCode = buildSeederCode(options);
+        const fileName = `${options.seederName}.ts`;
+        const filePath = path.join(options.seedersPath, fileName);
+        FileGenerator.writeFile(filePath, seederCode, { overwrite: true });
+        Logger.info(`✅ Created seeder: ${fileName}`);
+        return {
+            success: true,
+            filePath,
+            message: `Seeder '${options.seederName}' created successfully`,
+        };
+    }
+    catch (error) {
+        Logger.error('Seeder generation failed', error);
+        return {
+            success: false,
+            filePath: '',
+            message: error.message,
+        };
+    }
+}
+async function validateDatabaseSeederOptions(options) {
+    await assertDirectoryExists(options.seedersPath, 'Seeders path');
+}
+async function assertDirectoryExists(dirPath, label) {
+    const pathStat = await fs.stat(dirPath).catch(() => null);
+    if (pathStat === null) {
+        throw ErrorFactory.createCliError(`${label} does not exist: ${dirPath}`);
+    }
+    if (!pathStat.isDirectory()) {
+        throw ErrorFactory.createCliError(`${label} is not a directory: ${dirPath}`);
+    }
+}
+export async function generateDatabaseSeeder(options) {
+    try {
+        await validateDatabaseSeederOptions(options);
+        const seederCode = buildDatabaseSeederCode();
+        const fileName = 'DatabaseSeeder.ts';
+        const filePath = path.join(options.seedersPath, fileName);
+        FileGenerator.writeFile(filePath, seederCode, { overwrite: true });
+        Logger.info(`✅ Created seeder: ${fileName}`);
+        return {
+            success: true,
+            filePath,
+            message: `Seeder '${fileName}' created successfully`,
+        };
+    }
+    catch (error) {
+        Logger.error('DatabaseSeeder generation failed', error);
+        return {
+            success: false,
+            filePath: '',
+            message: error.message,
+        };
+    }
+}
+function buildDatabaseSeederCode() {
+    return `import { SeederDiscovery } from '../../seeders/SeederDiscovery';
+import { SeederLoader } from '../../seeders/SeederLoader';
+import { CommonUtils } from '../../common/index';
+import type { IDatabase } from '../../orm/Database';
+import * as path from '../../node-singletons/path';
+
+export const DatabaseSeeder = Object.freeze({
+  async run(db: IDatabase): Promise<void> {
+    const dir = CommonUtils.esmDirname(import.meta.url);
+    const files = SeederDiscovery.listSeederFiles(dir).filter((filePath) => {
+      const base = path.basename(filePath, path.extname(filePath));
+      return base !== 'DatabaseSeeder';
+    });
+
+    for (const filePath of files) {
+      const loaded = await SeederLoader.load(filePath);
+      await loaded.run(db);
+    }
+  },
+});
+`;
+}
+/**
+ * Build complete seeder code
+ */
+function buildSeederCode(options) {
+    const imports = buildImports(options);
+    const className = options.seederName;
+    const count = options.count ?? 10;
+    const truncate = options.truncate === false ? 'false' : 'true';
+    const relationshipMethods = buildRelationshipMethods(options);
+    return `/**
+ * ${className}
+ * Seeder for populating ${options.modelName} table with test data
+ */
+
+${imports}
+
+export const ${className} = Object.freeze({
+${buildSeederObjectBody(options, count, truncate, relationshipMethods)}
+});
+`;
+}
+/**
+ * Build seeder object body
+ */
+function buildSeederObjectBody(options, count, truncate, relationshipMethods) {
+    const factoryName = getFactoryName(options);
+    const modelLower = options.modelName.toLowerCase();
+    return `${buildSeederRunMethod(options, count, truncate, factoryName, modelLower)},
+
+${buildSeederGetRecordsMethod(factoryName)},
+
+${buildSeederWithStatesMethod(options, count, factoryName, modelLower)},
+
+${buildSeederWithRelationshipsMethod(options, count, factoryName, modelLower, relationshipMethods)},
+
+${buildSeederResetMethod(options)}`;
+}
+/**
+ * Build seeder run method
+ */
+function buildSeederRunMethod(options, count, truncate, factoryName, modelLower) {
+    const tableName = getTableName(options.modelName);
+    return `  /**
+   * Run the seeder
+   * Populates the ${modelLower} table with ${count} records
+   */
+  async run(): Promise<void> {
+    const count = ${count};
+    const factory = ${factoryName}.new();
+
+    // Optionally truncate the table before seeding
+    if (${truncate}) {
+      // await Table.query().delete();
+      // Or use: await database.raw('TRUNCATE TABLE ${tableName}');
+    }
+
+    // Generate and create records
+    const records = factory.count(count);
+
+    for (const record of records) {
+      // Insert using Query Builder (recommended)
+      // await ${options.modelName}.create(record);
+    }
+
+    Logger.info(\`✅ Seeded \${count} ${modelLower} records\`);
+  }`;
+}
+/**
+ * Build seeder getRecords method
+ */
+function buildSeederGetRecordsMethod(factoryName) {
+    return `  /**
+   * Get records from this seeder
+   */
+  async getRecords(count: number): Promise<Record<string, unknown>[]> {
+    const factory = ${factoryName}.new();
+    return factory.count(count);
+  }`;
+}
+/**
+ * Build seeder with states method
+ */
+function buildSeederWithStatesMethod(options, count, factoryName, modelLower) {
+    return `  /**
+   * Seed with specific states
+   */
+  async seedWithStates(): Promise<void> {
+    const factory = ${factoryName}.new();
+
+    // Create active records (50%)
+    const active = factory.state('active').count(Math.ceil(${count} * 0.5));
+    for (const record of active) {
+      // await ${options.modelName}.create(record);
+    }
+
+    // Create inactive records (30%)
+    const inactive = factory.state('inactive').count(Math.ceil(${count} * 0.3));
+    for (const record of inactive) {
+      // await ${options.modelName}.create(record);
+    }
+
+    // Create deleted records (20%)
+    const deleted = factory.state('deleted').count(Math.ceil(${count} * 0.2));
+    for (const record of deleted) {
+      // await ${options.modelName}.create(record);
+    }
+
+    Logger.info(\`✅ Seeded ${count} ${modelLower} records with state distribution\`);
+  }`;
+}
+/**
+ * Build seeder with relationships method
+ */
+function buildSeederWithRelationshipsMethod(_options, count, factoryName, modelLower, relationshipMethods) {
+    return `  /**
+   * Seed with relationships
+   */
+  async seedWithRelationships(): Promise<void> {
+    const factory = ${factoryName}.new();
+
+${relationshipMethods}
+
+    Logger.info(\`✅ Seeded ${count} ${modelLower} records with relationships\`);
+  }`;
+}
+/**
+ * Build seeder reset method
+ */
+function buildSeederResetMethod(options) {
+    const tableName = getTableName(options.modelName);
+    return `  /**
+   * Reset seeder (truncate table)
+   */
+  async reset(): Promise<void> {
+    // await database.raw('TRUNCATE TABLE ${tableName}');
+    Logger.info(\`✅ Truncated ${tableName} table\`);
+  }`;
+}
+/**
+ * Build import statements
+ */
+function buildImports(options) {
+    const factoryName = getFactoryName(options);
+    return `import { Logger } from '../../config/logger';
+import { ${factoryName} } from '@database/factories/${factoryName}';
+import { ${options.modelName} } from '@app/Models/${options.modelName}';`;
+}
+/**
+ * Build relationship seeding methods
+ */
+function buildRelationshipMethods(options) {
+    if (options.relationships === undefined || options.relationships.length === 0) {
+        return `    const records = factory.count(${options.count ?? 10});
+
+    // Create records with relationships (implement as needed)
+    for (const record of records) {
+      // await ${options.modelName}.create(record);
+    }`;
+    }
+    const relationshipCode = options.relationships
+        .map((rel) => {
+        const relId = `${CommonUtils.camelCase(rel)}Id`;
+        return `    // Seed with ${rel} relationships
+    const ${CommonUtils.camelCase(rel)}s = await ${rel}.all();
+    if (${CommonUtils.camelCase(rel)}s.length > 0) {
+      const records = factory.count(Math.min(${options.count ?? 10}, ${CommonUtils.camelCase(rel)}s.length));
+
+      for (let i = 0; i < records.length; i++) {
+        (records[i] as Record<string, unknown>).${relId} = (${CommonUtils.camelCase(rel)}s[i] as { id?: unknown }).id;
+        // await ${options.modelName}.create(records[i]);
+      }
+    }`;
+    })
+        .join('\n\n');
+    return relationshipCode;
+}
+/**
+ * Get factory name from model name
+ */
+function getFactoryName(options) {
+    return options.factoryName ?? `${options.modelName}Factory`;
+}
+/**
+ * Get database table name from model name
+ */
+function getTableName(modelName) {
+    // Convert PascalCase to snake_case
+    return (modelName
+        .replaceAll(/([A-Z])/g, '_$1')
+        .toLowerCase()
+        .replace(/^_/, '') + 's');
+}
+/**
+ * Get available seeder options
+ */
+export function getAvailableOptions() {
+    return [
+        'Truncate table before seeding (default: true)',
+        'Custom record count (default: 10, max: 100000)',
+        'Relationship seeding',
+        'State-based distribution (active, inactive, deleted)',
+        'Batch operations for large datasets',
+    ];
+}
+export const SeederGenerator = Object.freeze({
+    validateOptions,
+    generateSeeder,
+    generateDatabaseSeeder,
+    getAvailableOptions,
+});
+export default SeederGenerator;

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

@@ -0,0 +1,40 @@
+/**
+ * Service Integration Test Generator
+ * Generates integration tests for service-to-service communication
+ */
+export interface ServiceEndpoint {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    name: string;
+    description?: string;
+}
+export interface ServiceIntegrationTestOptions {
+    name: string;
+    serviceName: string;
+    baseUrl?: string;
+    endpoints: ServiceEndpoint[];
+    authType?: 'none' | 'api-key' | 'jwt';
+    consumerService?: string;
+    testPath: string;
+}
+export interface ServiceIntegrationTestResult {
+    success: boolean;
+    testFile: string;
+    message: string;
+}
+/**
+ * Validate integration test options
+ */
+export declare function validateOptions(options: ServiceIntegrationTestOptions): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Generate service integration tests
+ */
+export declare function generateIntegrationTest(options: ServiceIntegrationTestOptions): Promise<ServiceIntegrationTestResult>;
+export declare const ServiceIntegrationTestGenerator: Readonly<{
+    validateOptions: typeof validateOptions;
+    generateIntegrationTest: typeof generateIntegrationTest;
+}>;
+//# sourceMappingURL=ServiceIntegrationTestGenerator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceIntegrationTestGenerator.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/ServiceIntegrationTestGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,6BAA6B,GAAG;IACvE,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAuBA;AAED;;GAEG;AAEH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,4BAA4B,CAAC,CAuBvC;AA4ND,eAAO,MAAM,+BAA+B;;;EAG1C,CAAC"}

package/src/cli/scaffolding/ServiceIntegrationTestGenerator.js

@@ -0,0 +1,268 @@
+/**
+ * Service Integration Test Generator
+ * Generates integration tests for service-to-service communication
+ */
+import { FileGenerator } from '../scaffolding/FileGenerator.js';
+import { CommonUtils } from '../../common/index.js';
+import { Logger } from '../../config/logger.js';
+import * as path from '../../node-singletons/path.js';
+/**
+ * Validate integration test options
+ */
+export function validateOptions(options) {
+    const errors = [];
+    if (options.name === undefined || options.name.trim() === '') {
+        errors.push('Integration test name is required');
+    }
+    else if (!/^[A-Z][a-zA-Z\d]*Service$/.test(options.name)) {
+        errors.push('Integration test name must be PascalCase and end with Service');
+    }
+    if (options.serviceName === undefined || options.serviceName.trim() === '') {
+        errors.push('Service name is required');
+    }
+    else if (!/^[a-z\d-]+$/.test(options.serviceName)) {
+        errors.push('Service name must be lowercase alphanumeric with hyphens');
+    }
+    if (options.endpoints === undefined || options.endpoints.length === 0) {
+        errors.push('At least one endpoint is required');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Generate service integration tests
+ */
+// eslint-disable-next-line @typescript-eslint/promise-function-async
+export function generateIntegrationTest(options) {
+    try {
+        const testCode = buildTestCode(options);
+        const fileName = `${CommonUtils.camelCase(options.name)}.test.ts`;
+        const filePath = path.join(options.testPath, fileName);
+        FileGenerator.writeFile(filePath, testCode, { overwrite: true });
+        Logger.info(`✅ Created service integration test: ${fileName}`);
+        return Promise.resolve({
+            success: true,
+            testFile: filePath,
+            message: `Service integration test '${options.name}' created successfully`,
+        });
+    }
+    catch (error) {
+        Logger.error('Service integration test generation failed', error);
+        return Promise.resolve({
+            success: false,
+            testFile: '',
+            message: error.message,
+        });
+    }
+}
+/**
+ * Build complete test code
+ */
+function buildTestCode(options) {
+    const baseUrl = getBaseUrl(options);
+    const endpointTests = buildEndpointTests(options);
+    const consumerNote = getConsumerNote(options);
+    return `/**
+ * ${CommonUtils.camelCase(options.name)} Integration Tests
+ * Tests service-to-service communication
+ * Service: ${options.serviceName}${consumerNote}
+ */
+
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+
+interface ServiceConfig {
+  baseUrl: string;
+  timeout?: number;
+  headers?: Record<string, string>;
+}
+
+interface TestContext {
+  baseUrl: string;
+  authToken?: string;
+}
+
+${buildServiceClientObject()}
+
+${buildTestHelpers()}
+
+describe('${options.name} Integration', () => {
+  let client: any;
+  const context: TestContext = {
+    baseUrl: '${baseUrl}',
+  };
+
+  beforeAll(async () => {
+    client = ServiceClient.create({
+      baseUrl: context.baseUrl,
+    });
+
+    // Optional: Setup auth or other prerequisites
+    if ('${options.authType}' === 'jwt') {
+      context.authToken = 'test-token';
+    }
+  });
+
+  ${endpointTests}
+});
+`;
+}
+/**
+ * Get base URL for tests
+ */
+function getBaseUrl(options) {
+    return options.baseUrl !== undefined && options.baseUrl !== ''
+        ? options.baseUrl
+        : 'http://localhost:3001';
+}
+/**
+ * Build endpoint tests
+ */
+function buildEndpointTests(options) {
+    return options.endpoints.map((ep) => buildEndpointTest(ep, options)).join('\n\n  ');
+}
+/**
+ * Get consumer note for header
+ */
+function getConsumerNote(options) {
+    return options.consumerService === undefined
+        ? ''
+        : `\n * Consumer Service: ${options.consumerService}\n`;
+}
+/**
+ * Build ServiceClient object code
+ */
+function buildServiceClientObject() {
+    return `/**
+ * Service client for making inter-service calls
+ */
+export const ServiceClient = {
+  /**
+   * Create a new service client instance
+   */
+  create(config: ServiceConfig) {
+    const baseUrl = config.baseUrl;
+    const timeout = config.timeout !== undefined ? config.timeout : 5000;
+    const defaultHeaders = {
+      'Content-Type': 'application/json',
+      ...config.headers,
+    };
+
+    const client = {
+      /**
+       * Make HTTP request
+       */
+      async request<T>(
+        method: string,
+        path: string,
+        data?: Record<string, unknown>,
+        headers?: Record<string, string>
+      ): Promise<{ status: number; body: T; headers: Record<string, string> }> {
+        const url = \\\`\\\${baseUrl}\\\${path}\\\`;
+
+        try {
+          const response = await fetch(url, {
+            method,
+            headers: { ...defaultHeaders, ...headers },
+            body: data ? JSON.stringify(data) : undefined,
+            signal: AbortSignal.timeout(timeout),
+          });
+
+          const body = await response.json();
+
+          return {
+            status: response.status,
+            body: body as T,
+            headers: Object.fromEntries(response.headers.entries()),
+          };
+        } catch (error) {
+          throw ErrorFactory.createTryCatchError(
+            \\\`Service call failed: \\\${(error as Error).message}\\\`,
+            error
+          );
+        }
+      },
+
+${buildClientMethods()}
+    };
+
+    return client;
+  }
+};`;
+}
+/**
+ * Build client methods for ServiceClient
+ */
+function buildClientMethods() {
+    return `      /**
+       * GET request
+       */
+      async get<T>(path: string, headers?: Record<string, string>): Promise<{ status: number; body: T }> {
+        const res = await client.request<T>('GET', path, undefined, headers);
+        return { status: res.status, body: res.body };
+      },
+
+      /**
+       * POST request
+       */
+      async post<T>(path: string, data: Record<string, unknown>, headers?: Record<string, string>): Promise<{ status: number; body: T }> {
+        const res = await client.request<T>('POST', path, data, headers);
+        return { status: res.status, body: res.body };
+      },
+
+      /**
+       * PUT request
+       */
+      async put<T>(path: string, data: Record<string, unknown>, headers?: Record<string, string>): Promise<{ status: number; body: T }> {
+        const res = await client.request<T>('PUT', path, data, headers);
+        return { status: res.status, body: res.body };
+      },
+
+      /**
+       * PATCH request
+       */
+      async patch<T>(path: string, data: Record<string, unknown>, headers?: Record<string, string>): Promise<{ status: number; body: T }> {
+        const res = await client.request<T>('PATCH', path, data, headers);
+        return { status: res.status, body: res.body };
+      },
+
+      /**
+       * DELETE request
+       */
+      async delete<T>(path: string, headers?: Record<string, string>): Promise<{ status: number; body: T }> {
+        const res = await client.request<T>('DELETE', path, undefined, headers);
+        return { status: res.status, body: res.body };
+      }`;
+}
+/**
+ * Build test helpers
+ */
+function buildTestHelpers() {
+    return `/**
+ * Test helper functions
+ */
+function createClient(config: ServiceConfig) {
+  return ServiceClient.create(config);
+}`;
+}
+/**
+ * Build single endpoint test
+ */
+function buildEndpointTest(endpoint, _options) {
+    const testName = endpoint.name || `should handle ${endpoint.method} ${endpoint.path}`;
+    const method = endpoint.method.toLowerCase();
+    const hasBody = ['post', 'put', 'patch'].includes(method);
+    const bodyArg = hasBody ? ', { test: true }' : '';
+    return `it('${testName}', async () => {
+    const response = await client.${method}('${endpoint.path}'${bodyArg});
+
+    expect(response.status).toBeLessThan(500);
+    expect(response.body).toBeDefined();
+  });`;
+}
+export const ServiceIntegrationTestGenerator = Object.freeze({
+    validateOptions,
+    generateIntegrationTest,
+});

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

@@ -0,0 +1,45 @@
+/**
+ * ServiceRequestFactoryGenerator - Generate inter-service request factories
+ * Creates type-safe factories for testing service-to-service API calls
+ */
+export interface ServiceRequestField {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'date' | 'email' | 'url' | 'uuid';
+    required?: boolean;
+    validation?: string[];
+    example?: string | number | boolean;
+    description?: string;
+}
+export interface ServiceRequestOptions {
+    name: string;
+    serviceName: string;
+    endpoint: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    fields: ServiceRequestField[];
+    factoryPath: string;
+    authenticated?: boolean;
+    headers?: Record<string, string>;
+    description?: string;
+}
+export interface ServiceRequestFactoryResult {
+    success: boolean;
+    factoryName: string;
+    factoryFile: string;
+    message: string;
+}
+/**
+ * Validate options
+ */
+export declare function validateOptions(options: ServiceRequestOptions): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Generate request factory file
+ */
+export declare function generateRequestFactory(options: ServiceRequestOptions): ServiceRequestFactoryResult;
+export declare const ServiceRequestFactoryGenerator: Readonly<{
+    validateOptions: typeof validateOptions;
+    generateRequestFactory: typeof generateRequestFactory;
+}>;
+//# sourceMappingURL=ServiceRequestFactoryGenerator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceRequestFactoryGenerator.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/ServiceRequestFactoryGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IAC/F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpD,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,qBAAqB,GAAG;IAC/D,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CA8BA;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,qBAAqB,GAC7B,2BAA2B,CAkC7B;AA8WD,eAAO,MAAM,8BAA8B;;;EAGzC,CAAC"}