@kurotako/ir 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @kurotako/ir
 
+## 0.3.0
+
+### Minor Changes
+
+- 9fe08b3: Add an `array` field type to the IR and bump the IR format to `'4'`.
+  
+  - `@kurotako/ir`: new `{ kind: 'array', element: FieldType }` field type, so an
+    array-typed type alias, union variant or map value can be represented (the
+    boolean `Field.list` fast path stays as an optimisation for a plain
+    `property: { type: 'array', items: <scalar|ref> }`). Builders (`.array(...)`),
+    validation, reference traversal, cycle analysis and TypeScript-type helpers
+    recurse through it. The strict compatibility check now requires `irVersion` `'4'`.
+  - `@kurotako/gen-zod`: renders an array as `z.array(<element>)` and its TS type as
+    `<element>[]`.
+  - `@kurotako/gen-typescript`: renders an array as `<element>[]`, parenthesising a
+    union element.
+  - `@kurotako/gen-angular`: renders an array field as `FormControl<<element>[]>`
+    seeded with `[]`.
+  - `@kurotako/parser-openapi`: an array schema that is not a plain object property
+    (an array-typed response/component alias, a nested array, an array inside a
+    `oneOf`/`additionalProperties`) now maps to the `array` field type instead of
+    silently dropping the array wrapper. Nested arrays are supported.
+- ecdb02c: Add the OpenAPI parser and IR typed maps.
+  
+  - `@kurotako/ir`: adds the `{ kind: 'map', value: FieldType }`
+    field type and the optional `Entity.additionalProperties` slot. Builders,
+    validation, reference traversal, cycle analysis and TypeScript-type helpers
+    recurse through both.
+  - `@kurotako/gen-zod`: renders map values as `z.record(z.string(), value)` and an
+    entity catch-all as `.catchall(value)`.
+  - `@kurotako/gen-typescript`: renders map values as `Record<string, Value>` and an
+    entity catch-all as an index signature.
+  - `@kurotako/gen-angular`: renders a map field as `FormControl<Record<string, Value>>`
+    seeded with `{}`; entity-level catch-all values stay under the emitted Zod validator.
+  - `@kurotako/parser-openapi`: new package. Turns an OpenAPI 3.0/3.1 document (local
+    JSON/YAML or an unauthenticated HTTP(S) URL) into one `SourceIR`, mapping component
+    and inline operation schemas to deterministic entities, aliases, enums and typed maps.
+
 ## 0.2.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -144,6 +144,8 @@ var FieldTypeSchema = v.lazy(
     v.object({ kind: v.literal("enum"), ref: v.string() }),
     v.object({ kind: v.literal("unknown"), hint: v.optional(v.string()) }),
     v.object({ kind: v.literal("ref"), ref: v.string() }),
