@demokit-ai/schema 0.0.1 → 0.1.0

package/dist/index.d.cts

@@ -379,6 +379,8 @@ declare function extractRefName(ref: string): string;
  *
  * Parses OpenAPI specs into DemoKit's internal schema representation
  * with automatic relationship detection.
+ *
+ * Uses @scalar/openapi-parser - a modern, webpack-compatible parser.
  */
 
 /**

package/dist/index.d.ts

@@ -379,6 +379,8 @@ declare function extractRefName(ref: string): string;
  *
  * Parses OpenAPI specs into DemoKit's internal schema representation
  * with automatic relationship detection.
+ *
+ * Uses @scalar/openapi-parser - a modern, webpack-compatible parser.
  */
 
 /**

package/dist/index.js

@@ -1,4 +1,4 @@
-import SwaggerParser from '@apidevtools/swagger-parser';
+import { validate, dereference } from '@scalar/openapi-parser';
 
 // src/parser.ts
 
@@ -151,47 +151,52 @@ function getModelDependencyOrder(models, relationships) {
 
 // src/parser.ts
 async function parseOpenAPIFromPath(pathOrUrl, options = {}) {
-  const { dereference = true } = options;
-  let api;
-  if (dereference) {
-    api = await SwaggerParser.dereference(pathOrUrl);
-  } else {
-    api = await SwaggerParser.parse(pathOrUrl);
+  const response = await fetch(pathOrUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch OpenAPI spec from ${pathOrUrl}: ${response.statusText}`);
   }
-  return parseOpenAPIDocument(api, options);
+  const content = await response.text();
+  return parseOpenAPIFromString(content, options);
 }
 async function parseOpenAPIFromString(spec, options = {}) {
-  const { dereference = true } = options;
-  let parsed;
-  try {
-    parsed = JSON.parse(spec);
-  } catch {
-    const api2 = await SwaggerParser.parse(spec);
-    if (dereference) {
-      return parseOpenAPIDocument(
-        await SwaggerParser.dereference(api2),
-        options
-      );
-    }
-    return parseOpenAPIDocument(api2, options);
+  const { dereference: shouldDereference = true } = options;
+  const validationResult = await validate(spec);
+  if (!validationResult.valid) {
+    const errorMessages = validationResult.errors?.map((e) => e.message).join(", ") || "Unknown validation error";
+    throw new Error(`Invalid OpenAPI specification: ${errorMessages}`);
   }
-  let api;
-  if (dereference) {
-    api = await SwaggerParser.dereference(parsed);
+  let schema;
+  if (shouldDereference) {
+    const derefResult = await dereference(spec);
+    if (derefResult.errors && derefResult.errors.length > 0) {
+      const errorMessages = derefResult.errors.map((e) => e.message).join(", ");
+      throw new Error(`Failed to dereference OpenAPI spec: ${errorMessages}`);
+    }
+    schema = derefResult.schema;
   } else {
-    api = await SwaggerParser.validate(parsed);
+    schema = validationResult.specification;
   }
-  return parseOpenAPIDocument(api, options);
+  return parseOpenAPIDocument(schema, options);
 }
 async function parseOpenAPIFromObject(spec, options = {}) {
-  const { dereference = true } = options;
-  let api;
-  if (dereference) {
-    api = await SwaggerParser.dereference(spec);
+  const { dereference: shouldDereference = true } = options;
+  const validationResult = await validate(spec);
+  if (!validationResult.valid) {
+    const errorMessages = validationResult.errors?.map((e) => e.message).join(", ") || "Unknown validation error";
+    throw new Error(`Invalid OpenAPI specification: ${errorMessages}`);
+  }
+  let schema;
+  if (shouldDereference) {
+    const derefResult = await dereference(spec);
+    if (derefResult.errors && derefResult.errors.length > 0) {
+      const errorMessages = derefResult.errors.map((e) => e.message).join(", ");
+      throw new Error(`Failed to dereference OpenAPI spec: ${errorMessages}`);
+    }
+    schema = derefResult.schema;
   } else {
-    api = await SwaggerParser.validate(spec);
+    schema = validationResult.specification;
   }
-  return parseOpenAPIDocument(api, options);
+  return parseOpenAPIDocument(schema, options);
 }
 function parseOpenAPIDocument(doc, options = {}) {
   const { detectRelationships: shouldDetect = true } = options;
@@ -207,24 +212,27 @@ function parseOpenAPIDocument(doc, options = {}) {
   };
 }
 function parseInfo(doc) {
+  const docInfo = doc.info || {};
   const info = {
-    title: doc.info?.title ?? "Untitled API",
-    version: doc.info?.version ?? "1.0.0",
-    description: doc.info?.description
+    title: docInfo.title ?? "Untitled API",
+    version: docInfo.version ?? "1.0.0",
+    description: docInfo.description
   };
-  if (doc.servers && doc.servers.length > 0 && doc.servers[0]) {
-    info.baseUrl = doc.servers[0].url;
+  const servers = doc.servers;
+  if (servers && servers.length > 0 && servers[0]) {
+    info.baseUrl = servers[0].url;
   }
   return info;
 }
 function parseModels(doc) {
   const models = {};
-  const schemas = doc.components?.schemas;
+  const components = doc.components;
+  const schemas = components?.schemas;
   if (!schemas) {
     return models;
   }
   for (const [name, schema] of Object.entries(schemas)) {
-    if ("$ref" in schema) {
+    if (schema && typeof schema === "object" && "$ref" in schema) {
       continue;
     }
     models[name] = parseSchemaToModel(name, schema);
@@ -232,17 +240,21 @@ function parseModels(doc) {
   return models;
 }
 function parseSchemaToModel(name, schema) {
+  if (!schema || typeof schema !== "object") {
+    return { name, type: "object" };
+  }
+  const s = schema;
   const model = {
     name,
-    type: schemaTypeToModelType(schema.type),
-    description: schema.description
+    type: schemaTypeToModelType(s.type),
+    description: s.description
   };
-  if (schema.type === "object" || schema.properties) {
+  if (s.type === "object" || s.properties) {
     model.type = "object";
     model.properties = {};
-    model.required = schema.required || [];
-    if (schema.properties) {
-      for (const [propName, propSchema] of Object.entries(schema.properties)) {
+    model.required = s.required || [];
+    if (s.properties && typeof s.properties === "object") {
+      for (const [propName, propSchema] of Object.entries(s.properties)) {
         model.properties[propName] = parseProperty(
           propName,
           propSchema,
@@ -250,39 +262,41 @@ function parseSchemaToModel(name, schema) {
         );
       }
     }
-    if (schema.additionalProperties !== void 0) {
-      if (typeof schema.additionalProperties === "boolean") {
-        model.additionalProperties = schema.additionalProperties;
-      } else if ("$ref" in schema.additionalProperties) {
-        model.additionalProperties = {
-          $ref: schema.additionalProperties.$ref
-        };
-      } else {
-        model.additionalProperties = parseSchemaToModel(
-          `${name}AdditionalProps`,
-          schema.additionalProperties
-        );
+    if (s.additionalProperties !== void 0) {
+      if (typeof s.additionalProperties === "boolean") {
+        model.additionalProperties = s.additionalProperties;
+      } else if (s.additionalProperties && typeof s.additionalProperties === "object") {
+        if ("$ref" in s.additionalProperties) {
+          model.additionalProperties = {
+            $ref: s.additionalProperties.$ref
+          };
+        } else {
+          model.additionalProperties = parseSchemaToModel(
+            `${name}AdditionalProps`,
+            s.additionalProperties
+          );
+        }
       }
     }
   }
-  if (schema.type === "array" && schema.items) {
+  if (s.type === "array" && s.items) {
     model.type = "array";
-    if ("$ref" in schema.items) {
-      model.items = { $ref: schema.items.$ref };
+    if (typeof s.items === "object" && "$ref" in s.items) {
+      model.items = { $ref: s.items.$ref };
     } else {
-      model.items = parseSchemaToModel(`${name}Item`, schema.items);
+      model.items = parseSchemaToModel(`${name}Item`, s.items);
     }
   }
-  if (schema.enum) {
-    model.enum = schema.enum;
+  if (s.enum) {
+    model.enum = s.enum;
   }
-  if (schema.example !== void 0) {
-    model.example = schema.example;
+  if (s.example !== void 0) {
+    model.example = s.example;
   }
   return model;
 }
 function parseProperty(name, schema, required) {
-  if ("$ref" in schema) {
+  if (schema && typeof schema === "object" && "$ref" in schema) {
     return {
       name,
       type: "object",
@@ -290,31 +304,32 @@ function parseProperty(name, schema, required) {
       $ref: schema.$ref
     };
   }
+  const s = schema;
   const prop = {
     name,
-    type: schemaTypeToPropertyType(schema.type),
+    type: schemaTypeToPropertyType(s.type),
     required,
-    nullable: schema.nullable,
-    description: schema.description,
-    format: schema.format,
-    enum: schema.enum,
-    example: schema.example,
-    default: schema.default,
-    minimum: schema.minimum,
-    maximum: schema.maximum,
-    minLength: schema.minLength,
-    maxLength: schema.maxLength,
-    pattern: schema.pattern
+    nullable: s.nullable,
+    description: s.description,
+    format: s.format,
+    enum: s.enum,
+    example: s.example,
+    default: s.default,
+    minimum: s.minimum,
+    maximum: s.maximum,
+    minLength: s.minLength,
+    maxLength: s.maxLength,
+    pattern: s.pattern
   };
-  if (schema.type === "array" && schema.items) {
+  if (s.type === "array" && s.items) {
     prop.type = "array";
-    if ("$ref" in schema.items) {
-      prop.items = { $ref: schema.items.$ref };
+    if (typeof s.items === "object" && "$ref" in s.items) {
+      prop.items = { $ref: s.items.$ref };
     } else {
-      prop.items = parseSchemaToModel(`${name}Item`, schema.items);
+      prop.items = parseSchemaToModel(`${name}Item`, s.items);
     }
   }
-  const xRelationship = schema["x-demokit-relationship"];
+  const xRelationship = s["x-demokit-relationship"];
   if (xRelationship && typeof xRelationship === "object") {
     prop["x-demokit-relationship"] = xRelationship;
   }
@@ -322,28 +337,32 @@ function parseProperty(name, schema, required) {
 }
 function parseEndpoints(doc) {
   const endpoints = [];
-  if (!doc.paths) {
+  const paths = doc.paths;
+  if (!paths) {
     return endpoints;
   }
   const methods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
-  for (const [path, pathItem] of Object.entries(doc.paths)) {
-    if (!pathItem) continue;
+  for (const [path, pathItem] of Object.entries(paths)) {
+    if (!pathItem || typeof pathItem !== "object") continue;
     for (const method of methods) {
       const operation = pathItem[method.toLowerCase()];
-      if (!operation) continue;
+      if (!operation || typeof operation !== "object") continue;
       endpoints.push(parseEndpoint(method, path, operation, pathItem));
     }
   }
   return endpoints;
 }
 function parseEndpoint(method, path, operation, pathItem) {
-  const allParams = [...pathItem.parameters || [], ...operation.parameters || []];
   const pathParams = [];
   const queryParams = [];
+  const allParams = [
+    ...pathItem.parameters || [],
+    ...operation.parameters || []
+  ];
   for (const param of allParams) {
+    if (!param || typeof param !== "object") continue;
     if ("$ref" in param) continue;
-    const paramObj = param;
-    const parsed = parseParameter(paramObj);
+    const parsed = parseParameter(param);
     if (parsed.in === "path") {
       pathParams.push(parsed);
     } else if (parsed.in === "query") {
@@ -351,12 +370,15 @@ function parseEndpoint(method, path, operation, pathItem) {
     }
   }
   let requestBody;
-  if (operation.requestBody && !("$ref" in operation.requestBody)) {
-    requestBody = parseRequestBody(operation.requestBody);
+  const opRequestBody = operation.requestBody;
+  if (opRequestBody && typeof opRequestBody === "object" && !("$ref" in opRequestBody)) {
+    requestBody = parseRequestBody(opRequestBody);
   }
   const responses = {};
-  if (operation.responses) {
-    for (const [statusCode, response] of Object.entries(operation.responses)) {
+  const opResponses = operation.responses;
+  if (opResponses && typeof opResponses === "object") {
+    for (const [statusCode, response] of Object.entries(opResponses)) {
+      if (!response || typeof response !== "object") continue;
       if ("$ref" in response) continue;
       responses[statusCode] = parseResponse(statusCode, response);
     }
@@ -375,52 +397,64 @@ function parseEndpoint(method, path, operation, pathItem) {
   };
 }
 function parseParameter(param) {
-  const schema = param.schema;
+  const p = param;
+  const schema = p.schema;
   return {
-    name: param.name,
-    in: param.in,
-    required: param.required ?? false,
+    name: p.name,
+    in: p.in,
+    required: p.required ?? false,
     type: schema ? schemaTypeToPropertyType(schema.type) : "string",
     format: schema?.format,
-    description: param.description,
-    example: param.example ?? schema?.example
+    description: p.description,
+    example: p.example ?? schema?.example
   };
 }
 function parseRequestBody(body) {
-  const contentType = Object.keys(body.content || {})[0] || "application/json";
-  const mediaType = body.content?.[contentType];
+  const b = body;
+  const content = b.content;
+  const contentType = Object.keys(content || {})[0] || "application/json";
+  const mediaType = content?.[contentType];
   let schema = { name: "Unknown", type: "object" };
-  if (mediaType?.schema) {
-    if ("$ref" in mediaType.schema) {
-      schema = { $ref: mediaType.schema.$ref };
-    } else {
-      schema = parseSchemaToModel("RequestBody", mediaType.schema);
+  if (mediaType) {
+    const m = mediaType;
+    const mediaSchema = m.schema;
+    if (mediaSchema && typeof mediaSchema === "object") {
+      if ("$ref" in mediaSchema) {
+        schema = { $ref: mediaSchema.$ref };
+      } else {
+        schema = parseSchemaToModel("RequestBody", mediaSchema);
+      }
     }
   }
   return {
     contentType,
     schema,
-    required: body.required ?? false,
-    description: body.description
+    required: b.required ?? false,
+    description: b.description
   };
 }
 function parseResponse(statusCode, response) {
+  const r = response;
   const responseDef = {
     statusCode,
-    description: response.description
+    description: r.description
   };
-  if (response.content) {
+  const content = r.content;
+  if (content) {
     responseDef.content = {};
-    for (const [contentType, mediaType] of Object.entries(response.content)) {
-      if (mediaType.schema) {
-        if ("$ref" in mediaType.schema) {
+    for (const [contentType, mediaType] of Object.entries(content)) {
+      if (!mediaType || typeof mediaType !== "object") continue;
+      const m = mediaType;
+      const schema = m.schema;
+      if (schema && typeof schema === "object") {
+        if ("$ref" in schema) {
           responseDef.content[contentType] = {
-            $ref: mediaType.schema.$ref
+            $ref: schema.$ref
           };
         } else {
           responseDef.content[contentType] = parseSchemaToModel(
             `Response${statusCode}`,
-            mediaType.schema
+            schema
           );
         }
       }