@intrig/plugin-nest 0.0.2-0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/index";
+export { default } from "./src/index";

package/dist/index.js

@@ -0,0 +1,694 @@
+import { StatsCounter, jsonLiteral, typescript, pascalCase, camelCase, markdown } from '@intrig/plugin-sdk';
+import * as path from 'path';
+import * as fsx from 'fs-extra';
+import chalk from 'chalk';
+
+class InternalGeneratorContext {
+    constructor(){
+        this.codeGenerationBreakdown = {};
+    }
+    getCounter(sourceId) {
+        this.codeGenerationBreakdown[sourceId] = this.codeGenerationBreakdown[sourceId] || new StatsCounter(sourceId);
+        return this.codeGenerationBreakdown[sourceId];
+    }
+    getCounters() {
+        return [
+            ...Object.values(this.codeGenerationBreakdown)
+        ];
+    }
+}
+
+function packageJsonTemplate(ctx) {
+    const projectDir = ctx.rootDir ?? process.cwd();
+    const packageJson = fsx.readJsonSync(path.resolve(projectDir, 'package.json'));
+    const json = jsonLiteral(path.resolve('package.json'));
+    return json`
+{
+  "name": "@intrig/generated",
+  "version": "d${Date.now()}",
+  "private": true,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "swc src -d dist --copy-files --strip-leading-paths && tsc --emitDeclarationOnly"
+  },
+  "dependencies": {
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/axios": "^3.0.0",
+    "axios": "^1.7.7",
+    "rxjs": "^7.8.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@swc/cli": "^0.7.7",
+    "@swc/core": "^1.12.6",
+    "@types/node": "^24.0.4",
+    "typescript": "${packageJson.devDependencies?.typescript ?? packageJson.dependencies?.typescript ?? '^5.0.0'}"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/axios": "^3.0.0",
+    "rxjs": "^7.0.0"
+  },
+  "_moduleAliases": {
+    "@intrig/nest": "./src"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "require": "./src/index.js",
+      "types": "./src/index.d.ts"
+    },
+    "./*": {
+      "import": "./src/*.js",
+      "require": "./src/*.js",
+      "types": "./src/*.d.ts"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "*": ["src/*"]
+    }
+  }
+}
+  `;
+}
+
+function indexTemplate(serviceNames) {
+    const ts = typescript(path.resolve("src", "index.ts"));
+    return ts`
+export * from './intrig.module';
+${serviceNames.map((name)=>`export * from './${name}/${name}.service';`).join('\n')}
+  `;
+}
+
+function nestTsConfigTemplate() {
+    const json = jsonLiteral(path.resolve('tsconfig.json'));
+    return json`
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "ESNext",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "noImplicitAny": false,
+    "moduleResolution": "node",
+    "baseUrl": "./",
+    "paths": {
+      "@intrig/nest": [
+        "./src"
+      ],
+      "@intrig/nest/*": [
+        "./src/*"
+      ]
+    },
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  },
+  "exclude": [
+    "node_modules",
+    "../../node_modules",
+    "**/__tests__/*"
+  ]
+}
+  `;
+}
+
+function moduleTemplate(serviceNames, sources) {
+    const ts = typescript(path.resolve("src", "intrig.module.ts"));
+    return ts`
+import { Module } from '@nestjs/common';
+import { HttpModule } from '@nestjs/axios';
+${serviceNames.map((name)=>`import { ${pascalCase(name)}Service } from './${name}/${name}.service';`).join('\n')}
+
+@Module({
+  imports: [
+    HttpModule.register({
+      timeout: 60000,
+      maxRedirects: 5,
+    }),
+  ],
+  providers: [${serviceNames.map((name)=>`${pascalCase(name)}Service`).join(', ')}],
+  exports: [${serviceNames.map((name)=>`${pascalCase(name)}Service`).join(', ')}],
+})
+export class IntrigModule {}
+  `;
+}
+
+function extractMethodSignature(descriptor, imports, source) {
+    const { data } = descriptor;
+    const params = [];
+    // Path and query parameters
+    if (data.variables && data.variables.length > 0) {
+        const pathParams = data.variables.filter((v)=>v.in === 'path');
+        const queryParams = data.variables.filter((v)=>v.in === 'query');
+        pathParams.forEach((param)=>{
+            const typeName = param.ref.split('/').pop() || 'any';
+            imports.add(`import { ${typeName} } from '../components/schemas/${typeName}';`);
+            params.push(`${camelCase(param.name)}: ${typeName}`);
+        });
+        queryParams.forEach((param)=>{
+            const typeName = param.ref.split('/').pop() || 'any';
+            imports.add(`import { ${typeName} } from '../components/schemas/${typeName}';`);
+            params.push(`${camelCase(param.name)}?: ${typeName}`);
+        });
+    }
+    // Request body
+    let bodyParam;
+    if (data.requestBody) {
+        const bodyType = data.requestBody;
+        imports.add(`import { ${bodyType} } from '../components/schemas/${bodyType}';`);
+        bodyParam = `data: ${bodyType}`;
+        params.push(bodyParam);
+    }
+    // Return type
+    let returnType = 'void';
+    if (data.response) {
+        returnType = data.response;
+        imports.add(`import { ${returnType} } from '../components/schemas/${returnType}';`);
+    }
+    return {
+        params,
+        returnType,
+        bodyParam
+    };
+}
+function buildUrlExpression(descriptor) {
+    const { data } = descriptor;
+    const urlPath = data.paths[0] || '';
+    if (!data.variables || data.variables.length === 0) {
+        return `'${urlPath}'`;
+    }
+    const pathParams = data.variables.filter((v)=>v.in === 'path');
+    if (pathParams.length === 0) {
+        return `'${urlPath}'`;
+    }
+    // Replace {param} with ${param}
+    let urlTemplate = urlPath;
+    pathParams.forEach((param)=>{
+        urlTemplate = urlTemplate.replace(`{${param.name}}`, `\${${camelCase(param.name)}}`);
+    });
+    return `\`${urlTemplate}\``;
+}
+function buildRequestConfig(descriptor) {
+    const { data } = descriptor;
+    const configParts = [];
+    // Query parameters
+    if (data.variables && data.variables.some((v)=>v.in === 'query')) {
+        const queryParams = data.variables.filter((v)=>v.in === 'query');
+        const paramsObj = queryParams.map((p)=>`${p.name}: ${camelCase(p.name)}`).join(', ');
+        configParts.push(`params: { ${paramsObj} }`);
+    }
+    // Headers
+    if (data.contentType) {
+        configParts.push(`headers: { 'Content-Type': '${data.contentType}' }`);
+    }
+    if (configParts.length === 0) {
+        return '';
+    }
+    return `, { ${configParts.join(', ')} }`;
+}
+function generateMethodTemplate(descriptor, imports, source) {
+    const { data } = descriptor;
+    const methodName = camelCase(data.operationId);
+    const signature = extractMethodSignature(descriptor, imports);
+    const urlExpression = buildUrlExpression(descriptor);
+    const configExpression = buildRequestConfig(descriptor);
+    const httpMethod = data.method.toLowerCase();
+    const hasBody = data.requestBody !== undefined;
+    const hasResponse = data.response !== undefined;
+    let methodBody;
+    if (hasResponse) {
+        if (hasBody) {
+            // POST/PUT/PATCH with body and response
+            methodBody = `
+  async ${methodName}(${signature.params.join(', ')}): Promise<${signature.returnType}> {
+    const response = await firstValueFrom(
+      this.httpService.${httpMethod}<${signature.returnType}>(${urlExpression}, data${configExpression})
+    );
+    return response.data;
+  }`;
+        } else {
+            // GET/DELETE with response
+            methodBody = `
+  async ${methodName}(${signature.params.join(', ')}): Promise<${signature.returnType}> {
+    const response = await firstValueFrom(
+      this.httpService.${httpMethod}<${signature.returnType}>(${urlExpression}${configExpression})
+    );
+    return response.data;
+  }`;
+        }
+    } else {
+        if (hasBody) {
+            // POST/PUT/PATCH with body but no response
+            methodBody = `
+  async ${methodName}(${signature.params.join(', ')}): Promise<void> {
+    await firstValueFrom(
+      this.httpService.${httpMethod}(${urlExpression}, data${configExpression})
+    );
+  }`;
+        } else {
+            // GET/DELETE with no response
+            methodBody = `
+  async ${methodName}(${signature.params.join(', ')}): Promise<void> {
+    await firstValueFrom(
+      this.httpService.${httpMethod}(${urlExpression}${configExpression})
+    );
+  }`;
+        }
+    }
+    return methodBody;
+}
+
+function serviceTemplate(serviceName, descriptors, source) {
+    const ts = typescript(path.resolve('src', serviceName, `${serviceName}.service.ts`));
+    const imports = new Set();
+    const methods = [];
+    for (const descriptor of descriptors){
+        const methodCode = generateMethodTemplate(descriptor, imports);
+        methods.push(methodCode);
+    }
+    return ts`
+import { Injectable } from '@nestjs/common';
+import { HttpService } from '@nestjs/axios';
+import { firstValueFrom } from 'rxjs';
+${[
+        ...imports
+    ].join('\n')}
+
+@Injectable()
+export class ${pascalCase(serviceName)}Service {
+  constructor(private readonly httpService: HttpService) {}
+
+${methods.join('\n\n')}
+}
+  `;
+}
+
+async function typeTemplate(descriptor) {
+    const { data: { schema, name: typeName }, source } = descriptor;
+    const { imports, tsType } = openApiSchemaToTypeScript(schema);
+    const ts = typescript(path.resolve('src', 'components', 'schemas', `${typeName}.ts`));
+    const simpleType = (await jsonLiteral('')`${JSON.stringify(schema)}`).content;
+    return ts`
+${[
+        ...imports
+    ].join('\n')}
+
+//--- TypeScript Type  ---//
+
+export type ${typeName} = ${tsType}
+
+//--- JSON Schema  ---//
+
+export const ${typeName}_jsonschema = ${JSON.stringify(schema) ?? "{}"}
+
+//--- Simple Type  ---//
+/*[${simpleType}]*/
+  `;
+}
+function isRef(schema) {
+    return '$ref' in (schema ?? {});
+}
+// Helper function to convert OpenAPI schema types to TypeScript types
+function openApiSchemaToTypeScript(schema, imports = new Set()) {
+    if (!schema) {
+        return {
+            tsType: 'any',
+            imports: new Set()
+        };
+    }
+    if (isRef(schema)) {
+        return handleRefSchema(schema.$ref, imports);
+    }
+    if (!schema.type) {
+        if ('properties' in schema) {
+            schema.type = 'object';
+        } else if ('items' in schema) {
+            schema.type = 'array';
+        }
+    }
+    switch(schema.type){
+        case 'string':
+            return handleStringSchema(schema);
+        case 'number':
+            return handleNumberSchema();
+        case 'integer':
+            return handleIntegerSchema();
+        case 'boolean':
+            return handleBooleanSchema();
+        case 'array':
+            return handleArraySchema(schema, imports);
+        case 'object':
+            return handleObjectSchema(schema, imports);
+        default:
+            return handleComplexSchema(schema, imports);
+    }
+}
+function handleRefSchema(ref, imports) {
+    const refParts = ref.split('/');
+    const refName = refParts[refParts.length - 1];
+    imports.add(`import { ${refName} } from './${refName}';`);
+    return {
+        tsType: refName,
+        imports
+    };
+}
+function handleStringSchema(schema) {
+    if (schema.enum) {
+        const enumValues = schema.enum.map((value)=>`'${value}'`).join(' | ');
+        return {
+            tsType: enumValues,
+            imports: new Set()
+        };
+    }
+    let tsType = 'string';
+    if (schema.format === 'date' || schema.format === 'date-time') {
+        tsType = 'Date';
+    } else if (schema.format === 'binary') {
+        tsType = 'Buffer';
+    } else if (schema.format === 'byte') {
+        tsType = 'string'; // base64 encoded string
+    }
+    return {
+        tsType,
+        imports: new Set()
+    };
+}
+function handleNumberSchema() {
+    return {
+        tsType: 'number',
+        imports: new Set()
+    };
+}
+function handleIntegerSchema() {
+    return {
+        tsType: 'number',
+        imports: new Set()
+    };
+}
+function handleBooleanSchema() {
+    return {
+        tsType: 'boolean',
+        imports: new Set()
+    };
+}
+function handleArraySchema(schema, imports) {
+    if (!schema.items) {
+        throw new Error('Array schema must have an items property');
+    }
+    const { tsType, imports: itemImports } = openApiSchemaToTypeScript(schema.items, imports);
+    return {
+        tsType: `(${tsType})[]`,
+        imports: new Set([
+            ...imports,
+            ...itemImports
+        ])
+    };
+}
+function handleObjectSchema(schema, imports) {
+    const updatedRequiredFields = schema.required || [];
+    if (schema.properties) {
+        const propertiesTs = Object.entries(schema.properties).map(([key, value])=>{
+            const { tsType, optional } = openApiSchemaToTypeScript(value);
+            const isRequired = !optional && updatedRequiredFields.includes(key);
+            return `${key}${isRequired ? '' : '?'}: ${tsType} ${isRequired ? '' : ' | null'};`;
+        });
+        return {
+            tsType: `{ ${propertiesTs.join(' ')} }`,
+            imports
+        };
+    }
+    return {
+        tsType: 'any',
+        imports: new Set(),
+        optional: true
+    };
+}
+function handleComplexSchema(schema, imports) {
+    if (schema.oneOf) {
+        const options = schema.oneOf.map((subSchema)=>openApiSchemaToTypeScript(subSchema));
+        const tsTypes = options.map((option)=>option.tsType);
+        return {
+            tsType: tsTypes.join(' | '),
+            imports: new Set([
+                ...imports,
+                ...options.flatMap((option)=>Array.from(option.imports))
+            ])
+        };
+    }
+    if (schema.anyOf) {
+        const options = schema.anyOf.map((subSchema)=>openApiSchemaToTypeScript(subSchema));
+        const tsTypes = options.map((option)=>option.tsType);
+        return {
+            tsType: tsTypes.join(' | '),
+            imports: new Set([
+                ...imports,
+                ...options.flatMap((option)=>Array.from(option.imports))
+            ])
+        };
+    }
+    if (schema.allOf) {
+        const options = schema.allOf.map((subSchema)=>openApiSchemaToTypeScript(subSchema));
+        const tsTypes = options.map((option)=>option.tsType);
+        return {
+            tsType: tsTypes.join(' & '),
+            imports: new Set([
+                ...imports,
+                ...options.flatMap((option)=>Array.from(option.imports))
+            ])
+        };
+    }
+    return {
+        tsType: 'any',
+        imports
+    };
+}
+
+/**
+ * Extract service name from operationId or path
+ * Examples:
+ *   - getUser -> users
+ *   - createPost -> posts
+ *   - listProducts -> products
+ *   - /api/users/{id} -> users
+ */ function extractServiceName(descriptor) {
+    const operationId = descriptor.data.operationId;
+    // Try to extract from operationId first
+    // Common patterns: getUser, createUser, listUsers, getUserById
+    const operationPrefixes = [
+        'get',
+        'post',
+        'put',
+        'patch',
+        'delete',
+        'create',
+        'update',
+        'list',
+        'fetch',
+        'remove'
+    ];
+    for (const prefix of operationPrefixes){
+        if (operationId.toLowerCase().startsWith(prefix)) {
+            const rest = operationId.substring(prefix.length);
+            if (rest.length > 0) {
+                // Extract the resource name (e.g., "User" from "getUser")
+                const resourceName = rest.replace(/By.*$/, ''); // Remove "ById", "ByName", etc.
+                return camelCase(resourceName.endsWith('s') ? resourceName : resourceName + 's');
+            }
+        }
+    }
+    // Fallback: extract from path
+    const path = descriptor.data.paths[0] || '';
+    const pathSegments = path.split('/').filter((s)=>s && !s.startsWith('{'));
+    if (pathSegments.length > 0) {
+        // Take the first meaningful segment
+        const segment = pathSegments[0];
+        return camelCase(segment);
+    }
+    // Ultimate fallback: use source name
+    return camelCase(descriptor.source);
+}
+/**
+ * Group REST descriptors by service name
+ */ function groupDescriptorsByService(descriptors) {
+    const grouped = {};
+    for (const descriptor of descriptors){
+        const serviceName = extractServiceName(descriptor);
+        if (!grouped[serviceName]) {
+            grouped[serviceName] = [];
+        }
+        grouped[serviceName].push(descriptor);
+    }
+    return grouped;
+}
+async function generateCode(ctx) {
+    // Root/project files
+    await ctx.dump(packageJsonTemplate(ctx));
+    await ctx.dump(nestTsConfigTemplate());
+    const internalGeneratorContext = new InternalGeneratorContext();
+    // Group REST descriptors by service
+    const groupedDescriptors = groupDescriptorsByService(ctx.restDescriptors);
+    const serviceNames = Object.keys(groupedDescriptors).sort();
+    // Generate module and index files
+    await ctx.dump(moduleTemplate(serviceNames, ctx.sources));
+    await ctx.dump(indexTemplate(serviceNames));
+    // Generate service files
+    for (const [serviceName, descriptors] of Object.entries(groupedDescriptors)){
+        const source = descriptors[0]?.source || 'default';
+        await ctx.dump(serviceTemplate(serviceName, descriptors));
+        // Track statistics
+        const counter = internalGeneratorContext.getCounter(source);
+        counter.inc('services');
+        descriptors.forEach(()=>counter.inc('methods'));
+    }
+    // Generate type files
+    for (const schemaDescriptor of ctx.schemaDescriptors){
+        await ctx.dump(typeTemplate(schemaDescriptor));
+        // Track statistics
+        const counter = internalGeneratorContext.getCounter(schemaDescriptor.source);
+        counter.inc('types');
+    }
+    return internalGeneratorContext.getCounters();
+}
+
+async function schemaTypescriptDoc(result) {
+    const { data: { name, schema }, source } = result;
+    const { tsType } = openApiSchemaToTypeScript(result.data.schema);
+    const ts = typescript(path.resolve('src', source, 'temp', name, `${name}.ts`));
+    const importContent = await ts`
+import { ${name} } from '@intrig/nest/components/schemas/${name}';
+  `;
+    const md = markdown('');
+    return md`
+\`\`\`typescript
+${importContent.content}
+
+type Example = ${tsType}
+\`\`\`
+  `;
+}
+async function schemaJsonSchemaDoc(result) {
+    const { data: { name, schema }, source } = result;
+    const ts = typescript(path.resolve('src', source, 'temp', name, `${name}.ts`));
+    const importContent = await ts`
+import { ${name}_jsonschema } from '@intrig/nest/components/schemas/${name}';
+  `;
+    const md = markdown('');
+    return md`
+\`\`\`typescript
+${importContent.content}
+
+console.log(${name}_jsonschema)
+\`\`\`
+
+\`\`\`json
+${JSON.stringify(schema, null, 2)}
+\`\`\`
+  `;
+}
+
+async function getSchemaDocumentation(result) {
+    const tabs = [];
+    tabs.push({
+        name: 'TypeScript Type',
+        content: (await schemaTypescriptDoc(result)).content
+    });
+    tabs.push({
+        name: 'JSON Schema',
+        content: (await schemaJsonSchemaDoc(result)).content
+    });
+    return tabs;
+}
+
+async function nestServiceMethodDocs(result) {
+    const { data: { operationId, method, paths, requestBody, response, variables }, source } = result;
+    const methodName = camelCase(operationId);
+    const ts = typescript(path.resolve('src', source, 'temp', operationId, `${operationId}.ts`));
+    // Build example usage
+    let exampleParams = [];
+    let exampleCall = '';
+    if (variables && variables.length > 0) {
+        variables.forEach((v)=>{
+            exampleParams.push(`// ${v.in} parameter\nconst ${camelCase(v.name)} = ...;`);
+        });
+    }
+    if (requestBody) {
+        exampleParams.push(`// request body\nconst data = ...;`);
+    }
+    const callParams = [
+        ...variables?.map((v)=>camelCase(v.name)) || [],
+        requestBody ? 'data' : ''
+    ].filter(Boolean);
+    exampleCall = `const result = await service.${methodName}(${callParams.join(', ')});`;
+    const importContent = await ts`
+import { SomeService } from '@intrig/nest';
+
+// Inject the service in your controller or another service
+constructor(private readonly service: SomeService) {}
+
+// Usage example
+${exampleParams.join('\n')}
+${exampleCall}
+  `;
+    const md = markdown('');
+    return md`
+\`\`\`typescript
+${importContent.content}
+\`\`\`
+
+**Endpoint Details:**
+- Method: \`${method.toUpperCase()}\`
+- Path: \`${paths[0] || ''}\`
+${requestBody ? `- Request Body Type: \`${requestBody}\`` : ''}
+${response ? `- Response Type: \`${response}\`` : ''}
+  `;
+}
+
+async function getEndpointDocumentation(result) {
+    const tabs = [];
+    tabs.push({
+        name: 'Service Method',
+        content: (await nestServiceMethodDocs(result)).content
+    });
+    return tabs;
+}
+
+async function initPlugin(ctx) {
+    // NestJS plugin doesn't need any specific initialization tasks currently
+    // But we return a postInit function to show instructions to the user
+    return {
+        postInit: ()=>{
+            console.log(chalk.blue('\n📋 Next Steps:'));
+            console.log(chalk.white('To complete your NestJS setup, import the generated IntrigModule into your app.module.ts:'));
+            console.log(chalk.cyan('\n  import { IntrigModule } from \'@intrig/nest\';'));
+            console.log(chalk.cyan('\n  @Module({'));
+            console.log(chalk.cyan('    imports: [IntrigModule],'));
+            console.log(chalk.cyan('  })'));
+            console.log(chalk.gray('\nThe generated services will be available for dependency injection.\n'));
+        }
+    };
+}
+
+function createPlugin() {
+    return {
+        meta () {
+            return {
+                name: 'intrig-binding',
+                version: '0.0.1',
+                compat: '^0.0.15',
+                generator: 'nest'
+            };
+        },
+        generate: generateCode,
+        getSchemaDocumentation,
+        getEndpointDocumentation,
+        init: initPlugin
+    };
+}
+
+export { createPlugin, createPlugin as default };