@supalive/codegen 1.7.0 → 1.8.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as generateToDisk, r as readEntryConfig } from "./src-DM44BrYS.js";
+import { n as generateToDisk, r as readEntryConfig } from "./src-BRGy8CeY.js";
 import path from "node:path";
 //#region src/cli.ts
 function parseArgs(argv) {

package/dist/index.js

@@ -1,2 +1,2 @@
-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-DM44BrYS.js";
+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-BRGy8CeY.js";
 export { SchemaEnumRegistry, emit, extractClient, generate, generateToDisk, loadSchemaEnums, readEntryConfig, resolveConfig };

package/dist/{src-DM44BrYS.js → src-BRGy8CeY.js}

@@ -92,12 +92,91 @@ 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);
+		for (const def of node.getDefinitionNodes()) {
+			const init = definitionInitializer(def);
+			if (init) {
+				const found = followToCall(init, depth + 1);
+				if (found) return found;
+			}
+		}
+		const imported = followImport(node);
+		if (imported) {
+			const found = followToCall(imported, depth + 1);
 			if (found) return found;
 		}
 	}
 }
+/**
+* Given an Identifier that may be an import binding, follow through the import
+* chain to the actual exported declaration's initializer node.
+*
+* Handles: `import { listItems } from "./procs.js"` → the exported VariableDeclaration
+*          `import { x } from "./reexport.js"` where that file re-exports → recursive follow
+*/
+function followImport(id) {
+	const sourceFile = id.getSourceFile();
+	const name = id.getText();
+	for (const imp of sourceFile.getImportDeclarations()) {
+		const specifiers = imp.getNamedImports();
+		for (const spec of specifiers) {
+			if (spec.getName() !== name) continue;
+			const resolved = imp.getModuleSpecifierSourceFile();
+			if (!resolved) continue;
+			const exportName = spec.getNameNode().getText();
+			const exported = resolved.getExportedDeclarations().get(exportName);
+			if (!exported || exported.length === 0) continue;
+			const decl = exported[0];
+			if (Node.isExportSpecifier(decl)) {
+				const targets = decl.getLocalTargetDeclarations();
+				if (targets.length > 0) return definitionInitializer(targets[0]);
+				continue;
+			}
+			return definitionInitializer(decl);
+		}
+	}
+	for (const exp of sourceFile.getExportDeclarations()) {
+		const specifiers = exp.getNamedExports();
+		for (const spec of specifiers) {
+			if (spec.getName() !== name) continue;
+			const resolved = exp.getModuleSpecifierSourceFile();
+			if (!resolved) continue;
+			const exportName = spec.getNameNode().getText();
+			const exported = resolved.getExportedDeclarations().get(exportName);
+			if (!exported || exported.length === 0) continue;
+			const decl = exported[0];
+			if (Node.isExportSpecifier(decl)) {
+				const targets = decl.getLocalTargetDeclarations();
+				if (targets.length > 0) return definitionInitializer(targets[0]);
+				continue;
+			}
+			return definitionInitializer(decl);
+		}
+	}
+}
+/** Extract the initializer expression from a definition node, unwrapping any
+*  container nodes (VariableStatement, ExportNamedDeclaration, etc.) that
+*  ts-morph may return for cross-file imports. */
+function definitionInitializer(def) {
+	if (Node.isVariableDeclaration(def)) return def.getInitializer();
+	if (Node.isVariableStatement(def)) for (const d of def.getDeclarationList().getDeclarations()) {
+		const init = d.getInitializer();
+		if (init) return init;
+	}
+	for (const child of def.getChildren()) {
+		const init = definitionInitializer(child);
+		if (init) return init;
+	}
+}
+/** Resolve an Identifier to its initializer, following definitions across files. */
+function resolveIdentifierInit(id) {
+	if (!Node.isIdentifier(id)) return void 0;
+	for (const def of id.getDefinitionNodes()) {
+		const init = definitionInitializer(def);
+		if (init) return init;
+	}
+	const imported = followImport(id);
+	if (imported) return imported;
+}
 /** From a `query({ args: z.object({...}), handler })` call, get the schema. */
 function getArgsSchema(call) {
 	if (!Node.isCallExpression(call)) return void 0;
@@ -110,7 +189,12 @@ function getArgsSchema(call) {
 /** Scan `z.object({ field: <expr>, ... })` for per-field metadata. */
 function scanObjectSchema(schema) {
 	const map = /* @__PURE__ */ new Map();
-	const objectLiteral = findZodObjectLiteral(schema);
+	let node = schema;
+	if (Node.isIdentifier(node)) {
+		const init = resolveIdentifierInit(node);
+		if (init) node = init;
+	}
+	const objectLiteral = findZodObjectLiteral(node);
 	if (!objectLiteral || !Node.isObjectLiteralExpression(objectLiteral)) return map;
 	for (const prop of objectLiteral.getProperties()) {
 		if (!Node.isPropertyAssignment(prop)) continue;
@@ -428,6 +512,31 @@ var Extractor = class {
 			return;
 		}
 	}
+	/**
+	* Read an `@type` JSDoc tag from a property and parse it into a DartType.
+	*
+	* Supported formats:
+	*   - `/** @type StoreCardItem *​/` → model with that name
+	*   - `/** @type List<StoreCardItem> *​/` → list with model element
+	*   - `/** @type String *​/`, `/** @type int *​/`, etc. → primitive
+	*/
+	readTypeOverride(prop) {
+		try {
+			const decls = prop.getDeclarations();
+			if (!decls || decls.length === 0) return null;
+			const node = decls[0];
+			if (!Node.isJSDocable(node)) return null;
+			const jsDocs = node.getJsDocs();
+			if (jsDocs.length === 0) return null;
+			const typeTag = jsDocs[jsDocs.length - 1].getTags().find((t) => t.getTagName() === "type");
+			if (!typeTag) return null;
+			const raw = typeTag.compilerNode.typeExpression?.getText?.()?.trim();
+			if (!raw) return null;
+			return parseTypeOverride(raw);
+		} catch {
+			return null;
+		}
+	}
 	models() {
 		this.finalizeEnums();
 		return [...this.modelRegistry.values()];
@@ -544,11 +653,15 @@ var Extractor = class {
 			const { core, hasNull, hasUndefined } = splitNullish(propType);
 			const optional = declaredOptional || hasUndefined;
 			const nullable = hasNull;
+			const typeOverride = this.readTypeOverride(prop);
 			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, {
-				hint: name + pascal(jsonKey),
+			if (typeOverride) dartType = typeOverride;
+			else if (core.length === 0) dartType = { kind: "dynamic" };
+			else if (core.length === 1) {
+				const fieldHint = name.replace(/Result$/, "") + pascal(jsonKey);
+				dartType = this.walkSingle(core[0], fieldHint);
+			} else dartType = this.walkUnion(core, {
+				hint: name.replace(/Result$/, "") + pascal(jsonKey),
 				stem: cleanStem(name),
 				field: jsonKey
 			});
@@ -832,6 +945,40 @@ function cleanStem(modelName) {
 	}
 	return singularizeWord(s);
 }
+const PRIMITIVE_MAP = {
+	string: "string",
+	int: "int",
+	double: "double",
+	bool: "bool",
+	bigint: "bigint",
+	bytes: "bytes",
+	datetime: "datetime",
+	dynamic: "dynamic"
+};
+/**
+* Parse an `@type` override value into a DartType.
+*
+* - `"StoreCardItem"` → `{ kind: "model", name: "StoreCardItem" }`
+* - `"List<StoreCardItem>"` → `{ kind: "list", element: { kind: "model", name: "StoreCardItem" } }`
+* - `"String"` → `{ kind: "string" }`
+* - `"int"` → `{ kind: "int" }`
+*/
+function parseTypeOverride(raw) {
+	const listMatch = raw.match(/^List<(.+)>$/);
+	if (listMatch) {
+		const innerType = parseTypeOverride(listMatch[1].trim());
+		return innerType ? {
+			kind: "list",
+			element: innerType
+		} : null;
+	}
+	const prim = PRIMITIVE_MAP[raw.toLowerCase()];
+	if (prim) return { kind: prim };
+	return {
+		kind: "model",
+		name: raw
+	};
+}
 /** The bare candidate name for a structural (non-schema) enum group. */
 function fallbackBase(g) {
 	return pascal(g.field ?? g.hint);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supalive/codegen",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Generate type-safe client code (Dart, and more) from a Supalive TypeScript router.",
   "author": "Rebaz Raouf",
   "license": "MIT",