@atscript/typescript 0.1.89 → 0.1.90

package/dist/cli.cjs

@@ -1790,11 +1790,8 @@ var JsRenderer = class extends BaseRenderer {
 				const unwound = this.doc.unwindType(annotateNode.targetName);
 				if (unwound?.def) {
 					let def = this.doc.mergeIntersection(unwound.def);
-					if ((0, _atscript_core.isInterface)(def)) if (def.hasExtends) {
-						const resolved = unwound.doc.resolveInterfaceExtends(def);
-						if (resolved) def = resolved;
-						else def = def.getDefinition() || def;
-					} else def = def.getDefinition() || def;
+					if ((0, _atscript_core.isInterface)(def)) if (def.hasExtends) def = unwound.doc.resolveInterfaceExtends(def) || def.getDefinition() || def;
+					else def = def.getDefinition() || def;
 					this._adHocAnnotations = this.buildAdHocMap([annotateNode]);
 					this.annotateType(def, node.id);
 					this._adHocAnnotations = null;
@@ -2307,8 +2304,7 @@ var JsRenderer = class extends BaseRenderer {
 				targetValue += "}";
 			} else {
 				const aSpec = spec.arguments[0];
-				if (an.args[0]) targetValue = this.emitArgValue(aSpec, an.args[0]);
-				else targetValue = "true";
+				targetValue = an.args[0] ? this.emitArgValue(aSpec, an.args[0]) : "true";
 			}
 		} else {
 			multiple = node.countAnnotations(an.name) > 1 || an.args.length > 1;
@@ -2522,6 +2518,25 @@ async function getConfig(configFile, logger) {
 	}
 }
 
+//#endregion
+//#region packages/typescript/src/cli/emit-policy.ts
+/**
+* Printed when diagnostics found errors and the emit was suppressed, so the
+* user knows the previous outputs are still the last known-good ones.
+*/ const NOTHING_EMITTED_MESSAGE = "Nothing emitted — previous outputs were left untouched. Fix the errors above, or pass --skipDiag to emit anyway.";
+/**
+* Decides whether `asc` may write its outputs.
+*
+* A failing compile must never replace valid artifacts: half of the outputs
+* would be stale and aggregate manifests produced in `buildEnd` would be
+* regenerated from an incomplete document set. Errors therefore block the
+* write entirely — `--skipDiag` is the explicit opt-out.
+*/ function shouldEmit(input) {
+	if (input.noEmit) return false;
+	if (input.skipDiag) return true;
+	return input.errorCount === 0;
+}
+
 //#endregion
 //#region packages/typescript/src/cli/commands.controller.ts
 function _define_property$2(obj, key, value) {
@@ -2567,7 +2582,12 @@ var Commands = class {
 				}
 			}
 		}
