@looma/prisma-cli 0.1.1

package/dist/use-cases/auth.js

@@ -0,0 +1,70 @@
+import { usageError } from "../shell/errors.js";
+//#region src/use-cases/auth.ts
+function createAuthUseCases(dependencies) {
+	return {
+		whoami: () => resolveCurrentAuthState(dependencies),
+		login: async (selection) => {
+			await dependencies.sessionGateway.writeAuthSession({
+				provider: selection.provider,
+				userId: selection.userId,
+				workspaceId: selection.workspaceId
+			});
+			return resolveCurrentAuthState(dependencies);
+		},
+		logout: async () => {
+			await dependencies.sessionGateway.clearAuthSession();
+			return resolveCurrentAuthState(dependencies);
+		},
+		listProviders: async () => dependencies.identityGateway.listProviders(),
+		resolveProvider: async (providerId) => {
+			const provider = dependencies.identityGateway.getProvider(providerId);
+			if (!provider) throw usageError("Login requires a valid mock provider", `The mock provider "${providerId}" does not exist.`, "Use --provider github or --provider google.", ["prisma auth login"], "auth");
+			return provider;
+		},
+		listUsersForProvider: async (providerId) => {
+			const users = dependencies.identityGateway.listUsersForProvider(providerId);
+			if (users.length === 0) throw usageError("Login requires a valid mock user", `No mock users support provider "${providerId}".`, "Update the fixture data or choose a different provider.", ["prisma auth login"], "auth");
+			return users;
+		},
+		resolveUserForProvider: async (providerId, userId) => {
+			const user = dependencies.identityGateway.getUserForProvider(providerId, userId);
+			if (!user) throw usageError("Login requires a valid mock user", `The mock user "${userId}" is not available for provider "${providerId}".`, "Choose a user that supports the selected provider.", ["prisma auth login"], "auth");
+			return user;
+		},
+		listWorkspacesForUser: async (userId) => dependencies.identityGateway.listUserWorkspaces(userId),
+		resolveWorkspaceForUser: async (userId, workspaceId) => {
+			const workspace = dependencies.identityGateway.getUserWorkspace(userId, workspaceId);
+			if (!workspace) throw usageError("Login requires a valid mock workspace", `The mock workspace "${workspaceId}" is not available for the selected user.`, "Choose a workspace that the selected user can access.", ["prisma auth login"], "auth");
+			return workspace;
+		}
+	};
+}
+async function resolveCurrentAuthState(dependencies) {
+	const [session, linkedProjectId] = await Promise.all([dependencies.sessionGateway.readAuthSession(), dependencies.projectConfigGateway.readLinkedProjectId()]);
+	if (!session) return {
+		authenticated: false,
+		provider: null,
+		user: null,
+		workspace: null,
+		linkedProjectId
+	};
+	const provider = dependencies.identityGateway.getProvider(session.provider);
+	const user = dependencies.identityGateway.getUser(session.userId);
+	const workspace = dependencies.identityGateway.getWorkspace(session.workspaceId);
+	if (!provider || !user || !workspace) return {
+		authenticated: false,
+		provider: null,
+		user: null,
+		workspace: null,
+		linkedProjectId
+	};
+	return {
+		authenticated: true,
+		provider: provider.id,
+		user,
+		workspace,
+		linkedProjectId
+	};
+}
+//#endregion
+export { createAuthUseCases };

package/dist/use-cases/create-cli-gateways.js

