@ir-kit/openapi 0.1.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ir-kit/openapi",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Language-agnostic OpenAPI IR-walking primitives shared by the native-SDK generators. Each helper consumes @hey-api/shared's IR and returns target-neutral data — parameter locations, response categories, body media-type classifications — so per-language emitters can stay focused on rendering.",
   "keywords": [
     "openapi",
@@ -56,7 +56,7 @@
   },
   "dependencies": {
     "@ir-kit/codegen-core": "0.1.0",
-    "@ir-kit/openapi-core": "0.1.0"
+    "@ir-kit/schema": "0.2.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",

package/dist/type/enum.d.ts

@@ -1,42 +0,0 @@
-/**
- * The supported leaf shape for `IR.SchemaObject` enum values. Mirrors
- * `EnumLiteral` from `@ir-kit/openapi-tools` — re-declared here to keep
- * the package's dependency footprint minimal (this is a 3-word union;
- * a workspace dep just to import it would be heavyweight).
- */
-export type EnumLiteral = string | number | boolean;
-export type EnumKind = "string" | "integer";
-/**
- * Classify a set of enum literals as all-string or all-integer. Throws
- * on mixed (or otherwise unsupported) shapes. Each emitter then picks
- * its target rendering — Go emits `type ... string` + typed-consts,
- * Kotlin emits an `enum class(val raw: String)` or a typealias to
- * `Int`, Swift emits a raw-typed `enum: String, Codable`.
- *
- * `name` is woven into the thrown error message so the caller doesn't
- * have to re-wrap; emitter call-sites previously open-coded the same
- * `throw new Error(\`Enum ${name}: members must all be strings or all
- * integers; got ...\`)` line.
- */
-export declare function classifyEnumLiterals(values: ReadonlyArray<EnumLiteral>, name: string): EnumKind;
-export interface EnumEntryIdent<T extends string | number> {
-    /** The identifier emitted into the target source (Go `StatusAvailable`,
-     *  Kotlin `available`, Swift `available`). */
-    identifier: string;
-    /** The raw enum value the identifier was derived from. */
-    raw: T;
-}
-/**
- * Detect emitter-side identifier collisions across enum entries and
- * throw a descriptive error. Each emitter normalises raw enum values
- * to its own identifier convention (Go `enumEntrySuffix`, Kotlin
- * `enumEntryIdent`, Swift `safeCaseName`); when two raw values
- * normalise to the same identifier the emitted source won't compile,
- * so we throw early with the offending name and the colliding raws.
- *
- * `noun` is the label used in the error message — kept per-emitter to
- * preserve historical wording (Go / Kotlin say `entry name`, Swift
- * says `case name`); tests pin the exact phrase.
- */
-export declare function assertNoEnumCollisions<T extends string | number>(schemaName: string, entries: Iterable<EnumEntryIdent<T>>, noun?: "entry name" | "case name"): void;
-//# sourceMappingURL=enum.d.ts.map

package/dist/type/enum.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../src/type/enum.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEpD,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE5C;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,EAClC,IAAI,EAAE,MAAM,GACX,QAAQ,CAWV;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACvD;kDAC8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,GAAG,EAAE,CAAC,CAAC;CACR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAC9D,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EACpC,IAAI,GAAE,YAAY,GAAG,WAA0B,GAC9C,IAAI,CAiBN"}

package/dist/type/enum.js

@@ -1,49 +0,0 @@
-/**
- * Classify a set of enum literals as all-string or all-integer. Throws
- * on mixed (or otherwise unsupported) shapes. Each emitter then picks
- * its target rendering — Go emits `type ... string` + typed-consts,
- * Kotlin emits an `enum class(val raw: String)` or a typealias to
- * `Int`, Swift emits a raw-typed `enum: String, Codable`.
- *
- * `name` is woven into the thrown error message so the caller doesn't
- * have to re-wrap; emitter call-sites previously open-coded the same
- * `throw new Error(\`Enum ${name}: members must all be strings or all
- * integers; got ...\`)` line.
- */
-export function classifyEnumLiterals(values, name) {
-    const allStrings = values.every((v) => typeof v === "string");
-    const allIntegers = values.every((v) => typeof v === "number" && Number.isInteger(v));
-    if (!allStrings && !allIntegers) {
-        throw new Error(`Enum ${name}: members must all be strings or all integers; got ${JSON.stringify(values)}`);
-    }
-    return allIntegers ? "integer" : "string";
-}
-/**
- * Detect emitter-side identifier collisions across enum entries and
- * throw a descriptive error. Each emitter normalises raw enum values
- * to its own identifier convention (Go `enumEntrySuffix`, Kotlin
- * `enumEntryIdent`, Swift `safeCaseName`); when two raw values
- * normalise to the same identifier the emitted source won't compile,
- * so we throw early with the offending name and the colliding raws.
- *
- * `noun` is the label used in the error message — kept per-emitter to
- * preserve historical wording (Go / Kotlin say `entry name`, Swift
- * says `case name`); tests pin the exact phrase.
- */
-export function assertNoEnumCollisions(schemaName, entries, noun = "entry name") {
-    const collisions = new Map();
-    for (const { identifier, raw } of entries) {
-        const list = collisions.get(identifier) ?? [];
-        list.push(raw);
-        collisions.set(identifier, list);
-    }
-    for (const [identifier, raws] of collisions) {
-        if (raws.length > 1) {
-            const formatted = raws
-                .map((r) => (typeof r === "string" ? `"${r}"` : String(r)))
-                .join(", ");
-            throw new Error(`Enum ${schemaName}: ${noun} "${identifier}" collides for raw values [${formatted}]`);
-        }
-    }
-}
-//# sourceMappingURL=enum.js.map

package/dist/type/enum.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../src/type/enum.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAClC,MAAkC,EAClC,IAAY;IAEZ,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC;IAC9D,MAAM,WAAW,GAAG,MAAM,CAAC,KAAK,CAC9B,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CACpD,CAAC;IACF,IAAI,CAAC,UAAU,IAAI,CAAC,WAAW,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,QAAQ,IAAI,sDAAsD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAC3F,CAAC;IACJ,CAAC;IACD,OAAO,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC5C,CAAC;AAUD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,sBAAsB,CACpC,UAAkB,EAClB,OAAoC,EACpC,OAAmC,YAAY;IAE/C,MAAM,UAAU,GAAG,IAAI,GAAG,EAAe,CAAC;IAC1C,KAAK,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,OAAO,EAAE,CAAC;QAC1C,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QAC9C,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACf,UAAU,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;IACD,KAAK,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,UAAU,EAAE,CAAC;QAC5C,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpB,MAAM,SAAS,GAAG,IAAI;iBACnB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;iBAC1D,IAAI,CAAC,IAAI,CAAC,CAAC;YACd,MAAM,IAAI,KAAK,CACb,QAAQ,UAAU,KAAK,IAAI,KAAK,UAAU,8BAA8B,SAAS,GAAG,CACrF,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/type/object.d.ts

@@ -1,53 +0,0 @@
-import type { IR } from "@hey-api/shared";
-/**
- * High-level dispatch for inline object schemas. Each emitter then
- * picks its target rendering:
- *
- *  - `named-struct`  → synth a name, emit a struct/data-class/struct,
- *                      return a ref to it
- *  - `map`           → render as `map[string]V` / `Map<String, V>` /
- *                      `[String: V]` over the inner value schema
- *  - `open-map`      → same map, but value is `any` / `Any` / `Any`
- *                      since `additionalProperties` was missing or
- *                      `true`/empty
- */
-export type ObjectShape = {
-    kind: "named-struct";
-} | {
-    kind: "map";
-    valueSchema: IR.SchemaObject;
-} | {
-    kind: "open-map";
-};
-/**
- * Classify an object-shaped schema by its property layout. Used by
- * each emitter's `inlineObjectType` to drive the same three-way
- * dispatch identically.
- */
-export declare function classifyObjectShape(schema: IR.SchemaObject): ObjectShape;
-export interface ObjectProperty {
-    jsonKey: string;
-    schema: IR.SchemaObject;
-    /** True when the property name appears in `schema.required`. */
-    required: boolean;
-    /** True when the property is `string` + `format: "binary"`. Common
-     *  enough across emitters (multipart-binary handling) to surface
-     *  alongside the basic iteration. */
-    isBinary: boolean;
-    /** The propPath segment for this property, ready to plug into a
-     *  recursive `schemaToType(propSchema, { ...ctx, propPath: [segment] })`
-     *  call. Pre-computed as `pascal(jsonKey)` since both `synthName`
-     *  variants (codegen-core's `_`-joined and Go's `""`-joined) expect
-     *  PascalCase parts. */
-    propPathSegment: string;
-}
-/**
- * Walk `schema.properties` in declaration order and yield one
- * `ObjectProperty` per entry, with the `required` membership,
- * binary-format detection, and pre-computed propPath segment
- * surfaced. Used by every emitter's `type/object.ts`
- * (struct/data-class/struct field generation) and `operation/body.ts`
- * (multipart / urlencoded flat-param expansion).
- */
-export declare function iterateObjectProperties(schema: IR.SchemaObject): Generator<ObjectProperty>;
-//# sourceMappingURL=object.d.ts.map

package/dist/type/object.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/type/object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAG1C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,WAAW,EAAE,EAAE,CAAC,YAAY,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC;AAEzB;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY,GAAG,WAAW,CAMxE;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,EAAE,CAAC,YAAY,CAAC;IACxB,gEAAgE;IAChE,QAAQ,EAAE,OAAO,CAAC;IAClB;;yCAEqC;IACrC,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;4BAIwB;IACxB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAiB,uBAAuB,CACtC,MAAM,EAAE,EAAE,CAAC,YAAY,GACtB,SAAS,CAAC,cAAc,CAAC,CAW3B"}

package/dist/type/object.js

@@ -1,36 +0,0 @@
-import { pascal } from "@ir-kit/codegen-core";
-/**
- * Classify an object-shaped schema by its property layout. Used by
- * each emitter's `inlineObjectType` to drive the same three-way
- * dispatch identically.
- */
-export function classifyObjectShape(schema) {
-    const hasNamedProperties = Object.keys(schema.properties ?? {}).length > 0;
-    if (hasNamedProperties)
-        return { kind: "named-struct" };
-    const ap = schema.additionalProperties;
-    if (ap && typeof ap === "object")
-        return { kind: "map", valueSchema: ap };
-    return { kind: "open-map" };
-}
-/**
- * Walk `schema.properties` in declaration order and yield one
- * `ObjectProperty` per entry, with the `required` membership,
- * binary-format detection, and pre-computed propPath segment
- * surfaced. Used by every emitter's `type/object.ts`
- * (struct/data-class/struct field generation) and `operation/body.ts`
- * (multipart / urlencoded flat-param expansion).
- */
-export function* iterateObjectProperties(schema) {
-    const required = new Set(schema.required ?? []);
-    for (const [jsonKey, propSchema] of Object.entries(schema.properties ?? {})) {
-        yield {
-            jsonKey,
-            schema: propSchema,
-            required: required.has(jsonKey),
-            isBinary: propSchema.type === "string" && propSchema.format === "binary",
-            propPathSegment: pascal(jsonKey),
-        };
-    }
-}
-//# sourceMappingURL=object.js.map

package/dist/type/object.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/type/object.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAmB9C;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAuB;IACzD,MAAM,kBAAkB,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IAC3E,IAAI,kBAAkB;QAAE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC;IACxD,MAAM,EAAE,GAAG,MAAM,CAAC,oBAAoB,CAAC;IACvC,IAAI,EAAE,IAAI,OAAO,EAAE,KAAK,QAAQ;QAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC;IAC1E,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAC9B,CAAC;AAmBD;;;;;;;GAOG;AACH,MAAM,SAAS,CAAC,CAAC,uBAAuB,CACtC,MAAuB;IAEvB,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;IAChD,KAAK,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC,EAAE,CAAC;QAC5E,MAAM;YACJ,OAAO;YACP,MAAM,EAAE,UAAU;YAClB,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC;YAC/B,QAAQ,EAAE,UAAU,CAAC,IAAI,KAAK,QAAQ,IAAI,UAAU,CAAC,MAAM,KAAK,QAAQ;YACxE,eAAe,EAAE,MAAM,CAAC,OAAO,CAAC;SACjC,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/type/union.d.ts

@@ -1,35 +0,0 @@
-import type { IR } from "@hey-api/shared";
-/**
- * Outcome of inspecting a union-shaped schema. Pure structural —
- * caller still needs to decide how to render each kind in its target
- * language (Go pointer vs Kotlin nullable vs Swift optional, fall-back
- * to `any` vs `Any` vs language equivalents).
- */
-export type UnionShape = {
-    kind: "intersection-with-properties";
-} | {
-    kind: "intersection-empty";
-} | {
-    kind: "single";
-    inner: IR.SchemaObject;
-    nullable: boolean;
-} | {
-    kind: "multi";
-    nullable: boolean;
-};
-/**
- * Classify a union-shaped schema (`logicalOperator: "or" | "and"`)
- * into one of the cases each emitter handles. hey-api represents
- * OpenAPI 3.1 nullables as `or` unions with a `{type:"null"}` branch;
- * `allOf` folds become `and`.
- *
- *  - `and` + properties → caller dispatches to its inline-object path.
- *  - `and` empty        → caller renders its `any` analog.
- *  - 1 non-null branch  → caller renders the inner, applying its own
- *                         nullable wrapper iff `nullable === true`.
- *  - 2+ non-null        → caller falls back to its `any`; `nullable`
- *                         is reported but caller decides whether to
- *                         apply it (Go drops it, KT/Swift wrap).
- */
-export declare function classifyUnion(schema: IR.SchemaObject): UnionShape;
-//# sourceMappingURL=union.d.ts.map

package/dist/type/union.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"union.d.ts","sourceRoot":"","sources":["../../src/type/union.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,8BAA8B,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,oBAAoB,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;AAEzC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY,GAAG,UAAU,CAajE"}

package/dist/type/union.js

@@ -1,29 +0,0 @@
-/**
- * Classify a union-shaped schema (`logicalOperator: "or" | "and"`)
- * into one of the cases each emitter handles. hey-api represents
- * OpenAPI 3.1 nullables as `or` unions with a `{type:"null"}` branch;
- * `allOf` folds become `and`.
- *
- *  - `and` + properties → caller dispatches to its inline-object path.
- *  - `and` empty        → caller renders its `any` analog.
- *  - 1 non-null branch  → caller renders the inner, applying its own
- *                         nullable wrapper iff `nullable === true`.
- *  - 2+ non-null        → caller falls back to its `any`; `nullable`
- *                         is reported but caller decides whether to
- *                         apply it (Go drops it, KT/Swift wrap).
- */
-export function classifyUnion(schema) {
-    if (schema.logicalOperator === "and") {
-        return schema.properties
-            ? { kind: "intersection-with-properties" }
-            : { kind: "intersection-empty" };
-    }
-    const items = schema.items ?? [];
-    const nonNull = items.filter((i) => i.type !== "null");
-    const nullable = nonNull.length < items.length;
-    if (nonNull.length === 1) {
-        return { kind: "single", inner: nonNull[0], nullable };
-    }
-    return { kind: "multi", nullable };
-}
-//# sourceMappingURL=union.js.map

package/dist/type/union.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"union.js","sourceRoot":"","sources":["../../src/type/union.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,aAAa,CAAC,MAAuB;IACnD,IAAI,MAAM,CAAC,eAAe,KAAK,KAAK,EAAE,CAAC;QACrC,OAAO,MAAM,CAAC,UAAU;YACtB,CAAC,CAAC,EAAE,IAAI,EAAE,8BAA8B,EAAE;YAC1C,CAAC,CAAC,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC;IACrC,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC;IACjC,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC;IACvD,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC/C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAE,EAAE,QAAQ,EAAE,CAAC;IAC1D,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;AACrC,CAAC"}