@prisma/cli 2.20.0 → 3.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,158 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work.
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work by
+the copyright owner or by an individual or Legal Entity authorized to submit on
+behalf of the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent to the
+Licensor or its representatives, including but not limited to communication on
+electronic mailing lists, source code control systems, and issue tracking
+systems that are managed by, or on behalf of, the Licensor for the purpose of
+discussing and improving the Work, but excluding communication that is
+conspicuously marked or otherwise designated in writing by the copyright owner
+as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or Object
+form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License,
+each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section) patent
+license to make, have made, use, offer to sell, sell, import, and otherwise
+transfer the Work, where such license applies only to those patent claims
+licensable by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s) with the Work to
+which such Contribution(s) was submitted. If You institute patent litigation
+against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Work or a Contribution incorporated within the Work
+constitutes direct or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate as of the date
+such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any part
+of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then
+any Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the Derivative
+Works; within the Source form or documentation, if provided along with the
+Derivative Works; or, within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents of the NOTICE
+file are for informational purposes only and do not modify the License. You may
+add Your own attribution notices within Derivative Works that You distribute,
+alongside or as an addendum to the NOTICE text from the Work, provided that such
+additional attribution notices cannot be construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions. Notwithstanding the above, nothing herein shall
+supersede or modify the terms of any separate license agreement you may have
+executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work (and each Contributor provides its
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied, including, without limitation, any warranties or
+conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any risks
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by
+applicable law (such as deliberate and grossly negligent acts) or agreed to in
+writing, shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any character
+arising as a result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill, work stoppage,
+computer failure or malfunction, or any and all other commercial damages or
+losses), even if such Contributor has been advised of the possibility of such
+damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations and/or
+rights consistent with this License. However, in accepting such obligations, You
+may act only on Your own behalf and on Your sole responsibility, not on behalf of
+any other Contributor, and only if You agree to indemnify, defend, and hold each
+Contributor harmless for any liability incurred by, or claims asserted against,
+such Contributor by reason of your accepting any such warranty or additional
+liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -1,41 +1,42 @@
-# Prisma CLI · [![npm version](https://img.shields.io/npm/v/prisma.svg?style=flat)](https://www.npmjs.com/package/prisma) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/prisma/prisma/blob/master/CONTRIBUTING.md) [![GitHub license](https://img.shields.io/badge/license-Apache%202-blue)](https://github.com/prisma/prisma/blob/master/LICENSE) [![Slack](https://img.shields.io/badge/chat-on%20slack-blue.svg)](https://slack.prisma.io/)
+# Prisma CLI Preview
 
