node-apis/dist/templates/typed-custom.services.js

🚀 Advanced TypeScript API generator with clean architecture, comprehensive testing, and automatic formatting. Generate production-ready Node.js APIs with complete integration test suites.

"use strict";
/**
 * Typed custom service templates - generates custom services with actual field names from parsed types
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.generateTypedCustomServiceContent = void 0;
const type_parser_service_1 = require("../services/type-parser.service");
/**
 * Generates TypeScript service file content for custom operations with parsed types
 */
const generateTypedCustomServiceContent = ({ customName, moduleName, parsedType, }) => {
    const capitalizedModule = moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
    const capitalizedCustom = customName.charAt(0).toUpperCase() + customName.slice(1);
    return generateTypedGenericCustomServiceContent(customName, capitalizedModule, capitalizedCustom, moduleName, parsedType);
};
exports.generateTypedCustomServiceContent = generateTypedCustomServiceContent;
/**
 * Generates generic custom service content with parsed types
 */
const generateTypedGenericCustomServiceContent = (customName, capitalizedModule, _capitalizedCustom, moduleName, parsedType) => {
    const fieldDestructuring = (0, type_parser_service_1.generateFieldDestructuring)(parsedType.fields);
    return `import type { typeResult } from '../types/${customName}.${moduleName}';
import * as ${moduleName}Repository from '../repository/${moduleName}.repository';

export const ${customName}${capitalizedModule} = async ({
${fieldDestructuring}
  requestId,
}: {
  ${parsedType.fields.map(field => `${field.name}${field.optional ? '?' : ''}: ${field.type};`).join('\n  ')}
  requestId: string;
}): Promise<typeResult> => {
  try {
    // TODO: Add business logic here
    // Example: const result = await ${moduleName}Repository.${customName}({
    //   ${parsedType.fields.map(f => f.name).join(',\n    //   ')}
    // });

    // Add your custom business logic
    // This might involve multiple repository calls, external API calls, etc.

    const result = {}; // Replace with actual implementation

    return { data: result, error: null };
  } catch (err) {
    const error = err as Error;
    // Handle specific error types
    if (error.name === 'NotFoundError') {
      return {
        data: null,
        error: {
          code: 'NOT_FOUND',
          message: \`${capitalizedModule} not found\`,
          statusCode: 404,
          requestId
        }
      };
    }

    if (error.name === 'ValidationError') {
      return {
        data: null,
        error: {
          code: 'VALIDATION_ERROR',
          message: error.message,
          statusCode: 400,
          requestId
        }
      };
    }

    return {
      data: null,
      error: {
        code: 'INTERNAL_ERROR',
        message: error.message || 'Failed to ${customName} ${moduleName}',
        statusCode: 500,
        requestId
      }
    };
  }
};
`;
};
//# sourceMappingURL=typed-custom.services.js.map