@prisma/cli 3.0.0-dev.99.1 → 8.0.0-rc.2

package/dist/deploy-framework-C7bQM00A.js

@@ -0,0 +1,23 @@
+import path from "node:path";
+import { detectComputeAppFromDirectory } from "@prisma/compute-sdk/config/directory";
+//#region src/lib/app/deploy-framework.ts
+/** Reads the directory's package.json and framework config to name the
+*  framework a deploy would use, or null when none is recognised. */
+async function detectDeployFramework(cwd, signal) {
+	const detected = await detectComputeAppFromDirectory({
+		appPath: cwd,
+		signal
+	});
+	if (!detected) return null;
+	let annotation = "detected from package.json";
+	if (detected.configFile?.standaloneOutput) annotation = "standalone output detected";
+	else if (detected.configFile) annotation = `detected from ${path.basename(detected.configFile.path)}`;
+	return {
+		key: detected.framework,
+		buildType: detected.buildType,
+		displayName: detected.frameworkName,
+		annotation
+	};
+}
+//#endregion
+export { detectDeployFramework };

package/dist/payload-B88Qvzxk-CrtTXSOe.js

@@ -0,0 +1,34 @@
+//#region ../cli-telemetry/dist/payload-B88Qvzxk.js
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+/**
+* Runtime validation for {@link ParentToSenderPayload}. The child sender
+* uses this before `postEvent` so a payload missing a required field
+* cannot silently produce a degraded telemetry event downstream.
+*
+* Same semantics as the ORM CLI's arktype schema (this repo carries no
+* arktype dependency, so the checks are spelled out): required scalars
+* must be non-empty strings; the optional `databaseTarget` override is
+* a `string` when present (no `null` — see the type's doc-block); the
+* string array is validated element-by-element. Size caps are enforced
+* by the backend, not here — IPC is structured-cloned and the
+* parent/child agree on the schema by version-coupling.
+*/
+function isParentToSenderPayload(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const record = value;
+	if (!isNonEmptyString(record.installationId)) return false;
+	if (!isNonEmptyString(record.version)) return false;
+	if (!isNonEmptyString(record.command)) return false;
+	if (!isStringArray(record.flags)) return false;
+	if (!isNonEmptyString(record.projectRoot)) return false;
+	if (!isNonEmptyString(record.endpoint)) return false;
+	if ("databaseTarget" in record && typeof record.databaseTarget !== "string") return false;
+	return true;
+}
+//#endregion
+export { isParentToSenderPayload as t };

package/dist/sender.js