-Learn more about Prisma in the [docs](https://www.prisma.io/docs/).
+Preview npm package for the unified Prisma CLI.
 
-## Getting started
+Install:
 
-Check out the [**Getting Started Quickstart**](https://www.prisma.io/docs/getting-started/quickstart).
-
-## Installation
-
-The Prisma CLI currently requires Node.js 10.4 (or higher).
-We recommend using [the latest Node.js LTS ("long-term support") release.](https://nodejs.org/en/about/releases/)
-
-### npm
-
-```
-npm install prisma --save-dev
+```bash
+pnpm add -D @prisma/cli@preview
 ```
 
-### Yarn
+Run:
 
+```bash
+pnpm prisma-cli --help
+pnpm prisma-cli auth login
+pnpm prisma-cli app deploy --env DATABASE_URL=postgresql://example
+pnpm prisma-cli app list-env
 ```
-yarn add prisma --dev
-```
-
-[Check out the docs for more information.](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-cli/installation)
 
-## CLI Reference
+The package exposes `prisma-cli` so it can coexist with the existing `prisma`
+executable. If you want local project scripts that use the future command shape,
+add:
 
-[Check out the docs for Prisma CLI commands, arguments, and options.](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-cli/command-reference)
+```json
+{
+  "scripts": {
+    "prisma": "prisma-cli"
+  }
+}
+```
 
-## Contributing
+Then run:
 
-Refer to our [contribution guidelines](https://github.com/prisma/prisma/blob/master/CONTRIBUTING.md) and [Code of Conduct for contributors](https://github.com/prisma/prisma/blob/master/CODE_OF_CONDUCT.md).
+```bash
+pnpm prisma app deploy
+```
 
-## Build Status
+Notes:
 
-- Prisma Tests Status:  
-  [![Build status](https://badge.buildkite.com/590e1981074b70961362481ad8319a831b44a38c5d468d6408.svg?branch=master)](https://buildkite.com/prisma/prisma2-test)
-- E2E Tests Status:  
-  [![Actions Status](https://github.com/prisma/prisma2-e2e-tests/workflows/test/badge.svg)](https://github.com/prisma/prisma2-e2e-tests/actions)
+- This is a preview package and may change quickly.
+- `prisma.config.ts` stores linked project context for this CLI.
+- Environment variable values passed with `--env` are not printed back to the terminal.

package/dist/adapters/config.js

@@ -0,0 +1,74 @@
+import path from "node:path";
+import { copyFile, mkdir, mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import { updateConfig } from "c12/update";
+//#region src/adapters/config.ts
+const PROJECT_FIELD_PATTERN = /project\s*:\s*["']([^"']+)["']/;
+async function readLinkedProjectId(cwd) {
+	const configPath = path.join(cwd, "prisma.config.ts");
+	try {
+		return (await readFile(configPath, "utf8")).match(PROJECT_FIELD_PATTERN)?.[1] ?? null;
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+var UnsafeConfigWriteError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnsafeConfigWriteError";
+	}
+};
+async function assertLinkedProjectIdWritable(cwd) {
+	const tempDir = await mkdtemp(path.join(os.tmpdir(), "prisma-cli-config-"));
+	const sourceConfigPath = path.join(cwd, "prisma.config.ts");
+	const tempConfigPath = path.join(tempDir, "prisma.config.ts");
+	try {
+		try {
+			await copyFile(sourceConfigPath, tempConfigPath);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		await applyLinkedProjectIdUpdate(tempDir, "proj_preflight");
+	} catch (error) {
+		throw toUnsafeConfigWriteError(error);
+	} finally {
+		await rm(tempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function writeLinkedProjectId(cwd, projectId) {
+	try {
+		await applyLinkedProjectIdUpdate(cwd, projectId);
+	} catch (error) {
+		if (error.code === "ENOENT") {
+			await mkdir(cwd, { recursive: true });
+			await applyLinkedProjectIdUpdate(cwd, projectId);
+			return;
+		}
+		throw toUnsafeConfigWriteError(error);
+	}
+}
+async function applyLinkedProjectIdUpdate(cwd, projectId) {
+	await updateConfig({
+		cwd,
+		configFile: "prisma.config",
+		onUpdate(config) {
+			config.project = projectId;
+		},
+		onCreate() {
+			return renderProjectConfig(projectId);
+		}
+	});
+}
+function renderProjectConfig(projectId) {
+	return `export default {\n  project: "${projectId}",\n};\n`;
+}
+function toUnsafeConfigWriteError(error) {
+	if (error instanceof UnsafeConfigWriteError) return error;
+	return new UnsafeConfigWriteError("The existing prisma.config.ts file could not be updated safely.");
+}
+//#endregion
+export { UnsafeConfigWriteError, assertLinkedProjectIdWritable, readLinkedProjectId, writeLinkedProjectId };

package/dist/adapters/local-state.js

@@ -0,0 +1,98 @@
+import path from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+//#region src/adapters/local-state.ts
+const DEFAULT_STATE = {
+	auth: null,
+	branch: { active: "preview" },
+	app: {
+		selectedByProject: {},
+		knownLiveDeploymentByProject: {}
+	}
+};
+const DEFAULT_STATE_FILE_NAME = "state.json";
+function resolveLocalStateFilePath(stateDir) {
+	return path.join(stateDir, DEFAULT_STATE_FILE_NAME);
+}
+var LocalStateStore = class {
+	stateFilePath;
+	constructor(stateDir) {
+		this.stateFilePath = resolveLocalStateFilePath(stateDir);
+	}
+	async read() {
+		try {
+			const raw = await readFile(this.stateFilePath, "utf8");
+			const parsed = JSON.parse(raw);
+			return {
+				auth: parsed.auth ?? structuredClone(DEFAULT_STATE.auth),
+				branch: { active: parsed.branch?.active ?? DEFAULT_STATE.branch.active },
+				app: {
+					selectedByProject: parsed.app?.selectedByProject ?? {},
+					knownLiveDeploymentByProject: parsed.app?.knownLiveDeploymentByProject ?? {}
+				}
+			};
+		} catch (error) {
+			if (error.code === "ENOENT") return structuredClone(DEFAULT_STATE);
+			throw error;
+		}
+	}
+	async write(state) {
+		await mkdir(path.dirname(this.stateFilePath), { recursive: true });
+		await writeFile(this.stateFilePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+	}
+	async setAuthSession(session) {
+		const state = await this.read();
+		state.auth = session;
+		await this.write(state);
+		return state;
+	}
+	async clearAuthSession() {
+		const state = await this.read();
+		state.auth = null;
+		await this.write(state);
+		return state;
+	}
+	async setActiveBranch(active) {
+		const state = await this.read();
+		state.branch.active = active;
+		await this.write(state);
+		return state;
+	}
+	async readSelectedApp(projectId) {
+		return (await this.read()).app.selectedByProject[projectId] ?? null;
+	}
+	async setSelectedApp(projectId, app) {
+		const state = await this.read();
+		state.app.selectedByProject[projectId] = app;
+		await this.write(state);
+		return state;
+	}
+	async clearSelectedApp(projectId, appId) {
+		const state = await this.read();
+		const selectedApp = state.app.selectedByProject[projectId];
+		if (!selectedApp || selectedApp.id !== appId) return state;
+		delete state.app.selectedByProject[projectId];
+		await this.write(state);
+		return state;
+	}
+	async readKnownLiveDeployment(projectId, appId) {
+		return (await this.read()).app.knownLiveDeploymentByProject[projectId]?.[appId] ?? null;
+	}
+	async setKnownLiveDeployment(projectId, appId, deploymentId) {
+		const state = await this.read();
+		state.app.knownLiveDeploymentByProject[projectId] ??= {};
+		state.app.knownLiveDeploymentByProject[projectId][appId] = deploymentId;
+		await this.write(state);
+		return state;
+	}
+	async clearKnownLiveDeployment(projectId, appId) {
+		const state = await this.read();
+		const projectDeployments = state.app.knownLiveDeploymentByProject[projectId];
+		if (!projectDeployments || !(appId in projectDeployments)) return state;
+		delete projectDeployments[appId];
+		if (Object.keys(projectDeployments).length === 0) delete state.app.knownLiveDeploymentByProject[projectId];
+		await this.write(state);
+		return state;
+	}
+};
+//#endregion
+export { LocalStateStore };

package/dist/adapters/mock-api.js

@@ -0,0 +1,57 @@
+import { readFile } from "node:fs/promises";
+//#region src/adapters/mock-api.ts
+var MockApi = class MockApi {
+	data;
+	constructor(data) {
+		this.data = data;
+	}
+	static async load(fixturePath) {
+		const raw = await readFile(fixturePath, "utf8");
+		return new MockApi(JSON.parse(raw));
+	}
+	listProviders() {
+		return this.data.providers;
+	}
+	getProvider(providerId) {
+		return this.data.providers.find((provider) => provider.id === providerId);
+	}
+	listUsersForProvider(providerId) {
+		return this.data.users.filter((user) => user.providerIds.includes(providerId));
+	}
+	getUser(userId) {
+		return this.data.users.find((user) => user.id === userId);
+	}
+	getUserForProvider(providerId, userId) {
+		return this.listUsersForProvider(providerId).find((user) => user.id === userId);
+	}
+	listUserWorkspaces(userId) {
+		const workspaceIds = this.data.memberships.filter((membership) => membership.userId === userId).map((membership) => membership.workspaceId);
+		return this.data.workspaces.filter((workspace) => workspaceIds.includes(workspace.id));
+	}
+	getWorkspace(workspaceId) {
+		return this.data.workspaces.find((workspace) => workspace.id === workspaceId);
+	}
+	getUserWorkspace(userId, workspaceId) {
+		return this.listUserWorkspaces(userId).find((workspace) => workspace.id === workspaceId);
+	}
+	listProjectsForWorkspace(workspaceId) {
+		return this.data.projects.filter((project) => project.workspaceId === workspaceId);
+	}
+	getProject(projectId) {
+		return this.data.projects.find((project) => project.id === projectId);
+	}
+	getProjectForWorkspace(workspaceId, projectId) {
+		return this.listProjectsForWorkspace(workspaceId).find((project) => project.id === projectId);
+	}
+	listBranchesForProject(projectId) {
+		return this.data.branches.filter((branch) => branch.projectId === projectId);
+	}
+	getBranchForProject(projectId, name) {
+		return this.listBranchesForProject(projectId).find((branch) => branch.name === name);
+	}
+	getDeployment(deploymentId) {
+		return this.data.deployments.find((deployment) => deployment.id === deploymentId);
+	}
+};
+//#endregion
+export { MockApi };

package/dist/adapters/token-storage.js

@@ -0,0 +1,43 @@
+import { getAuthFilePath } from "../lib/auth/client.js";
+import { CredentialsStore } from "@prisma/credentials-store";
+//#region src/adapters/token-storage.ts
+function findLatestValidTokens(allCredentials) {
+	for (let i = allCredentials.length - 1; i >= 0; i -= 1) {
+		const credential = allCredentials[i];
+		if (!credential) continue;
+		if (typeof credential.workspaceId !== "string" || credential.workspaceId.length === 0 || typeof credential.token !== "string" || credential.token.length === 0 || typeof credential.refreshToken !== "string" || credential.refreshToken.length === 0) continue;
+		return {
+			workspaceId: credential.workspaceId,
+			accessToken: credential.token,
+			refreshToken: credential.refreshToken
+		};
+	}
+	return null;
+}
+var FileTokenStorage = class {
+	credentialsStore;
+	constructor(env = process.env) {
+		this.credentialsStore = new CredentialsStore(getAuthFilePath(env));
+	}
+	async getTokens() {
+		try {
+			return findLatestValidTokens(await this.credentialsStore.getCredentials());
+		} catch {
+			return null;
+		}
+	}
+	async setTokens(tokens) {
+		await this.credentialsStore.storeCredentials({
+			workspaceId: tokens.workspaceId,
+			token: tokens.accessToken,
+			refreshToken: tokens.refreshToken
+		});
+	}
+	async clearTokens() {
+		const tokens = findLatestValidTokens(await this.credentialsStore.getCredentials());
+		if (!tokens) return;
+		await this.credentialsStore.deleteCredentials(tokens.workspaceId);
+	}
+};
+//#endregion
+export { FileTokenStorage };

package/dist/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runCli } from "./cli2.js";
+import process from "node:process";
+//#region src/bin.ts
+runCli().then((exitCode) => {
+	process.exitCode = exitCode;
+});
+//#endregion
+export {};

package/dist/cli2.js

@@ -0,0 +1,59 @@
+import { attachCommandDescriptor } from "./shell/command-meta.js";
+import { configureRuntimeCommand } from "./shell/runtime.js";
+import "./shell/prompt.js";
+import { createAppCommand } from "./commands/app/index.js";
+import { createAuthCommand } from "./commands/auth/index.js";
+import { createBranchCommand } from "./commands/branch/index.js";
+import { createProjectCommand } from "./commands/project/index.js";
+import process from "node:process";
+import { Command, CommanderError } from "commander";
+//#region src/cli.ts
+async function runCli(options = {}) {
+	const runtime = resolveRuntime(options);
+	const program = createProgram(runtime);
+	process.exitCode = 0;
+	try {
+		const bareHelpCommand = resolveBareHelpCommand(program, runtime.argv);
+		if (bareHelpCommand) {
+			runtime.stderr.write(bareHelpCommand.helpInformation());
+			return 0;
+		}
+		await program.parseAsync(runtime.argv, { from: "user" });
+		return process.exitCode ?? 0;
+	} catch (error) {
+		if (error instanceof CommanderError) return error.code === "commander.helpDisplayed" ? 0 : 2;
+		const message = error instanceof Error ? error.stack ?? error.message : String(error);
+		runtime.stderr.write(`${message}\n`);
+		return 1;
+	} finally {
+		runtime.stdin;
+	}
+}
+function createProgram(runtime) {
+	const program = attachCommandDescriptor(configureRuntimeCommand(new Command(), runtime), "root");
+	program.name("prisma").showSuggestionAfterError();
+	program.addCommand(createAuthCommand(runtime));
+	program.addCommand(createBranchCommand(runtime));
+	program.addCommand(createProjectCommand(runtime));
+	program.addCommand(createAppCommand(runtime));
+	return program;
+}
+function resolveBareHelpCommand(program, argv) {
+	if (argv.length === 0) return program;
+	if (argv.length !== 1) return null;
+	return program.commands.find((command) => command.name() === argv[0]) ?? null;
+}
+function resolveRuntime(options) {
+	return {
+		argv: options.argv ?? process.argv.slice(2),
+		cwd: options.cwd ?? process.env.INIT_CWD ?? process.cwd(),
+		env: options.env ?? process.env,
+		stdin: options.stdin ?? process.stdin,
+		stdout: options.stdout ?? process.stdout,
+		stderr: options.stderr ?? process.stderr,
+		fixturePath: options.fixturePath,
+		stateDir: options.stateDir
+	};
+}
+//#endregion
+export { runCli };