@supalive/codegen 1.1.0

package/README.md

@@ -0,0 +1,90 @@
+# @supalive/codegen
+
+Generate a type-safe client from a [Supalive](https://github.com/rebaz94/supalive)
+TypeScript router. The TypeScript router is the single source of truth: this tool
+reads its procedures, inputs, and output schemas and emits a strongly-typed
+client for another language.
+
+Dart/Flutter is the first target (the `supalive-dart` binary). The package is
+named generically so additional targets (e.g. Swift, Kotlin) can ship as
+sibling binaries in future releases.
+
+## Install
+
+```sh
+npm install --save-dev @supalive/codegen
+```
+
+The generated Dart code depends on the `supalive_client` package — add it to
+your Flutter/Dart app's `pubspec.yaml`.
+
+## CLI
+
+```sh
+npx supalive-dart <entry.ts> [options]
+```
+
+`<entry.ts>` is a TypeScript file that exports your router.
+
+| Option | Description | Default |
+| --- | --- | --- |
+| `-o, --output <dir>` | Output directory for generated Dart files | `.` |
+| `-r, --router <name>` | Router export name | `appRouter` |
+| `-c, --client-class <name>` | Generated client class name | `AppClient` |
+| `--config <name>` | Config object export name | `dartCodegen` |
+| `--tsconfig <path>` | `tsconfig.json` used to resolve types | — |
+| `--include-internal` | Also generate `internal: true` procedures | off |
+| `-h, --help` | Show help | — |
+
+Example:
+
+```sh
+npx supalive-dart src/server/procedures.ts \
+  --router appRouter \
+  --client-class BasicClient \
+  --output lib/api \
+  --tsconfig tsconfig.json
+```
+
+This writes `models.dart` and `client.dart` into `lib/api/`. Treat that
+directory as generated — never edit it by hand; re-run the command after
+changing your procedures.
+
+## Config in the entry file
+
+Instead of passing flags, export a `dartCodegen` object next to your router.
+CLI flags take precedence over these values.
+
+```ts
+export const dartCodegen = {
+  output: "lib/api",
+  clientClassName: "BasicClient",
+  // router, includeInternal, tsconfig, numericOverrides also supported
+};
+```
+
+Only JSON-literal values are read statically; dynamic expressions are ignored.
+
+## Programmatic API
+
+```ts
+import { generateToDisk, generate } from "@supalive/codegen";
+
+// Extract + emit + write files to `output`.
+generateToDisk({
+  entry: "src/server/procedures.ts",
+  output: "lib/api",
+  clientClassName: "BasicClient",
+  tsconfig: "tsconfig.json",
+});
+
+// Or get the emitted files in memory without touching disk.
+const { files } = generate({ entry: "src/server/procedures.ts" });
+```
+
+`extractClient` (build the intermediate representation) and `emit` (turn the IR
+into files) are also exported for advanced use.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/cli.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { n as generateToDisk, r as readEntryConfig } from "./src-BD-RIuCu.js";
+import path from "node:path";
+//#region src/cli.ts
+function parseArgs(argv) {
+	const args = {
+		configExport: "dartCodegen",
+		help: false
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		switch (a) {
+			case "-h":
+			case "--help":
+				args.help = true;
+				break;
+			case "-o":
+			case "--output":
+				args.output = argv[++i];
+				break;
+			case "-r":
+			case "--router":
+				args.router = argv[++i];
+				break;
+			case "-c":
+			case "--client-class":
+				args.clientClass = argv[++i];
+				break;
+			case "--config":
+				args.configExport = argv[++i] ?? args.configExport;
+				break;
+			case "--tsconfig":
+				args.tsconfig = argv[++i];
+				break;
+			case "--include-internal":
+				args.includeInternal = true;
+				break;
+			default:
+				if (a.startsWith("-")) throw new Error(`Unknown option: ${a}`);
+				if (args.entry) throw new Error(`Unexpected extra argument: ${a}`);
+				args.entry = a;
+		}
+	}
+	return args;
+}
+const HELP = `supalive-dart — generate a type-safe Dart client from a Supalive router
+
+Usage:
+  supalive-dart <entry.ts> [options]
+
+Options:
+  -o, --output <dir>          Output directory for generated Dart files
+  -r, --router <name>         Router export name (default: appRouter)
+  -c, --client-class <name>   Generated client class name (default: AppClient)
+      --config <name>         Config object export name (default: dartCodegen)
+      --tsconfig <path>       tsconfig.json used to resolve types
+      --include-internal      Also generate internal (server-only) procedures
+  -h, --help                  Show this help
+
+The entry file may export a \`dartCodegen\` object with any of the above
+options; CLI flags take precedence.`;
+async function main() {
+	const args = parseArgs(process.argv.slice(2));
+	if (args.help || !args.entry) {
+		console.log(HELP);
+		process.exit(args.entry ? 0 : args.help ? 0 : 1);
+	}
+	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({
+		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
+	});
+	console.log(`Generated ${files.length} file(s) into ${config.output}:\n` + files.map((f) => `  - ${f.path}`).join("\n"));
+}
+main().catch((err) => {
+	console.error(`supalive-dart: ${err instanceof Error ? err.message : err}`);
+	process.exit(1);
+});
+//#endregion
+export {};

package/dist/index.d.ts

@@ -0,0 +1,134 @@
+//#region src/config.d.ts
+interface SupaliveDartConfig {
+  /** Output directory for generated Dart files. */
+  output?: string;
+  /** Export name of the router value in the entry file. Default "appRouter". */
+  router?: string;
+  /** Generate internal (server-only) procedures too. Default false. */
+  includeInternal?: boolean;
+  /** Name of the generated client class. Default "AppClient". */
+  clientClassName?: string;
+  /** Path to tsconfig.json used to resolve types. */
+  tsconfig?: string;
+  /**
+   * Force specific numeric fields to Dart `int` where TS erased the
+   * distinction (outputs). Keyed by `ModelName.fieldName`.
+   */
+  numericOverrides?: Record<string, "int" | "double" | "bigint">;
+}
+interface ResolvedConfig extends Required<Omit<SupaliveDartConfig, "tsconfig" | "numericOverrides">> {
+  entry: string;
+  tsconfig?: string;
+  numericOverrides: Record<string, "int" | "double" | "bigint">;
+}
+//#endregion
+//#region src/ir.d.ts
+type DartType = {
+  kind: "string";
+} | {
+  kind: "bool";
+} | {
+  kind: "double";
+} | {
+  kind: "int";
+} | {
+  kind: "bigint";
+} | {
+  kind: "bytes";
+} | {
+  kind: "datetime";
+} | {
+  kind: "dynamic";
+} | {
+  kind: "list";
+  element: DartType;
+} | {
+  kind: "map";
+  value: DartType;
+} | {
+  kind: "enum";
+  name: string;
+} | {
+  kind: "model";
+  name: string;
+};
+interface FieldIR {
+  /** Dart field name (camelCase). */
+  name: string;
+  /** Wire JSON key. */
+  jsonKey: string;
+  type: DartType;
+  /** May be omitted from the payload (Zod `.optional()` / TS `?`). */
+  optional: boolean;
+  /** May be explicitly null (Zod `.nullable()` / TS `| null`). */
+  nullable: boolean;
+}
+interface ModelIR {
+  name: string;
+  fields: FieldIR[];
+}
+interface EnumValueIR {
+  dartName: string;
+  wire: string;
+}
+interface EnumIR {
+  name: string;
+  values: EnumValueIR[];
+}
+type ProcedureKind = "query" | "mutation" | "action";
+interface ProcedureIR {
+  name: string;
+  kind: ProcedureKind;
+  internal: boolean;
+  args: DartType;
+  /** Whether args (the whole input) is a plain object model. */
+  argsIsModel: boolean;
+  result: DartType;
+  /** Whether the result may be null (TS `T | null`). */
+  resultNullable: boolean;
+}
+interface ClientIR {
+  clientClassName: string;
+  procedures: ProcedureIR[];
+  models: ModelIR[];
+  enums: EnumIR[];
+}
+//#endregion
+//#region src/emit.d.ts
+interface EmittedFile {
+  path: string;
+  contents: string;
+}
+declare function emit(ir: ClientIR): EmittedFile[];
+//#endregion
+//#region src/extract.d.ts
+/** Load the router from the entry file and extract a ClientIR. */
+declare function extractClient(config: ResolvedConfig): ClientIR;
+//#endregion
+//#region src/index.d.ts
+interface GenerateOptions extends SupaliveDartConfig {
+  /** Path to the TypeScript entry file that exports the router. */
+  entry: string;
+}
+interface GenerateResult {
+  files: EmittedFile[];
+  config: ResolvedConfig;
+}
+/** 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 + write the files to `config.output`. */
+declare function generateToDisk(opts: GenerateOptions): 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:
+ *
+ *   export const dartCodegen = { output: "lib/api", clientClassName: "Api" };
+ *
+ * Only JSON-literal values are read (string / boolean / number / nested
+ * object). Anything dynamic is ignored. Returns `{}` if not found.
+ */
+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 };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { a as emit, i as resolveConfig, n as generateToDisk, o as extractClient, r as readEntryConfig, t as generate } from "./src-BD-RIuCu.js";
+export { emit, extractClient, generate, generateToDisk, readEntryConfig, resolveConfig };