@@ -0,0 +1,93 @@
+import { UnsafeConfigWriteError, readLinkedProjectId, writeLinkedProjectId } from "../adapters/config.js";
+import { usageError } from "../shell/errors.js";
+//#region src/use-cases/create-cli-gateways.ts
+function createCliUseCaseGateways(context) {
+	return {
+		identityGateway: {
+			listProviders: () => context.api.listProviders(),
+			getProvider: (providerId) => context.api.getProvider(providerId),
+			listUsersForProvider: (providerId) => context.api.listUsersForProvider(providerId).map(toAuthUser),
+			getUser: (userId) => {
+				const user = context.api.getUser(userId);
+				return user ? toAuthUser(user) : void 0;
+			},
+			getUserForProvider: (providerId, userId) => {
+				const user = context.api.getUserForProvider(providerId, userId);
+				return user ? toAuthUser(user) : void 0;
+			},
+			listUserWorkspaces: (userId) => context.api.listUserWorkspaces(userId).map(toAuthWorkspace),
+			getWorkspace: (workspaceId) => {
+				const workspace = context.api.getWorkspace(workspaceId);
+				return workspace ? toAuthWorkspace(workspace) : void 0;
+			},
+			getUserWorkspace: (userId, workspaceId) => {
+				const workspace = context.api.getUserWorkspace(userId, workspaceId);
+				return workspace ? toAuthWorkspace(workspace) : void 0;
+			}
+		},
+		projectGateway: {
+			listProjectsForWorkspace: (workspaceId) => context.api.listProjectsForWorkspace(workspaceId),
+			getProject: (projectId) => context.api.getProject(projectId),
+			getProjectForWorkspace: (workspaceId, projectId) => context.api.getProjectForWorkspace(workspaceId, projectId)
+		},
+		environmentGateway: {
+			listEnvironmentsForProject: (projectId) => context.api.listEnvironmentsForProject(projectId).map((environment) => ({
+				...environment,
+				kind: environment.name === "production" ? "production" : "preview"
+			})),
+			getEnvironmentForProject: (projectId, name) => {
+				const environment = context.api.getEnvironmentForProject(projectId, name);
+				return environment ? {
+					...environment,
+					kind: environment.name === "production" ? "production" : "preview"
+				} : void 0;
+			},
+			getDeployment: (deploymentId) => context.api.getDeployment(deploymentId)
+		},
+		projectConfigGateway: {
+			readLinkedProjectId: () => readLinkedProjectId(context.runtime.cwd),
+			writeLinkedProjectId: async (projectId) => {
+				try {
+					await writeLinkedProjectId(context.runtime.cwd, projectId);
+				} catch (error) {
+					if (error instanceof UnsafeConfigWriteError) throw usageError("Project link requires a writable Prisma config", error.message, "Update prisma.config.ts to use a recognizable project field, or remove it and rerun prisma project link.", ["prisma project link proj_123"], "project");
+					throw error;
+				}
+			}
+		},
+		sessionGateway: {
+			readAuthSession: async () => {
+				return (await context.stateStore.read()).auth;
+			},
+			writeAuthSession: async (session) => {
+				await context.stateStore.setAuthSession(session);
+			},
+			clearAuthSession: async () => {
+				await context.stateStore.clearAuthSession();
+			}
+		},
+		environmentStateGateway: {
+			readActiveEnvironment: async () => {
+				return (await context.stateStore.read()).environment.active;
+			},
+			writeActiveEnvironment: async (environmentName) => {
+				await context.stateStore.setActiveEnvironment(environmentName);
+			}
+		}
+	};
+}
+function toAuthUser(user) {
+	return {
+		id: user.id,
+		name: user.name,
+		email: user.email
+	};
+}
+function toAuthWorkspace(workspace) {
+	return {
+		id: workspace.id,
+		name: workspace.name
+	};
+}
+//#endregion
+export { createCliUseCaseGateways };

package/dist/use-cases/env.js

@@ -0,0 +1,104 @@
+//#region src/use-cases/env.ts
+function createEnvUseCases(dependencies) {
+	return {
+		list: async () => {
+			const [linkedProjectId, activeEnvironment] = await Promise.all([dependencies.projectConfigGateway.readLinkedProjectId(), dependencies.environmentStateGateway.readActiveEnvironment()]);
+			const remoteEnvironments = await listRemoteEnvironments(dependencies.environmentGateway, linkedProjectId);
+			return {
+				linkedProjectId,
+				projectName: resolveProjectName(dependencies.projectGateway, linkedProjectId),
+				activeEnvironment,
+				environments: buildEnvironmentSummaries(linkedProjectId, activeEnvironment, remoteEnvironments)
+			};
+		},
+		show: async () => {
+			const [linkedProjectId, activeEnvironment] = await Promise.all([dependencies.projectConfigGateway.readLinkedProjectId(), dependencies.environmentStateGateway.readActiveEnvironment()]);
+			return {
+				linkedProjectId,
+				projectName: resolveProjectName(dependencies.projectGateway, linkedProjectId),
+				environment: buildEnvironmentDetail(dependencies.environmentGateway, linkedProjectId, activeEnvironment)
+			};
+		},
+		use: async (environmentName) => {
+			await dependencies.environmentStateGateway.writeActiveEnvironment(environmentName);
+			const linkedProjectId = await dependencies.projectConfigGateway.readLinkedProjectId();
+			return {
+				linkedProjectId,
+				projectName: resolveProjectName(dependencies.projectGateway, linkedProjectId),
+				environment: buildEnvironmentDetail(dependencies.environmentGateway, linkedProjectId, environmentName)
+			};
+		}
+	};
+}
+function resolveProjectName(projectGateway, linkedProjectId) {
+	if (!linkedProjectId) return null;
+	return projectGateway.getProject(linkedProjectId)?.name ?? null;
+}
+async function listRemoteEnvironments(environmentGateway, linkedProjectId) {
+	if (!linkedProjectId) return [];
+	return environmentGateway.listEnvironmentsForProject(linkedProjectId);
+}
+function buildEnvironmentSummaries(linkedProjectId, activeEnvironment, remoteEnvironments) {
+	const byName = /* @__PURE__ */ new Map();
+	byName.set("local", {
+		id: "local",
+		name: "local",
+		kind: "local",
+		active: activeEnvironment === "local",
+		remoteState: false
+	});
+	for (const environment of remoteEnvironments) byName.set(environment.name, {
+		id: environment.id,
+		name: environment.name,
+		kind: environment.kind,
+		active: activeEnvironment === environment.name,
+		remoteState: true
+	});
+	if (!byName.has(activeEnvironment) && activeEnvironment !== "local") byName.set(activeEnvironment, {
+		id: activeEnvironment,
+		name: activeEnvironment,
+		kind: toEnvironmentKind(activeEnvironment),
+		active: true,
+		remoteState: false
+	});
+	return sortEnvironments([...byName.values()]);
+}
+function buildEnvironmentDetail(environmentGateway, linkedProjectId, environmentName) {
+	const kind = toEnvironmentKind(environmentName);
+	const remoteEnvironment = linkedProjectId && kind !== "local" ? environmentGateway.getEnvironmentForProject(linkedProjectId, environmentName) : void 0;
+	return {
+		name: environmentName,
+		kind,
+		active: true,
+		remoteState: Boolean(remoteEnvironment),
+		liveDeployment: remoteEnvironment && remoteEnvironment.currentDeploymentId ? toLiveDeployment(environmentGateway.getDeployment(remoteEnvironment.currentDeploymentId)) : null
+	};
+}
+function toEnvironmentKind(name) {
+	if (name === "local") return "local";
+	if (name === "production") return "production";
+	return "preview";
+}
+function sortEnvironments(environments) {
+	return environments.slice().sort((left, right) => {
+		const leftRank = environmentOrder(left);
+		const rightRank = environmentOrder(right);
+		if (leftRank !== rightRank) return leftRank - rightRank;
+		return left.name.localeCompare(right.name);
+	});
+}
+function environmentOrder(environment) {
+	if (environment.name === "local") return 0;
+	if (environment.name === "production") return 1;
+	return 2;
+}
+function toLiveDeployment(deployment) {
+	if (!deployment) return null;
+	return {
+		id: deployment.id,
+		status: deployment.status,
+		url: deployment.url
+	};
+}
+//#endregion
+export { createEnvUseCases };

