@supalive/codegen 1.2.1 → 1.3.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as generateToDisk, r as readEntryConfig } from "./src-DIj2CWMc.js";
+import { n as generateToDisk, r as readEntryConfig } from "./src-O2U-Keyx.js";
 import path from "node:path";
 //#region src/cli.ts
 function parseArgs(argv) {
@@ -35,6 +35,9 @@ function parseArgs(argv) {
 			case "--include-internal":
 				args.includeInternal = true;
 				break;
+			case "--schema-module":
+				args.schemaModule = argv[++i];
+				break;
 			default:
 				if (a.startsWith("-")) throw new Error(`Unknown option: ${a}`);
 				if (args.entry) throw new Error(`Unexpected extra argument: ${a}`);
@@ -55,6 +58,8 @@ Options:
       --config <name>         Config object export name (default: dartCodegen)
       --tsconfig <path>       tsconfig.json used to resolve types
       --include-internal      Also generate internal (server-only) procedures
+      --schema-module <path>  Module that registers defineSchema tables, for
+                              schema-aware enum names (relative to the entry)
   -h, --help                  Show this help
 
 The entry file may export a \`dartCodegen\` object with any of the above
@@ -68,14 +73,16 @@ async function main() {
 	const fromEntry = readEntryConfig(args.entry, args.configExport, args.tsconfig);
 	const entryDir = path.dirname(path.resolve(args.entry));
 	const output = args.output ?? (fromEntry.output ? path.resolve(entryDir, fromEntry.output) : void 0);
-	const { files, config } = generateToDisk({
+	const schemaModule = args.schemaModule ? path.resolve(args.schemaModule) : fromEntry.schemaModule ? path.resolve(entryDir, fromEntry.schemaModule) : void 0;
+	const { files, config } = await generateToDisk({
 		entry: args.entry,
 		output,
 		router: args.router ?? fromEntry.router,
 		clientClassName: args.clientClass ?? fromEntry.clientClassName,
 		includeInternal: args.includeInternal ?? fromEntry.includeInternal,
 		tsconfig: args.tsconfig ?? fromEntry.tsconfig,
-		numericOverrides: fromEntry.numericOverrides
+		numericOverrides: fromEntry.numericOverrides,
+		schemaModule
 	});
 	console.log(`Generated ${files.length} file(s) into ${config.output}:\n` + files.map((f) => `  - ${f.path}`).join("\n"));
 }

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { SchemaDefinition } from "@supalive/core/client";
+
 //#region src/config.d.ts
 interface SupaliveDartConfig {
   /** Output directory for generated Dart files. */
@@ -15,11 +17,21 @@ interface SupaliveDartConfig {
    * distinction (outputs). Keyed by `ModelName.fieldName`.
    */
   numericOverrides?: Record<string, "int" | "double" | "bigint">;
+  /**
+   * Path to a module that, when imported, registers every `defineSchema` table
+   * (typically the schema barrel, e.g. `"../schema/index.ts"`). Resolved
+   * relative to this entry file's directory. When set, the generator
+   * runtime-imports it (with schema tracking on) and names string-literal enums
+   * after their originating table+column (`StaffStatus`, `PosDeviceStatus`)
+   * instead of structurally. Best-effort: import failures degrade gracefully.
+   */
+  schemaModule?: string;
 }
-interface ResolvedConfig extends Required<Omit<SupaliveDartConfig, "tsconfig" | "numericOverrides">> {
+interface ResolvedConfig extends Required<Omit<SupaliveDartConfig, "tsconfig" | "numericOverrides" | "schemaModule">> {
   entry: string;
   tsconfig?: string;
   numericOverrides: Record<string, "int" | "double" | "bigint">;
+  schemaModule?: string;
 }
 //#endregion
 //#region src/ir.d.ts
@@ -107,9 +119,48 @@ interface EmittedFile {
 }
 declare function emit(ir: ClientIR): EmittedFile[];
 //#endregion
+//#region src/schema-enums.d.ts
+/** One enum-typed column discovered in a tracked schema. */
+interface SchemaEnumEntry {
+  /** SQL table name, e.g. "pos_devices". */
+  table: string;
+  /** PascalCase singular table stem, e.g. "PosDevice". */
+  tableStem: string;
+  /** camelCase column/field key, e.g. "status". */
+  field: string;
+  /** Canonical Dart enum name, e.g. "PosDeviceStatus". */
+  enumName: string;
+  /** Values in schema (canonical) order. */
+  values: string[];
+  /** Order-independent value-set signature, for matching. */
+  setSig: string;
+}
+declare class SchemaEnumRegistry {
+  private readonly byField;
+  private constructor();
+  static empty(): SchemaEnumRegistry;
+  get size(): number;
+  /**
+   * Resolve a string-literal union to a schema enum, or `undefined` when there
+   * is no confident match. Requires the field name and the exact value set to
+   * agree; when several tables share both (e.g. `status: active|disabled` on
+   * staff/tenants/stores/pos_devices) the result model's `stem` disambiguates.
+   */
+  match(field: string, values: string[], stem: string): SchemaEnumEntry | undefined;
+  static fromRegistry(registry: Map<string, SchemaDefinition<string, any, any>>): SchemaEnumRegistry;
+}
+/**
+ * Runtime-import the configured `schemaModule` with schema tracking enabled and
+ * build a {@link SchemaEnumRegistry}. Best-effort: any failure (no module
+ * configured, no `@supalive/core`, no TypeScript loader for a `.ts` module)
+ * downgrades to an empty registry so generation still succeeds with structural
+ * names.
+ */
+declare function loadSchemaEnums(config: ResolvedConfig): Promise<SchemaEnumRegistry>;
+//#endregion
 //#region src/extract.d.ts
 /** Load the router from the entry file and extract a ClientIR. */
-declare function extractClient(config: ResolvedConfig): ClientIR;
+declare function extractClient(config: ResolvedConfig, schemaEnums?: SchemaEnumRegistry): ClientIR;
 //#endregion
 //#region src/index.d.ts
 interface GenerateOptions extends SupaliveDartConfig {
@@ -122,10 +173,14 @@ interface GenerateResult {
 }
 /** Resolve a partial config against defaults, anchoring relative paths. */
 declare function resolveConfig(opts: GenerateOptions): ResolvedConfig;
-/** Extract + emit. Does not touch the filesystem. */
-declare function generate(opts: GenerateOptions): GenerateResult;
+/**
+ * Extract + emit. Does not touch the filesystem, and stays synchronous. Pass a
+ * pre-loaded {@link SchemaEnumRegistry} to get schema-aware enum names; omit it
+ * (the default) for purely structural naming.
+ */
+declare function generate(opts: GenerateOptions, schemaEnums?: SchemaEnumRegistry): GenerateResult;
 /** Extract + emit + write the files to `config.output`. */
-declare function generateToDisk(opts: GenerateOptions): GenerateResult;
+declare function generateToDisk(opts: GenerateOptions): Promise<GenerateResult>;
 /**
  * Best-effort static read of a config object exported from the entry file,
  * so users can keep `router` + codegen options next to the router itself:
@@ -137,4 +192,4 @@ declare function generateToDisk(opts: GenerateOptions): GenerateResult;
  */
 declare function readEntryConfig(entry: string, exportName?: string, tsconfig?: string): SupaliveDartConfig;
 //#endregion
-export { ClientIR, DartType, type EmittedFile, EnumIR, EnumValueIR, FieldIR, GenerateOptions, GenerateResult, ModelIR, ProcedureIR, ProcedureKind, type ResolvedConfig, type SupaliveDartConfig, emit, extractClient, generate, generateToDisk, readEntryConfig, resolveConfig };
+export { ClientIR, DartType, type EmittedFile, EnumIR, EnumValueIR, FieldIR, GenerateOptions, GenerateResult, ModelIR, ProcedureIR, ProcedureKind, type ResolvedConfig, SchemaEnumRegistry, type SupaliveDartConfig, emit, extractClient, generate, generateToDisk, loadSchemaEnums, readEntryConfig, resolveConfig };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as emit, i as resolveConfig, n as generateToDisk, o as extractClient, r as readEntryConfig, t as generate } from "./src-DIj2CWMc.js";
-export { emit, extractClient, generate, generateToDisk, readEntryConfig, resolveConfig };
+import { a as emit, c as loadSchemaEnums, i as resolveConfig, n as generateToDisk, o as extractClient, r as readEntryConfig, s as SchemaEnumRegistry, t as generate } from "./src-O2U-Keyx.js";
+export { SchemaEnumRegistry, emit, extractClient, generate, generateToDisk, loadSchemaEnums, readEntryConfig, resolveConfig };

package/dist/{src-DIj2CWMc.js → src-O2U-Keyx.js}

@@ -1,6 +1,9 @@
+import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
 import { Node, Project, ts } from "ts-morph";
+import { pathToFileURL } from "node:url";
+import { schemaRegistry, trackSchema } from "@supalive/core/procedure";
 //#region src/zod-schema.ts
 /**
 * Map each procedure to the doc comment on its declaration, so the generated
@@ -185,9 +188,177 @@ function findZodObjectLiteral(node) {
 	return cur && Node.isObjectLiteralExpression(cur) ? cur : void 0;
 }
 //#endregion
+//#region src/names.ts
+/** PascalCase an arbitrary string (splitting on any non-alphanumeric run). */
+function pascal(s) {
+	return s.replace(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+/** camelCase an arbitrary string. */
+function camel(s) {
+	const p = pascal(s);
+	return p.charAt(0).toLowerCase() + p.slice(1);
+}
+/**
+* Best-effort English singularization of a single trailing noun, used to turn a
+* (usually plural) table name into a clean type stem: `pos_devices → PosDevice`,
+* `settlement_entries → SettlementEntry`, `card_batches → CardBatch`. Leaves
+* words that don't look plural untouched (`staff`, `status`).
+*/
+function singularizeWord(w) {
+	if (w.length > 4 && /(?:ch|sh|ss|x|s)es$/i.test(w)) return w.slice(0, -2);
+	if (w.length > 3 && /ies$/i.test(w)) return w.slice(0, -3) + "y";
+	if (/ss$/i.test(w)) return w;
+	if (w.length > 1 && /s$/i.test(w)) return w.slice(0, -1);
+	return w;
+}
+//#endregion
+//#region src/schema-enums.ts
+function setSignature(values) {
+	return [...values].sort().join("");
+}
+var SchemaEnumRegistry = class SchemaEnumRegistry {
+	byField = /* @__PURE__ */ new Map();
+	constructor(entries) {
+		for (const e of entries) {
+			const arr = this.byField.get(e.field);
+			if (arr) arr.push(e);
+			else this.byField.set(e.field, [e]);
+		}
+	}
+	static empty() {
+		return new SchemaEnumRegistry([]);
+	}
+	get size() {
+		let n = 0;
+		for (const arr of this.byField.values()) n += arr.length;
+		return n;
+	}
+	/**
+	* Resolve a string-literal union to a schema enum, or `undefined` when there
+	* is no confident match. Requires the field name and the exact value set to
+	* agree; when several tables share both (e.g. `status: active|disabled` on
+	* staff/tenants/stores/pos_devices) the result model's `stem` disambiguates.
+	*/
+	match(field, values, stem) {
+		const candidates = this.byField.get(camel(field));
+		if (!candidates) return void 0;
+		const sig = setSignature(values);
+		const matches = candidates.filter((c) => c.setSig === sig);
+		if (matches.length === 0) return void 0;
+		if (matches.length === 1) return matches[0];
+		const pick = (test) => {
+			let best;
+			for (const m of matches) if (test(m.tableStem) && (!best || m.tableStem.length > best.tableStem.length)) best = m;
+			return best;
+		};
+		return pick((t) => stem.endsWith(t)) ?? pick((t) => stem.includes(t));
+	}
+	static fromRegistry(registry) {
+		const entries = [];
+		for (const def of registry.values()) {
+			const table = def.table;
+			const shape = def.schema.shape;
+			if (typeof table !== "string" || !shape || typeof shape !== "object") continue;
+			const tableStem = tableStemName(table);
+			for (const [fieldKey, zodType] of Object.entries(shape)) {
+				const values = readEnumValues(zodType);
+				if (!values || values.length === 0) continue;
+				entries.push({
+					table,
+					tableStem,
+					field: camel(fieldKey),
+					enumName: tableStem + pascal(fieldKey),
+					values,
+					setSig: setSignature(values)
+				});
+			}
+		}
+		return new SchemaEnumRegistry(entries);
+	}
+};
+/** "pos_devices" → "PosDevice"; "settlement_entries" → "SettlementEntry". */
+function tableStemName(table) {
+	const parts = table.split(/[^A-Za-z0-9]+/).filter(Boolean);
+	if (parts.length === 0) return pascal(table);
+	const last = parts.length - 1;
+	return parts.map((p, i) => i === last ? pascal(singularizeWord(p)) : pascal(p)).join("");
+}
+/** Read a Zod enum's values, unwrapping optional/nullable/default wrappers.
+* Realm-independent: never uses `instanceof` (the schema's Zod may be a
+* different module instance than any the codegen could import). */
+function readEnumValues(field) {
+	const e = unwrapToEnum(field);
+	if (!e) return void 0;
+	try {
+		const opts = e.options;
+		if (Array.isArray(opts)) return opts.map((v) => String(v));
+	} catch {}
+	const def = zodDef(e);
+	const entries = def?.entries ?? def?.values;
+	if (entries && typeof entries === "object") return Object.values(entries).map((v) => String(v));
+}
+function zodDef(node) {
+	const n = node;
+	return n?._zod?.def ?? n?.def;
+}
+const WRAPPERS = /* @__PURE__ */ new Set([
+	"optional",
+	"nullable",
+	"default",
+	"catch",
+	"readonly",
+	"nonoptional",
+	"prefault"
+]);
+function unwrapToEnum(field) {
+	let cur = field;
+	for (let guard = 0; cur && guard < 12; guard++) {
+		const def = zodDef(cur);
+		if (!def) return void 0;
+		if (def.type === "enum") return cur;
+		if (def.type && WRAPPERS.has(def.type) && def.innerType) {
+			cur = def.innerType;
+			continue;
+		}
+		return;
+	}
+}
+/**
+* Runtime-import the configured `schemaModule` with schema tracking enabled and
+* build a {@link SchemaEnumRegistry}. Best-effort: any failure (no module
+* configured, no `@supalive/core`, no TypeScript loader for a `.ts` module)
+* downgrades to an empty registry so generation still succeeds with structural
+* names.
+*/
+async function loadSchemaEnums(config) {
+	if (!config.schemaModule) return SchemaEnumRegistry.empty();
+	try {
+		const require_ = createRequire(config.entry);
+		pathToFileURL(require_.resolve("@supalive/core/schema-sql")).href;
+		let unregister;
+		try {
+			unregister = (await import(pathToFileURL(require_.resolve("tsx/esm/api")).href)).register();
+		} catch {}
+		try {
+			trackSchema();
+			await import(pathToFileURL(config.schemaModule).href);
+			const registry = schemaRegistry;
+			if (!registry || registry.size === 0) return SchemaEnumRegistry.empty();
+			return SchemaEnumRegistry.fromRegistry(registry);
+		} finally {
+			if (unregister) try {
+				await unregister();
+			} catch {}
+		}
+	} catch (err) {
+		console.warn(`[supalive-codegen] Could not load schemaModule (${config.schemaModule}) for schema-aware enum names; falling back to structural names. ${err instanceof Error ? err.message : String(err)}`);
+		return SchemaEnumRegistry.empty();
+	}
+}
+//#endregion
 //#region src/extract.ts
 /** Load the router from the entry file and extract a ClientIR. */
-function extractClient(config) {
+function extractClient(config, schemaEnums = SchemaEnumRegistry.empty()) {
 	const project = new Project({
 		tsConfigFilePath: config.tsconfig,
 		skipAddingFilesFromTsConfig: config.tsconfig ? false : true,
@@ -207,7 +378,7 @@ function extractClient(config) {
 	const proceduresType = proceduresSym.getTypeAtLocation(routerDecl);
 	const argMeta = scanZodArgMeta(routerDecl);
 	const procDocs = scanProcedureDocs(routerDecl);
-	const extractor = new Extractor(routerDecl, config, argMeta, project.getTypeChecker());
+	const extractor = new Extractor(routerDecl, config, argMeta, project.getTypeChecker(), schemaEnums);
 	const procedures = [];
 	for (const procSym of proceduresType.getProperties()) {
 		const name = procSym.getName();
@@ -232,17 +403,20 @@ var Extractor = class {
 	config;
 	argMeta;
 	tc;
+	schemaEnums;
 	modelRegistry = /* @__PURE__ */ new Map();
-	enumRegistry = /* @__PURE__ */ new Map();
-	/** Value-set signature → already-registered enum name, for structural dedup. */
-	enumBySignature = /* @__PURE__ */ new Map();
+	/** Discovered enums, keyed by a dedup key (schema name, or stem∙field∙set). */
+	enumGroups = /* @__PURE__ */ new Map();
+	finalEnums = [];
+	enumsFinalized = false;
 	nameCounts = /* @__PURE__ */ new Map();
 	visiting = /* @__PURE__ */ new Set();
-	constructor(locationNode, config, argMeta, tc) {
+	constructor(locationNode, config, argMeta, tc, schemaEnums) {
 		this.locationNode = locationNode;
 		this.config = config;
 		this.argMeta = argMeta;
 		this.tc = tc;
+		this.schemaEnums = schemaEnums;
 	}
 	/** Doc comment attached to a symbol's declaration (resolves TS aliases). */
 	symbolDoc(sym) {
@@ -255,10 +429,12 @@ var Extractor = class {
 		}
 	}
 	models() {
+		this.finalizeEnums();
 		return [...this.modelRegistry.values()];
 	}
 	enums() {
-		return [...this.enumRegistry.values()];
+		this.finalizeEnums();
+		return [...this.finalEnums].sort((a, b) => a.name.localeCompare(b.name));
 	}
 	procedure(name, procType) {
 		const kind = this.literalString(procType, "procedureType");
@@ -298,7 +474,7 @@ var Extractor = class {
 	walk(type, hint) {
 		const { core } = splitNullish(type);
 		if (core.length === 0) return { kind: "dynamic" };
-		if (core.length > 1) return this.walkUnion(core, hint);
+		if (core.length > 1) return this.walkUnion(core, { hint });
 		return this.walkSingle(core[0], hint);
 	}
 	walkSingle(type, hint) {
@@ -326,7 +502,7 @@ var Extractor = class {
 		if (type.isUnion()) {
 			const { core } = splitNullish(type);
 			if (core.length === 1) return this.walkSingle(core[0], hint);
-			return this.walkUnion(core, hint);
+			return this.walkUnion(core, { hint });
 		}
 		if (type.isObject()) {
 			const props = type.getProperties();
@@ -342,10 +518,10 @@ var Extractor = class {
 		}
 		return { kind: "dynamic" };
 	}
-	walkUnion(members, hint, enumHint) {
+	walkUnion(members, ctx) {
 		if (members.every((m) => m.getFlags() & (ts.TypeFlags.BooleanLiteral | ts.TypeFlags.Boolean))) return { kind: "bool" };
-		if (members.every((m) => m.getFlags() & ts.TypeFlags.StringLiteral)) return this.registerEnum(enumHint ?? hint, members.map((m) => String(m.getLiteralValue())));
-		if (members.every((m) => m.isObject())) return this.registerSealed(hint, members);
+		if (members.every((m) => m.getFlags() & ts.TypeFlags.StringLiteral)) return this.registerEnum(members.map((m) => String(m.getLiteralValue())), ctx);
+		if (members.every((m) => m.isObject())) return this.registerSealed(ctx.hint, members);
 		return { kind: "dynamic" };
 	}
 	walkObject(type, hint) {
@@ -371,7 +547,11 @@ var Extractor = class {
 			let dartType;
 			if (core.length === 0) dartType = { kind: "dynamic" };
 			else if (core.length === 1) dartType = this.walkSingle(core[0], name + pascal(jsonKey));
-			else dartType = this.walkUnion(core, name + pascal(jsonKey), pascal(jsonKey));
+			else dartType = this.walkUnion(core, {
+				hint: name + pascal(jsonKey),
+				stem: cleanStem(name),
+				field: jsonKey
+			});
 			const override = this.config.numericOverrides[`${name}.${jsonKey}`];
 			if (override && (dartType.kind === "double" || dartType.kind === "int")) dartType = { kind: override };
 			fields.push({
@@ -416,26 +596,106 @@ var Extractor = class {
 			name
 		};
 	}
-	registerEnum(hint, values) {
-		const signature = values.join("\0");
-		const existing = this.enumBySignature.get(signature);
-		if (existing) return {
+	/**
+	* Register a string-literal union as an enum. Two tiers:
+	*  1. Schema-backed — the field name + value set match a tracked `defineSchema`
+	*     column, so we use its canonical `<Table><Column>` name and reuse it
+	*     everywhere that column appears. Values follow the schema's order.
+	*  2. Structural fallback — no schema match; named later in `finalizeEnums`
+	*     from the model stem + field (bare when the field name is globally
+	*     unique). Deduped per `(stem, field, value-set)`.
+	* Returns a shared DartType instance whose `name` is filled in at finalize.
+	*/
+	registerEnum(values, ctx) {
+		if (ctx.field) {
+			const hit = this.schemaEnums.match(ctx.field, values, ctx.stem ?? "");
+			if (hit) {
+				const key = `schema${hit.enumName}`;
+				const existing = this.enumGroups.get(key);
+				if (existing) return existing.type;
+				const type = {
+					kind: "enum",
+					name: hit.enumName
+				};
+				this.enumGroups.set(key, {
+					type,
+					values: hit.values,
+					schemaName: hit.enumName,
+					stem: ctx.stem,
+					field: ctx.field,
+					hint: ctx.hint
+				});
+				return type;
+			}
+		}
+		const key = `fallback${ctx.stem ?? ""}${ctx.field ?? ctx.hint}${values.join(" ")}`;
+		const existing = this.enumGroups.get(key);
+		if (existing) return existing.type;
+		const type = {
 			kind: "enum",
-			name: existing
+			name: key
 		};
-		const name = this.uniqueHint(hint);
-		this.enumRegistry.set(name, {
+		this.enumGroups.set(key, {
+			type,
+			values,
+			stem: ctx.stem,
+			field: ctx.field,
+			hint: ctx.hint
+		});
+		return type;
+	}
+	/**
+	* Assign every enum its final Dart name and materialize the `EnumIR` list.
+	* Idempotent — mutates the shared DartType instances in place, so every
+	* referencing model field / procedure result sees the resolved name.
+	*/
+	finalizeEnums() {
+		if (this.enumsFinalized) return;
+		this.enumsFinalized = true;
+		const used = new Set(this.modelRegistry.keys());
+		const groups = [...this.enumGroups.values()];
+		const schemaGroups = groups.filter((g) => g.schemaName).sort((a, b) => a.schemaName.localeCompare(b.schemaName));
+		for (const g of schemaGroups) {
+			const name = this.ensureUnique(g.schemaName, used);
+			g.type.name = name;
+			this.pushEnumIR(name, g.values);
+		}
+		const fallbackGroups = groups.filter((g) => !g.schemaName).sort((a, b) => fallbackBase(a).localeCompare(fallbackBase(b)));
+		const baseCount = /* @__PURE__ */ new Map();
+		for (const g of fallbackGroups) {
+			const base = fallbackBase(g);
+			baseCount.set(base, (baseCount.get(base) ?? 0) + 1);
+		}
+		for (const g of fallbackGroups) {
+			const base = fallbackBase(g);
+			let name;
+			if (baseCount.get(base) === 1 && !used.has(base)) name = base;
+			else if (g.stem && g.field) name = pascal(g.stem) + pascal(g.field);
+			else name = pascal(g.hint);
+			name = this.ensureUnique(name, used);
+			g.type.name = name;
+			this.pushEnumIR(name, g.values);
+		}
+	}
+	ensureUnique(name, used) {
+		if (!used.has(name)) {
+			used.add(name);
+			return name;
+		}
+		let i = 2;
+		while (used.has(`${name}${i}`)) i++;
+		const unique = `${name}${i}`;
+		used.add(unique);
+		return unique;
+	}
+	pushEnumIR(name, values) {
+		this.finalEnums.push({
 			name,
 			values: values.map((wire) => ({
 				dartName: enumValueName(wire),
 				wire
 			}))
 		});
-		this.enumBySignature.set(signature, name);
-		return {
-			kind: "enum",
-			name
-		};
 	}
 	registerSealed(hint, members) {
 		const name = this.uniqueHint(hint);
@@ -454,7 +714,11 @@ var Extractor = class {
 			const propType = prop.getTypeAtLocation(this.locationNode);
 			const declaredOptional = (prop.getFlags() & ts.SymbolFlags.Optional) !== 0;
 			const { core, hasNull, hasUndefined } = splitNullish(propType);
-			const dt = core.length === 0 ? { kind: "dynamic" } : core.length === 1 ? this.walkSingle(core[0], name + pascal(jsonKey)) : this.walkUnion(core, name + pascal(jsonKey), pascal(jsonKey));
+			const dt = core.length === 0 ? { kind: "dynamic" } : core.length === 1 ? this.walkSingle(core[0], name + pascal(jsonKey)) : this.walkUnion(core, {
+				hint: name + pascal(jsonKey),
+				stem: cleanStem(name),
+				field: jsonKey
+			});
 			const acc = fieldMap.get(jsonKey) ?? {
 				types: [],
 				present: 0,
@@ -543,19 +807,34 @@ function splitNullish(type) {
 function uniqueName(symName, registry, _type) {
 	return pascal(symName);
 }
-function pascal(s) {
-	return s.replace(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
-}
-function camel(s) {
-	const p = pascal(s);
-	return p.charAt(0).toLowerCase() + p.slice(1);
-}
 function singular(hint) {
 	if (hint.endsWith("ies")) return hint.slice(0, -3) + "y";
 	if (hint.endsWith("s") && !hint.endsWith("ss")) return hint.slice(0, -1);
 	return hint + "Item";
 }
 /**
+* A clean type stem for a generated model name, used both to name structural
+* enums and to disambiguate schema matches: strip the trailing generated
+* suffix (`ResultItem`/`Result`/`Args`) and de-pluralize, so
+* `PosDevicesResultItem → PosDevice`, `CurrentCashSessionResult → CurrentCashSession`.
+*/
+function cleanStem(modelName) {
+	let s = modelName;
+	for (const suffix of [
+		"ResultItem",
+		"Result",
+		"Args"
+	]) if (s.length > suffix.length && s.endsWith(suffix)) {
+		s = s.slice(0, -suffix.length);
+		break;
+	}
+	return singularizeWord(s);
+}
+/** The bare candidate name for a structural (non-schema) enum group. */
+function fallbackBase(g) {
+	return pascal(g.field ?? g.hint);
+}
+/**
 * Dart reserved words — none may be used as a bare identifier (e.g. an enum
 * constant), so a wire value like `void` must be escaped.
 */
@@ -700,7 +979,6 @@ function emitModels(ir) {
 	const out = [HEADER];
 	if (modelsUseBytes(ir)) out.push("import 'dart:typed_data';\n");
 	out.push("import 'package:supalive_client/supalive_client.dart';\n");
-	out.push("const Object _undefined = Object();\n");
 	for (const e of ir.enums) out.push(emitEnum(e));
 	for (const m of ir.models) out.push(emitModel(m));
 	return out.join("\n");
@@ -736,7 +1014,7 @@ ${values};
 }
 /** Dart declared type for a field, applying nullability. */
 function fieldType(f) {
-	if (f.optional && f.nullable) return `Optional<${typeName(f.type)}>`;
+	if (f.optional && f.nullable) return `Option<${typeName(f.type)}>`;
 	const base = typeName(f.type);
 	const nullable = f.optional || f.nullable;
 	if (base === "Object?") return "Object?";
@@ -744,17 +1022,17 @@ function fieldType(f) {
 }
 function emitModel(m) {
 	const ctorParams = m.fields.map((f) => {
-		if (f.optional && f.nullable) return `    this.${f.name} = const Optional.absent()`;
+		if (f.optional && f.nullable) return `    this.${f.name} = const .undefined()`;
 		return !(f.optional || f.nullable) ? `    required this.${f.name}` : `    this.${f.name}`;
 	}).join(",\n");
 	const fields = m.fields.map((f) => `${docComment(f.doc, "  ")}  final ${fieldType(f)} ${f.name};`).join("\n");
 	const fromJson = m.fields.map((f) => emitFromJsonField(f)).join("\n");
 	const toJson = m.fields.map((f) => emitToJsonField(f)).join("\n");
-	const copyParams = m.fields.map((f) => `    Object? ${f.name} = _undefined`).join(",\n");
+	const isNullableType = (f) => fieldType(f).endsWith("?");
+	const copyParams = m.fields.map((f) => isNullableType(f) ? `    Option<${typeName(f.type)}> ${f.name} = const .undefined()` : `    ${fieldType(f)}? ${f.name}`).join(",\n");
 	const copyArgs = m.fields.map((f) => {
-		const ft = fieldType(f);
-		const value = ft === "Object?" ? f.name : `${f.name} as ${ft}`;
-		return `      ${f.name}: identical(${f.name}, _undefined) ? this.${f.name} : ${value}`;
+		if (isNullableType(f)) return `      ${f.name}: ${f.name}.isUndefined ? this.${f.name} : ${f.name}.casted()`;
+		return `      ${f.name}: ${f.name} ?? this.${f.name}`;
 	}).join(",\n");
 	const isDeep = (f) => {
 		if (f.optional && f.nullable) return false;
@@ -797,23 +1075,23 @@ ${toJson}
 }
 function emitFromJsonField(f) {
 	const key = `json['${f.jsonKey}']`;
-	if (f.optional && f.nullable) {
-		const inner = typeName(f.type);
-		return `        ${f.name}: json.containsKey('${f.jsonKey}')
+	if (f.optional && f.nullable) return `        ${f.name}: json.containsKey('${f.jsonKey}')
             ? (${key} == null
-                ? const Optional<${inner}>.ofNull()
-                : Optional<${inner}>.of(${decodeNonNull(f.type, key)}))
-            : const Optional<${inner}>.absent(),`;
-	}
+                ? const Option.nil()
+                : Option.value(${decodeNonNull(f.type, key)}))
+            : const Option.undefined(),`;
 	if (f.optional || f.nullable) return `        ${f.name}: ${decodeNullable(f.type, key)},`;
 	return `        ${f.name}: ${decodeNonNull(f.type, key)},`;
 }
 function emitToJsonField(f) {
 	const key = `'${f.jsonKey}'`;
-	if (f.optional && f.nullable) return `    if (${f.name}.isPresent) {
-      final v = ${f.name}.value;
+	if (f.optional && f.nullable) {
+		const inner = typeName(f.type);
+		return `    if (!${f.name}.isUndefined) {
+      final v = ${f.name}.casted<${inner}?>();
       json[${key}] = v == null ? null : ${encodeNonNull(f.type, "v")};
     }`;
+	}
 	if (f.optional) return `    if (${f.name} != null) json[${key}] = ${encodeNonNull(f.type, `${f.name}!`)};`;
 	if (f.nullable) return `    json[${key}] = ${encodeNullable(f.type, f.name)};`;
 	return `    json[${key}] = ${encodeNonNull(f.type, f.name)};`;
@@ -895,20 +1173,25 @@ function resolveConfig(opts) {
 		includeInternal: opts.includeInternal ?? DEFAULTS.includeInternal,
 		clientClassName: opts.clientClassName ?? DEFAULTS.clientClassName,
 		tsconfig: opts.tsconfig ? path.resolve(opts.tsconfig) : void 0,
-		numericOverrides: opts.numericOverrides ?? {}
+		numericOverrides: opts.numericOverrides ?? {},
+		schemaModule: opts.schemaModule ? path.resolve(opts.schemaModule) : void 0
 	};
 }