+    v.object({ kind: v.literal("map"), value: FieldTypeSchema }),
+    v.object({ kind: v.literal("array"), element: FieldTypeSchema }),
     v.object({
       kind: v.literal("union"),
       variants: v.array(FieldTypeSchema),
@@ -228,6 +230,7 @@ var CompositeUniqueSchema = v.object({
 var EntitySchema = v.object({
   name: v.string(),
   fields: v.array(FieldSchema),
+  additionalProperties: v.optional(FieldTypeSchema),
   relations: v.array(RelationSchema),
   enums: v.optional(v.record(v.string(), EnumDefSchema)),
   primaryKey: v.optional(v.array(v.string())),
@@ -253,7 +256,7 @@ var IrSchema = v.object({
 var v2 = __toESM(require("valibot"), 1);
 
 // src/version.ts
-var IR_VERSION = "2";
+var IR_VERSION = "4";
 function isCompatible(irVersion) {
   return irVersion === IR_VERSION;
 }
@@ -351,6 +354,19 @@ function walkFieldType(type, path, entity, source, issues, info) {
       }
       return;
     }
+    case "map":
+      walkFieldType(type.value, `${path}.value`, entity, source, issues, info);
+      return;
+    case "array":
+      walkFieldType(
+        type.element,
+        `${path}.element`,
+        entity,
+        source,
+        issues,
+        info
+      );
+      return;
     case "union": {
       if (type.variants.length < 2) {
         pushIssue(
@@ -397,6 +413,10 @@ function collectRefs(type, out) {
     for (const variant2 of type.variants) {
       collectRefs(variant2, out);
     }
+  } else if (type.kind === "map") {
+    collectRefs(type.value, out);
+  } else if (type.kind === "array") {
+    collectRefs(type.element, out);
   }
 }
 function checkRefCycles(namespace, source, info) {
@@ -486,6 +506,16 @@ function checkSource(namespace, source, lookupEntity, isNamespacePresent, issues
       checkConstraints(issues, `${fPath}.constraints`, field.constraints);
       walkFieldType(field.type, fPath, entity, source, issues, info);
     }
+    if (entity.additionalProperties !== void 0) {
+      walkFieldType(
+        entity.additionalProperties,
+        `${ePath}.additionalProperties`,
+        entity,
+        source,
+        issues,
+        info
+      );
+    }
     for (const [localKey, def] of Object.entries(entity.enums ?? {})) {
       if (def.name !== localKey) {
         pushIssue(
@@ -736,6 +766,18 @@ var UnionBuilderImpl = class _UnionBuilderImpl {
     }
     return this;
   }
+  map(build) {
+    const value = new TypeAliasBuilderImpl(this.#path, "map-value");
+    build(value);
+    this.#variants.push({ kind: "map", value: value.build().type });
+    return this;
+  }
+  array(build) {
+    const element = new TypeAliasBuilderImpl(this.#path, "array-element");
+    build(element);
+    this.#variants.push({ kind: "array", element: element.build().type });
+    return this;
+  }
   unknown(hint) {
     this.#variants.push(
       hint === void 0 ? { kind: "unknown" } : { kind: "unknown", hint }
@@ -777,7 +819,7 @@ var UnionBuilderImpl = class _UnionBuilderImpl {
     return type;
   }
 };
-var TypeAliasBuilderImpl = class {
+var TypeAliasBuilderImpl = class _TypeAliasBuilderImpl {
   #path;
   #name;
   #type = { kind: "unknown" };
@@ -804,6 +846,18 @@ var TypeAliasBuilderImpl = class {
     this.#type = nested.build();
     return this;
   }
+  map(build) {
+    const value = new _TypeAliasBuilderImpl(this.#path, "map-value");
+    build(value);
+    this.#type = { kind: "map", value: value.build().type };
+    return this;
+  }
+  array(build) {
+    const element = new _TypeAliasBuilderImpl(this.#path, "array-element");
+    build(element);
+    this.#type = { kind: "array", element: element.build().type };
+    return this;
+  }
   unknown(hint) {
     this.#type = hint === void 0 ? { kind: "unknown" } : { kind: "unknown", hint };
     return this;
@@ -857,6 +911,18 @@ var FieldBuilderImpl = class {
     this.#field.type = builder.build();
     return this;
   }
+  map(build) {
+    const value = new TypeAliasBuilderImpl(this.#path, "map-value");
+    build(value);
+    this.#field.type = { kind: "map", value: value.build().type };
+    return this;
+  }
+  array(build) {
+    const element = new TypeAliasBuilderImpl(this.#path, "array-element");
+    build(element);
+    this.#field.type = { kind: "array", element: element.build().type };
+    return this;
+  }
   unknown(hint) {
     this.#field.type = hint === void 0 ? { kind: "unknown" } : { kind: "unknown", hint };
     return this;
@@ -1000,6 +1066,7 @@ var EntityBuilderImpl = class {
   #uniques = [];
   #doc;
   #dbName;
+  #additionalProperties;
   constructor(namespace, name) {
     this.#namespace = namespace;
     this.#name = name;
@@ -1026,6 +1093,15 @@ var EntityBuilderImpl = class {
     this.#fields.push(builder);
     return this;
   }
+  additionalProperties(def) {
+    const value = new TypeAliasBuilderImpl(
+      `${this.#namespace}.${this.#name}.additionalProperties`,
+      "additionalProperties"
+    );
+    def(value);
+    this.#additionalProperties = value.build().type;
+    return this;
+  }
   relation(name, def) {
     const builder = new RelationBuilderImpl(name);
     def(builder);
@@ -1091,6 +1167,9 @@ var EntityBuilderImpl = class {
     if (this.#dbName !== void 0) {
       entity.dbName = this.#dbName;
     }
+    if (this.#additionalProperties !== void 0) {
+      entity.additionalProperties = this.#additionalProperties;
+    }
     return entity;
   }
 };
@@ -1209,6 +1288,10 @@ function collectRefNames(type, into = /* @__PURE__ */ new Set()) {
     for (const variant2 of type.variants) {
       collectRefNames(variant2, into);
     }
+  } else if (type.kind === "map") {
+    collectRefNames(type.value, into);
+  } else if (type.kind === "array") {
+    collectRefNames(type.element, into);
   }
   return into;
 }
@@ -1230,6 +1313,9 @@ function refCycleMembers(source) {
     for (const field of entity.fields) {
       collectRefNames(field.type, set);
     }
+    if (entity.additionalProperties !== void 0) {
+      collectRefNames(entity.additionalProperties, set);
+    }
   }
   const canReachSelf = (start) => {
     const seen = /* @__PURE__ */ new Set();
@@ -1270,6 +1356,10 @@ function fieldTypeKey(type) {
       return `ref:${type.ref}`;
     case "unknown":
       return `unknown:${type.hint ?? ""}`;
+    case "map":
+      return `map:${fieldTypeKey(type.value)}`;
+    case "array":
+      return `array:${fieldTypeKey(type.element)}`;
     case "union":
       return `union:${flattenUnion(type).map(fieldTypeKey).join(",")}`;
   }
@@ -1357,6 +1447,12 @@ function scalarTsType(type) {
       return flattenUnion(type).map(
         (variant2) => variant2.kind === "union" ? `(${scalarTsType(variant2)})` : scalarTsType(variant2)
       ).join(" | ");
+    case "map":
+      return `Record<string, ${scalarTsType(type.value)}>`;
+    case "array": {
+      const element = scalarTsType(type.element);
+      return type.element.kind === "union" ? `(${element})[]` : `${element}[]`;
+    }
   }
 }
 function mapScalar(scalar) {