@kurotako/gen-angular 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @kurotako/gen-angular
 
+## 0.2.0
+
+### Minor Changes
+
+- da7dd32: Union-type control support. A `{ kind: 'ref' }` field now types its control as
+  the Zod-emitted DTO / alias name (`FormControl<AddressDto>`); a non-discriminated
+  `union` types as the variant types joined (`FormControl<string | number>`), a branch whose ref is
+  in `GenerateContext.cycles` widening the control to `unknown`. Both fallback
+  controls carry a `// union: validated by zodValidator(schema)` note and a
+  `logger.warn`.
+  
+  A **discriminated** union field (`discriminator.mapping` set, every target an
+  entity in the same source) becomes a nested `FormGroup` holding a discriminator
+  `FormControl` plus one `FormGroup<<Variant>FormControls>` per discriminator
+  value, built by delegating to the target entity's injected `FormFactory`. A new
+  runtime helper `switchDiscriminatedGroup` toggles the active sub-group on the
+  discriminator control's `valueChanges` and rewrites the group's `getRawValue()`
+  to the flat active-variant shape a root `z.discriminatedUnion` schema can parse.
+  
+  A `{ kind: 'ref' }` field whose target is an alias resolves its type through the
+  Zod artifact's alias entry; `gen-angular` itself adds no alias entry to its own
+  artifact (aliases produce no Angular form and `gen-zod`'s `<ns>/zod/aliases.ts`
+  is the single exporter — re-declaring them would make the root-barrel ambiguity
+  check flag a phantom conflict).
+
+### Patch Changes
+
+- Updated dependencies [489a50d]
+- Updated dependencies [c575bc1]
+- Updated dependencies [6307397]
+- Updated dependencies [7a50439]
+  - @kurotako/core@0.1.1
+  - @kurotako/gen-zod@0.2.0
+  - @kurotako/ir@0.2.0
+  - @kurotako/config@0.1.1
+
 ## 0.1.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -139,6 +139,18 @@ function zodSymbol(zod, namespace, entity, role) {
 function zodModule(zod, namespace, entity) {
   return zodEntity(zod, namespace, entity).module;
 }
+function zodRefType(zod, namespace, ref) {
+  const key = entityKey(namespace, ref);
+  const entry = zod.entities[key];
+  if (entry === void 0) {
+    throw new MissingZodSymbolError(key, "type");
+  }
+  const id = entry.symbols.type;
+  if (id === void 0) {
+    throw new MissingZodSymbolError(key, "type");
+  }
+  return { typeName: id, module: entry.module };
+}
 function zodExtra(zod) {
   return zod.extra;
 }
@@ -264,7 +276,37 @@ function importStmt(spec, names, typeOnly) {
 }
 
 // src/render/controls.ts
+var import_ir3 = require("@kurotako/ir");
+
+// src/render/unions.ts
 var import_ir2 = require("@kurotako/ir");
