@prisma/cli 3.0.0-dev.52.1 → 3.0.0-dev.54.1

package/dist/shell/update-check.js

@@ -0,0 +1,247 @@
+import { getCliName, getCliVersion } from "../lib/version.js";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import { spawn } from "node:child_process";
+//#region src/shell/update-check.ts
+const UPDATE_CHECK_FILE_NAME = "update-check.json";
+const FALLBACK_INSTALL_DOCS_URL = "https://www.prisma.io/docs/orm/tools/prisma-cli";
+const NOTIFICATION_INTERVAL_MS = 1440 * 60 * 1e3;
+const REGISTRY_URL = "https://registry.npmjs.org/@prisma%2fcli";
+const REGISTRY_TIMEOUT_MS = 3e3;
+var UpdateCheckStore = class {
+	filePath;
+	constructor(cacheDir) {
+		this.filePath = path.join(cacheDir, UPDATE_CHECK_FILE_NAME);
+	}
+	async read() {
+		try {
+			return JSON.parse(await readFile(this.filePath, "utf8"));
+		} catch (error) {
+			if (isUnreadableCacheError(error)) return null;
+			throw error;
+		}
+	}
+	async write(state) {
+		const dir = path.dirname(this.filePath);
+		const tempPath = path.join(dir, `${UPDATE_CHECK_FILE_NAME}.${process.pid}.${randomUUID()}.tmp`);
+		await mkdir(dir, { recursive: true });
+		await writeFile(tempPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+		await rename(tempPath, this.filePath);
+	}
+};
+async function maybeWriteCachedUpdateNotification(runtime) {
+	if (!canRunUpdateCheck(runtime)) return;
+	try {
+		const cacheDir = resolveUpdateCheckCacheDir(runtime);
+		const store = new UpdateCheckStore(cacheDir);
+		const state = await store.read();
+		const latestVersion = state?.latestVersion;
+		if (latestVersion && isInstalledVersionStale(getCliVersion(), latestVersion) && shouldNotify(state)) {
+			runtime.stderr.write(renderUpdateNotification(latestVersion, selectUpdateInstruction(runtime.env)));
+			await store.write({
+				...state,
+				packageName: "@prisma/cli",
+				installedVersion: getCliVersion(),
+				notifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		}
+		await scheduleRemoteDiscovery(runtime, store, state, cacheDir);
+	} catch {
+		return;
+	}
+}
+async function runUpdateDiscovery(options) {
+	try {
+		const latestVersion = await fetchLatestVersion(options.registryUrl ?? REGISTRY_URL, options.fetchImpl ?? fetch);
+		if (!latestVersion) return;
+		const store = new UpdateCheckStore(options.cacheDir);
+		const previousState = await store.read();
+		await store.write({
+			...previousState,
+			packageName: "@prisma/cli",
+			installedVersion: options.installedVersion,
+			latestVersion,
+			checkedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString()
+		});
+	} catch {
+		return;
+	}
+}
+function isUnreadableCacheError(error) {
+	const code = error.code;
+	return code === "ENOENT" || code === "EACCES" || code === "EPERM" || error instanceof SyntaxError;
+}
+async function runUpdateDiscoveryWorker(env = process.env) {
+	const cacheDir = env.PRISMA_CLI_UPDATE_CHECK_DIR;
+	const installedVersion = env.PRISMA_CLI_UPDATE_CHECK_INSTALLED_VERSION;
+	if (!cacheDir || !installedVersion) return;
+	await runUpdateDiscovery({
+		cacheDir,
+		installedVersion,
+		registryUrl: env.PRISMA_CLI_UPDATE_CHECK_REGISTRY_URL
+	});
+}
+function canRunUpdateCheck(runtime) {
+	if (runtime.env.NO_UPDATE_NOTIFIER !== void 0) return false;
+	if (isTestRuntime(runtime.env) && runtime.env.PRISMA_CLI_TEST_ENABLE_UPDATE_CHECK !== "1") return false;
+	if (runtime.env.CI || runtime.env.GITHUB_ACTIONS) return false;
+	if (!runtime.stderr.isTTY) return false;
+	if (runtime.argv.includes("--json") || runtime.argv.includes("--quiet") || runtime.argv.includes("-q")) return false;
+	if (runtime.argv.includes("--version")) return false;
+	return true;
+}
+function shouldNotify(state) {
+	return !state.notifiedAt || isAtLeastIntervalAgo(state.notifiedAt);
+}
+async function scheduleRemoteDiscovery(runtime, store, state, cacheDir) {
+	if (state?.checkedAt && !isAtLeastIntervalAgo(state.checkedAt)) return;
+	const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await store.write({
+		...state,
+		packageName: "@prisma/cli",
+		installedVersion: getCliVersion(),
+		checkedAt
+	});
+	if (isTestRuntime(runtime.env)) return;
+	const entrypoint = process.argv[1];
+	if (!entrypoint) return;
+	spawn(process.execPath, [entrypoint], {
+		detached: true,
+		stdio: "ignore",
+		env: {
+			...process.env,
+			PRISMA_CLI_RUN_UPDATE_CHECK_WORKER: "1",
+			PRISMA_CLI_UPDATE_CHECK_DIR: cacheDir,
+			PRISMA_CLI_UPDATE_CHECK_INSTALLED_VERSION: getCliVersion(),
+			PRISMA_CLI_UPDATE_CHECK_REGISTRY_URL: runtime.env.PRISMA_CLI_UPDATE_CHECK_REGISTRY_URL ?? REGISTRY_URL
+		}
+	}).unref();
+}
+function selectUpdateInstruction(env, processArgv = process.argv) {
+	const entrypoint = (processArgv[1] ?? "").replace(/\\/g, "/").toLowerCase();
+	const userAgent = env.npm_config_user_agent?.toLowerCase() ?? "";
+	if (isEphemeralInvocation(entrypoint, env.npm_lifecycle_event?.toLowerCase() ?? "")) return docsInstruction();
+	if (entrypoint.includes("/node_modules/.bin/")) {
+		if (userAgent.startsWith("pnpm")) return commandInstruction("pnpm add -D @prisma/cli@latest");
+		if (userAgent.startsWith("bun")) return commandInstruction("bun add -d @prisma/cli@latest");
+		if (userAgent.startsWith("npm")) return commandInstruction("npm install --save-dev @prisma/cli@latest");
+	}
+	if (env.npm_config_global === "true" || isLikelyGlobalNpmEntrypoint(entrypoint)) return commandInstruction("npm install --global @prisma/cli@latest");
+	return docsInstruction();
+}
+function renderUpdateNotification(latestVersion, instruction) {
+	return [
+		`Update available: ${getCliName()} ${getCliVersion()} -> ${latestVersion}`,
+		renderUpdateInstruction(instruction),
+		""
+	].join("\n");
+}
+function renderUpdateInstruction(instruction) {
+	if (instruction.type === "command") return `Run ${instruction.value} to update.`;
+	return `See ${instruction.value} for update instructions.`;
+}
+function isEphemeralInvocation(entrypoint, lifecycle) {
+	return lifecycle === "npx" || lifecycle === "pnpx" || entrypoint.includes("/_npx/") || entrypoint.includes("/.bun/");
+}
+function isLikelyGlobalNpmEntrypoint(entrypoint) {
+	return /\/npm\/prisma-cli(\.cmd|\.exe)?$/.test(entrypoint) || /\/npm-global\/bin\/prisma-cli$/.test(entrypoint);
+}
+function commandInstruction(value) {
+	return {
+		type: "command",
+		value
+	};
+}
+function docsInstruction() {
+	return {
+		type: "docs",
+		value: FALLBACK_INSTALL_DOCS_URL
+	};
+}
+function resolveUpdateCheckCacheDir(runtime) {
+	const configured = runtime.env.PRISMA_CLI_UPDATE_CHECK_DIR;
+	if (configured?.trim()) return path.resolve(configured);
+	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Caches", "prisma-cli");
+	if (process.platform === "win32") {
+		const localAppData = runtime.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local");
+		return path.join(localAppData, "prisma-cli", "cache");
+	}
+	const xdgCacheHome = runtime.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
+	return path.join(xdgCacheHome, "prisma-cli");
+}
+function isTestRuntime(env) {
+	return env.VITEST !== void 0 || env.NODE_ENV === "test";
+}
+function isAtLeastIntervalAgo(value) {
+	const timestamp = Date.parse(value);
+	return Number.isNaN(timestamp) || Date.now() - timestamp >= NOTIFICATION_INTERVAL_MS;
+}
+function isInstalledVersionStale(installedVersion, latestVersion) {
+	const installed = parseVersion(installedVersion);
+	const latest = parseVersion(latestVersion);
+	if (!installed || !latest) return false;
+	return compareVersions(installed, latest) < 0;
+}
+function parseVersion(version) {
+	const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(version);
+	if (!match) return null;
+	return {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3]),
+		prerelease: match[4]?.split(".") ?? []
+	};
+}
+function compareVersions(left, right) {
+	for (const key of [
+		"major",
+		"minor",
+		"patch"
+	]) {
+		const diff = left[key] - right[key];
+		if (diff !== 0) return diff;
+	}
+	return comparePrerelease(left.prerelease, right.prerelease);
+}
+function comparePrerelease(left, right) {
+	if (left.length === 0 && right.length === 0) return 0;
+	if (left.length === 0) return 1;
+	if (right.length === 0) return -1;
+	const count = Math.max(left.length, right.length);
+	for (let index = 0; index < count; index += 1) {
+		const leftPart = left[index];
+		const rightPart = right[index];
+		if (leftPart === void 0) return -1;
+		if (rightPart === void 0) return 1;
+		const diff = comparePrereleasePart(leftPart, rightPart);
+		if (diff !== 0) return diff;
+	}
+	return 0;
+}
+function comparePrereleasePart(left, right) {
+	const leftNumber = /^\d+$/.test(left) ? Number(left) : null;
+	const rightNumber = /^\d+$/.test(right) ? Number(right) : null;
+	if (leftNumber !== null && rightNumber !== null) return leftNumber - rightNumber;
+	if (leftNumber !== null) return -1;
+	if (rightNumber !== null) return 1;
+	return left.localeCompare(right);
+}
+async function fetchLatestVersion(registryUrl, fetchImpl) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), REGISTRY_TIMEOUT_MS);
+	try {
+		const response = await fetchImpl(registryUrl, {
+			signal: controller.signal,
+			headers: { accept: "application/json" }
+		});
+		if (!response.ok) return null;
+		const latest = (await response.json())["dist-tags"]?.latest;
+		return typeof latest === "string" ? latest : null;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+//#endregion
+export { maybeWriteCachedUpdateNotification, runUpdateDiscoveryWorker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.52.1",
+  "version": "3.0.0-dev.54.1",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {