@workos/oagen 0.1.0 → 0.2.0

package/dist/types-O25qZxMl.d.mts

@@ -0,0 +1,397 @@
+//#region src/compat/types.d.ts
+interface ApiSurface {
+  language: string;
+  extractedFrom: string;
+  extractedAt: string;
+  classes: Record<string, ApiClass>;
+  interfaces: Record<string, ApiInterface>;
+  typeAliases: Record<string, ApiTypeAlias>;
+  enums: Record<string, ApiEnum>;
+  exports: Record<string, string[]>;
+}
+interface ApiClass {
+  name: string;
+  sourceFile?: string;
+  methods: Record<string, ApiMethod[]>;
+  properties: Record<string, ApiProperty>;
+  constructorParams: ApiParam[];
+}
+interface ApiMethod {
+  name: string;
+  params: ApiParam[];
+  returnType: string;
+  async: boolean;
+}
+interface ApiParam {
+  name: string;
+  type: string;
+  optional: boolean;
+}
+interface ApiProperty {
+  name: string;
+  type: string;
+  readonly: boolean;
+}
+interface ApiInterface {
+  name: string;
+  sourceFile?: string;
+  fields: Record<string, ApiField>;
+  extends: string[];
+}
+interface ApiField {
+  name: string;
+  type: string;
+  optional: boolean;
+}
+interface ApiTypeAlias {
+  name: string;
+  sourceFile?: string;
+  value: string;
+}
+interface ApiEnum {
+  name: string;
+  sourceFile?: string;
+  members: Record<string, string | number>;
+}
+interface LanguageHints {
+  /** Strip nullable wrapper, return inner type. null if not nullable.
+   *  Node: "string | null" → "string"
+   *  Go: "*Organization" → "Organization"
+   *  Python: "Optional[str]" → "str" */
+  stripNullable(type: string): string | null;
+  /** True if a and b differ only by nullability. */
+  isNullableOnlyDifference(a: string, b: string): boolean;
+  /** True if a and b are union types with same members in different order. */
+  isUnionReorder(a: string, b: string): boolean;
+  /** True if type is a generic type parameter the extractor can't resolve. */
+  isGenericTypeParam(type: string): boolean;
+  /** True if type is an extraction artifact (extractor couldn't resolve).
+   *  Node: "any"; Python: "Any"; Go: "interface{}" */
+  isExtractionArtifact(type: string): boolean;
+  /** Whether a missing type alias should be tolerated when the candidate
+   *  has the same name as an interface or class (TS allows this). */
+  tolerateCategoryMismatch: boolean;
+  /** Extract innermost meaningful type name from a return type string.
+   *  Node: "Promise<AutoPaginatable<Organization>>" → "Organization" */
+  extractReturnTypeName(returnType: string): string | null;
+  /** Extract meaningful type name from a param type string. null for primitives. */
+  extractParamTypeName(paramType: string): string | null;
+  /** True if sdkResourceProperty maps to className.
+   *  Node: camelCase ("organizations" → "Organizations")
+   *  Ruby: snake_case ("organizations" → "Organizations") */
+  propertyMatchesClass(propertyName: string, className: string): boolean;
+  /** Additional names derived from a model name by this language's emitter.
+   *  Node: ["FooResponse", "SerializedFoo"]
+   *  Go: ["FooResponse"] */
+  derivedModelNames(modelName: string): string[];
+  /** True if two type strings are semantically equivalent even when
+   *  structurally different — e.g., a named enum vs an inline union
+   *  of its string literal values. The candidate surface is provided
+   *  so the hint can look up enum definitions.
+   *  Returns true to suppress the mismatch, false to report it. */
+  isTypeEquivalent?(baselineType: string, candidateType: string, candidateSurface: ApiSurface): boolean;
+  /** True if two method signatures should be considered equivalent despite
+   *  structural differences. Called as a fallback when strict positional
+   *  matching fails — e.g., when the baseline unpacks body fields into
+   *  individual params while the candidate uses a dict/array payload.
+   *  Returns true to suppress the mismatch. */
+  isSignatureEquivalent?(baseline: ApiMethod, candidate: ApiMethod, candidateSurface: ApiSurface): boolean;
+  /** Base class names that indicate a data model (→ ApiInterface).
+   *  Python: ["BaseModel"]; PHP: ["BaseResource"].
+   *  Extractors should provide these for their SDK. */
+  modelBaseClasses?: string[];
+  /** Base class names that indicate an exception class.
+   *  Python: ["Exception", "BaseException"]; PHP: ["Exception"]. */
+  exceptionBaseClasses?: string[];
+  /** Type names for list/paginated resource wrappers (for return type unwrapping).
+   *  The first type argument is extracted as the inner item type.
+   *  e.g., ["ListResource"] causes `ListResource[Org, ...]` → `Org`. */
+  listResourcePatterns?: string[];
+}
+interface Extractor {
+  language: string;
+  extract(sdkPath: string): Promise<ApiSurface>;
+  hints: LanguageHints;
+}
+interface MethodOverlay {
+  className: string;
+  methodName: string;
+  params: ApiParam[];
+  returnType: string;
+}
+interface OverlayLookup {
+  /** HTTP method + path → existing method info */
+  methodByOperation: Map<string, MethodOverlay>;
+  /** Reverse map: "ClassName.methodName" → HTTP key for patchOverlay */
+  httpKeyByMethod: Map<string, string>;
+  /** IR interface name → existing interface name */
+  interfaceByName: Map<string, string>;
+  /** IR type alias name → existing type alias name */
+  typeAliasByName: Map<string, string>;
+  /** Barrel file path → symbols that must be exported */
+  requiredExports: Map<string, Set<string>>;
+  /** IR model name → SDK interface name (auto-inferred from field structure) */
+  modelNameByIR: Map<string, string>;
+  /** IR symbol name → relative file path in the live SDK */
+  fileBySymbol: Map<string, string>;
+}
+type ViolationCategory = 'public-api' | 'signature' | 'export-structure' | 'behavioral' | 'staleness';
+type ViolationSeverity = 'breaking' | 'warning';
+interface Violation {
+  category: ViolationCategory;
+  severity: ViolationSeverity;
+  symbolPath: string;
+  baseline: string;
+  candidate: string;
+  message: string;
+}
+interface Addition {
+  symbolPath: string;
+  symbolType: 'class' | 'method' | 'interface' | 'type-alias' | 'enum' | 'property';
+}
+interface DiffResult {
+  preservationScore: number;
+  totalBaselineSymbols: number;
+  preservedSymbols: number;
+  violations: Violation[];
+  additions: Addition[];
+}
+//#endregion
+//#region src/ir/types.d.ts
+/** Authentication scheme extracted from OpenAPI securitySchemes */
+type AuthScheme = {
+  kind: 'bearer';
+} | {
+  kind: 'apiKey';
+  in: 'header' | 'query' | 'cookie';
+  name: string;
+} | {
+  kind: 'oauth2';
+  flows: Record<string, unknown>;
+};
+/** Root IR node representing the full API surface */
+/** A server entry from the OpenAPI servers array */
+interface ServerEntry {
+  url: string;
+  description?: string;
+}
+/** Root IR node representing the full API surface */
+interface ApiSpec {
+  name: string;
+  version: string;
+  description?: string;
+  baseUrl: string;
+  servers?: ServerEntry[];
+  services: Service[];
+  models: Model[];
+  enums: Enum[];
+  auth?: AuthScheme[];
+}
+/** A service groups related operations (maps to an SDK resource class) */
+interface Service {
+  name: string;
+  description?: string;
+  operations: Operation[];
+}
+/** A single API operation (maps to an SDK method) */
+interface Operation {
+  name: string;
+  description?: string;
+  httpMethod: HttpMethod;
+  path: string;
+  pathParams: Parameter[];
+  queryParams: Parameter[];
+  headerParams: Parameter[];
+  cookieParams?: Parameter[];
+  requestBody?: TypeRef;
+  requestBodyEncoding?: 'json' | 'form-data' | 'form-urlencoded' | 'binary' | 'text';
+  response: TypeRef;
+  successResponses?: SuccessResponse[];
+  errors: ErrorResponse[];
+  pagination?: PaginationMeta;
+  injectIdempotencyKey: boolean;
+  deprecated?: boolean;
+  async?: boolean;
+}
+/** Structured pagination metadata for auto-paging iterator generation */
+interface PaginationMeta {
+  strategy: 'cursor' | 'offset' | 'link-header';
+  param: string;
+  limitParam?: string;
+  dataPath?: string;
+  itemType: TypeRef;
+}
+type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'head' | 'options' | 'trace';
+interface Parameter {
+  name: string;
+  type: TypeRef;
+  required: boolean;
+  description?: string;
+  deprecated?: boolean;
+  default?: unknown;
+  example?: unknown;
+}
+/** Type reference — the core type system of the IR */
+type TypeRef = PrimitiveType | ArrayType | ModelRef | EnumRef | UnionType | NullableType | LiteralType | MapType;
+interface PrimitiveType {
+  kind: 'primitive';
+  type: 'string' | 'integer' | 'number' | 'boolean' | 'unknown';
+  format?: string;
+}
+interface ArrayType {
+  kind: 'array';
+  items: TypeRef;
+}
+interface ModelRef {
+  kind: 'model';
+  name: string;
+}
+interface EnumRef {
+  kind: 'enum';
+  name: string;
+  values?: (string | number)[];
+}
+interface LiteralType {
+  kind: 'literal';
+  value: string | number | boolean | null;
+}
+interface UnionType {
+  kind: 'union';
+  variants: TypeRef[];
+  discriminator?: {
+    property: string;
+    mapping: Record<string, string>;
+  };
+  /** Which OAS composition keyword produced this union. Emitters can use this to
+   *  distinguish inheritance (allOf) from exclusive union (oneOf) from open union (anyOf). */
+  compositionKind?: 'allOf' | 'oneOf' | 'anyOf';
+}
+interface NullableType {
+  kind: 'nullable';
+  inner: TypeRef;
+}
+interface MapType {
+  kind: 'map';
+  valueType: TypeRef;
+  keyType?: TypeRef;
+}
+/**
+ * A generic type parameter on a model.
+ * Example: `DirectoryUser<TCustomAttributes = Record<string, unknown>>`
+ * → `{ name: 'TCustomAttributes', default: { kind: 'map', valueType: { kind: 'primitive', type: 'unknown' } } }`
+ */
+interface TypeParam {
+  name: string;
+  /** Default type when the param is not specified. */
+  default?: TypeRef;
+}
+/** Model definition (maps to an SDK model/data class) */
+interface Model {
+  name: string;
+  description?: string;
+  fields: Field[];
+  /** Generic type parameters. Empty/undefined for non-generic models. */
+  typeParams?: TypeParam[];
+}
+interface Field {
+  name: string;
+  type: TypeRef;
+  required: boolean;
+  description?: string;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  deprecated?: boolean;
+  default?: unknown;
+  example?: unknown;
+}
+/** Enum definition */
+interface Enum {
+  name: string;
+  values: EnumValue[];
+}
+interface EnumValue {
+  name: string;
+  value: string | number;
+  description?: string;
+  deprecated?: boolean;
+}
+/**
+ * Exhaustive check helper for TypeRef switches.
+ * If a new kind is added to TypeRef, any switch that doesn't handle it
+ * will fail to compile because `never` won't accept the unhandled variant.
+ *
+ * Usage:
+ *   switch (ref.kind) {
+ *     case 'primitive': ...
+ *     case 'array': ...
+ *     // If you forget 'literal', TypeScript errors here:
+ *     default: assertNever(ref);
+ *   }
+ */
+declare function assertNever(x: never): never;
+/**
+ * Generic depth-first walker for TypeRef trees.
+ * Handles recursion into array/nullable/union/map children and provides
+ * an exhaustive `assertNever` check so callers don't need to repeat the
+ * switch boilerplate.  Supply callbacks only for the leaf kinds you care about.
+ */
+declare function walkTypeRef(ref: TypeRef, visitor: {
+  model?: (ref: ModelRef) => void;
+  enum?: (ref: EnumRef) => void;
+  primitive?: (ref: PrimitiveType) => void;
+  literal?: (ref: LiteralType) => void;
+}): void;
+/**
+ * Generic depth-first mapper for TypeRef trees.
+ * Like walkTypeRef but returns a transformed value instead of void.
+ * Handles recursion into array/nullable/union/map children, passing
+ * already-mapped child values to the parent callback.
+ */
+declare function mapTypeRef<T>(ref: TypeRef, mapper: {
+  primitive: (ref: PrimitiveType) => T;
+  array: (ref: ArrayType, mappedItems: T) => T;
+  model: (ref: ModelRef) => T;
+  enum: (ref: EnumRef) => T;
+  union: (ref: UnionType, mappedVariants: T[]) => T;
+  nullable: (ref: NullableType, mappedInner: T) => T;
+  literal: (ref: LiteralType) => T;
+  map: (ref: MapType, mappedValue: T, mappedKey?: T) => T;
+}): T;
+/**
+ * Collect all model names referenced (directly or transitively) by a TypeRef.
+ */
+declare function collectModelRefs(ref: TypeRef): string[];
+/**
+ * Collect all enum names referenced by a TypeRef.
+ */
+declare function collectEnumRefs(ref: TypeRef): string[];
+/**
+ * Collect all TypeRef-referenced model and enum names from a model's fields.
+ * Returns { models, enums } sets for generating import statements.
+ */
+declare function collectFieldDependencies(model: Model): {
+  models: Set<string>;
+  enums: Set<string>;
+};
+/**
+ * Assign each model to the service that first references it.
+ * Models referenced by multiple services are assigned to the first.
+ * Models not referenced by any service are unassigned (absent from the map).
+ */
+declare function assignModelsToServices(models: Model[], services: Service[]): Map<string, string>;
+/**
+ * Collect all model names referenced as request bodies across all services.
+ */
+declare function collectRequestBodyModels(services: Service[]): Set<string>;
+interface ErrorResponse {
+  statusCode: number;
+  type?: TypeRef;
+}
+/** A successful response entry from a 2xx status code */
+interface SuccessResponse {
+  statusCode: number;
+  type: TypeRef;
+}
+//#endregion
+export { collectRequestBodyModels as A, ApiProperty as B, TypeRef as C, collectEnumRefs as D, assignModelsToServices as E, ApiEnum as F, LanguageHints as G, ApiTypeAlias as H, ApiField as I, Violation as J, MethodOverlay as K, ApiInterface as L, walkTypeRef as M, Addition as N, collectFieldDependencies as O, ApiClass as P, ApiMethod as R, TypeParam as S, assertNever as T, DiffResult as U, ApiSurface as V, Extractor as W, ViolationSeverity as X, ViolationCategory as Y, Parameter as _, EnumRef as a, Service as b, Field as c, MapType as d, Model as f, PaginationMeta as g, Operation as h, Enum as i, mapTypeRef as j, collectModelRefs as k, HttpMethod as l, NullableType as m, ArrayType as n, EnumValue as o, ModelRef as p, OverlayLookup as q, AuthScheme as r, ErrorResponse as s, ApiSpec as t, LiteralType as u, PrimitiveType as v, UnionType as w, SuccessResponse as x, ServerEntry as y, ApiParam as z };
+//# sourceMappingURL=types-O25qZxMl.d.mts.map

package/dist/types-O25qZxMl.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-O25qZxMl.d.mts","names":[],"sources":["../src/compat/types.ts","../src/ir/types.ts"],"mappings":"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"}

package/dist/verify/index.d.mts

@@ -0,0 +1,82 @@
+import { J as Violation, U as DiffResult, V as ApiSurface, t as ApiSpec } from "../types-O25qZxMl.mjs";
+
+//#region src/verify/types.d.ts
+interface VerifyDiagnostics {
+  compatCheck?: {
+    totalBaselineSymbols: number;
+    preservedSymbols: number;
+    preservationScore: number;
+    violationsByCategory: Record<string, number>;
+    violationsBySeverity: Record<string, number>;
+    additions: number;
+    scopedToSpec: boolean;
+    scopedSymbolCount?: number;
+  };
+  stalenessCheck?: {
+    staleSymbolCount: number;
+    staleSymbols: string[];
+  };
+  smokeCheck?: {
+    passed: boolean;
+    findingsCount?: number;
+    compileErrors?: boolean;
+  };
+  retryLoop?: {
+    attempts: number;
+    converged: boolean;
+    finalScore: number;
+    patchedPerIteration: number[];
+  };
+}
+interface CompatCheckResult {
+  passed: boolean;
+  diff: DiffResult;
+  scopedToSpec: boolean;
+  scopedSymbolCount?: number;
+}
+interface OverlayRetryResult {
+  status: 'passed' | 'max-retries' | 'no-patchable' | 'stalled';
+  attempts: number;
+  patchedPerIteration: number[];
+  compatResult: CompatCheckResult;
+}
+interface SmokeCheckResult {
+  passed: boolean;
+  findingsCount?: number;
+  compileErrors?: boolean;
+  baselinePath: string;
+  generatedBaseline: boolean;
+}
+interface StalenessCheckResult {
+  violations: Violation[];
+}
+//#endregion
+//#region src/verify/run-compat-check.d.ts
+declare function runCompatCheck(baseline: ApiSurface, outputDir: string, lang: string, spec?: ApiSpec): Promise<CompatCheckResult>;
+//#endregion
+//#region src/verify/run-overlay-retry-loop.d.ts
+declare function runOverlayRetryLoop(opts: {
+  baseline: ApiSurface;
+  parsedSpec: ApiSpec;
+  outputDir: string;
+  lang: string;
+  maxRetries: number;
+  namespace?: string;
+  onRetry?: (attemptNumber: number, maxRetries: number, patchableCount: number) => void;
+}): Promise<OverlayRetryResult>;
+//#endregion
+//#region src/verify/run-staleness-check.d.ts
+declare function runStalenessCheck(baseline: ApiSurface, oldSpec: ApiSpec, newSpec: ApiSpec, lang: string): StalenessCheckResult;
+//#endregion
+//#region src/verify/run-smoke-check.d.ts
+declare function runSmokeCheck(opts: {
+  spec?: string;
+  lang: string;
+  output: string;
+  rawResults?: string;
+  smokeConfig?: string;
+  smokeRunner?: string;
+}): SmokeCheckResult;
+//#endregion
+export { type VerifyDiagnostics, runCompatCheck, runOverlayRetryLoop, runSmokeCheck, runStalenessCheck };
+//# sourceMappingURL=index.d.mts.map