@@ -0,0 +1,192 @@
+import { t as isParentToSenderPayload } from "./payload-B88Qvzxk-CrtTXSOe.js";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { determineAgent } from "@vercel/detect-agent";
+//#region ../cli-telemetry/dist/sender.js
+/**
+* Identify the runtime the sender is running in. Same-runtime as the
+* parent is a correctness requirement: the parent forked us via
+* `child_process.fork`, which inherits the parent's runtime. Detection
+* keys on the runtime-specific version field rather than env vars so a
+* spoofed env can't lie about the actual interpreter.
+*/
+function resolveRuntime(versions) {
+	if (versions.bun !== void 0) return {
+		name: "bun",
+		version: versions.bun
+	};
+	if (versions.deno !== void 0) return {
+		name: "deno",
+		version: versions.deno
+	};
+	return {
+		name: "node",
+		version: versions.node
+	};
+}
+const WHITESPACE = /\s+/;
+const SEMVER_RANGE_PREFIX = /^[\^~]/;
+/**
+* Parse `npm_config_user_agent` into a `<pm>/<version>` token. The
+* value, when present, looks like
+* `"pnpm/10.27.0 npm/? node/v24.13.0 darwin arm64"` — we take the first
+* whitespace-separated token. Any failure → `null`.
+*/
+function parsePackageManager(userAgent) {
+	if (userAgent === void 0) return null;
+	const first = userAgent.split(WHITESPACE)[0];
+	if (first === void 0 || first.length === 0) return null;
+	if (!first.includes("/")) return null;
+	return first;
+}
+/**
+* Read the user's project `package.json` and resolve a TypeScript
+* version from `devDependencies.typescript` (preferred) or
+* `dependencies.typescript`. Strips a leading `^` or `~` semver
+* prefix. Returns `null` on any failure mode — file missing,
+* unreadable, malformed JSON, key absent, not a string.
+*/
+function readTsVersionFromPackageJson(raw) {
+	if (raw === null) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	const candidate = pickStringDep(parsed.devDependencies) ?? pickStringDep(parsed.dependencies);
+	if (candidate === null) return null;
+	return candidate.replace(SEMVER_RANGE_PREFIX, "");
+}
+function pickStringDep(deps) {
+	if (deps === null || typeof deps !== "object" || Array.isArray(deps)) return null;
+	const value = deps.typescript;
+	return typeof value === "string" ? value : null;
+}
+/**
+* Build the full backend event from the parent's payload, the
+* project-config slice, and the child's per-process snapshot. Pure
+* given a `projectConfig` + `EnrichEnvironment`.
+*/
+function buildTelemetryEvent(payload, projectConfig, env) {
+	const runtime = resolveRuntime(env.versions);
+	return {
+		installationId: payload.installationId,
+		version: payload.version,
+		command: payload.command,
+		flags: payload.flags,
+		runtimeName: runtime.name,
+		runtimeVersion: runtime.version,
+		os: env.platform,
+		arch: env.arch,
+		packageManager: parsePackageManager(env.env.npm_config_user_agent),
+		databaseTarget: projectConfig.databaseTarget,
+		tsVersion: readTsVersionFromPackageJson(env.readProjectPackageJson()),
+		agent: env.agent,
+		extensions: projectConfig.extensions
+	};
+}
+/**
+* Resolve the agent label for the telemetry event via
+* `@vercel/detect-agent`, collapsing its discriminated result to the
+* event's `string | null` shape. Any detection failure counts as
+* "no agent" — telemetry is best-effort and non-blocking.
+*/
+async function resolveAgentLabel() {
+	try {
+		const result = await determineAgent();
+		return result.isAgent ? result.agent.name : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Convenience for the sender entry: build the event from the live
+* `process` plus a real project-package.json reader, swallowing any
+* I/O errors in the file read.
+*
+* The project-config slice is payload-only: `databaseTarget` is the
+* parent's override when present (else `null`), and `extensions` is
+* always empty — there is no `prisma-next.config.*` in this product to
+* derive them from.
+*/
+async function buildTelemetryEventFromProcess(payload) {
+	return buildTelemetryEvent(payload, {
+		databaseTarget: payload.databaseTarget ?? null,
+		extensions: []
+	}, {
+		platform: process.platform,
+		arch: process.arch,
+		versions: process.versions,
+		env: process.env,
+		agent: await resolveAgentLabel(),
+		readProjectPackageJson: () => {
+			try {
+				return readFileSync(join(payload.projectRoot, "package.json"), "utf-8");
+			} catch {
+				return null;
+			}
+		}
+	});
+}
+/**
+* Sender script entry — forked into a detached child by the parent CLI via
+* `child_process.fork(senderPath, [], { detached: true, ... })`.
+*
+* Lifecycle:
+*   1. Wait for the parent's IPC `message` event carrying a
+*      `ParentToSenderPayload`.
+*   2. Enrich with the local-process probes (runtime, os, arch, agent,
+*      package manager, tsVersion).
+*   3. POST the event to the endpoint URL with a hard 1.5 s timeout.
+*   4. Exit 0 unconditionally — successful POST, network failure, server
+*      error, parse error of the response, anything else: same outcome.
+*
+* Every error is swallowed; the only escape valve for visibility is
+* `PRISMA_DEBUG=1`, which routes diagnostics to stderr. In normal
+* operation no telemetry-originating output ever reaches the user — the
+* parent's stdio map ignores our streams anyway, but stderr writes are
+* also held behind the debug flag so the same binary is safe to invoke
+* directly outside the spawn flow.
+*/
+const REQUEST_TIMEOUT_MS = 1500;
+function debugLog(message, error) {
+	if (process.env.PRISMA_DEBUG !== "1") return;
+	if (error !== void 0) process.stderr.write(`[cli-telemetry] ${message}: ${String(error)}\n`);
+	else process.stderr.write(`[cli-telemetry] ${message}\n`);
+}
+async function postEvent(payload) {
+	const event = await buildTelemetryEventFromProcess(payload);
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+	try {
+		debugLog(`sent event: status=${(await fetch(payload.endpoint, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(event),
+			signal: controller.signal
+		})).status}`);
+	} catch (err) {
+		debugLog("send failed", err);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function exitClean() {
+	try {
+		process.disconnect?.();
+	} catch {}
+	process.exit(0);
+}
+process.once("message", (message) => {
+	if (!isParentToSenderPayload(message)) {
+		debugLog("received malformed payload; exiting");
+		exitClean();
+		return;
+	}
+	postEvent(message).catch((err) => debugLog("post threw", err)).finally(exitClean);
+});
+const SENDER_IDLE_EXIT_MS = REQUEST_TIMEOUT_MS * 2;
+setTimeout(exitClean, SENDER_IDLE_EXIT_MS).unref();
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-dev.99.1",
+  "version": "8.0.0-rc.2",
   "description": "Command-line interface for the Prisma Developer Platform.",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=22.18.0"
   },
   "keywords": [
     "prisma",
@@ -37,31 +37,35 @@
     "url": "https://github.com/prisma/prisma-cli/issues"
   },
   "license": "Apache-2.0",
-  "scripts": {
-    "build": "tsdown",
-    "prepack": "pnpm run build",
-    "test": "vitest run"
-  },
   "dependencies": {
-    "@clack/prompts": "^1.5.0",
-    "@prisma/compute-sdk": "^0.28.0",
+    "@prisma/cli-engine": "8.0.0-rc.2",
+    "@prisma/composer": "0.6.0-dev.16",
+    "@prisma/compute-sdk": "0.39.0",
     "@prisma/credentials-store": "^7.8.0",
-    "@prisma/management-api-sdk": "^1.37.0",
+    "@prisma/management-api-sdk": "1.55.0",
+    "@prisma/orm-toolchain": "8.0.0-rc.1-dev.40",
+    "@vercel/detect-agent": "^1.2.3",
     "better-result": "^2.9.2",
-    "colorette": "^2.0.20",
-    "commander": "^14.0.3",
     "dotenv": "^17.4.2",
-    "magicast": "^0.5.3",
-    "open": "^11.0.0",
-    "string-width": "^8.2.1",
-    "strip-ansi": "^7.2.0",
-    "wrap-ansi": "^10.0.0"
+    "execa": "^9.6.1",
+    "open": "^11.0.0"
   },
   "devDependencies": {
+    "@repo/cli-conformance": "8.0.0-rc.2",
+    "@repo/cli-telemetry": "8.0.0-rc.2",
+    "@repo/tsconfig": "8.0.0-rc.2",
     "@types/node": "^22.19.19",
     "tsdown": "^0.21.10",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",
     "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check:grammar": "vitest run tests/mount-coverage.test.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "pnpm run build && vitest run",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "conformance": "tsx scripts/conformance.ts"
   }
-}
+}

package/dist/adapters/git.js

@@ -1,54 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-//#region src/adapters/git.ts
-const execFileAsync = promisify(execFile);
-async function readGitOriginRemote(cwd, signal) {
-	try {
-		const { stdout } = await execFileAsync("git", [
-			"config",
-			"--get",
-			"remote.origin.url"
-		], {
-			cwd,
-			timeout: 5e3,
-			signal
-		});
-		const remote = stdout.trim();
-		return remote.length > 0 ? remote : null;
-	} catch (error) {
-		if (signal?.aborted || isAbortError(error)) throw error;
-		return null;
-	}
-}
-function isAbortError(error) {
-	return error instanceof Error && error.name === "AbortError";
-}
-function parseGitHubRepositoryUrl(value) {
-	const input = value.trim();
-	const shorthand = input.match(/^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?$/);
-	if (shorthand) return toGitHubRepositoryReference(shorthand[1], shorthand[2]);
-	let parsed;
-	try {
-		parsed = new URL(input);
-	} catch {
-		return null;
-	}
-	if (parsed.hostname !== "github.com") return null;
-	if (parsed.protocol !== "https:" && parsed.protocol !== "http:" && parsed.protocol !== "ssh:") return null;
-	const parts = parsed.pathname.split("/").filter(Boolean);
-	if (parts.length !== 2) return null;
-	const [owner, rawName] = parts;
-	return toGitHubRepositoryReference(owner, rawName.endsWith(".git") ? rawName.slice(0, -4) : rawName);
-}
-function toGitHubRepositoryReference(owner, name) {
-	if (!owner || !name || owner.includes("/") || name.includes("/")) return null;
-	return {
-		provider: "github",
-		owner,
-		name,
-		fullName: `${owner}/${name}`,
-		url: `https://github.com/${owner}/${name}`
-	};
-}
-//#endregion
-export { parseGitHubRepositoryUrl, readGitOriginRemote };

package/dist/adapters/local-state.js

@@ -1,144 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-//#region src/adapters/local-state.ts
-const DEFAULT_STATE = {
-	auth: null,
-	project: {
-		rememberedByWorkspace: {},
-		lastResolved: null,
-		repositoryConnectionsByProject: {}
-	},
-	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, signal) {
-		this.signal = signal;
-		this.stateFilePath = resolveLocalStateFilePath(stateDir);
-	}
-	async read() {
-		this.signal?.throwIfAborted();
-		try {
-			const raw = await readFile(this.stateFilePath, {
-				encoding: "utf8",
-				signal: this.signal
-			});
-			const parsed = JSON.parse(raw);
-			return {
-				auth: parsed.auth ?? structuredClone(DEFAULT_STATE.auth),
-				project: {
-					rememberedByWorkspace: parsed.project?.rememberedByWorkspace ?? {},
-					lastResolved: parsed.project?.lastResolved ?? null,
-					repositoryConnectionsByProject: parsed.project?.repositoryConnectionsByProject ?? {}
-				},
-				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) {
-		this.signal?.throwIfAborted();
-		await mkdir(path.dirname(this.stateFilePath), { recursive: true });
-		this.signal?.throwIfAborted();
-		await writeFile(this.stateFilePath, `${JSON.stringify(state, null, 2)}\n`, { encoding: "utf8" });
-		this.signal?.throwIfAborted();
-	}
-	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 readRememberedProject(workspaceId) {
-		return (await this.read()).project.rememberedByWorkspace[workspaceId] ?? null;
-	}
-	async readLastResolvedProject() {
-		return (await this.read()).project.lastResolved;
-	}
-	async setRememberedProject(project) {
-		const state = await this.read();
-		state.project.rememberedByWorkspace[project.workspaceId] = project;
-		state.project.lastResolved = project;
-		await this.write(state);
-		return state;
-	}
-	async readRepositoryConnection(projectId) {
-		return (await this.read()).project.repositoryConnectionsByProject[projectId] ?? null;
-	}
-	async setRepositoryConnection(projectId, connection) {
-		const state = await this.read();
-		state.project.repositoryConnectionsByProject[projectId] = connection;
-		await this.write(state);
-		return state;
-	}
-	async clearRepositoryConnection(projectId) {
-		const state = await this.read();
-		delete state.project.repositoryConnectionsByProject[projectId];
-		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, resolveLocalStateFilePath };

package/dist/adapters/mock-api.js

@@ -1,136 +0,0 @@
-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, signal) {
-		signal?.throwIfAborted();
-		const raw = await readFile(fixturePath, {
-			encoding: "utf8",
-			signal
-		});
-		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);
-	}
-	listDatabasesForProject(projectId, branchName) {
-		return (this.data.databases ?? []).filter((database) => database.projectId === projectId && (!branchName || database.branchName === branchName));
-	}
-	getDatabase(databaseId) {
-		return (this.data.databases ?? []).find((database) => database.id === databaseId);
-	}
-	createDatabase(input) {
-		this.data.databases ??= [];
-		this.data.databaseConnections ??= [];
-		const database = {
-			id: `db_${this.data.databases.length + 1e3}`,
-			projectId: input.projectId,
-			branchId: input.branchName ? this.getBranchForProject(input.projectId, input.branchName)?.id ?? null : null,
-			branchName: input.branchName ?? null,
-			name: input.name,
-			region: input.region ?? null,
-			status: "ready",
-			isDefault: false,
-			createdAt: "2026-06-09T00:00:00.000Z"
-		};
-		const connectionString = `postgresql://${database.id}.example.prisma.io/postgres`;
-		const connection = {
-			id: `conn_${this.data.databaseConnections.length + 1e3}`,
-			databaseId: database.id,
-			name: "primary",
-			createdAt: "2026-06-09T00:00:00.000Z",
-			connectionString
-		};
-		this.data.databases.push(database);
-		this.data.databaseConnections.push(connection);
-		return {
-			database,
-			connection,
-			connectionString
-		};
-	}
-	removeDatabase(databaseId) {
-		this.data.databases ??= [];
-		this.data.databaseConnections ??= [];
-		const database = this.getDatabase(databaseId);
-		if (!database) return;
-		this.data.databases = this.data.databases.filter((candidate) => candidate.id !== databaseId);
-		this.data.databaseConnections = this.data.databaseConnections.filter((connection) => connection.databaseId !== databaseId);
-		return database;
-	}
-	listDatabaseConnections(databaseId) {
-		return (this.data.databaseConnections ?? []).filter((connection) => connection.databaseId === databaseId);
-	}
-	getDatabaseConnection(connectionId) {
-		return (this.data.databaseConnections ?? []).find((connection) => connection.id === connectionId);
-	}
-	createDatabaseConnection(input) {
-		if (!this.getDatabase(input.databaseId)) return;
-		this.data.databaseConnections ??= [];
-		const connectionString = `postgresql://${input.databaseId}-${this.data.databaseConnections.length + 1}.example.prisma.io/postgres`;
-		const connection = {
-			id: `conn_${this.data.databaseConnections.length + 1e3}`,
-			databaseId: input.databaseId,
-			name: input.name,
-			createdAt: "2026-06-09T00:00:00.000Z",
-			connectionString
-		};
-		this.data.databaseConnections.push(connection);
-		return {
-			connection,
-			connectionString
-		};
-	}
-	removeDatabaseConnection(connectionId) {
-		this.data.databaseConnections ??= [];
-		const connection = this.getDatabaseConnection(connectionId);
-		if (!connection) return;
-		this.data.databaseConnections = this.data.databaseConnections.filter((candidate) => candidate.id !== connectionId);
-		return connection;
-	}
-};
-//#endregion
-export { MockApi };