@intrig/core 0.0.15-20 → 0.0.15-22

package/main.js

@@ -2845,7 +2845,8 @@ rest_resource_data_ts_decorate([
 ], Variable.prototype, "in", void 0);
 rest_resource_data_ts_decorate([
     (0,swagger.ApiProperty)({
-        description: 'Reference of the variable'
+        description: 'Reference of the variable',
+        required: false
     }),
     rest_resource_data_ts_metadata("design:type", String)
 ], Variable.prototype, "ref", void 0);
@@ -3234,13 +3235,18 @@ function jsonLiteral(path) {
 
 ;// ../../lib/common/src/lib/template/template-util.ts
 function getVariableName(ref) {
+    if (!ref) return undefined;
     return ref.split('/').pop();
 }
 function getVariableImports(variables, source, prefix) {
-    return variables.map((a)=>getVariableName(a.ref)).map((ref)=>`import { ${ref} } from "${prefix}/${source}/components/schemas/${ref}"`).join("\n");
+    return variables.filter((a)=>a.ref) // Skip variables without schema refs
+    .map((a)=>getVariableName(a.ref)).filter((ref)=>!!ref).map((ref)=>`import { ${ref} } from "${prefix}/${source}/components/schemas/${ref}"`).join("\n");
 }
 function getVariableTypes(variables) {
-    return variables.map((p)=>`${p.name}${p.in === "path" ? "" : "?"}: ${getVariableName(p.ref)}`).join("\n");
+    return variables.map((p)=>{
+        const typeName = getVariableName(p.ref) ?? 'any'; // Use 'any' for inline schemas
+        return `${p.name}${p.in === "path" ? "" : "?"}: ${typeName}`;
+    }).join("\n");
 }
 function isParamMandatory(variables) {
     return variables.some((a)=>a.in === 'path');
@@ -7900,19 +7906,50 @@ class ExtractRequestsService {
         this.logger.debug(`Processing ${pathCount} paths from OpenAPI spec`);
         const requests = [];
         const skippedEndpoints = [];
+        const httpMethods = [
+            'get',
+            'put',
+            'post',
+            'delete',
+            'options',
+            'head',
+            'patch',
+            'trace'
+        ];
         for (const [path, pathData] of Object.entries(spec.paths)){
             this.logger.debug(`Processing path: ${path}`);
+            // Extract path-level parameters
+            const pathItem = pathData;
+            const pathLevelParams = (pathItem.parameters ?? []).map((p)=>deref(spec)(p)).filter((p)=>!!p);
             for (const [method, methodData] of Object.entries(pathData)){
+                // Skip non-HTTP method properties (parameters, summary, description, servers, $ref)
+                if (!httpMethods.includes(method.toLowerCase())) {
+                    continue;
+                }
                 const operation = deref(spec)(methodData);
                 if (this.isOperationObject(operation)) {
                     this.logger.debug(`Processing operation: ${method.toUpperCase()} ${path} (${operation.operationId})`);
-                    const variables = operation.parameters?.map((p)=>p)?.map((param)=>{
+                    // Merge path-level and operation-level parameters (operation params override path params)
+                    const operationParams = (operation.parameters ?? []).map((p)=>deref(spec)(p)).filter((p)=>!!p);
+                    const mergedParams = [
+                        ...pathLevelParams
+                    ];
+                    for (const opParam of operationParams){
+                        const existingIndex = mergedParams.findIndex((p)=>p.name === opParam.name && p.in === opParam.in);
+                        if (existingIndex >= 0) {
+                            mergedParams[existingIndex] = opParam; // Override path-level param
+                        } else {
+                            mergedParams.push(opParam);
+                        }
+                    }
+                    const variables = mergedParams.map((param)=>{
                         return {
                             name: param.name,
                             in: param.in,
-                            ref: isRef(param.schema) ? param.schema.$ref : "any"
+                            // Use undefined for inline schemas instead of "any" to avoid reserved keyword issues
+                            ref: isRef(param.schema) ? param.schema.$ref : undefined
                         };
-                    }) ?? [];
+                    });
                     let params = {
                         paths: [
                             operation.tags?.[0]
@@ -19566,6 +19603,27 @@ async function bootstrapDaemon() {
     const discovery = app.get(DiscoveryService);
     const intrigConfig = app.get(IntrigConfigService).get();
     discovery.register(actualPort, url, intrigConfig.generator);
+    // Handle crashes and cleanup discovery file
+    let isCleaningUp = false;
+    const cleanupAndExit = (reason, err)=>{
+        if (isCleaningUp) return; // Prevent re-entrancy
+        isCleaningUp = true;
+        logger?.error(`Daemon crash (${reason}):`, err?.stack || err);
+        // Synchronously cleanup discovery file - don't rely on async app.close()
+        try {
+            discovery.onApplicationShutdown(reason);
+        } catch (cleanupErr) {
+            logger?.error('Failed to cleanup discovery file:', cleanupErr);
+        }
+        // Give logs time to flush, then exit
+        setImmediate(()=>process.exit(1));
+    };
+    process.on('uncaughtException', (err)=>{
+        cleanupAndExit('uncaughtException', err);
+    });
+    process.on('unhandledRejection', (reason)=>{
+        cleanupAndExit('unhandledRejection', reason instanceof Error ? reason : new Error(String(reason)));
+    });
     logger?.log(`🚀 Application is running on: ${url}/${globalPrefix}`);
     logger?.log(`📖 Swagger docs available at: ${url}/docs`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intrig/core",
-  "version": "0.0.15-20",
+  "version": "0.0.15-22",
   "private": false,
   "type": "module",
   "bin": {