@stackwright-pro/openapi 0.3.0-alpha.4 → 0.3.0-alpha.6

package/dist/index.mjs

@@ -33,8 +33,18 @@ var OpenAPIParser = class {
         await SwaggerParser.validate(api);
       }
       let document;
+      let dereferenced = false;
       if (dereference) {
-        document = await SwaggerParser.dereference(api);
+        try {
+          document = await SwaggerParser.dereference(api);
+          dereferenced = true;
+        } catch {
+          console.warn(
+            `[OpenAPIParser] Warning: Could not fully dereference "${specPath}" (dangling $ref or circular ref). Proceeding without full dereferencing \u2014 some schema references may not resolve.`
+          );
+          document = api;
+          dereferenced = false;
+        }
       } else {
         document = api;
       }
@@ -42,7 +52,7 @@ var OpenAPIParser = class {
       return {
         document,
         version,
-        dereferenced: dereference
+        dereferenced
       };
     } catch (error) {
       throw this.enhanceError(error, specPath);
@@ -92,6 +102,19 @@ var OpenAPIParser = class {
 };
 
 // src/parser/SchemaResolver.ts
+var SUPPORTED_CONTENT_TYPES = [
+  "application/json",
+  "application/geo+json",
+  // GeoJSON (ORS, mapping APIs)
+  "application/vnd.api+json",
+  // JSON:API
+  "application/ld+json",
+  // JSON-LD
+  "application/problem+json",
+  // RFC 7807 problem details
+  "*/*"
+  // wildcard fallback
+];
 var SchemaResolver = class {
   /**
    * @param document - Fully dereferenced OpenAPI document. Pass the result of
@@ -124,16 +147,19 @@ var SchemaResolver = class {
     const extractSchema = (responseCode) => {
       const response = responses[responseCode];
       if (!response) return void 0;
-      const content = response.content?.["application/json"];
-      const schema = content?.schema;
-      if (!schema) return void 0;
-      if ("$ref" in schema) {
-        console.warn(
-          `[SchemaResolver] Unresolved $ref in schema for ${path3}. Ensure the document is fully dereferenced before passing to SchemaResolver.`
-        );
+      for (const contentType of SUPPORTED_CONTENT_TYPES) {
+        const content = response.content?.[contentType];
+        if (!content?.schema) continue;
+        const schema = content.schema;
+        if ("$ref" in schema) {
+          console.warn(
+            `[SchemaResolver] Unresolved $ref in schema for ${path3}. Ensure the document is fully dereferenced before passing to SchemaResolver.`
+          );
+          return schema;
+        }
         return schema;
       }
-      return schema;
+      return void 0;
     };
     const preferred = extractSchema(preferredResponseCode);
     if (preferred) return preferred;
@@ -544,9 +570,12 @@ var CollectionProviderGenerator = class {
     const resolver = new SchemaResolver(this.document);
     const schema = resolver.getResponseSchema(endpoint, method);
     if (!schema) {
-      throw new Error(`No response schema found for ${method.toUpperCase()} ${endpoint}`);
+      console.warn(
+        `    > No response schema found for ${method.toUpperCase()} ${endpoint} \u2014 falling back to z.unknown()`
+      );
     }
-    const isArray = schema.type === "array";
+    const isArray = schema != null ? schema.type === "array" : false;
+    const unknownFallback = schema == null;
     const schemaName = `${this.capitalize(collectionName)}Schema`;
     const params = {
       providerName,
@@ -557,6 +586,7 @@ var CollectionProviderGenerator = class {
       baseUrl,
       schemaName,
       isArray,
+      unknownFallback,
       bare
     };
     if (auth !== void 0) {
@@ -578,13 +608,17 @@ var CollectionProviderGenerator = class {
       auth,
       schemaName,
       isArray,
+      unknownFallback,
       bare
     } = params;
     const authHeader = this.generateAuthHeader(auth);
     const arraySchemaName = `${schemaName.replace(/Schema$/, "")}ArraySchema`;
-    const validationSchema = isArray ? arraySchemaName : schemaName;
-    const imports = bare ? "" : `import type { CollectionProvider, CollectionItem } from '@stackwright/collections';
-import { ${isArray ? arraySchemaName : schemaName}} } from './schemas';
+    const validationSchema = unknownFallback ? "z.unknown()" : isArray ? arraySchemaName : schemaName;
+    const imports = bare ? "" : unknownFallback ? `import type { CollectionProvider, CollectionItem } from '@stackwright/collections';
+import { z } from 'zod';
+
+` : `import type { CollectionProvider, CollectionItem } from '@stackwright/collections';
+import { ${isArray ? arraySchemaName : schemaName} } from './schemas';
 
 `;
     return `${imports}/**
@@ -648,7 +682,7 @@ export class ${providerName} implements CollectionProvider {
    * Get a single item by slug
    */
   async get(slug: string): Promise<CollectionItem | null> {
-    ${this.generateGetMethod(endpoint, slugField, isArray, collectionName, schemaName)}
+    ${this.generateGetMethod(endpoint, slugField, isArray, collectionName, schemaName, unknownFallback)}
   }
 
   /**
@@ -684,7 +718,8 @@ export class ${providerName} implements CollectionProvider {
   /**
    * Generate get method implementation
    */
-  generateGetMethod(endpoint, slugField, isArray, collectionName, schemaName) {
+  generateGetMethod(endpoint, slugField, isArray, collectionName, schemaName, unknownFallback = false) {
+    const validationExpr = unknownFallback ? "z.unknown()" : schemaName;
     if (endpoint.includes("{id}") || endpoint.includes(":id")) {
       const detailEndpoint = endpoint.replace("{id}", "${slug}").replace(":id", "${slug}");
       return `const url = \`\${this.baseUrl}${detailEndpoint}\`;
@@ -702,7 +737,7 @@ export class ${providerName} implements CollectionProvider {
     }
 
     const data = await response.json();
-    const validated = ${schemaName}.parse(data);
+    const validated = ${validationExpr}.parse(data);
     
     return this.toCollectionItem(validated);`;
     } else {
@@ -2804,6 +2839,23 @@ var OpenAPIPlugin = class {
   async processIntegration(config, projectRoot) {
     const { name, spec, auth, mockUrl, collections, endpoints, actions } = config;
     console.log(`  - Processing integration: ${name}`);
+    const httpCollections = (collections || []).filter((c) => {
+      if (c.transport === "websocket") {
+        console.warn(
+          `    > Skipping collection "${c.endpoint}" (transport: websocket \u2014 not yet supported)`
+        );
+        return false;
+      }
+      return true;
+    });
+    const hasEndpoints = endpoints && (endpoints.include?.length || endpoints.exclude?.length);
+    const hasActions = actions && actions.length > 0;
+    if (httpCollections.length === 0 && !hasEndpoints && !hasActions) {
+      console.log(
+        "    > No HTTP endpoints or REST collections found \u2014 skipping (WebSocket-only integration not yet supported)"
+      );
+      return;
+    }
     const specPath = spec.startsWith("http") ? spec : path2.resolve(projectRoot, spec);
     const parser = new OpenAPIParser();
     const { document } = await parser.parse(specPath);
@@ -2822,13 +2874,13 @@ var OpenAPIPlugin = class {
     fs2.mkdirSync(outputDir, { recursive: true });
     const schemaMapping = await this.generateSchemas(
       document,
-      collections || [],
+      httpCollections,
       outputDir,
       name,
       endpointFilter
     );
-    await this.generateTypes(document, collections || [], outputDir, name);
-    if (collections && collections.length > 0) {
+    await this.generateTypes(document, httpCollections, outputDir, name);
+    if (httpCollections.length > 0) {
       await this.generateProvider(document, config, outputDir, name);
     }
     await this.generateClient(document, outputDir, name, schemaMapping, endpointFilter);