package/dist/verify/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/verify/types.ts","../../src/verify/run-compat-check.ts","../../src/verify/run-overlay-retry-loop.ts","../../src/verify/run-staleness-check.ts","../../src/verify/run-smoke-check.ts"],"mappings":";;;UAEiB,iBAAA;EACf,WAAA;IACE,oBAAA;IACA,gBAAA;IACA,iBAAA;IACA,oBAAA,EAAsB,MAAA;IACtB,oBAAA,EAAsB,MAAA;IACtB,SAAA;IACA,YAAA;IACA,iBAAA;EAAA;EAEF,cAAA;IACE,gBAAA;IACA,YAAA;EAAA;EAEF,UAAA;IACE,MAAA;IACA,aAAA;IACA,aAAA;EAAA;EAEF,SAAA;IACE,QAAA;IACA,SAAA;IACA,UAAA;IACA,mBAAA;EAAA;AAAA;AAAA,UAIa,iBAAA;EACf,MAAA;EACA,IAAA,EAAM,UAAA;EACN,YAAA;EACA,iBAAA;AAAA;AAAA,UAGe,kBAAA;EACf,MAAA;EACA,QAAA;EACA,mBAAA;EACA,YAAA,EAAc,iBAAA;AAAA;AAAA,UAGC,gBAAA;EACf,MAAA;EACA,aAAA;EACA,aAAA;EACA,YAAA;EACA,iBAAA;AAAA;AAAA,UAGe,oBAAA;EACf,UAAA,EAAY,SAAA;AAAA;;;iBCxCQ,cAAA,CACpB,QAAA,EAAU,UAAA,EACV,SAAA,UACA,IAAA,UACA,IAAA,GAAO,OAAA,GACN,OAAA,CAAQ,iBAAA;;;iBC8EW,mBAAA,CAAoB,IAAA;EACxC,QAAA,EAAU,UAAA;EACV,UAAA,EAAY,OAAA;EACZ,SAAA;EACA,IAAA;EACA,UAAA;EACA,SAAA;EACA,OAAA,IAAW,aAAA,UAAuB,UAAA,UAAoB,cAAA;AAAA,IACpD,OAAA,CAAQ,kBAAA;;;iBClGI,iBAAA,CACd,QAAA,EAAU,UAAA,EACV,OAAA,EAAS,OAAA,EACT,OAAA,EAAS,OAAA,EACT,IAAA,WACC,oBAAA;;;iBCca,aAAA,CAAc,IAAA;EAC5B,IAAA;EACA,IAAA;EACA,MAAA;EACA,UAAA;EACA,WAAA;EACA,WAAA;AAAA,IACE,gBAAA"}