-/** Extract + emit. Does not touch the filesystem. */
-function generate(opts) {
+/**
+* Extract + emit. Does not touch the filesystem, and stays synchronous. Pass a
+* pre-loaded {@link SchemaEnumRegistry} to get schema-aware enum names; omit it
+* (the default) for purely structural naming.
+*/
+function generate(opts, schemaEnums) {
 	const config = resolveConfig(opts);
 	return {
-		files: emit(extractClient(config)),
+		files: emit(extractClient(config, schemaEnums)),
 		config
 	};
 }
 /** Extract + emit + write the files to `config.output`. */
-function generateToDisk(opts) {
-	const result = generate(opts);
+async function generateToDisk(opts) {
+	const result = generate(opts, await loadSchemaEnums(resolveConfig(opts)));
 	fs.mkdirSync(result.config.output, { recursive: true });
 	for (const file of result.files) fs.writeFileSync(path.join(result.config.output, file.path), file.contents, "utf8");
 	return result;
@@ -955,4 +1238,4 @@ function evalLiteral(node) {
 	if (text === "false") return false;
 }
 //#endregion
-export { emit as a, resolveConfig as i, generateToDisk as n, extractClient as o, readEntryConfig as r, generate as t };
+export { emit as a, loadSchemaEnums as c, resolveConfig as i, generateToDisk as n, extractClient as o, readEntryConfig as r, SchemaEnumRegistry as s, generate as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supalive/codegen",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Generate type-safe client code (Dart, and more) from a Supalive TypeScript router.",
   "author": "Rebaz Raouf",
   "license": "MIT",
@@ -21,7 +21,7 @@
     "type-safe"
   ],
   "bin": {
-    "supalive-dart": "./dist/cli.js"
+    "supalive-codegen": "./dist/cli.js"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -45,7 +45,8 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "ts-morph": "^24.0.0"
+    "ts-morph": "^24.0.0",
+    "@supalive/core": "*"
   },
   "devDependencies": {
     "tsdown": "^0.22.3",