@intrig/core 0.0.15-21 → 0.0.15-23

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');
@@ -7621,6 +7627,17 @@ var external_node_crypto_ = __webpack_require__(1273);
 
 
 
+// HTTP methods to process during normalization
+const HTTP_METHODS = [
+    'get',
+    'post',
+    'put',
+    'delete',
+    'patch',
+    'options',
+    'head',
+    'trace'
+];
 // Utility to generate type names
 function generateTypeName(operationOb, postFix) {
     return [
@@ -7649,12 +7666,7 @@ function registerTags(spec) {
         for (const pathItem of Object.values(paths)){
             const pathItemObject = pathItem;
             for (const [method, operation] of Object.entries(pathItemObject)){
-                if ([
-                    "get",
-                    "post",
-                    "put",
-                    "delete"
-                ].includes(method.toLowerCase())) {
+                if (HTTP_METHODS.includes(method.toLowerCase())) {
                     const operationOb = operation;
                     operationOb.tags?.forEach((tag)=>{
                         draft.tags = draft.tags ?? [];
@@ -7676,12 +7688,7 @@ function generateOperationIds(spec) {
         for (const [path, pathItem] of Object.entries(paths)){
             const pathItemObject = pathItem;
             for (const [method, operation] of Object.entries(pathItemObject)){
-                if ([
-                    "get",
-                    "post",
-                    "put",
-                    "delete"
-                ].includes(method.toLowerCase())) {
+                if (HTTP_METHODS.includes(method.toLowerCase())) {
                     const operationOb = operation;
                     if (!operationOb.operationId) {
                         operationOb.operationId = camelCase(`${method.toLowerCase()}_${path.replace("/", "_")}`);
@@ -7699,12 +7706,7 @@ function normalizeParameters(spec) {
         for (const pathItem of Object.values(paths)){
             const pathItemObject = pathItem;
             for (const [method, operation] of Object.entries(pathItemObject)){
-                if ([
-                    "get",
-                    "post",
-                    "put",
-                    "delete"
-                ].includes(method.toLowerCase())) {
+                if (HTTP_METHODS.includes(method.toLowerCase())) {
                     const operationOb = operation;
                     if (operationOb.parameters) {
                         operationOb.parameters = operationOb.parameters.map(doDeref).map((a)=>a);
@@ -7733,12 +7735,7 @@ function normalizeRequestBodies(spec) {
         for (const pathItem of Object.values(paths)){
             const pathItemObject = pathItem;
             for (const [method, operation] of Object.entries(pathItemObject)){
-                if ([
-                    "get",
-                    "post",
-                    "put",
-                    "delete"
-                ].includes(method.toLowerCase())) {
+                if (HTTP_METHODS.includes(method.toLowerCase())) {
                     const operationOb = operation;
                     if (operationOb.requestBody) {
                         const requestBody = doDeref(operationOb.requestBody);
@@ -7774,12 +7771,7 @@ function normalizeCallbacks(spec) {
         for (const pathItem of Object.values(paths)){
             const pathItemObject = pathItem;
             for (const [method, operation] of Object.entries(pathItemObject)){
-                if ([
-                    "get",
-                    "post",
-                    "put",
-                    "delete"
-                ].includes(method.toLowerCase())) {
+                if (HTTP_METHODS.includes(method.toLowerCase())) {
                     const operationOb = operation;
                     if (operationOb.callbacks) {
                         operationOb.callbacks = Object.fromEntries(Object.entries(operationOb.callbacks).map(([k, v])=>[
@@ -7800,12 +7792,7 @@ function normalizeResponses(spec) {
         for (const pathItem of Object.values(paths)){
             const pathItemObject = pathItem;
             for (const [method, operation] of Object.entries(pathItemObject)){
-                if ([
-                    "get",
-                    "post",
-                    "put",
-                    "delete"
-                ].includes(method.toLowerCase())) {
+                if (HTTP_METHODS.includes(method.toLowerCase())) {
                     const operationOb = operation;
                     if (operationOb.responses) {
                         operationOb.responses = Object.fromEntries(Object.entries(operationOb.responses).map(([k, v])=>[
@@ -7900,19 +7887,66 @@ 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
                         };
-                    }) ?? [];
+                    });
+                    // Auto-detect path parameters from URL that are missing from parameters array
+                    // This handles incomplete swagger specs where {param} is in URL but not defined in parameters
+                    const pathParamRegex = /\{([^}]+)\}/g;
+                    let match;
+                    while((match = pathParamRegex.exec(path)) !== null){
+                        const paramName = match[1];
+                        const alreadyDefined = variables.some((v)=>v.name === paramName && v.in === 'path');
+                        if (!alreadyDefined) {
+                            this.logger.debug(`Auto-detected missing path parameter '${paramName}' from URL: ${path}`);
+                            variables.push({
+                                name: paramName,
+                                in: 'path',
+                                ref: undefined // No schema available, will use 'any' type
+                            });
+                        }
+                    }
                     let params = {
                         paths: [
                             operation.tags?.[0]
@@ -10565,7 +10599,7 @@ function search_service_ts_metadata(k, v) {
 };
 /**
  * HTTP methods recognized for method-only search
- */ const HTTP_METHODS = [
+ */ const search_service_HTTP_METHODS = [
     'GET',
     'POST',
     'PUT',
@@ -10943,7 +10977,7 @@ class SearchService {
         }
         // Handle HTTP method-only query (e.g., "GET", "POST")
         const upperQuery = trimmed.toUpperCase();
-        if (HTTP_METHODS.includes(upperQuery)) {
+        if (search_service_HTTP_METHODS.includes(upperQuery)) {
             return this.countAllWithFilters({
                 ...opts,
                 method: upperQuery
@@ -10973,7 +11007,7 @@ class SearchService {
         }
         // Handle HTTP method-only query (e.g., "GET", "POST")
         const upperQuery = trimmed.toUpperCase();
-        if (HTTP_METHODS.includes(upperQuery)) {
+        if (search_service_HTTP_METHODS.includes(upperQuery)) {
             return this.listAllWithFilters({
                 ...opts,
                 method: upperQuery
@@ -19566,6 +19600,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-21",
+  "version": "0.0.15-23",
   "private": false,
   "type": "module",
   "bin": {