package/dist/use-cases/project.js

@@ -0,0 +1,75 @@
+import { CliError, authRequiredError } from "../shell/errors.js";
+//#region src/use-cases/project.ts
+function createProjectUseCases(dependencies) {
+	return {
+		list: async (authState) => {
+			const workspace = requireWorkspace(authState);
+			return {
+				workspace,
+				linkedProjectId: authState.linkedProjectId,
+				projects: listSortedWorkspaceProjects(dependencies.projectGateway, workspace.id).map(toProjectSummary)
+			};
+		},
+		show: async (authState) => {
+			if (!authState.linkedProjectId) return {
+				linkedProjectId: null,
+				workspace: null,
+				project: null
+			};
+			if (!authState.authenticated || !authState.workspace) return {
+				linkedProjectId: authState.linkedProjectId,
+				workspace: null,
+				project: null
+			};
+			const project = dependencies.projectGateway.getProjectForWorkspace(authState.workspace.id, authState.linkedProjectId);
+			if (!project) return {
+				linkedProjectId: authState.linkedProjectId,
+				workspace: null,
+				project: null
+			};
+			return {
+				linkedProjectId: authState.linkedProjectId,
+				workspace: authState.workspace,
+				project: toProjectSummary(project)
+			};
+		},
+		link: async (authState, projectId) => {
+			const workspace = requireWorkspace(authState);
+			const project = dependencies.projectGateway.getProjectForWorkspace(workspace.id, projectId);
+			if (!project) throw projectNotFoundError(`The project "${projectId}" does not exist in workspace "${workspace.name}".`, "Run prisma project list and choose a project id from the active workspace.");
+			await dependencies.projectConfigGateway.writeLinkedProjectId(project.id);
+			return {
+				linkedProjectId: project.id,
+				workspace,
+				project: toProjectSummary(project)
+			};
+		},
+		listProjectsForWorkspace: async (workspaceId) => listSortedWorkspaceProjects(dependencies.projectGateway, workspaceId).map(toProjectSummary)
+	};
+}
+function requireWorkspace(authState) {
+	if (!authState.authenticated || !authState.workspace) throw authRequiredError();
+	return authState.workspace;
+}
+function listSortedWorkspaceProjects(projectGateway, workspaceId) {
+	return projectGateway.listProjectsForWorkspace(workspaceId).slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+}
+function toProjectSummary(project) {
+	return {
+		id: project.id,
+		name: project.name
+	};
+}
+function projectNotFoundError(why, fix, nextSteps = ["prisma project list"]) {
+	return new CliError({
+		code: "PROJECT_NOT_FOUND",
+		domain: "project",
+		summary: "Project not found",
+		why,
+		fix,
+		exitCode: 1,
+		nextSteps
+	});
+}
+//#endregion
+export { createProjectUseCases, projectNotFoundError };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@looma/prisma-cli",
+  "version": "0.1.1",
+  "description": "Prototype Prisma Compute CLI.",
+  "type": "module",
+  "bin": {
+    "prisma-cli": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "@prisma/compute-sdk": "^0.11.0",
+    "c12": "4.0.0-beta.4",
+    "@prisma/credentials-store": "^7.7.0",
+    "@prisma/management-api-sdk": "^1.23.0",
+    "colorette": "^2.0.20",
+    "commander": "^12.1.0",
+    "magicast": "^0.3.5",
+    "open": "^11.0.0",
+    "string-width": "^8.2.0",
+    "strip-ansi": "^7.2.0",
+    "wrap-ansi": "^10.0.0"
+  }
+}