@jsorm/cli 0.3.3 → 0.4.0

package/README.md

@@ -74,6 +74,15 @@ The engine lives in `~/.jsorm/engines/v<version>/` (owner-only). Before every ru
 
 ---
 
+## Environment
+
+| Variable | Effect |
+|---|---|
+| `JSORM_NO_UPDATE_CHECK=1` | Skips the update check while an engine is installed (useful in CI) |
+| `JSORM_DEV_ENGINE=1` | Runs the engine built in this repository instead of the signed release. It only works inside a JSORM source checkout whose `engine/target/debug/jsorm` or `engine/target/release/jsorm` exists, and it never runs a binary from `node_modules`. The local engine is not signed or verified, so leave it unset outside monorepo development |
+
+---
+
 ## Requirements
 
 - Node.js 22+

package/dist/index.d.mts

@@ -1 +1 @@
-import "./rolldown-runtime-ClRpJifh.js";
+import "./rolldown-runtime-CPxUEhZH.js";

package/dist/index.mjs

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { execFileSync, spawn } from "node:child_process";
-import { chmodSync, createReadStream, createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { chmodSync, createReadStream, createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createHash, createPublicKey, verify } from "node:crypto";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-//#region src/platform.ts
+// src/platform.ts
 function detectPlatform() {
 	switch (process.platform) {
 		case "linux": return "linux";
@@ -93,8 +93,7 @@ function detectFramework() {
 	}
 	return "none";
 }
-//#endregion
-//#region src/version.ts
+// src/version.ts
 function compareVersions(a, b) {
 	const pa = a.split(".").map(Number);
 	const pb = b.split(".").map(Number);
@@ -115,8 +114,7 @@ function releaseLine(version) {
 function isCompatibleEngine(cliVersion, engineVersion) {
 	return releaseLine(cliVersion) === releaseLine(engineVersion);
 }
-//#endregion
-//#region src/install.ts
+// src/install.ts
 function getVersionDir(enginesDir, version) {
 	return join(enginesDir, `v${version}`);
 }
@@ -221,8 +219,44 @@ async function installEngine(options) {
 		});
 	}
 }
-//#endregion
-//#region src/manifest.ts
+// src/dev-engine.ts
+/** Binary produced by `cargo build` in `engine/`; not the published, target-suffixed name. */
+const DEV_BINARY = "jsorm";
+const DEV_ROOT_MARKER = join("engine", "Cargo.toml");
+const PROFILES = ["debug", "release"];
+/**
+* Returns the engine compiled in this checkout, or `null`.
+*
+* Development mode is opt-in: it requires `JSORM_DEV_ENGINE=1`, a source
+* checkout of this monorepo, and a regular binary inside `engine/target`.
+* A path that resolves under a `node_modules` directory is never accepted:
+* that directory belongs to the project being built, so an installed CLI
+* must not run an engine taken from it.
+*/
+function resolveDevEnginePath({ moduleDir, env = process.env }) {
+	if (env.JSORM_DEV_ENGINE !== "1") return null;
+	const root = resolve(moduleDir, "..", "..", "..");
+	if (root.split(sep).includes("node_modules")) return null;
+	if (!existsSync(join(root, DEV_ROOT_MARKER))) return null;
+	const targetDir = join(root, "engine", "target");
+	for (const profile of PROFILES) {
+		const candidate = join(targetDir, profile, DEV_BINARY);
+		if (isFileInside(targetDir, candidate)) return candidate;
+	}
+	return null;
+}
+/** True when `candidate` resolves to a regular file inside `dir`, following symlinks. */
+function isFileInside(dir, candidate) {
+	try {
+		const realDir = realpathSync(dir);
+		const real = realpathSync(candidate);
+		if (!statSync(real).isFile()) return false;
+		return real.startsWith(realDir.endsWith(sep) ? realDir : `${realDir}${sep}`);
+	} catch {
+		return false;
+	}
+}
+// src/manifest.ts
 const EMBEDDED_PUBLIC_KEY_B64 = "6AUQMvF7jBV+S8yv9K8hnnoYzIznQw4nf5x5LAuEsfM=";
 function getSpkiPublicKey(rawKeyB64 = EMBEDDED_PUBLIC_KEY_B64) {
 	const rawKey = Buffer.from(rawKeyB64, "base64");
@@ -296,8 +330,7 @@ async function fetchManifest(url, publicKey = getSpkiPublicKey()) {
 	}
 	return parseSignedEnvelope(envelope, publicKey);
 }
-//#endregion
-//#region src/verify.ts
+// src/verify.ts
 const SHA256_HEX = /^[0-9a-f]{64}$/;
 /**
 * Checks an installed engine before it runs: its stored envelope must be
@@ -339,8 +372,7 @@ async function verifyInstalledEngine(enginesDir, version, binaryName, publicKey)
 	};
 	return { ok: true };
 }
-//#endregion
-//#region src/resolve.ts
+// src/resolve.ts
 const DAY_MS = 864e5;
 const LAST_CHECK_FILE = ".last-check";
 function readLastCheck(enginesDir) {
@@ -478,8 +510,7 @@ async function checkForUpdate(options) {
 		updateAvailable: latestCompatible && (installed === null || compareVersions(manifest.version, installed) > 0)
 	};
 }
-//#endregion
-//#region src/update.ts
+// src/update.ts
 /**
 * `jsorm update`: checks the live manifest now, installs the newest
 * compatible engine (again when `force`), and removes every other installed
@@ -522,8 +553,7 @@ async function reportUpdate(options) {
 	else if (status.updateAvailable) log(`  Update available. Run: jsorm update`);
 	else log(`  ✓ Up to date`);
 }
-//#endregion
-//#region src/index.ts
+// src/index.ts
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const ENGINES_DIR = join(homedir(), ".jsorm", "engines");
@@ -537,13 +567,6 @@ function readVersion() {
 		return "unknown";
 	}
 }
-function getLocalDevEnginePath() {
-	const debug = join(__dirname, "..", "..", "..", "engine", "target", "debug", "jsorm");
-	if (existsSync(debug)) return debug;
-	const release = join(__dirname, "..", "..", "..", "engine", "target", "release", "jsorm");
-	if (existsSync(release)) return release;
-	return null;
-}
 function executeEngine(enginePath, args) {
 	const engineArgs = [
 		...args,
@@ -566,16 +589,26 @@ function executeEngine(enginePath, args) {
 		process.exit(code ?? 0);
 	});
 }
-async function main() {
-	const args = process.argv.slice(2);
-	if (args.includes("--version") || args.includes("-v") || args.includes("-V")) {
+/** The local engine is unverified by design, so say so before it runs. */
+function runDevEngine(enginePath, args, execute) {
+	console.error(`  ⚠ JSORM_DEV_ENGINE=1: running the unverified engine at ${enginePath}`);
+	execute(enginePath, args);
+}
+async function main(argv = process.argv.slice(2), deps = {}) {
+	const env = deps.env ?? process.env;
+	const execute = deps.execute ?? executeEngine;
+	const enginesDir = deps.enginesDir ?? ENGINES_DIR;
+	if (argv.includes("--version") || argv.includes("-v") || argv.includes("-V")) {
 		console.log(readVersion());
 		return;
 	}
-	if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
-		const localEnginePath = getLocalDevEnginePath();
-		if (localEnginePath) {
-			executeEngine(localEnginePath, args);
+	const devEnginePath = resolveDevEnginePath({
+		moduleDir: deps.moduleDir ?? __dirname,
+		env
+	});
+	if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+		if (devEnginePath) {
+			runDevEngine(devEnginePath, argv, execute);
 			return;
 		}
 		console.log(`jsorm ${readVersion()}`);
@@ -596,45 +629,55 @@ async function main() {
 		console.log();
 		console.log("Environment:");
 		console.log("  JSORM_NO_UPDATE_CHECK=1   Skip engine update checks while an engine is installed");
+		console.log("  JSORM_DEV_ENGINE=1        Run the engine built in this checkout (never an installed package)");
 		return;
 	}
 	try {
-		ensureOwnerOnlyDir(dirname(ENGINES_DIR));
+		ensureOwnerOnlyDir(dirname(enginesDir));
 	} catch (err) {
-		console.error(`  ⚠ Could not restrict ${dirname(ENGINES_DIR)}: ${err instanceof Error ? err.message : err}`);
+		console.error(`  ⚠ Could not restrict ${dirname(enginesDir)}: ${err instanceof Error ? err.message : err}`);
 	}
 	const resolveOptions = {
-		enginesDir: ENGINES_DIR,
+		enginesDir,
 		binaryName: getEngineBinaryName(),
 		manifestUrl: STABLE_MANIFEST_URL,
 		downloadUrl: STABLE_DOWNLOAD_URL,
 		cliVersion: readVersion(),
-		skipUpdateCheck: process.env.JSORM_NO_UPDATE_CHECK === "1",
+		skipUpdateCheck: env.JSORM_NO_UPDATE_CHECK === "1",
 		updateCommand: `${cliRunner(detectPackageManager())} update`,
 		log: console.log
 	};
 	try {
-		if (args[0] === "update") {
-			const invalid = validateUpdateArgs(args.slice(1));
+		if (argv[0] === "update") {
+			const invalid = validateUpdateArgs(argv.slice(1));
 			if (invalid) throw new Error(invalid);
-			if (args.includes("--check")) await reportUpdate(resolveOptions);
+			if (argv.includes("--check")) await reportUpdate(resolveOptions);
 			else await updateEngine({
 				...resolveOptions,
-				force: args.includes("--force")
+				force: argv.includes("--force")
 			});
 			return;
 		}
-		const localEnginePath = getLocalDevEnginePath();
-		if (localEnginePath) {
-			executeEngine(localEnginePath, args);
+		if (devEnginePath) {
+			runDevEngine(devEnginePath, argv, execute);
 			return;
 		}
-		executeEngine(await resolveEngine(resolveOptions), args);
+		execute(await resolveEngine(resolveOptions), argv);
 	} catch (err) {
 		console.error(`  ✖ ${err instanceof Error ? err.message : err}`);
 		process.exit(1);
 	}
 }
-main();
-//#endregion
-export {};
+/** True when this module is the executable, not a module imported by a test. */
+function isEntryPoint() {
+	const invoked = process.argv[1];
+	if (!invoked) return false;
+	const self = fileURLToPath(import.meta.url);
+	try {
+		return resolve(invoked) === resolve(self) || realpathSync(invoked) === realpathSync(self);
+	} catch {
+		return false;
+	}
+}
+if (isEntryPoint()) main();
+export { main };

package/dist/index2.d.mts

@@ -1 +1,13 @@
-import "./rolldown-runtime-ClRpJifh.js";
+import "./rolldown-runtime-CPxUEhZH.js";
+interface CliDeps {
+  /** Environment read for `JSORM_DEV_ENGINE` and the update check. Defaults to `process.env`. */
+  env?: NodeJS.ProcessEnv;
+  /** Replaced in tests to observe which engine would run. */
+  execute?: (enginePath: string, args: string[]) => void;
+  /** Directory of this module; defaults to the running file's directory. */
+  moduleDir?: string;
+  /** Engines directory; defaults to `~/.jsorm/engines`. */
+  enginesDir?: string;
+}
+export declare function main(argv?: string[], deps?: CliDeps): Promise<void>;
+export {};

package/package.json

@@ -1,8 +1,19 @@
 {
   "name": "@jsorm/cli",
   "type": "module",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "CLI de JSORM",
+  "keywords": [
+    "jsorm",
+    "orm",
+    "cli",
+    "codegen",
+    "typescript",
+    "schema",
+    "migrations",
+    "postgresql",
+    "sqlite"
+  ],
   "license": "MPL-2.0",
   "repository": {
     "type": "git",
@@ -12,7 +23,7 @@
   "bugs": {
     "url": "https://github.com/jsorm/jsorm-monorepo/issues"
   },
-  "homepage": "https://github.com/jsorm/jsorm-monorepo/tree/main/packages/cli#readme",
+  "homepage": "https://jsorm.dev",
   "files": [
     "dist"
   ],
@@ -35,14 +46,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@jsorm/core": "1.3.3"
+    "@jsorm/core": "1.4.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",
-    "rolldown": "1.2.3",
-    "rolldown-plugin-dts": "0.28.0",
-    "typescript": "6.0.3",
-    "vitest": "4.1.10"
+    "rolldown": "1.2.16",
+    "rolldown-plugin-dts": "0.29.0",
+    "typescript": "7.0.2",
+    "vitest": "5.1.0"
   },
   "scripts": {
     "build": "rm -rf dist/ && rolldown -c rolldown.config.ts && rolldown -c rolldown.dts.config.ts",