@workos/oagen 0.0.1 → 0.1.1

package/dist/index.js

@@ -8,9 +8,8 @@ import {
   getEmitter,
   integrateGeneratedFiles,
   mapFilesForTargetIntegration,
-  registerEmitter,
-  writeFiles
-} from "./chunk-P5XUDUGY.js";
+  registerEmitter
+} from "./chunk-2JXFTDTO.js";
 import {
   ACRONYM_SET,
   CommandError,
@@ -139,17 +138,26 @@ function buildInlineModel(name, schema) {
 
 // src/parser/schemas.ts
 function extractSchemas(schemas) {
-  const models = [];
   const enums = [];
-  if (!schemas) return { models, enums };
+  if (!schemas) return { models: [], enums };
+  const modelsByCleanName = /* @__PURE__ */ new Map();
   for (const [name, schema] of Object.entries(schemas)) {
     const pascalName = cleanSchemaName(toPascalCase(name));
     if (schema.enum) {
       enums.push(extractEnum(pascalName, schema));
     } else {
-      models.push(extractModel(pascalName, schema, schemas));
+      const model = extractModel(pascalName, schema, schemas);
+      const existing = modelsByCleanName.get(pascalName);
+      if (existing) {
+        if (model.fields.length > existing.fields.length) {
+          modelsByCleanName.set(pascalName, model);
+        }
+      } else {
+        modelsByCleanName.set(pascalName, model);
+      }
     }
   }
+  const models = [...modelsByCleanName.values()];
   const modelNames = new Set(models.map((m) => m.name));
   const inlineQueue = [...models];
   while (inlineQueue.length > 0) {
@@ -240,9 +248,9 @@ function extractNestedSchema(name, schema) {
       if (variant.properties && (variant.type === "object" || !variant.type)) {
         const requiredSet = new Set(variant.required ?? []);
         const fields = [];
-        for (const [fn, fs2] of Object.entries(variant.properties)) {
-          if (!fs2) continue;
-          fields.push(buildFieldFromSchema(fn, fs2, name, requiredSet));
+        for (const [fn, fs] of Object.entries(variant.properties)) {
+          if (!fs) continue;
+          fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
         }
         const variantName = models.length === 0 ? name : `${name}${models.length + 1}`;
         models.push({ name: variantName, description: variant.description, fields });
@@ -253,18 +261,18 @@ function extractNestedSchema(name, schema) {
   if (schema.properties && (schema.type === "object" || !schema.type)) {
     const requiredSet = new Set(schema.required ?? []);
     const fields = [];
-    for (const [fn, fs2] of Object.entries(schema.properties)) {
-      if (!fs2) continue;
-      fields.push(buildFieldFromSchema(fn, fs2, name, requiredSet));
+    for (const [fn, fs] of Object.entries(schema.properties)) {
+      if (!fs) continue;
+      fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
     }
     return [{ name, description: schema.description, fields }];
   }
   if (schema.type === "array" && schema.items?.properties) {
     const requiredSet = new Set(schema.items.required ?? []);
     const fields = [];
-    for (const [fn, fs2] of Object.entries(schema.items.properties)) {
-      if (!fs2) continue;
-      fields.push(buildFieldFromSchema(fn, fs2, name, requiredSet));
+    for (const [fn, fs] of Object.entries(schema.items.properties)) {
+      if (!fs) continue;
+      fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
     }
     return [{ name, description: schema.items.description, fields }];
   }
@@ -579,6 +587,18 @@ function classifyAndExtractResponse(schema, contextName) {
   }
   return extractDirectResource(schema, contextName);
 }
+var KNOWN_DATA_PATHS = /* @__PURE__ */ new Set(["data", "items", "results", "records", "entries", "values", "nodes", "edges"]);
+var PAGINATION_METADATA_PATTERNS = [
+  "metadata",
+  "pagination",
+  "cursor",
+  "has_more",
+  "page_info",
+  "total",
+  "next_page",
+  "previous_page",
+  "offset"
+];
 function detectListEnvelope(schema) {
   const propSources = [];
   if (schema.allOf) {
@@ -595,17 +615,26 @@ function detectListEnvelope(schema) {
     Object.assign(mergedProps, source);
   }
   const arrayProps = [];
-  let nonArrayCount = 0;
+  const nonArrayKeys = [];
   for (const [key, propSchema] of Object.entries(mergedProps)) {
     if (!propSchema) continue;
     if (propSchema.type === "array") {
       arrayProps.push(key);
     } else {
-      nonArrayCount++;
+      nonArrayKeys.push(key);
     }
   }
-  if (arrayProps.length === 1 && nonArrayCount >= 1) {
-    return { isEnvelope: true, dataPath: arrayProps[0] };
+  if (arrayProps.length === 1 && nonArrayKeys.length >= 1) {
+    const arrayPropName = arrayProps[0];
+    if (KNOWN_DATA_PATHS.has(arrayPropName)) {
+      return { isEnvelope: true, dataPath: arrayPropName };
+    }
+    const hasPaginationCompanion = nonArrayKeys.some(
+      (key) => PAGINATION_METADATA_PATTERNS.some((pattern) => key.toLowerCase().includes(pattern))
+    );
+    if (hasPaginationCompanion) {
+      return { isEnvelope: true, dataPath: arrayPropName };
+    }
   }
   return { isEnvelope: false, dataPath: null };
 }
@@ -870,15 +899,15 @@ function extractOperations(paths, operationIdTransform) {
   if (!paths) return { services: [], inlineModels: [] };
   const serviceMap = /* @__PURE__ */ new Map();
   const inlineModels = [];
-  for (const [path2, pathItem] of Object.entries(paths)) {
+  for (const [path, pathItem] of Object.entries(paths)) {
     const pathLevelParams = pathItem.parameters ?? [];
     for (const method of HTTP_METHODS) {
       const op = pathItem[method];
       if (!op) continue;
-      const serviceName = inferServiceName(path2, op.tags?.[0]);
+      const serviceName = inferServiceName(path, op.tags?.[0]);
       const { operation, inlineModels: opModels } = buildOperation(
         method,
-        path2,
+        path,
         op,
         pathLevelParams,
         operationIdTransform
@@ -898,28 +927,28 @@ function extractOperations(paths, operationIdTransform) {
   }));
   return { services, inlineModels };
 }
-function inferServiceName(path2, tag) {
+function inferServiceName(path, tag) {
   if (tag) {
     return toPascalCase(tag);
   }
-  const segments = path2.split("/").filter(Boolean);
+  const segments = path.split("/").filter(Boolean);
   const first = segments[0] ?? "Default";
   if (first.startsWith("{")) return "Default";
   return toPascalCase(first);
 }
-function inferOperationName(method, path2, operationId, operationIdTransform) {
+function inferOperationName(method, path, operationId, operationIdTransform) {
   if (operationId) {
     if (operationIdTransform) {
       return operationIdTransform(operationId);
     }
     return toCamelCase(operationId);
   }
-  const verb = inferVerb(method, path2);
-  const resource = inferResourceFromPath(path2);
+  const verb = inferVerb(method, path);
+  const resource = inferResourceFromPath(path);
   return resource ? toCamelCase(`${verb}_${resource}`) : verb;
 }
-function inferVerb(method, path2) {
-  const segments = path2.split("/").filter(Boolean);
+function inferVerb(method, path) {
+  const segments = path.split("/").filter(Boolean);
   const hasTrailingParam = segments.length > 0 && segments[segments.length - 1].startsWith("{");
   switch (method) {
     case "get":
@@ -941,8 +970,8 @@ function inferVerb(method, path2) {
       return method;
   }
 }
-function inferResourceFromPath(path2) {
-  const segments = path2.split("/").filter(Boolean);
+function inferResourceFromPath(path) {
+  const segments = path.split("/").filter(Boolean);
   if (segments.length <= 1) return null;
   let resourceSegment = null;
   for (let i = segments.length - 1; i >= 0; i--) {
@@ -990,15 +1019,15 @@ function disambiguateOperationNames(operations) {
     }
   }
 }
-function inferDeeperContext(path2) {
-  const segments = path2.split("/").filter(Boolean);
+function inferDeeperContext(path) {
+  const segments = path.split("/").filter(Boolean);
   const nonParams = segments.filter((s) => !s.startsWith("{"));
   if (nonParams.length >= 3) {
     return toPascalCase(nonParams.slice(1, -1).join("_"));
   }
   return null;
 }
-function buildOperation(method, path2, op, pathLevelParams, operationIdTransform) {
+function buildOperation(method, path, op, pathLevelParams, operationIdTransform) {
   const allParams = [...pathLevelParams, ...op.parameters ?? []];
   const hasIdempotencyHeader = allParams.some((p) => p.in === "header" && p.name.toLowerCase() === "idempotency-key");
   const pathParams = extractParams(allParams, "path");
@@ -1015,7 +1044,7 @@ function buildOperation(method, path2, op, pathLevelParams, operationIdTransform
     isPaginated,
     dataPath: responseDataPath,
     itemType: responseItemType
-  } = extractResponses(op.responses, op, path2, method);
+  } = extractResponses(op.responses, op, path, method);
   inlineModels.push(...reqBodyModels);
   const paginationFromParams = detectPagination(response, queryParams, responseDataPath);
   let pagination;
@@ -1033,10 +1062,10 @@ function buildOperation(method, path2, op, pathLevelParams, operationIdTransform
   }
   return {
     operation: {
-      name: inferOperationName(method, path2, op.operationId, operationIdTransform),
+      name: inferOperationName(method, path, op.operationId, operationIdTransform),
       description: buildDescription(op.summary, op.description),
       httpMethod: method,
-      path: path2,
+      path,
       pathParams,
       queryParams,
       headerParams,
@@ -1167,15 +1196,15 @@ function deriveOneOfVariantName(variant, baseName, existingModels) {
   }
   return name;
 }
-function deriveResponseName(op, path2, method) {
+function deriveResponseName(op, path, method) {
   if (op?.operationId) {
     return cleanSchemaName(toPascalCase(op.operationId) + "Response");
   }
-  const segments = path2.split("/").filter(Boolean);
+  const segments = path.split("/").filter(Boolean);
   const resource = segments[0] ?? "Unknown";
   return toPascalCase(resource) + toPascalCase(method) + "Response";
 }
-function extractResponses(responses, op, path2, method) {
+function extractResponses(responses, op, path, method) {
   const errors = [];
   let response = { kind: "primitive", type: "string" };
   let inlineModels = [];
@@ -1190,7 +1219,7 @@ function extractResponses(responses, op, path2, method) {
       let extractedType = { kind: "primitive", type: "unknown" };
       const jsonContent = resp.content?.["application/json"];
       if (jsonContent?.schema) {
-        const contextName = deriveResponseName(op, path2 ?? "/", method ?? "get");
+        const contextName = deriveResponseName(op, path ?? "/", method ?? "get");
         const result = classifyAndExtractResponse(jsonContent.schema, contextName);
         extractedType = result.response;
         inlineModels = result.inlineModels;
@@ -1209,7 +1238,7 @@ function extractResponses(responses, op, path2, method) {
             if (firstContent?.schema) {
               extractedType = schemaToTypeRef(
                 firstContent.schema,
-                deriveResponseName(op, path2 ?? "/", method ?? "get")
+                deriveResponseName(op, path ?? "/", method ?? "get")
               );
             }
           }
@@ -1242,20 +1271,24 @@ function keepLargestByName(models) {
   }
   return [...byName.values()];
 }
-function rewriteModelRefsInServices(services, oldName, newName) {
+function rewriteModelRef(ref, oldName, newName) {
+  walkTypeRef(ref, {
+    model: (r) => {
+      if (r.name === oldName) r.name = newName;
+    }
+  });
+}
+function rewriteModelRefs(models, services, oldName, newName) {
+  for (const model of models) {
+    for (const field of model.fields) {
+      rewriteModelRef(field.type, oldName, newName);
+    }
+  }
   for (const service of services) {
     for (const op of service.operations) {
-      walkTypeRef(op.response, {
-        model: (r) => {
-          if (r.name === oldName) r.name = newName;
-        }
-      });
+      rewriteModelRef(op.response, oldName, newName);
       if (op.requestBody) {
-        walkTypeRef(op.requestBody, {
-          model: (r) => {
-            if (r.name === oldName) r.name = newName;
-          }
-        });
+        rewriteModelRef(op.requestBody, oldName, newName);
       }
     }
   }
@@ -1304,9 +1337,30 @@ function mergeFieldInlineModels(existingModels, fieldInlineModels) {
   });
   return [...existingModels, ...keepLargestByName(deduplicatedFieldModels)];
 }
+function hasModelConstDiscriminant(model) {
+  return model.fields.some(
+    (f) => (f.name === "object" || f.name === "type") && f.type.kind === "literal" && typeof f.type.value === "string"
+  );
+}
+function isModelReferencedByOthers(name, models, excludeNames) {
+  for (const model of models) {
+    if (excludeNames.has(model.name)) continue;
+    for (const field of model.fields) {
+      let found = false;
+      walkTypeRef(field.type, {
+        model: (r) => {
+          if (r.name === name) found = true;
+        }
+      });
+      if (found) return true;
+    }
+  }
+  return false;
+}
 function collapseJsonSuffixModels(models, services) {
   const normalizedModels = [...models];
   const byName = new Map(normalizedModels.map((m) => [m.name, m]));
+  const mergeCandidates = [];
   for (const model of normalizedModels) {
     if (!model.name.endsWith("Json")) continue;
     const baseName = model.name.slice(0, -4);
@@ -1314,13 +1368,20 @@ function collapseJsonSuffixModels(models, services) {
     if (!baseModel || model.fields.length <= baseModel.fields.length) continue;
     const isSuperset = baseModel.fields.every((f) => model.fields.some((mf) => mf.name === f.name));
     if (!isSuperset) continue;
-    baseModel.fields = model.fields;
-    const jsonIdx = normalizedModels.indexOf(model);
-    if (jsonIdx !== -1) normalizedModels.splice(jsonIdx, 1);
-    rewriteModelRefsInServices(services, model.name, baseName);
-    console.warn(`[oagen] Merged "${model.name}" into "${baseName}" (${model.fields.length} fields, superset)`);
+    if (hasModelConstDiscriminant(model) && hasModelConstDiscriminant(baseModel)) continue;
+    if (isModelReferencedByOthers(model.name, normalizedModels, /* @__PURE__ */ new Set([model.name, baseName]))) continue;
+    mergeCandidates.push({ jsonModel: model, baseModel });
+  }
+  const toRemove = /* @__PURE__ */ new Set();
+  for (const { jsonModel, baseModel } of mergeCandidates) {
+    baseModel.fields = jsonModel.fields;
+    toRemove.add(jsonModel.name);
+    rewriteModelRefs(normalizedModels, services, jsonModel.name, baseModel.name);
+    console.warn(
+      `[oagen] Merged "${jsonModel.name}" into "${baseModel.name}" (${jsonModel.fields.length} fields, superset)`
+    );
   }
-  return normalizedModels;
+  return normalizedModels.filter((m) => !toRemove.has(m.name));
 }
 
 // src/parser/collect-inline-enums.ts
@@ -1382,11 +1443,11 @@ async function parseSpec(specPath, options) {
     options?.operationIdTransform
   );
   const responseNormalizedModels = mergeInlineResponseModels(models, inlineModels);
-  const jsonCollapsedModels = collapseJsonSuffixModels(responseNormalizedModels, services);
   const fieldInlineModels = extractInlineModelsFromSchemas(
     spec.components?.schemas
   );
-  const finalModels = mergeFieldInlineModels(jsonCollapsedModels, fieldInlineModels);
+  const fieldMergedModels = mergeFieldInlineModels(responseNormalizedModels, fieldInlineModels);
+  const finalModels = collapseJsonSuffixModels(fieldMergedModels, services);
   collectInlineEnumsFromModels(finalModels, enums);
   const auth = extractAuthSchemes(spec.components?.securitySchemes);
   const serverEntries = (spec.servers ?? []).map((s) => ({ url: s.url ?? "", description: s.description })).filter((s) => s.url);
@@ -1419,233 +1480,6 @@ function extractAuthSchemes(securitySchemes) {
   return schemes.length > 0 ? schemes : void 0;
 }
 
-// src/differ/file-map.ts
-function mapChangesToFiles(changes, emitter, ctx) {
-  const regenerate = /* @__PURE__ */ new Set();
-  const toDelete = /* @__PURE__ */ new Set();
-  const modelFiles = /* @__PURE__ */ new Map();
-  const enumFiles = /* @__PURE__ */ new Map();
-  const serviceFiles = /* @__PURE__ */ new Map();
-  for (const model of ctx.spec.models) {
-    const files = emitter.generateModels([model], ctx);
-    const sigs = emitter.generateTypeSignatures?.({ ...ctx.spec, models: [model], enums: [], services: [] }, ctx) ?? [];
-    modelFiles.set(
-      model.name,
-      [...files, ...sigs].map((f) => f.path)
-    );
-  }
-  for (const enumDef of ctx.spec.enums) {
-    const files = emitter.generateEnums([enumDef], ctx);
-    enumFiles.set(
-      enumDef.name,
-      files.map((f) => f.path)
-    );
-  }
-  for (const service of ctx.spec.services) {
-    const files = [
-      ...emitter.generateResources([service], ctx),
-      ...emitter.generateTests({ ...ctx.spec, services: [service], models: [], enums: [] }, ctx)
-    ];
-    const sigs = emitter.generateTypeSignatures?.({ ...ctx.spec, services: [service], models: [], enums: [] }, ctx) ?? [];
-    serviceFiles.set(
-      service.name,
-      [...files, ...sigs].map((f) => f.path)
-    );
-  }
-  const modelToServices = buildReferenceGraph(ctx.spec);
-  for (const change of changes) {
-    switch (change.kind) {
-      case "model-added":
-      case "model-modified": {
-        const files = modelFiles.get(change.name) ?? [];
-        files.forEach((f) => regenerate.add(f));
-        const refs = modelToServices.get(change.name) ?? [];
-        for (const svc of refs) {
-          const svcFiles = serviceFiles.get(svc) ?? [];
-          svcFiles.forEach((f) => regenerate.add(f));
-        }
-        break;
-      }
-      case "model-removed": {
-        const files = modelFiles.get(change.name) ?? [];
-        files.forEach((f) => toDelete.add(f));
-        const refs = modelToServices.get(change.name) ?? [];
-        for (const svc of refs) {
-          const svcFiles = serviceFiles.get(svc) ?? [];
-          svcFiles.forEach((f) => regenerate.add(f));
-        }
-        break;
-      }
-      case "enum-added":
-      case "enum-modified": {
-        const files = enumFiles.get(change.name) ?? [];
-        files.forEach((f) => regenerate.add(f));
-        const refs = modelToServices.get(change.name) ?? [];
-        for (const svc of refs) {
-          const svcFiles = serviceFiles.get(svc) ?? [];
-          svcFiles.forEach((f) => regenerate.add(f));
-        }
-        break;
-      }
-      case "enum-removed": {
-        const files = enumFiles.get(change.name) ?? [];
-        files.forEach((f) => toDelete.add(f));
-        const refs = modelToServices.get(change.name) ?? [];
-        for (const svc of refs) {
-          const svcFiles = serviceFiles.get(svc) ?? [];
-          svcFiles.forEach((f) => regenerate.add(f));
-        }
-        break;
-      }
-      case "service-added": {
-        const files = serviceFiles.get(change.name) ?? [];
-        files.forEach((f) => regenerate.add(f));
-        break;
-      }
-      case "service-removed": {
-        const files = serviceFiles.get(change.name) ?? [];
-        files.forEach((f) => toDelete.add(f));
-        break;
-      }
-      case "operation-added":
-      case "operation-removed":
-      case "operation-modified": {
-        const files = serviceFiles.get(change.serviceName) ?? [];
-        files.forEach((f) => regenerate.add(f));
-        break;
-      }
-    }
-  }
-  for (const f of toDelete) {
-    regenerate.delete(f);
-  }
-  return {
-    regenerate: [...regenerate].sort(),
-    delete: [...toDelete].sort()
-  };
-}
-function buildReferenceGraph(spec) {
-  const refs = /* @__PURE__ */ new Map();
-  function trackRef(typeRef, serviceName) {
-    const addName = (name) => {
-      if (!refs.has(name)) refs.set(name, /* @__PURE__ */ new Set());
-      refs.get(name).add(serviceName);
-    };
-    walkTypeRef(typeRef, {
-      model: (r) => addName(r.name),
-      enum: (r) => addName(r.name)
-    });
-  }
-  for (const service of spec.services) {
-    for (const op of service.operations) {
-      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
-        trackRef(p.type, service.name);
-      }
-      if (op.requestBody) trackRef(op.requestBody, service.name);
-      trackRef(op.response, service.name);
-    }
-  }
-  const modelDeps = /* @__PURE__ */ new Map();
-  function collectDeps(typeRef, deps) {
-    walkTypeRef(typeRef, {
-      model: (r) => deps.add(r.name),
-      enum: (r) => deps.add(r.name)
-    });
-  }
-  for (const model of spec.models) {
-    const deps = /* @__PURE__ */ new Set();
-    for (const field of model.fields) {
-      collectDeps(field.type, deps);
-    }
-    deps.delete(model.name);
-    if (deps.size > 0) {
-      modelDeps.set(model.name, deps);
-    }
-  }
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const [modelName, services] of refs) {
-      const deps = modelDeps.get(modelName);
-      if (!deps) continue;
-      for (const dep of deps) {
-        if (!refs.has(dep)) refs.set(dep, /* @__PURE__ */ new Set());
-        const depServices = refs.get(dep);
-        for (const svc of services) {
-          if (!depServices.has(svc)) {
-            depServices.add(svc);
-            changed = true;
-          }
-        }
-      }
-    }
-  }
-  const result = /* @__PURE__ */ new Map();
-  for (const [name, svcSet] of refs) {
-    result.set(name, [...svcSet]);
-  }
-  return result;
-}
-
-// src/engine/incremental.ts
-import * as fs from "fs/promises";
-import * as path from "path";
-async function generateIncremental(oldSpec, newSpec, emitter, options) {
-  const diff = diffSpecs(oldSpec, newSpec);
-  if (diff.changes.length === 0) {
-    return { generated: [], deleted: [], diff };
-  }
-  const ctx = buildEmitterContext(newSpec, options);
-  const affected = mapChangesToFiles(diff.changes, emitter, ctx);
-  const allFiles = generateAllFiles(newSpec, emitter, ctx);
-  const header = emitter.fileHeader();
-  const affectedSet = new Set(affected.regenerate);
-  const generated = applyFileHeaders(
-    allFiles.filter((f) => affectedSet.has(f.path)),
-    header
-  );
-  if (!options.dryRun) {
-    const writeResult = await writeFiles(generated, options.outputDir, {
-      language: emitter.language,
-      header
-    });
-    if (writeResult.ignored.length > 0) {
-      console.log(`Ignored ${writeResult.ignored.length} files (@oagen-ignore-file)`);
-    }
-    if (options.target) {
-      const targetResult = await integrateGeneratedFiles({
-        files: generated,
-        language: emitter.language,
-        targetDir: options.target,
-        header
-      });
-      if (targetResult.written.length > 0) {
-        console.log(`Target: created ${targetResult.written.length} new files`);
-      }
-      if (targetResult.merged.length > 0) {
-        console.log(`Target: merged into ${targetResult.merged.length} existing files (additive only)`);
-      }
-      if (targetResult.skipped.length > 0) {
-        console.log(`Target: skipped ${targetResult.skipped.length} files (excluded or no grammar)`);
-      }
-      if (targetResult.ignored.length > 0) {
-        console.log(`Target: ignored ${targetResult.ignored.length} files (@oagen-ignore-file)`);
-      }
-    }
-    if (options.force) {
-      for (const filePath of affected.delete) {
-        const fullPath = path.join(options.outputDir, filePath);
-        await fs.rm(fullPath, { force: true });
-      }
-    }
-  }
-  return {
-    generated,
-    deleted: options.force ? affected.delete : [],
-    diff
-  };
-}
-
 // src/engine/operation-plan.ts
 function planOperation(op) {
   const isDelete = op.httpMethod === "delete";
@@ -1714,10 +1548,8 @@ export {
   generate,
   generateAllFiles,
   generateFiles,
-  generateIncremental,
   getEmitter,
   integrateGeneratedFiles,
-  mapChangesToFiles,
   mapFilesForTargetIntegration,
   mapTypeRef,
   parseSpec,