-		if (!noEmit) {
+		const emit = shouldEmit({
+			noEmit,
+			skipDiag,
+			errorCount
+		});
+		if (emit) {
 			const out = await builder.write(config);
 			for (const { target } of out) this.logger.log(`✅ created ${target}`);
 		}
@@ -2577,7 +2597,10 @@ var Commands = class {
 			if (warningCount > 0) parts.push(`${warningCount} warning${warningCount > 1 ? "s" : ""}`);
 			this.logger.log(`\nFound ${parts.join(" and ")}`);
 		}
-		if (errorCount > 0) process.exit(1);
+		if (errorCount > 0) {
+			if (!emit && !noEmit) this.logger.log(`${NOTHING_EMITTED_MESSAGE}`);
+			process.exit(1);
+		}
 	}
 	constructor(logger) {
 		_define_property$2(this, "logger", void 0);
@@ -2619,6 +2642,188 @@ Commands = _ts_decorate$1([
 	_ts_metadata$1("design:paramtypes", [typeof TConsoleBase === "undefined" ? Object : TConsoleBase])
 ], Commands);
 
+//#endregion
+//#region packages/typescript/src/cli/db-sync-models.ts
+/** Depth cap for `config.models` — deep enough for nested arrays and namespaces. */ const MAX_MODELS_DEPTH = 6;
+/** Keeps two runs in the same process (and the same millisecond) apart. */ let runSeq = 0;
+/**
+* Compiles the project's `.as` files and loads every `@db.table` / `@db.view`
+* model, plus the models contributed by `config.models`.
+*
+* The result is only a complete inventory when `diagnostics.errors` is 0 and
+* both `failures` and `modelsError` are empty — a caller that plans a sync
+* from a partial inventory would propose dropping the tables it failed to see.
+*/ async function loadDbModels(options) {
+	const { config, cwd = process.cwd(), logger } = options;
+	const buildConfig = toBuildConfig(config);
+	logger?.log(`Compiling .as files...`);
+	const builder = await (0, _atscript_core.build)(buildConfig);
+	const diagnostics = await collectDiagnostics(builder);
+	if (diagnostics.errors > 0) return {
+		types: [],
+		failures: [],
+		diagnostics,
+		packaged: 0
+	};
+	const { types, failures } = await importGeneratedModules(await builder.generate(buildConfig), buildConfig.rootDir || cwd, cwd);
+	const result = {
+		types,
+		failures,
+		diagnostics,
+		packaged: 0
+	};
+	if (failures.length > 0 || !config.models) return result;
+	try {
+		const seen = new Set(types);
+		for (const model of flattenModels(await config.models())) if (!seen.has(model)) {
+			seen.add(model);
+			types.push(model);
+			result.packaged++;
+		}
+	} catch (error) {
+		result.modelsError = error;
+	}
+	return result;
+}
+/** Abort message printed when some generated modules could not be imported. */ function partialInventoryMessage(count) {
+	return `Could not load ${count} compiled model module(s); aborting before planning — a partial inventory would propose dropping tables.`;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Collects every `@db.table` / `@db.view` model out of whatever `config.models`
+* returned — an annotated type, an array, a module namespace object, or any
+* nesting of those. Deduplicated by identity.
+*/ function flattenModels(value) {
+	const out = [];
+	walkModels(value, out, /* @__PURE__ */ new Set(), 0);
+	return out;
+}
+/** Rewrites the emitted `.as` specifiers to the `.mjs` files we just wrote. */ function patchAsImports(content) {
+	return content.replace(/(from\s+["'][^"']+)\.as(["'])/g, "$1.as.mjs$2");
+}
+function toBuildConfig(config) {
+	const buildConfig = { ...config };
+	if (typeof config.db === "object" && "adapter" in config.db) {
+		const dbConfig = config.db;
+		if (dbConfig.include) buildConfig.include = dbConfig.include;
+		if (dbConfig.exclude) buildConfig.exclude = dbConfig.exclude;
+	}
+	buildConfig.format = "js";
+	return buildConfig;
+}
+async function collectDiagnostics(builder) {
+	const diagnostics = {
+		errors: 0,
+		warnings: 0,
+		messages: []
+	};
+	const diagMap = await builder.diagnostics();
+	for (const [docId, messages] of diagMap) {
+		const doc = builder.getDoc(docId);
+		for (const m of messages) {
+			if (m.severity === 1) diagnostics.errors++;
+			else if (m.severity === 2) diagnostics.warnings++;
+			if (doc) diagnostics.messages.push(doc.renderDiagMessage(m, true, true));
+		}
+	}
+	return diagnostics;
+}
+async function importGeneratedModules(outputs, rootDir, cwd) {
+	const jsOutputs = [];
+	for (const o of outputs) if (o.fileName.endsWith(".js") && o.source) jsOutputs.push({
+		fileName: o.fileName,
+		content: o.content,
+		source: o.source
+	});
+	const base = resolveLayoutBase(rootDir, jsOutputs.map((o) => path.default.dirname((0, _atscript_core.fileUriToPath)(o.source))));
+	const tmpDir = path.default.join(cwd, `.atscript-db-sync-${process.pid}-${Date.now()}-${runSeq++}`);
+	const cleanup = () => {
+		try {
+			(0, fs.rmSync)(tmpDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	};
+	process.on("exit", cleanup);
+	try {
+		const files = [];
+		for (const o of jsOutputs) {
+			const srcDir = path.default.dirname((0, _atscript_core.fileUriToPath)(o.source));
+			const rel = path.default.join(path.default.relative(base, srcDir), o.fileName.replace(/\.js$/, ".mjs"));
+			const abs = path.default.join(tmpDir, rel);
+			(0, fs.mkdirSync)(path.default.dirname(abs), { recursive: true });
+			(0, fs.writeFileSync)(abs, patchAsImports(o.content));
+			files.push({
+				abs,
+				rel
+			});
+		}
+		const types = [];
+		const failures = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const file of files) try {
+			collectFromModule(await import(
+				/* @vite-ignore */
+				(0, node_url.pathToFileURL)(file.abs).href
+), types, seen);
+		} catch (error) {
+			failures.push({
+				file: file.rel,
+				error
+			});
+		}
+		return {
+			types,
+			failures
+		};
+	} finally {
+		cleanup();
+		process.off("exit", cleanup);
+	}
+}
+function collectFromModule(mod, types, seen) {
+	for (const exp of Object.values(mod)) if (isDbModel(exp) && !seen.has(exp)) {
+		seen.add(exp);
+		types.push(exp);
+	}
+}
+/**
+* Directory the temp layout mirrors. Normally `rootDir`; when a source lives
+* outside it, the common ancestor of `rootDir` and every source, so that no
+* `..` segment ever escapes the temp directory.
+*/ function resolveLayoutBase(rootDir, sourceDirs) {
+	const root = path.default.resolve(rootDir);
+	return sourceDirs.some((dir) => {
+		const rel = path.default.relative(root, path.default.resolve(dir));
+		return rel === ".." || rel.startsWith(`..${path.default.sep}`);
+	}) ? commonAncestor([root, ...sourceDirs]) : root;
+}
+function commonAncestor(dirs) {
+	const parts = dirs.map((d) => path.default.resolve(d).split(path.default.sep));
+	const first = parts[0];
+	let i = 0;
+	while (i < first.length && parts.every((p) => p[i] === first[i])) i++;
+	return first.slice(0, i).join(path.default.sep) || path.default.sep;
+}
+function isDbModel(value) {
+	return isAnnotatedType(value) && Boolean(value.metadata?.has("db.table") || value.metadata?.has("db.view"));
+}
+function walkModels(value, out, seen, depth) {
+	if (!value || typeof value !== "object" && typeof value !== "function") return;
+	if (seen.has(value)) return;
+	seen.add(value);
+	if (isAnnotatedType(value)) {
+		if (isDbModel(value)) out.push(value);
+		return;
+	}
+	if (depth >= MAX_MODELS_DEPTH) return;
+	const items = Array.isArray(value) ? value : Object.values(value);
+	for (const item of items) walkModels(item, out, seen, depth + 1);
+}
+
 //#endregion
 //#region packages/typescript/src/cli/db-sync-printer.ts
 function _define_property$1(obj, key, value) {
@@ -2815,13 +3020,14 @@ var DbSyncController = class {
 			this.logger.error("\x1B[31mNo \"db\" field in atscript config. Add a db configuration to use schema sync.\x1B[39m");
 			process.exit(1);
 		}
-		const [dbSpace, dbTypes] = await Promise.all([this.resolveDbSpace(config.db), this.compileAndLoadTypes(config)]);
+		const dbTypes = await this.loadTypes(config);
 		if (dbTypes.length === 0) {
 			this.info(`No types with @db.table or @db.view found. Nothing to sync.`);
 			return;
 		}
 		this.printer.typeCount(dbTypes.length);
 		this.printer.banner();
+		const dbSpace = await this.resolveDbSpace(config.db);
 		const { SchemaSync } = await this.importFromCwd("@atscript/db/sync", true);
 		const sync = new SchemaSync(dbSpace);
 		const plan = await sync.plan(dbTypes, {
@@ -2877,44 +3083,33 @@ var DbSyncController = class {
 		});
 		this.printer.result(result);
 	}
-	async compileAndLoadTypes(config) {
-		const buildConfig = { ...config };
-		if (typeof config.db === "object" && "adapter" in config.db) {
-			const dbConfig = config.db;
-			if (dbConfig.include) buildConfig.include = dbConfig.include;
-			if (dbConfig.exclude) buildConfig.exclude = dbConfig.exclude;
-		}
-		buildConfig.format = "js";
-		this.info(`Compiling .as files...`);
-		const jsOutputs = (await (await (0, _atscript_core.build)(buildConfig)).generate(buildConfig)).filter((o) => o.fileName.endsWith(".js"));
-		const tmpDir = path.default.join(process.cwd(), `.atscript-db-sync-${Date.now()}`);
-		const writtenFiles = [];
-		for (const o of jsOutputs) {
-			const target = path.default.join(tmpDir, o.fileName.replace(/\.js$/, ".mjs"));
-			(0, fs.mkdirSync)(path.default.dirname(target), { recursive: true });
-			(0, fs.writeFileSync)(target, patchAsImports(o.content));
-			writtenFiles.push(target);
+	/**
+	* Loads the full model inventory or aborts. Diagnostics run first, every
+	* generated module is imported individually, and any failure exits 1 before
+	* a plan is computed.
+	*/ async loadTypes(config) {
+		const result = await loadDbModels({
+			config,
+			cwd: process.cwd(),
+			logger: { log: (message) => this.info(message) }
+		});
+		if (result.diagnostics.errors > 0) {
+			for (const message of result.diagnostics.messages) this.logger.error(message);
+			this.logger.error(`Fix the errors above before syncing.`);
+			process.exit(1);
 		}
-		const dbTypes = [];
-		try {
-			for (const file of writtenFiles) {
-				const mod = await import(
-					/* @vite-ignore */
-					(0, node_url.pathToFileURL)(file).href
-);
-				for (const exp of Object.values(mod)) if (isAnnotatedType(exp) && (exp.metadata?.has("db.table") || exp.metadata?.has("db.view"))) dbTypes.push(exp);
-			}
-		} catch (error) {
-			this.logger.warn?.(`Could not import compiled types: ${error}`);
-		} finally {
-			try {
-				(0, fs.rmSync)(tmpDir, {
-					recursive: true,
-					force: true
-				});
-			} catch {}
+		for (const message of result.diagnostics.messages) this.info(message);
+		if (result.failures.length > 0) {
+			for (const failure of result.failures) this.logger.error(`✖ ${failure.file}: ${errorMessage(failure.error)}`);
+			this.logger.error(`${partialInventoryMessage(result.failures.length)}`);
+			process.exit(1);
 		}
-		return dbTypes;
+		if (result.modelsError) {
+			this.logger.error(`config.models failed: ${errorMessage(result.modelsError)}`);
+			process.exit(1);
+		}
+		if (result.packaged > 0) this.info(`Loaded ${result.packaged} packaged model(s) from config.models`);
+		return result.types;
 	}
 	async resolveDbSpace(dbConfig) {
 		if (typeof dbConfig === "function") {
@@ -3023,9 +3218,6 @@ DbSyncController = _ts_decorate([
 	_ts_metadata("design:type", Function),
 	_ts_metadata("design:paramtypes", [typeof TConsoleBase === "undefined" ? Object : TConsoleBase])
 ], DbSyncController);
-function patchAsImports(content) {
-	return content.replace(/(from\s+["'][^"']+)\.as(["'])/g, "$1.as.mjs$2");
-}
 
 //#endregion
 //#region packages/typescript/src/cli/cli.ts

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
-const require_plugin = require('./plugin-DMBkdYCf.cjs');
+const require_plugin = require('./plugin-Cs9mKJ8h.cjs');
 
 exports.default = require_plugin.tsPlugin;
 exports.tsPlugin = require_plugin.tsPlugin;

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { t as tsPlugin } from "./plugin-BOoquMkD.mjs";
+import { t as tsPlugin } from "./plugin-DHhdrTs8.mjs";
 
 export { tsPlugin as default, tsPlugin };

package/dist/{plugin-DMBkdYCf.cjs → plugin-Cs9mKJ8h.cjs}

@@ -875,11 +875,8 @@ var JsRenderer = class extends BaseRenderer {
 				const unwound = this.doc.unwindType(annotateNode.targetName);
 				if (unwound?.def) {
 					let def = this.doc.mergeIntersection(unwound.def);
-					if ((0, _atscript_core.isInterface)(def)) if (def.hasExtends) {
-						const resolved = unwound.doc.resolveInterfaceExtends(def);
-						if (resolved) def = resolved;
-						else def = def.getDefinition() || def;
-					} else def = def.getDefinition() || def;
+					if ((0, _atscript_core.isInterface)(def)) if (def.hasExtends) def = unwound.doc.resolveInterfaceExtends(def) || def.getDefinition() || def;
+					else def = def.getDefinition() || def;
 					this._adHocAnnotations = this.buildAdHocMap([annotateNode]);
 					this.annotateType(def, node.id);
 					this._adHocAnnotations = null;
@@ -1392,8 +1389,7 @@ var JsRenderer = class extends BaseRenderer {
 				targetValue += "}";
 			} else {
 				const aSpec = spec.arguments[0];
-				if (an.args[0]) targetValue = this.emitArgValue(aSpec, an.args[0]);
-				else targetValue = "true";
+				targetValue = an.args[0] ? this.emitArgValue(aSpec, an.args[0]) : "true";
 			}
 		} else {
 			multiple = node.countAnnotations(an.name) > 1 || an.args.length > 1;

package/dist/{plugin-BOoquMkD.mjs → plugin-DHhdrTs8.mjs}

@@ -847,11 +847,8 @@ var JsRenderer = class extends BaseRenderer {
 				const unwound = this.doc.unwindType(annotateNode.targetName);
 				if (unwound?.def) {
 					let def = this.doc.mergeIntersection(unwound.def);
-					if (isInterface(def)) if (def.hasExtends) {
-						const resolved = unwound.doc.resolveInterfaceExtends(def);
-						if (resolved) def = resolved;
-						else def = def.getDefinition() || def;
-					} else def = def.getDefinition() || def;
+					if (isInterface(def)) if (def.hasExtends) def = unwound.doc.resolveInterfaceExtends(def) || def.getDefinition() || def;
+					else def = def.getDefinition() || def;
 					this._adHocAnnotations = this.buildAdHocMap([annotateNode]);
 					this.annotateType(def, node.id);
 					this._adHocAnnotations = null;
@@ -1364,8 +1361,7 @@ var JsRenderer = class extends BaseRenderer {
 				targetValue += "}";
 			} else {
 				const aSpec = spec.arguments[0];
-				if (an.args[0]) targetValue = this.emitArgValue(aSpec, an.args[0]);
-				else targetValue = "true";
+				targetValue = an.args[0] ? this.emitArgValue(aSpec, an.args[0]) : "true";
 			}
 		} else {
 			multiple = node.countAnnotations(an.name) > 1 || an.args.length > 1;

package/dist/test-utils.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_plugin = require('./plugin-DMBkdYCf.cjs');
+const require_plugin = require('./plugin-Cs9mKJ8h.cjs');
 let path = require("path");
 path = require_plugin.__toESM(path);
 let _atscript_core = require("@atscript/core");

package/dist/test-utils.mjs

@@ -1,4 +1,4 @@
-import { t as tsPlugin } from "./plugin-BOoquMkD.mjs";
+import { t as tsPlugin } from "./plugin-DHhdrTs8.mjs";
 import path from "path";
 import { build } from "@atscript/core";
 import { readFileSync, writeFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/typescript",
-  "version": "0.1.89",
+  "version": "0.1.90",
   "description": "Atscript: typescript-gen support.",
   "keywords": [
     "annotations",
@@ -63,8 +63,8 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@moostjs/event-cli": "^0.6.35",
-    "moost": "^0.6.35"
+    "@moostjs/event-cli": "^0.6.36",
+    "moost": "^0.6.36"
   },
   "devDependencies": {
     "@atscript/db": "^0.1.125",
@@ -73,7 +73,7 @@
   },
   "peerDependencies": {
     "@atscript/db": "^0.1.97",
-    "@atscript/core": "^0.1.89"
+    "@atscript/core": "^0.1.90"
   },
   "peerDependenciesMeta": {
     "@atscript/db": {