+function discriminatedUnion(field, source) {
+  const type = field.type;
+  if (type.kind !== "union" || type.discriminator?.mapping === void 0) {
+    return void 0;
+  }
+  if (field.list || field.nullable) {
+    return void 0;
+  }
+  const variants = [];
+  for (const [value, ref] of Object.entries(type.discriminator.mapping)) {
+    if (source.entities[ref] === void 0) {
+      return void 0;
+    }
+    variants.push({ value, entity: ref });
+  }
+  return variants.length >= 2 ? { discriminator: type.discriminator.propertyName, variants } : void 0;
+}
+function refNames(type, into = /* @__PURE__ */ new Set()) {
+  if (type.kind === "ref") {
+    into.add(type.ref);
+  } else if (type.kind === "union") {
+    for (const variant of type.variants) {
+      refNames(variant, into);
+    }
+  }
+  return into;
+}
 var SCALAR_BASE = {
   string: "string",
   uuid: "string",
@@ -278,18 +320,71 @@ var SCALAR_BASE = {
   datetime: "Date",
   json: "unknown"
 };
-function baseType(field, zodEnumTypeName) {
+function variantType(type, refTypeName, enumTypeName, cyclicRefs) {
+  switch (type.kind) {
+    case "scalar":
+      return SCALAR_BASE[type.scalar] ?? "unknown";
+    case "enum":
+      return enumTypeName(type.ref);
+    case "ref":
+      return refTypeName(type.ref);
+    case "unknown":
+      return "unknown";
+    case "union":
+      return unionType(type, refTypeName, enumTypeName, cyclicRefs).text;
+  }
+}
+function unionType(type, refTypeName, enumTypeName, cyclicRefs = /* @__PURE__ */ new Set()) {
+  const variants = (0, import_ir2.flattenUnion)(type);
+  if (variants.length === 0) {
+    return { text: "unknown", recursive: false };
+  }
+  const recursive = [...refNames(type)].some((ref) => cyclicRefs.has(ref));
+  if (recursive) {
+    return { text: "unknown", recursive: true };
+  }
+  const text = variants.map((variant) => {
+    const inner = variantType(variant, refTypeName, enumTypeName, cyclicRefs);
+    return variant.kind === "union" ? `(${inner})` : inner;
+  }).join(" | ");
+  return { text, recursive: false };
+}
+
+// src/render/controls.ts
+var SCALAR_BASE2 = {
+  string: "string",
+  uuid: "string",
+  decimal: "string",
+  bytes: "string",
+  int: "number",
+  float: "number",
+  bigint: "bigint",
+  boolean: "boolean",
+  date: "Date",
+  datetime: "Date",
+  json: "unknown"
+};
+function baseType(field, resolvers) {
   switch (field.type.kind) {
     case "scalar":
-      return SCALAR_BASE[field.type.scalar];
+      return SCALAR_BASE2[field.type.scalar];
     case "enum":
-      return zodEnumTypeName(field.type.ref);
+      return resolvers.enumTypeName(field.type.ref);
     case "unknown":
       return "unknown";
+    case "ref":
+      return resolvers.refTypeName(field.type.ref);
+    case "union":
+      return unionType(
+        field.type,
+        resolvers.refTypeName,
+        resolvers.enumTypeName,
+        resolvers.cyclicRefs
+      ).text;
   }
 }
-function controlType(field, zodEnumTypeName) {
-  let t = baseType(field, zodEnumTypeName);
+function controlType(field, resolvers) {
+  let t = baseType(field, resolvers);
   if (field.list) {
     t = `${t}[]`;
   }
@@ -299,7 +394,7 @@ function controlType(field, zodEnumTypeName) {
   return t;
 }
 function enumZeroFromSource(source, entity) {
-  return (ref) => (0, import_ir2.resolveEnum)(source, entity, ref)?.values[0]?.name;
+  return (ref) => (0, import_ir3.resolveEnum)(source, entity, ref)?.values[0]?.name;
 }
 function zeroValue(field, enumZero) {
   if (field.type.kind === "scalar") {
@@ -345,12 +440,18 @@ function controlExpr(field, typeArg, sourceExpr) {
   if (field.nullable) {
     return `new FormControl<${typeArg}>(${sourceExpr})`;
   }
+  if (field.type.kind === "union") {
+    return `new FormControl<${typeArg}>((${sourceExpr}) as ${typeArg}) /* union: validated by zodValidator(schema) */`;
+  }
+  if (field.type.kind === "ref") {
+    return `new FormControl<${typeArg}>((${sourceExpr}) as ${typeArg})`;
+  }
   return `new FormControl(${sourceExpr}, { nonNullable: true })`;
 }
-function fieldControlEntry(field, zodEnumTypeName) {
+function fieldControlEntry(field, resolvers) {
   return {
     name: field.name,
-    fullType: `FormControl<${controlType(field, zodEnumTypeName)}>`
+    fullType: `FormControl<${controlType(field, resolvers)}>`
   };
 }
 function controlsInterface(interfaceName, entries) {
@@ -364,11 +465,11 @@ ${body}
 }
 
 // src/render/relations.ts
-var import_ir3 = require("@kurotako/ir");
+var import_ir4 = require("@kurotako/ir");
 function deepRelations(entity, variant, namespace, logger) {
   const out = [];
   for (const relation of entity.relations) {
-    if ((0, import_ir3.isCrossSource)(namespace, relation)) {
+    if ((0, import_ir4.isCrossSource)(namespace, relation)) {
       logger?.debug(
         `gen-angular: relation '${relation.name}' targets another source ('${relation.target.namespace}.${relation.target.entity}'); degrading to the flat FK scalar in deep mode`
       );
@@ -399,16 +500,48 @@ function deepRelations(entity, variant, namespace, logger) {
 }
 
 // src/render/variants.ts
-var import_ir4 = require("@kurotako/ir");
+var import_ir5 = require("@kurotako/ir");
 function variantFields(entity, variant) {
-  return variant === "Create" ? (0, import_ir4.createFields)(entity) : (0, import_ir4.updateFields)(entity);
+  return variant === "Create" ? (0, import_ir5.createFields)(entity) : (0, import_ir5.updateFields)(entity);
 }
 
 // src/render/reactive.ts
+function discriminatedControlEntry(union, fieldName, variant, family) {
+  const lit = union.variants.map((v2) => JSON.stringify(v2.value)).join(" | ");
+  const subs = union.variants.map(
+    (v2) => `${JSON.stringify(v2.value)}: FormGroup<${controlsTypeName(v2.entity, variant, family)}>`
+  ).join("; ");
+  return {
+    name: fieldName,
+    fullType: `FormGroup<{ ${JSON.stringify(union.discriminator)}: FormControl<${lit}>; ${subs} }>`
+  };
+}
+function discriminatedFactoryExpr(union, fieldName, variant, deep, zod, namespace, injectedFactories) {
+  const lit = union.variants.map((v2) => JSON.stringify(v2.value)).join(" | ");
+  const first = JSON.stringify(union.variants[0]?.value ?? "");
+  const method = factoryMethod(variant);
+  const subLines = union.variants.map((v2) => {
+    const param = injectedFactories.get(v2.entity) ?? `${lowerFirst2(v2.entity)}FormFactory`;
+    if (variant === "Create") {
+      return `    ${JSON.stringify(v2.value)}: this.${param}.${method}(),`;
+    }
+    const role = deep ? "updateDeepType" : "updateType";
+    const dto = zodSymbol(zod, namespace, v2.entity, role);
+    return `    ${JSON.stringify(v2.value)}: this.${param}.${method}(value.${fieldName} as unknown as ${dto}),`;
+  }).join("\n");
+  return `(() => {
+  const g = new FormGroup({
+    ${JSON.stringify(union.discriminator)}: new FormControl<${lit}>(${first}, { nonNullable: true }),
+${subLines}
+  });
+  switchDiscriminatedGroup(g, ${JSON.stringify(union.discriminator)});
+  return g;
+})()`;
+}
 function lowerFirst2(s) {
   return s.length === 0 ? s : s.charAt(0).toLowerCase() + s.slice(1);
 }
-function reactiveEntity(entity, namespace, source, options, zod, imports, logger) {
+function reactiveEntity(entity, namespace, source, options, zod, imports, cyclicRefs, logger) {
   const deep = options.relations === "deep";
   const enumZero = enumZeroFromSource(source, entity);
   imports.value("@angular/core", "Injectable");
@@ -421,6 +554,7 @@ function reactiveEntity(entity, namespace, source, options, zod, imports, logger
   };
   const blocks = [];
   const injectedFactories = /* @__PURE__ */ new Map();
+  const warnedUnionFields = /* @__PURE__ */ new Set();
   for (const variant of ["Create", "Update"]) {
     const family = deep ? "Deep" : "";
     const schemaRole = deep ? variant === "Create" ? "createDeepSchema" : "updateDeepSchema" : variant === "Create" ? "createSchema" : "updateSchema";
@@ -433,8 +567,61 @@ function reactiveEntity(entity, namespace, source, options, zod, imports, logger
     imports.value(`${namespace}/angular/zod-forms.runtime`, "zodValidator");
     const interfaceName = controlsTypeName(entity.name, variant, family);
     const formType = formTypeName(entity.name, variant, family);
+    const resolvers = {
+      enumTypeName: zodEnumTypeName,
+      refTypeName: (ref) => {
+        const r = zodRefType(zod, namespace, ref);
+        imports.type(r.module, r.typeName);
+        return r.typeName;
+      },
+      cyclicRefs
+    };
     const fieldEntries = variantFields(entity, variant).map(
-      (field) => fieldControlEntry(field, zodEnumTypeName)
+      (field) => {
+        const union = field.type.kind === "union" ? discriminatedUnion(field, source) : void 0;
+        if (union !== void 0) {
+          imports.value(
+            `${namespace}/angular/zod-forms.runtime`,
+            "switchDiscriminatedGroup"
+          );
+          for (const v2 of union.variants) {
+            const targetModule = `${namespace}/angular/${v2.entity}.form`;
+            imports.type(
+              targetModule,
+              controlsTypeName(v2.entity, variant, family)
+            );
+            if (!injectedFactories.has(v2.entity)) {
+              injectedFactories.set(
+                v2.entity,
+                `${lowerFirst2(v2.entity)}FormFactory`
+              );
+              imports.value(targetModule, factoryName(v2.entity));
+            }
+            if (variant === "Update") {
+              const role = deep ? "updateDeepType" : "updateType";
+              imports.type(
+                zodModule(zod, namespace, v2.entity),
+                zodSymbol(zod, namespace, v2.entity, role)
+              );
+            }
+          }
+          return discriminatedControlEntry(union, field.name, variant, family);
+        }
+        if (field.type.kind === "union" && !warnedUnionFields.has(field.name)) {
+          warnedUnionFields.add(field.name);
+          const recursive = unionType(
+            field.type,
+            resolvers.refTypeName,
+            resolvers.enumTypeName,
+            cyclicRefs
+          ).recursive;
+          const cause = recursive ? "a recursive ref branch (chains into a cycle)" : "no discriminator mapping, an alias target, or a list/nullable union";
+          logger?.warn(
+            `gen-angular: union field '${entity.name}.${field.name}' has no usable discriminated sub-form (${cause}); emitting a free FormControl${recursive ? "<unknown>" : ""} validated by zodValidator`
+          );
+        }
+        return fieldControlEntry(field, resolvers);
+      }
     );
     const relations = deep ? deepRelations(entity, variant, namespace, logger) : [];
     const manyRelations = relations.filter((r) => r.many);
@@ -481,15 +668,17 @@ function reactiveEntity(entity, namespace, source, options, zod, imports, logger
     renderFactoryClass(
       entity,
       namespace,
+      source,
       options,
       zod,
       injectedFactories,
-      enumZero
+      enumZero,
+      cyclicRefs
     )
   );
   return blocks.join("\n\n");
 }
-function renderFactoryClass(entity, namespace, options, zod, injectedFactories, enumZero) {
+function renderFactoryClass(entity, namespace, source, options, zod, injectedFactories, enumZero, cyclicRefs) {
   const deep = options.relations === "deep";
   const className = factoryName(entity.name);
   const ctorParams = [...injectedFactories.entries()].map(
@@ -504,11 +693,13 @@ function renderFactoryClass(entity, namespace, options, zod, injectedFactories,
       renderFactoryMethod(
         entity,
         namespace,
+        source,
         variant,
         options,
         zod,
         injectedFactories,
-        enumZero
+        enumZero,
+        cyclicRefs
       )
     );
   }
@@ -546,7 +737,7 @@ export class ${className} {
 ${body}
 }`;
 }
-function renderFactoryMethod(entity, namespace, variant, options, zod, injectedFactories, enumZero) {
+function renderFactoryMethod(entity, namespace, source, variant, options, zod, injectedFactories, enumZero, cyclicRefs) {
   const deep = options.relations === "deep";
   const family = deep ? "Deep" : "";
   const typeRole = deep && variant === "Create" ? "createDeepType" : deep && variant === "Update" ? "updateDeepType" : variant === "Create" ? "createType" : "updateType";
@@ -556,13 +747,29 @@ function renderFactoryMethod(entity, namespace, variant, options, zod, injectedF
   const interfaceName = controlsTypeName(entity.name, variant, family);
   const formType = formTypeName(entity.name, variant, family);
   const methodName = factoryMethod(variant);
-  const zodEnumTypeName = (ref) => ref;
+  const resolvers = {
+    enumTypeName: (ref) => ref,
+    refTypeName: (ref) => zodRefType(zod, namespace, ref).typeName,
+    cyclicRefs
+  };
   const fields = variantFields(entity, variant);
   const lines = fields.map((field) => {
-    const typeArg = controlType(field, zodEnumTypeName);
+    const union = field.type.kind === "union" ? discriminatedUnion(field, source) : void 0;
+    if (union !== void 0) {
+      return `    ${field.name}: ${discriminatedFactoryExpr(
+        union,
+        field.name,
+        variant,
+        deep,
+        zod,
+        namespace,
+        injectedFactories
+      )},`;
+    }
+    const typeArg = controlType(field, resolvers);
     const accessor = variant === "Create" ? `init?.${field.name}` : `value.${field.name}`;
-    const source = `${accessor} ?? ${initExpr(field, enumZero)}`;
-    return `    ${field.name}: ${controlExpr(field, typeArg, source)},`;
+    const seed = `${accessor} ?? ${initExpr(field, enumZero)}`;
+    return `    ${field.name}: ${controlExpr(field, typeArg, seed)},`;
   });
   const relations = deep ? deepRelations(entity, variant, namespace, void 0) : [];
   const relationLines = relations.map((r) => {
@@ -623,9 +830,12 @@ function signalEntity(entity, namespace, source, options, zod, imports, logger)
     imports.value(module2, schemaId);
     imports.value(`${namespace}/angular/zod-forms.runtime`, "zodTreeValidate");
     const fields = variantFields(entity, variant);
-    const fieldLines = fields.map(
-      (field) => `    ${field.name}: init?.${field.name} ?? ${initExpr(field, enumZero)},`
-    );
+    const fieldLines = fields.map((field) => {
+      if (field.type.kind === "ref" || field.type.kind === "union") {
+        return `    ${field.name}: (init?.${field.name} ?? undefined) as ${typeId}[${JSON.stringify(field.name)}],`;
+      }
+      return `    ${field.name}: init?.${field.name} ?? ${initExpr(field, enumZero)},`;
+    });
     const relations = deep ? deepRelations(entity, variant, namespace, logger) : [];
     const relationLines = relations.map((rel) => {
       if (rel.many) {
@@ -665,12 +875,21 @@ ${modelBody}
 }
 
 // src/emit/entity.ts
-function emitEntity(entity, namespace, source, options, zod, logger) {
+function emitEntity(entity, namespace, source, options, zod, cyclicRefs, logger) {
   const imports = new ImportsRecorder();
   const blocks = [];
   if (options.forms.includes("reactive")) {
     blocks.push(
-      reactiveEntity(entity, namespace, source, options, zod, imports, logger)
+      reactiveEntity(
+        entity,
+        namespace,
+        source,
+        options,
+        zod,
+        imports,
+        cyclicRefs,
+        logger
+      )
     );
   }
   if (options.forms.includes("signal")) {
@@ -764,6 +983,53 @@ function collectControls(control: AbstractControl): AbstractControl[] {
   }
   return out;
 }`;
+var SWITCH_DISCRIMINATED_GROUP = `/**
+ * Wire a discriminated-union sub-FormGroup: enable only the sub-group named by
+ * the discriminator control's value (disable the rest), keep it in sync on
+ * valueChanges, and rewrite the group's getRawValue() to the flat
+ * active-variant shape a z.discriminatedUnion schema can parse.
+ */
+export function switchDiscriminatedGroup(
+  group: AbstractControl,
+  discriminator: string,
+): void {
+  const controls = (group as unknown as {
+    controls: Record<string, AbstractControl>;
+  }).controls;
+  const selector = controls[discriminator];
+  if (selector === undefined) {
+    return;
+  }
+  const variantKeys = Object.keys(controls).filter(
+    (key) => key !== discriminator,
+  );
+
+  const apply = (active: unknown): void => {
+    for (const key of variantKeys) {
+      const sub = controls[key];
+      if (sub === undefined) {
+        continue;
+      }
+      if (key === active) {
+        sub.enable({ emitEvent: false });
+      } else {
+        sub.disable({ emitEvent: false });
+      }
+    }
+  };
+
+  apply(selector.value);
+  selector.valueChanges.subscribe(apply);
+
+  (group as { getRawValue: () => unknown }).getRawValue = () => {
+    const active = controls[String(selector.value)];
+    const variant =
+      active === undefined || active === selector
+        ? {}
+        : (active.getRawValue() as Record<string, unknown>);
+    return { ...variant, [discriminator]: selector.value };
+  };
+}`;
 var ZOD_TREE_VALIDATE = `export function zodTreeValidate<T>(
   path: SchemaPath<T>,
   schema: ZodType<T>,
@@ -813,7 +1079,7 @@ function emitRuntime(_source, options) {
   imports.push("import type { ZodType } from 'zod';");
   const blocks = [];
   if (reactive) {
-    blocks.push(ZOD_VALIDATOR);
+    blocks.push(ZOD_VALIDATOR, SWITCH_DISCRIMINATED_GROUP);
   }
   if (signal) {
     blocks.push(ZOD_TREE_VALIDATE);
@@ -850,6 +1116,13 @@ var angularGenerator = (0, import_config.defineGenerator)({
     for (const [namespace, source] of Object.entries(ctx.ir.sources)) {
       const prefix = `${namespace}/angular`;
       const entities = Object.values(source.entities);
+      const cyclicRefs = /* @__PURE__ */ new Set();
+      for (const key of ctx.cycles) {
+        const dot = key.indexOf(".");
+        if (dot > 0 && key.slice(0, dot) === namespace) {
+          cyclicRefs.add(key.slice(dot + 1));
+        }
+      }
       if (entities.length > 0 && options.forms.length > 0) {
         files.push({
           path: `${prefix}/zod-forms.runtime.ts`,
@@ -865,6 +1138,7 @@ var angularGenerator = (0, import_config.defineGenerator)({
             source,
             options,
             zod,
+            cyclicRefs,
             ctx.logger
           )
         });