package/dist/src-BD-RIuCu.js

@@ -0,0 +1,812 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Node, Project, ts } from "ts-morph";
+//#region src/zod-schema.ts
+function scanZodArgMeta(routerDecl) {
+	const result = /* @__PURE__ */ new Map();
+	try {
+		const proceduresObj = getProceduresObjectLiteral(routerDecl);
+		if (!proceduresObj) return result;
+		for (const prop of proceduresObj.getProperties()) {
+			const key = getPropertyKey(prop);
+			if (!key) continue;
+			const call = resolveProcedureCall(prop);
+			if (!call) continue;
+			const argsSchema = getArgsSchema(call);
+			if (!argsSchema) continue;
+			const fieldMap = scanObjectSchema(argsSchema);
+			if (fieldMap.size > 0) result.set(key, fieldMap);
+		}
+	} catch {}
+	return result;
+}
+function getProceduresObjectLiteral(routerDecl) {
+	let init;
+	if (Node.isVariableDeclaration(routerDecl)) init = routerDecl.getInitializer();
+	else if (Node.isExportAssignment(routerDecl)) init = routerDecl.getExpression();
+	if (!init || !Node.isCallExpression(init)) return void 0;
+	const arg = init.getArguments()[0];
+	if (!arg || !Node.isObjectLiteralExpression(arg)) return void 0;
+	const proceduresProp = arg.getProperty("procedures");
+	if (!proceduresProp || !Node.isPropertyAssignment(proceduresProp)) return;
+	const value = proceduresProp.getInitializer();
+	return value && Node.isObjectLiteralExpression(value) ? value : void 0;
+}
+function getPropertyKey(prop) {
+	if (Node.isPropertyAssignment(prop) || Node.isShorthandPropertyAssignment(prop)) return prop.getName();
+}
+/** Follow a procedures-map entry to its `query/mutation/action({...})` call. */
+function resolveProcedureCall(prop) {
+	let expr;
+	if (Node.isShorthandPropertyAssignment(prop)) expr = prop.getNameNode();
+	else if (Node.isPropertyAssignment(prop)) expr = prop.getInitializer();
+	return followToCall(expr, 0);
+}
+function followToCall(node, depth) {
+	if (!node || depth > 8) return void 0;
+	if (Node.isCallExpression(node)) return node;
+	if (Node.isIdentifier(node)) {
+		for (const def of node.getDefinitionNodes()) if (Node.isVariableDeclaration(def)) {
+			const found = followToCall(def.getInitializer(), depth + 1);
+			if (found) return found;
+		}
+	}
+}
+/** From a `query({ args: z.object({...}), handler })` call, get the schema. */
+function getArgsSchema(call) {
+	if (!Node.isCallExpression(call)) return void 0;
+	const arg = call.getArguments()[0];
+	if (!arg || !Node.isObjectLiteralExpression(arg)) return void 0;
+	const argsProp = arg.getProperty("args");
+	if (!argsProp || !Node.isPropertyAssignment(argsProp)) return void 0;
+	return argsProp.getInitializer();
+}
+/** Scan `z.object({ field: <expr>, ... })` for per-field metadata. */
+function scanObjectSchema(schema) {
+	const map = /* @__PURE__ */ new Map();
+	const objectLiteral = findZodObjectLiteral(schema);
+	if (!objectLiteral || !Node.isObjectLiteralExpression(objectLiteral)) return map;
+	for (const prop of objectLiteral.getProperties()) {
+		if (!Node.isPropertyAssignment(prop)) continue;
+		const key = prop.getName();
+		const init = prop.getInitializer();
+		if (!init) continue;
+		const methods = topLevelZodMethods(init);
+		const meta = {};
+		if (methods.has("bigint")) meta.numeric = "bigint";
+		else if (methods.has("int")) meta.numeric = "int";
+		if (methods.has("default") || methods.has("catch") || methods.has("prefault")) meta.optional = true;
+		if (meta.numeric || meta.optional) map.set(key, meta);
+	}
+	return map;
+}
+/**
+* Names of the methods called at the top level of a Zod field expression.
+* For `z.number().int().default(0)` → `{ number, int, default }`. Nested
+* schemas (inside an object argument) are not descended into.
+*/
+function topLevelZodMethods(node) {
+	const methods = /* @__PURE__ */ new Set();
+	let cur = node;
+	while (cur && Node.isCallExpression(cur)) {
+		const expr = cur.getExpression();
+		if (Node.isPropertyAccessExpression(expr)) {
+			methods.add(expr.getName());
+			cur = expr.getExpression();
+		} else break;
+	}
+	return methods;
+}
+function findZodObjectLiteral(node) {
+	let cur = node;
+	while (cur && Node.isCallExpression(cur)) {
+		const expr = cur.getExpression();
+		const exprText = expr.getText();
+		if (/(^|\.)(strict|loose)?[oO]bject$/.test(exprText)) {
+			const arg = cur.getArguments()[0];
+			return arg && Node.isObjectLiteralExpression(arg) ? arg : void 0;
+		}
+		if (Node.isPropertyAccessExpression(expr)) cur = expr.getExpression();
+		else break;
+	}
+	return cur && Node.isObjectLiteralExpression(cur) ? cur : void 0;
+}
+//#endregion
+//#region src/extract.ts
+/** Load the router from the entry file and extract a ClientIR. */
+function extractClient(config) {
+	const exported = new Project({
+		tsConfigFilePath: config.tsconfig,
+		skipAddingFilesFromTsConfig: config.tsconfig ? false : true,
+		compilerOptions: config.tsconfig ? void 0 : {
+			strict: true,
+			target: ts.ScriptTarget.ES2022
+		}
+	}).addSourceFileAtPath(path.resolve(config.entry)).getExportedDeclarations().get(config.router);
+	if (!exported || exported.length === 0) throw new Error(`Could not find an export named "${config.router}" in ${config.entry}. Set { router: "<name>" } in your config or pass --router.`);
+	const routerDecl = exported[0];
+	const proceduresSym = routerDecl.getType().getProperty("procedures");
+	if (!proceduresSym) throw new Error(`Export "${config.router}" does not look like a Supalive router (no "procedures" property).`);
+	const proceduresType = proceduresSym.getTypeAtLocation(routerDecl);
+	const extractor = new Extractor(routerDecl, config, scanZodArgMeta(routerDecl));
+	const procedures = [];
+	for (const procSym of proceduresType.getProperties()) {
+		const name = procSym.getName();
+		const procType = procSym.getTypeAtLocation(routerDecl);
+		const ir = extractor.procedure(name, procType);
+		if (!ir) continue;
+		if (ir.internal && !config.includeInternal) continue;
+		procedures.push(ir);
+	}
+	procedures.sort((a, b) => a.name.localeCompare(b.name));
+	return {
+		clientClassName: config.clientClassName,
+		procedures,
+		models: extractor.models(),
+		enums: extractor.enums()
+	};
+}
+var Extractor = class {
+	locationNode;
+	config;
+	argMeta;
+	modelRegistry = /* @__PURE__ */ new Map();
+	enumRegistry = /* @__PURE__ */ new Map();
+	/** Value-set signature → already-registered enum name, for structural dedup. */
+	enumBySignature = /* @__PURE__ */ new Map();
+	nameCounts = /* @__PURE__ */ new Map();
+	visiting = /* @__PURE__ */ new Set();
+	constructor(locationNode, config, argMeta) {
+		this.locationNode = locationNode;
+		this.config = config;
+		this.argMeta = argMeta;
+	}
+	models() {
+		return [...this.modelRegistry.values()];
+	}
+	enums() {
+		return [...this.enumRegistry.values()];
+	}
+	procedure(name, procType) {
+		const kind = this.literalString(procType, "procedureType");
+		if (!kind) return null;
+		const internal = this.literalBoolean(procType, "internal") ?? false;
+		if (internal && !this.config.includeInternal) return null;
+		const fnSym = procType.getProperty("fn");
+		if (!fnSym) return null;
+		const sig = fnSym.getTypeAtLocation(this.locationNode).getCallSignatures()[0];
+		if (!sig) return null;
+		const inputParam = sig.getParameters()[1];
+		const argsType = inputParam ? this.walk(inputParam.getTypeAtLocation(this.locationNode), pascal(name) + "Args") : { kind: "dynamic" };
+		const metas = this.argMeta.get(name);
+		if (metas && argsType.kind === "model") {
+			const model = this.modelRegistry.get(argsType.name);
+			if (model) for (const f of model.fields) {
+				const meta = metas.get(f.jsonKey);
+				if (!meta) continue;
+				if (meta.numeric && (f.type.kind === "double" || f.type.kind === "int")) f.type = { kind: meta.numeric };
+				if (meta.optional) f.optional = true;
+			}
+		}
+		const ret = unwrapPromise(sig.getReturnType());
+		const { hasNull, hasUndefined } = splitNullish(ret);
+		const resultType = this.walk(ret, pascal(name) + "Result");
+		return {
+			name,
+			kind,
+			internal,
+			args: argsType,
+			argsIsModel: argsType.kind === "model",
+			result: resultType,
+			resultNullable: hasNull || hasUndefined
+		};
+	}
+	walk(type, hint) {
+		const { core } = splitNullish(type);
+		if (core.length === 0) return { kind: "dynamic" };
+		if (core.length > 1) return this.walkUnion(core, hint);
+		return this.walkSingle(core[0], hint);
+	}
+	walkSingle(type, hint) {
+		const flags = type.getFlags();
+		if (flags & ts.TypeFlags.String) return { kind: "string" };
+		if (flags & ts.TypeFlags.Number) return this.numberType(hint);
+		if (flags & ts.TypeFlags.Boolean) return { kind: "bool" };
+		if (flags & ts.TypeFlags.BooleanLiteral) return { kind: "bool" };
+		if (flags & ts.TypeFlags.BigInt) return { kind: "bigint" };
+		if (flags & ts.TypeFlags.BigIntLiteral) return { kind: "bigint" };
+		if (flags & ts.TypeFlags.StringLiteral) return { kind: "string" };
+		if (flags & ts.TypeFlags.NumberLiteral) return this.numberType(hint);
+		if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return { kind: "dynamic" };
+		if (type.isArray()) {
+			const el = type.getArrayElementTypeOrThrow();
+			return {
+				kind: "list",
+				element: this.walk(el, singular(hint))
+			};
+		}
+		const symName = type.getSymbol()?.getName();
+		if (symName === "Uint8Array") return { kind: "bytes" };
+		if (symName === "Date") return { kind: "datetime" };
+		if (isFunctionLike(type)) return { kind: "dynamic" };
+		if (type.isUnion()) {
+			const { core } = splitNullish(type);
+			if (core.length === 1) return this.walkSingle(core[0], hint);
+			return this.walkUnion(core, hint);
+		}
+		if (type.isObject()) {
+			const props = type.getProperties();
+			const indexType = type.getStringIndexType();
+			if (props.length === 0 && indexType) {
+				if (indexType.isNever()) return this.registerEmptyModel(hint);
+				return {
+					kind: "map",
+					value: this.walk(indexType, hint + "Value")
+				};
+			}
+			return this.walkObject(type, hint);
+		}
+		return { kind: "dynamic" };
+	}
+	walkUnion(members, hint, enumHint) {
+		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);
+		return { kind: "dynamic" };
+	}
+	walkObject(type, hint) {
+		const name = this.modelName(type, hint);
+		if (this.modelRegistry.has(name)) return {
+			kind: "model",
+			name
+		};
+		if (this.visiting.has(name)) return {
+			kind: "model",
+			name
+		};
+		this.visiting.add(name);
+		const fields = [];
+		for (const prop of type.getProperties()) {
+			const jsonKey = prop.getName();
+			const propType = prop.getTypeAtLocation(this.locationNode);
+			if (prop.getFlags() & ts.SymbolFlags.Method || isFunctionLike(propType)) continue;
+			const declaredOptional = (prop.getFlags() & ts.SymbolFlags.Optional) !== 0;
+			const { core, hasNull, hasUndefined } = splitNullish(propType);
+			const optional = declaredOptional || hasUndefined;
+			const nullable = hasNull;
+			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));
+			const override = this.config.numericOverrides[`${name}.${jsonKey}`];
+			if (override && (dartType.kind === "double" || dartType.kind === "int")) dartType = { kind: override };
+			fields.push({
+				name: camel(jsonKey),
+				jsonKey,
+				type: dartType,
+				optional,
+				nullable
+			});
+		}
+		this.visiting.delete(name);
+		this.modelRegistry.set(name, {
+			name,
+			fields
+		});
+		return {
+			kind: "model",
+			name
+		};
+	}
+	numberType(hint) {
+		return { kind: "double" };
+	}
+	modelName(type, hint) {
+		const symName = (type.getAliasSymbol() ?? type.getSymbol())?.getName();
+		if (symName && symName !== "__type" && symName !== "__object") return uniqueName(symName, this.modelRegistry, type);
+		return this.uniqueHint(hint);
+	}
+	/** Register (or reuse) a fieldless model named from the hint. */
+	registerEmptyModel(hint) {
+		const name = this.uniqueHint(hint);
+		if (!this.modelRegistry.has(name)) this.modelRegistry.set(name, {
+			name,
+			fields: []
+		});
+		return {
+			kind: "model",
+			name
+		};
+	}
+	registerEnum(hint, values) {
+		const signature = values.join("\0");
+		const existing = this.enumBySignature.get(signature);
+		if (existing) return {
+			kind: "enum",
+			name: existing
+		};
+		const name = this.uniqueHint(hint);
+		this.enumRegistry.set(name, {
+			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);
+		if (this.modelRegistry.has(name)) return {
+			kind: "model",
+			name
+		};
+		if (this.visiting.has(name)) return {
+			kind: "model",
+			name
+		};
+		this.visiting.add(name);
+		const fieldMap = /* @__PURE__ */ new Map();
+		for (const m of members) for (const prop of m.getProperties()) {
+			const jsonKey = prop.getName();
+			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 acc = fieldMap.get(jsonKey) ?? {
+				types: [],
+				present: 0,
+				nullable: false,
+				optional: false
+			};
+			acc.types.push(dt);
+			acc.present++;
+			if (hasNull) acc.nullable = true;
+			if (declaredOptional || hasUndefined) acc.optional = true;
+			fieldMap.set(jsonKey, acc);
+		}
+		const fields = [];
+		for (const [jsonKey, acc] of fieldMap) {
+			const consistent = acc.types.every((t) => JSON.stringify(t) === JSON.stringify(acc.types[0]));
+			fields.push({
+				name: camel(jsonKey),
+				jsonKey,
+				type: consistent ? acc.types[0] : { kind: "dynamic" },
+				optional: acc.optional || acc.present < members.length,
+				nullable: acc.nullable
+			});
+		}
+		this.visiting.delete(name);
+		this.modelRegistry.set(name, {
+			name,
+			fields
+		});
+		return {
+			kind: "model",
+			name
+		};
+	}
+	uniqueHint(hint) {
+		const base = pascal(hint);
+		const count = this.nameCounts.get(base) ?? 0;
+		if (count === 0) {
+			this.nameCounts.set(base, 1);
+			return base;
+		}
+		this.nameCounts.set(base, count + 1);
+		return `${base}${count + 1}`;
+	}
+	literalString(type, prop) {
+		const p = type.getProperty(prop);
+		if (!p) return void 0;
+		const t = p.getTypeAtLocation(this.locationNode);
+		if (t.getFlags() & ts.TypeFlags.StringLiteral) return String(t.getLiteralValue());
+	}
+	literalBoolean(type, prop) {
+		const p = type.getProperty(prop);
+		if (!p) return void 0;
+		const txt = p.getTypeAtLocation(this.locationNode).getText();
+		if (txt === "true") return true;
+		if (txt === "false") return false;
+	}
+};
+/** A type whose primary shape is a call/construct signature (a function). */
+function isFunctionLike(type) {
+	return type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0;
+}
+function unwrapPromise(type) {
+	if (type.getSymbol()?.getName() === "Promise") {
+		const args = type.getTypeArguments();
+		if (args.length === 1) return args[0];
+	}
+	return type;
+}
+function splitNullish(type) {
+	const parts = type.isUnion() ? type.getUnionTypes() : [type];
+	let hasNull = false;
+	let hasUndefined = false;
+	const core = [];
+	for (const p of parts) {
+		const f = p.getFlags();
+		if (f & ts.TypeFlags.Null) hasNull = true;
+		else if (f & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) hasUndefined = true;
+		else core.push(p);
+	}
+	return {
+		core,
+		hasNull,
+		hasUndefined
+	};
+}
+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";
+}
+function enumValueName(wire) {
+	const c = camel(wire);
+	if (!c || /^[0-9]/.test(c)) return "v" + pascal(wire);
+	return c;
+}
+//#endregion
+//#region src/emit.ts
+const HEADER = "// GENERATED by @supalive/codegen. Do not edit by hand.\n// ignore_for_file: type=lint\n";
+function emit(ir) {
+	return [{
+		path: "models.dart",
+		contents: emitModels(ir)
+	}, {
+		path: "client.dart",
+		contents: emitClient(ir)
+	}];
+}
+/** Dart type name for a non-null [DartType]. */
+function typeName(t) {
+	switch (t.kind) {
+		case "string": return "String";
+		case "bool": return "bool";
+		case "double": return "double";
+		case "int": return "int";
+		case "bigint": return "BigInt";
+		case "bytes": return "Uint8List";
+		case "datetime": return "DateTime";
+		case "dynamic": return "Object?";
+		case "list": return `List<${typeName(t.element)}>`;
+		case "map": return `Map<String, ${typeName(t.value)}>`;
+		case "enum": return t.name;
+		case "model": return t.name;
+	}
+}
+/** Decode `expr` (an `Object?` value known to be non-null) into [t]. */
+function decodeNonNull(t, expr) {
+	switch (t.kind) {
+		case "string": return `${expr} as String`;
+		case "bool": return `${expr} as bool`;
+		case "double": return `doubleFromJson(${expr})`;
+		case "int": return `intFromJson(${expr})`;
+		case "bigint": return `bigIntFromJson(${expr})`;
+		case "bytes": return `bytesFromJson(${expr})`;
+		case "datetime": return `dateTimeFromJson(${expr})`;
+		case "dynamic": return expr;
+		case "enum": return `${t.name}.fromJson(${expr})`;
+		case "model": return `${t.name}.fromJson(${expr} as Map<String, Object?>)`;
+		case "list": return `(${expr} as List).map((e) => ${decodeNonNull(t.element, "e")}).toList()`;
+		case "map": return `(${expr} as Map<String, Object?>).map((k, v) => MapEntry(k, ${decodeNonNull(t.value, "v")}))`;
+	}
+}
+/** Decode `expr` allowing null. */
+function decodeNullable(t, expr) {
+	switch (t.kind) {
+		case "string": return `${expr} as String?`;
+		case "bool": return `${expr} as bool?`;
+		case "dynamic": return expr;
+		default: return `${expr} == null ? null : ${decodeNonNull(t, expr)}`;
+	}
+}
+/** Encode a non-null Dart value [expr] of type [t] to a JSON-native value. */
+function encodeNonNull(t, expr) {
+	switch (t.kind) {
+		case "string":
+		case "bool":
+		case "double":
+		case "int":
+		case "bigint":
+		case "bytes":
+		case "dynamic": return expr;
+		case "datetime": return `dateTimeToJson(${expr})`;
+		case "enum": return `${expr}.toJson()`;
+		case "model": return `${expr}.toJson()`;
+		case "list": return `${expr}.map((e) => ${encodeNonNull(t.element, "e")}).toList()`;
+		case "map": return `${expr}.map((k, v) => MapEntry(k, ${encodeNonNull(t.value, "v")}))`;
+	}
+}
+/** Encode a possibly-null value. */
+function encodeNullable(t, expr) {
+	switch (t.kind) {
+		case "string":
+		case "bool":
+		case "double":
+		case "int":
+		case "bigint":
+		case "bytes":
+		case "dynamic": return expr;
+		default: return `${expr} == null ? null : ${encodeNonNull(t, stripNull(expr))}`;
+	}
+}
+function stripNull(expr) {
+	return `${expr}!`;
+}
+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");
+}
+/** Whether any generated model field decodes to `Uint8List` (needs typed_data). */
+function modelsUseBytes(ir) {
+	const hasBytes = (t) => {
+		switch (t.kind) {
+			case "bytes": return true;
+			case "list": return hasBytes(t.element);
+			case "map": return hasBytes(t.value);
+			default: return false;
+		}
+	};
+	return ir.models.some((m) => m.fields.some((f) => hasBytes(f.type)));
+}
+function emitEnum(e) {
+	const values = e.values.map((v) => `  ${v.dartName}('${v.wire}')`).join(",\n");
+	return `enum ${e.name} {
+${values};
+
+  const ${e.name}(this.wire);
+  final String wire;
+
+  static ${e.name} fromJson(Object? value) => values.firstWhere(
+        (e) => e.wire == value,
+        orElse: () => throw ArgumentError('Unknown ${e.name}: \$value'),
+      );
+
+  String toJson() => wire;
+}
+`;
+}
+/** Dart declared type for a field, applying nullability. */
+function fieldType(f) {
+	if (f.optional && f.nullable) return `Optional<${typeName(f.type)}>`;
+	const base = typeName(f.type);
+	const nullable = f.optional || f.nullable;
+	if (base === "Object?") return "Object?";
+	return nullable ? `${base}?` : base;
+}
+function emitModel(m) {
+	const ctorParams = m.fields.map((f) => {
+		if (f.optional && f.nullable) return `    this.${f.name} = const Optional.absent()`;
+		return !(f.optional || f.nullable) ? `    required this.${f.name}` : `    this.${f.name}`;
+	}).join(",\n");
+	const fields = m.fields.map((f) => `  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 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}`;
+	}).join(",\n");
+	const isDeep = (f) => {
+		if (f.optional && f.nullable) return false;
+		const k = f.type.kind;
+		return k === "list" || k === "map" || k === "bytes" || k === "dynamic";
+	};
+	const eqFields = m.fields.map((f) => {
+		const cmp = isDeep(f) ? `deepEquals(other.${f.name}, ${f.name})` : `other.${f.name} == ${f.name}`;
+		return `(identical(other.${f.name}, ${f.name}) || ${cmp})`;
+	}).join(" &&\n          ");
+	const hashParts = m.fields.map((f) => isDeep(f) ? `deepHashCode(${f.name})` : f.name).join(", ");
+	const hashBody = m.fields.length === 0 ? "runtimeType.hashCode" : m.fields.length <= 19 ? `Object.hash(runtimeType, ${hashParts})` : `Object.hashAll([runtimeType, ${hashParts}])`;
+	return `class ${m.name} implements SupaliveModel {
+  const ${m.name}(${m.fields.length ? "{\n" + ctorParams + ",\n  }" : ""});
+
+${fields}
+
+  factory ${m.name}.fromJson(Map<String, Object?> json) => ${m.name}(${m.fields.length ? "\n" + fromJson + "\n  " : ""});
+
+  @override
+  Map<String, Object?> toJson() {
+    final json = <String, Object?>{};
+${toJson}
+    return json;
+  }
+
+  ${m.name} copyWith(${m.fields.length ? "{\n" + copyParams + ",\n  }" : ""}) =>
+      ${m.name}(${m.fields.length ? "\n" + copyArgs + ",\n    " : ""});
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      (other is ${m.name} &&
+          other.runtimeType == runtimeType${m.fields.length ? " &&\n          " + eqFields : ""});
+
+  @override
+  int get hashCode => ${hashBody};
+}
+`;
+}
+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}')
+            ? (${key} == null
+                ? const Optional<${inner}>.ofNull()
+                : Optional<${inner}>.of(${decodeNonNull(f.type, key)}))
+            : const Optional<${inner}>.absent(),`;
+	}
+	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;
+      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)};`;
+}
+function emitClient(ir) {
+	const out = [HEADER];
+	out.push("import 'package:supalive_client/supalive_client.dart';");
+	out.push("import 'models.dart';");
+	out.push("\nexport 'models.dart';");
+	out.push("export 'package:supalive_client/supalive_client.dart';\n");
+	const endpoints = ir.procedures.map((p) => emitEndpoint(p)).join("\n\n");
+	out.push(`class ${ir.clientClassName} {
+  ${ir.clientClassName}(SupaliveConfig config) : _client = SupaliveClient(config);
+
+  /// Construct around an existing transport (e.g. shared across clients).
+  ${ir.clientClassName}.fromClient(this._client);
+
+  final SupaliveClient _client;
+
+  /// The underlying transport, for connection-state APIs.
+  SupaliveClient get raw => _client;
+
+  Future<void> connect() => _client.connect();
+  void disconnect() => _client.disconnect();
+  bool get isReady => _client.isReady;
+  bool get isAuthenticated => _client.isAuthenticated;
+  bool get isAnonymous => _client.isAnonymous;
+  String? get authUserId => _client.authUserId;
+  ClientPublicState get publicState => _client.publicState;
+  void Function() onClientState(void Function(ClientPublicState) listener) =>
+      _client.onClientState(listener);
+
+${endpoints}
+}
+`);
+	return out.join("\n");
+}
+function argsTypeName(p) {
+	return p.argsIsModel ? typeName(p.args) : typeName(p.args);
+}
+function encodeArgs(p) {
+	if (p.argsIsModel) return "(a) => a.toJson()";
+	return `(a) => ${encodeNonNull(p.args, "a")}`;
+}
+function resultTypeName(p) {
+	const base = typeName(p.result);
+	if (base === "Object?") return "Object?";
+	return p.resultNullable ? `${base}?` : base;
+}
+function decodeResult(p) {
+	if (p.resultNullable) return `(raw) => ${decodeNullable(p.result, "raw")}`;
+	return `(raw) => ${decodeNonNull(p.result, "raw")}`;
+}
+function emitEndpoint(p) {
+	const endpointClass = p.kind === "query" ? "QueryEndpoint" : p.kind === "mutation" ? "MutationEndpoint" : "ActionEndpoint";
+	const args = argsTypeName(p);
+	const result = resultTypeName(p);
+	return `  late final ${p.name} = ${endpointClass}<${args}, ${result}>(
+    _client,
+    '${p.name}',
+    ${encodeArgs(p)},
+    ${decodeResult(p)},
+  );`;
+}
+//#endregion
+//#region src/index.ts
+const DEFAULTS = {
+	output: "lib/generated",
+	router: "appRouter",
+	includeInternal: false,
+	clientClassName: "AppClient"
+};
+/** Resolve a partial config against defaults, anchoring relative paths. */
+function resolveConfig(opts) {
+	return {
+		entry: path.resolve(opts.entry),
+		output: path.resolve(opts.output ?? DEFAULTS.output),
+		router: opts.router ?? DEFAULTS.router,
+		includeInternal: opts.includeInternal ?? DEFAULTS.includeInternal,
+		clientClassName: opts.clientClassName ?? DEFAULTS.clientClassName,
+		tsconfig: opts.tsconfig ? path.resolve(opts.tsconfig) : void 0,
+		numericOverrides: opts.numericOverrides ?? {}
+	};
+}
+/** Extract + emit. Does not touch the filesystem. */
+function generate(opts) {
+	const config = resolveConfig(opts);
+	return {
+		files: emit(extractClient(config)),
+		config
+	};
+}
+/** Extract + emit + write the files to `config.output`. */
+function generateToDisk(opts) {
+	const result = generate(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;
+}
+/**
+* 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:
+*
+*   export const dartCodegen = { output: "lib/api", clientClassName: "Api" };
+*
+* Only JSON-literal values are read (string / boolean / number / nested
+* object). Anything dynamic is ignored. Returns `{}` if not found.
+*/
+function readEntryConfig(entry, exportName = "dartCodegen", tsconfig) {
+	const decls = new Project({
+		tsConfigFilePath: tsconfig,
+		skipAddingFilesFromTsConfig: true,
+		compilerOptions: tsconfig ? void 0 : { allowJs: true }
+	}).addSourceFileAtPath(path.resolve(entry)).getExportedDeclarations().get(exportName);
+	if (!decls || decls.length === 0) return {};
+	const decl = decls[0];
+	const init = Node.isVariableDeclaration(decl) ? decl.getInitializer() : Node.isExpression(decl) ? decl : void 0;
+	if (!init || !Node.isObjectLiteralExpression(init)) return {};
+	return evalObjectLiteral(init);
+}
+function evalObjectLiteral(obj) {
+	const out = {};
+	if (!Node.isObjectLiteralExpression(obj)) return out;
+	for (const prop of obj.getProperties()) {
+		if (!Node.isPropertyAssignment(prop)) continue;
+		const nameNode = prop.getNameNode();
+		const key = Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : nameNode.getText();
+		const value = evalLiteral(prop.getInitializerOrThrow());
+		if (value !== void 0) out[key] = value;
+	}
+	return out;
+}
+function evalLiteral(node) {
+	if (Node.isStringLiteral(node)) return node.getLiteralValue();
+	if (Node.isNumericLiteral(node)) return node.getLiteralValue();
+	if (Node.isObjectLiteralExpression(node)) return evalObjectLiteral(node);
+	const text = node.getText();
+	if (text === "true") return true;
+	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 };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@supalive/codegen",
+  "version": "1.1.0",
+  "description": "Generate type-safe client code (Dart, and more) from a Supalive TypeScript router.",
+  "author": "Rebaz Raouf",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rebaz94/supalive",
+    "directory": "packages/codegen"
+  },
+  "homepage": "https://github.com/rebaz94/supalive#readme",
+  "bugs": "https://github.com/rebaz94/supalive/issues",
+  "keywords": [
+    "supalive",
+    "codegen",
+    "dart",
+    "flutter",
+    "client",
+    "type-safe"
+  ],
+  "bin": {
+    "supalive-dart": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "node --import tsx ./src/cli.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "ts-morph": "^24.0.0"
+  },
+  "devDependencies": {
+    "tsdown": "^0.22.3",
+    "tsx": "^4.19.0",
+    "typescript": "^6.0.0",
+    "@types/node": "25.6.0"
+  }
+}