@mastra/factory 0.0.0-fix-thread-subscription-multi-instance-redis-streams-20260730204150

package/dist/storage/domains/source-control/base.js

@@ -0,0 +1,908 @@
+import { FactoryStorageDomain, UniqueViolationError } from "@mastra/core/storage";
+//#region src/storage/domains/source-control/base.ts
+const FACTORY_PROJECTS = "factory_projects";
+const INSTALLATIONS = "source_control_installations";
+const REPOSITORIES = "source_control_repositories";
+const CONNECTIONS = "factory_project_source_control_connections";
+const PROJECT_REPOSITORIES = "factory_project_repositories";
+const SANDBOXES = "source_control_project_repository_sandboxes";
+const SANDBOX_POOL = "source_control_sandbox_pool";
+const WORKTREES = "source_control_worktrees";
+const SESSIONS = "source_control_sessions";
+const SOURCE_CONTROL_SCHEMAS = [
+	{
+		name: INSTALLATIONS,
+		columns: {
+			id: { type: "uuid-pk" },
+			integration_id: { type: "text" },
+			org_id: { type: "text" },
+			connected_by_user_id: { type: "text" },
+			external_id: { type: "text" },
+			account_name: {
+				type: "text",
+				nullable: true
+			},
+			account_type: {
+				type: "text",
+				nullable: true
+			},
+			provider_metadata: { type: "json" },
+			created_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "source_control_installations_integration_org_external_unique",
+			columns: [
+				"integration_id",
+				"org_id",
+				"external_id"
+			]
+		}]
+	},
+	{
+		name: REPOSITORIES,
+		columns: {
+			id: { type: "uuid-pk" },
+			installation_id: { type: "text" },
+			external_id: { type: "text" },
+			slug: { type: "text" },
+			default_branch: {
+				type: "text",
+				default: "main"
+			},
+			provider_metadata: { type: "json" },
+			created_at: { type: "timestamp" },
+			updated_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "source_control_repositories_installation_external_unique",
+			columns: ["installation_id", "external_id"]
+		}],
+		indexes: [{
+			name: "source_control_repositories_installation_slug_idx",
+			columns: ["installation_id", "slug"]
+		}]
+	},
+	{
+		name: CONNECTIONS,
+		columns: {
+			id: { type: "uuid-pk" },
+			factory_project_id: { type: "text" },
+			integration_id: { type: "text" },
+			installation_id: { type: "text" },
+			created_by_user_id: { type: "text" },
+			created_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "factory_project_source_control_connections_project_integration_installation_unique",
+			columns: [
+				"factory_project_id",
+				"integration_id",
+				"installation_id"
+			]
+		}],
+		indexes: [{
+			name: "factory_project_source_control_connections_project_idx",
+			columns: ["factory_project_id"]
+		}]
+	},
+	{
+		name: PROJECT_REPOSITORIES,
+		columns: {
+			id: { type: "uuid-pk" },
+			connection_id: { type: "text" },
+			repository_id: { type: "text" },
+			created_by_user_id: { type: "text" },
+			branch: {
+				type: "text",
+				nullable: true
+			},
+			sandbox_provider: { type: "text" },
+			sandbox_workdir: { type: "text" },
+			setup_command: {
+				type: "text",
+				nullable: true
+			},
+			created_at: { type: "timestamp" },
+			updated_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "factory_project_repositories_connection_repository_unique",
+			columns: ["connection_id", "repository_id"]
+		}],
+		indexes: [{
+			name: "factory_project_repositories_connection_idx",
+			columns: ["connection_id"]
+		}]
+	},
+	{
+		name: SANDBOXES,
+		columns: {
+			id: { type: "uuid-pk" },
+			project_repository_id: { type: "text" },
+			user_id: { type: "text" },
+			sandbox_id: {
+				type: "text",
+				nullable: true
+			},
+			sandbox_workdir: { type: "text" },
+			materialized_at: {
+				type: "timestamp",
+				nullable: true
+			},
+			created_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "source_control_project_repository_sandboxes_link_user_unique",
+			columns: ["project_repository_id", "user_id"]
+		}]
+	},
+	{
+		name: SANDBOX_POOL,
+		columns: {
+			id: { type: "uuid-pk" },
+			org_id: { type: "text" },
+			project_repository_id: { type: "text" },
+			user_id: { type: "text" },
+			sandbox_id: { type: "text" },
+			sandbox_workdir: { type: "text" },
+			released_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "source_control_sandbox_pool_sandbox_unique",
+			columns: ["sandbox_id"]
+		}],
+		indexes: [{
+			name: "source_control_sandbox_pool_repository_user_idx",
+			columns: ["project_repository_id", "user_id"]
+		}]
+	},
+	{
+		name: WORKTREES,
+		columns: {
+			id: { type: "uuid-pk" },
+			project_repository_id: { type: "text" },
+			user_id: { type: "text" },
+			branch: { type: "text" },
+			base_branch: { type: "text" },
+			worktree_path: { type: "text" },
+			created_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "source_control_worktrees_project_repository_user_branch_unique",
+			columns: [
+				"project_repository_id",
+				"user_id",
+				"branch"
+			]
+		}]
+	},
+	{
+		name: SESSIONS,
+		columns: {
+			id: { type: "uuid-pk" },
+			session_id: { type: "text" },
+			project_repository_id: { type: "text" },
+			org_id: { type: "text" },
+			user_id: { type: "text" },
+			branch: { type: "text" },
+			base_branch: { type: "text" },
+			sandbox_id: {
+				type: "text",
+				nullable: true
+			},
+			sandbox_workdir: {
+				type: "text",
+				nullable: true
+			},
+			materialized_at: {
+				type: "timestamp",
+				nullable: true
+			},
+			created_at: { type: "timestamp" },
+			updated_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "source_control_sessions_session_id_unique",
+			columns: ["session_id"]
+		}, {
+			name: "source_control_sessions_repository_user_branch_unique",
+			columns: [
+				"project_repository_id",
+				"user_id",
+				"branch"
+			]
+		}]
+	}
+];
+function toInstallation(row) {
+	return {
+		id: row.id,
+		integrationId: row.integration_id,
+		orgId: row.org_id,
+		connectedByUserId: row.connected_by_user_id,
+		externalId: row.external_id,
+		accountName: row.account_name,
+		accountType: row.account_type,
+		providerMetadata: row.provider_metadata,
+		createdAt: row.created_at
+	};
+}
+function toRepository(row) {
+	return {
+		id: row.id,
+		installationId: row.installation_id,
+		externalId: row.external_id,
+		slug: row.slug,
+		defaultBranch: row.default_branch,
+		providerMetadata: row.provider_metadata,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function toConnection(row) {
+	return {
+		id: row.id,
+		factoryProjectId: row.factory_project_id,
+		integrationId: row.integration_id,
+		installationId: row.installation_id,
+		createdByUserId: row.created_by_user_id,
+		createdAt: row.created_at
+	};
+}
+function toProjectRepository(row) {
+	return {
+		id: row.id,
+		connectionId: row.connection_id,
+		repositoryId: row.repository_id,
+		createdByUserId: row.created_by_user_id,
+		branch: row.branch,
+		sandboxProvider: row.sandbox_provider,
+		sandboxWorkdir: row.sandbox_workdir,
+		setupCommand: row.setup_command,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function toSandbox(row) {
+	return {
+		id: row.id,
+		projectRepositoryId: row.project_repository_id,
+		userId: row.user_id,
+		sandboxId: row.sandbox_id,
+		sandboxWorkdir: row.sandbox_workdir,
+		materializedAt: row.materialized_at,
+		createdAt: row.created_at
+	};
+}
+function toPooledSandbox(row) {
+	return {
+		id: row.id,
+		orgId: row.org_id,
+		projectRepositoryId: row.project_repository_id,
+		userId: row.user_id,
+		sandboxId: row.sandbox_id,
+		sandboxWorkdir: row.sandbox_workdir,
+		releasedAt: row.released_at
+	};
+}
+function toWorktree(row) {
+	return {
+		id: row.id,
+		projectRepositoryId: row.project_repository_id,
+		userId: row.user_id,
+		branch: row.branch,
+		baseBranch: row.base_branch,
+		worktreePath: row.worktree_path,
+		createdAt: row.created_at
+	};
+}
+function toSession(row) {
+	return {
+		id: row.id,
+		sessionId: row.session_id,
+		projectRepositoryId: row.project_repository_id,
+		orgId: row.org_id,
+		userId: row.user_id,
+		branch: row.branch,
+		baseBranch: row.base_branch,
+		sandboxId: row.sandbox_id,
+		sandboxWorkdir: row.sandbox_workdir,
+		materializedAt: row.materialized_at,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+var SourceControlStorage = class extends FactoryStorageDomain {
+	constructor() {
+		super("source-control");
+	}
+	async init() {
+		await this.ensureCollections(SOURCE_CONTROL_SCHEMAS);
+	}
+	async dangerouslyClearAll() {
+		await this.ops.deleteMany(SESSIONS, {});
+		await this.ops.deleteMany(WORKTREES, {});
+		await this.ops.deleteMany(SANDBOX_POOL, {});
+		await this.ops.deleteMany(SANDBOXES, {});
+		await this.ops.deleteMany(PROJECT_REPOSITORIES, {});
+		await this.ops.deleteMany(CONNECTIONS, {});
+		await this.ops.deleteMany(REPOSITORIES, {});
+		await this.ops.deleteMany(INSTALLATIONS, {});
+	}
+	forIntegration(integrationId) {
+		if (!integrationId.trim()) throw new Error("[SourceControlStorage] integrationId must not be empty.");
+		const db = () => this.ops;
+		const getInstallation = async (args) => {
+			const row = await db().findOne(INSTALLATIONS, {
+				id: args.id,
+				integration_id: integrationId,
+				org_id: args.orgId
+			});
+			return row ? toInstallation(row) : null;
+		};
+		const requireInstallation = async (args) => {
+			const installation = await getInstallation(args);
+			if (!installation) throw new Error("Source-control installation not found for this organization and integration.");
+			return installation;
+		};
+		const getRepository = async (args) => {
+			const row = await db().findOne(REPOSITORIES, { id: args.id });
+			if (!row || !await getInstallation({
+				orgId: args.orgId,
+				id: row.installation_id
+			})) return null;
+			return toRepository(row);
+		};
+		const requireRepository = async (args) => {
+			const repository = await getRepository(args);
+			if (!repository) throw new Error("Source-control repository not found for this organization and integration.");
+			return repository;
+		};
+		const getConnection = async (args) => {
+			const row = await db().findOne(CONNECTIONS, {
+				id: args.id,
+				integration_id: integrationId
+			});
+			if (!row) return null;
+			if (!await db().findOne(FACTORY_PROJECTS, {
+				id: row.factory_project_id,
+				org_id: args.orgId
+			}) || !await getInstallation({
+				orgId: args.orgId,
+				id: row.installation_id
+			})) return null;
+			return toConnection(row);
+		};
+		const requireConnection = async (args) => {
+			const connection = await getConnection(args);
+			if (!connection) throw new Error("Project source-control connection not found for this organization and integration.");
+			return connection;
+		};
+		const getProjectRepository = async (args) => {
+			const row = await db().findOne(PROJECT_REPOSITORIES, { id: args.id });
+			if (!row || !await getConnection({
+				orgId: args.orgId,
+				id: row.connection_id
+			})) return null;
+			return toProjectRepository(row);
+		};
+		const getProjectRepositoryById = async (id) => {
+			const row = await db().findOne(PROJECT_REPOSITORIES, { id });
+			if (!row) return null;
+			return await db().findOne(CONNECTIONS, {
+				id: row.connection_id,
+				integration_id: integrationId
+			}) ? toProjectRepository(row) : null;
+		};
+		const requireProjectRepositoryById = async (id) => {
+			const projectRepository = await getProjectRepositoryById(id);
+			if (!projectRepository) throw new Error("Project repository not found for this integration.");
+			return projectRepository;
+		};
+		const getSandbox = async (id) => {
+			const row = await db().findOne(SANDBOXES, { id });
+			if (!row || !await getProjectRepositoryById(row.project_repository_id)) return null;
+			return toSandbox(row);
+		};
+		const requireSandbox = async (id) => {
+			const sandbox = await getSandbox(id);
+			if (!sandbox) throw new Error("Project-repository sandbox not found for this integration.");
+			return sandbox;
+		};
+		return {
+			integrationId,
+			installations: {
+				list: async ({ orgId }) => (await db().findMany(INSTALLATIONS, {
+					integration_id: integrationId,
+					org_id: orgId
+				})).map(toInstallation),
+				get: getInstallation,
+				findByExternalId: async ({ orgId, externalId }) => {
+					const row = await db().findOne(INSTALLATIONS, {
+						integration_id: integrationId,
+						org_id: orgId,
+						external_id: externalId
+					});
+					return row ? toInstallation(row) : null;
+				},
+				upsert: async (input) => {
+					return toInstallation(await db().upsertOne(INSTALLATIONS, [
+						"integration_id",
+						"org_id",
+						"external_id"
+					], {
+						integration_id: integrationId,
+						org_id: input.orgId,
+						connected_by_user_id: input.connectedByUserId,
+						external_id: input.externalId,
+						account_name: input.accountName ?? null,
+						account_type: input.accountType ?? null,
+						provider_metadata: input.providerMetadata ?? {},
+						created_at: /* @__PURE__ */ new Date()
+					}));
+				},
+				delete: async ({ orgId, id }) => {
+					if (!await getInstallation({
+						orgId,
+						id
+					})) return false;
+					await db().deleteMany(INSTALLATIONS, {
+						id,
+						integration_id: integrationId,
+						org_id: orgId
+					});
+					return true;
+				}
+			},
+			repositories: {
+				list: async ({ orgId, installationId }) => {
+					await requireInstallation({
+						orgId,
+						id: installationId
+					});
+					return (await db().findMany(REPOSITORIES, { installation_id: installationId })).map(toRepository);
+				},
+				get: getRepository,
+				findByExternalId: async ({ orgId, externalId }) => {
+					const rows = await db().findMany(REPOSITORIES, { external_id: externalId });
+					for (const row of rows) if (await getInstallation({
+						orgId,
+						id: row.installation_id
+					})) return toRepository(row);
+					return null;
+				},
+				findBySlug: async ({ orgId, installationId, slug }) => {
+					await requireInstallation({
+						orgId,
+						id: installationId
+					});
+					const row = await db().findOne(REPOSITORIES, {
+						installation_id: installationId,
+						slug
+					});
+					return row ? toRepository(row) : null;
+				},
+				upsert: async ({ orgId, input }) => {
+					await requireInstallation({
+						orgId,
+						id: input.installationId
+					});
+					const now = /* @__PURE__ */ new Date();
+					return toRepository(await db().upsertOne(REPOSITORIES, ["installation_id", "external_id"], {
+						installation_id: input.installationId,
+						external_id: input.externalId,
+						slug: input.slug,
+						default_branch: input.defaultBranch,
+						provider_metadata: input.providerMetadata ?? {},
+						created_at: now,
+						updated_at: now
+					}));
+				},
+				migrateInstallation: async ({ orgId, id, newInstallationId }) => {
+					const existing = await getRepository({
+						orgId,
+						id
+					});
+					if (!existing) throw new Error(`Repository ${id} not found in organization ${orgId}`);
+					await requireInstallation({
+						orgId,
+						id: newInstallationId
+					});
+					try {
+						await db().updateMany(REPOSITORIES, { id }, {
+							installation_id: newInstallationId,
+							updated_at: /* @__PURE__ */ new Date()
+						});
+						await db().updateMany(CONNECTIONS, { installation_id: existing.installationId }, { installation_id: newInstallationId });
+						const updated = await getRepository({
+							orgId,
+							id
+						});
+						if (!updated) throw new Error("Repository disappeared after update");
+						return updated;
+					} catch (error) {
+						if (!(error instanceof UniqueViolationError)) throw error;
+						const conflictRow = await db().findOne(REPOSITORIES, {
+							installation_id: newInstallationId,
+							external_id: existing.externalId
+						});
+						if (!conflictRow) throw error;
+						return toRepository(conflictRow);
+					}
+				}
+			},
+			connections: {
+				list: async ({ orgId, factoryProjectId }) => {
+					if (!await db().findOne(FACTORY_PROJECTS, {
+						id: factoryProjectId,
+						org_id: orgId
+					})) return [];
+					return (await db().findMany(CONNECTIONS, {
+						factory_project_id: factoryProjectId,
+						integration_id: integrationId
+					})).map(toConnection);
+				},
+				get: getConnection,
+				create: async (input) => {
+					if (!await db().findOne(FACTORY_PROJECTS, {
+						id: input.factoryProjectId,
+						org_id: input.orgId
+					})) throw new Error("Factory project not found for this organization.");
+					await requireInstallation({
+						orgId: input.orgId,
+						id: input.installationId
+					});
+					try {
+						return toConnection(await db().insertOne(CONNECTIONS, {
+							factory_project_id: input.factoryProjectId,
+							integration_id: integrationId,
+							installation_id: input.installationId,
+							created_by_user_id: input.createdByUserId,
+							created_at: /* @__PURE__ */ new Date()
+						}));
+					} catch (error) {
+						if (!(error instanceof UniqueViolationError)) throw error;
+						const row = await db().findOne(CONNECTIONS, {
+							factory_project_id: input.factoryProjectId,
+							integration_id: integrationId,
+							installation_id: input.installationId
+						});
+						if (!row) throw error;
+						return toConnection(row);
+					}
+				},
+				delete: async ({ orgId, id }) => {
+					if (!await getConnection({
+						orgId,
+						id
+					})) return false;
+					const projectRepositories = await db().findMany(PROJECT_REPOSITORIES, { connection_id: id });
+					for (const projectRepository of projectRepositories) {
+						await db().deleteMany(SESSIONS, { project_repository_id: projectRepository.id });
+						await db().deleteMany(WORKTREES, { project_repository_id: projectRepository.id });
+						await db().deleteMany(SANDBOX_POOL, { project_repository_id: projectRepository.id });
+						await db().deleteMany(SANDBOXES, { project_repository_id: projectRepository.id });
+					}
+					await db().deleteMany(PROJECT_REPOSITORIES, { connection_id: id });
+					await db().deleteMany(CONNECTIONS, {
+						id,
+						integration_id: integrationId
+					});
+					return true;
+				}
+			},
+			projectRepositories: {
+				list: async ({ orgId, connectionId }) => {
+					await requireConnection({
+						orgId,
+						id: connectionId
+					});
+					return (await db().findMany(PROJECT_REPOSITORIES, { connection_id: connectionId })).map(toProjectRepository);
+				},
+				listConfiguredExternalKeys: async () => {
+					const keys = /* @__PURE__ */ new Map();
+					const connections = await db().findMany(CONNECTIONS, { integration_id: integrationId });
+					for (const connection of connections) {
+						const installation = await db().findOne(INSTALLATIONS, {
+							id: connection.installation_id,
+							integration_id: integrationId
+						});
+						if (!installation) continue;
+						const links = await db().findMany(PROJECT_REPOSITORIES, { connection_id: connection.id });
+						for (const link of links) {
+							const repository = await db().findOne(REPOSITORIES, { id: link.repository_id });
+							if (!repository) continue;
+							keys.set(`${installation.external_id}\u0000${repository.external_id}`, {
+								installationExternalId: installation.external_id,
+								repositoryExternalId: repository.external_id
+							});
+						}
+					}
+					return [...keys.values()];
+				},
+				listByExternalRepository: async ({ installationExternalId, repositoryExternalId }) => {
+					const targets = [];
+					const installations = await db().findMany(INSTALLATIONS, {
+						integration_id: integrationId,
+						external_id: installationExternalId
+					});
+					for (const installation of installations) {
+						const repository = await db().findOne(REPOSITORIES, {
+							installation_id: installation.id,
+							external_id: repositoryExternalId
+						});
+						if (!repository) continue;
+						const links = await db().findMany(PROJECT_REPOSITORIES, { repository_id: repository.id });
+						for (const link of links) {
+							const connection = await db().findOne(CONNECTIONS, {
+								id: link.connection_id,
+								integration_id: integrationId,
+								installation_id: installation.id
+							});
+							if (!connection) continue;
+							if (!await db().findOne(FACTORY_PROJECTS, {
+								id: connection.factory_project_id,
+								org_id: installation.org_id
+							})) continue;
+							targets.push({
+								orgId: installation.org_id,
+								factoryProjectId: connection.factory_project_id,
+								projectRepository: toProjectRepository(link)
+							});
+						}
+					}
+					return targets;
+				},
+				get: getProjectRepository,
+				link: async (input) => {
+					const connection = await requireConnection({
+						orgId: input.orgId,
+						id: input.connectionId
+					});
+					if ((await requireRepository({
+						orgId: input.orgId,
+						id: input.repositoryId
+					})).installationId !== connection.installationId) throw new Error("Repository does not belong to the connection installation.");
+					const now = /* @__PURE__ */ new Date();
+					return toProjectRepository(await db().upsertOne(PROJECT_REPOSITORIES, ["connection_id", "repository_id"], {
+						connection_id: input.connectionId,
+						repository_id: input.repositoryId,
+						created_by_user_id: input.createdByUserId,
+						branch: input.branch ?? null,
+						sandbox_provider: input.sandboxProvider,
+						sandbox_workdir: input.sandboxWorkdir,
+						setup_command: input.setupCommand ?? null,
+						created_at: now,
+						updated_at: now
+					}));
+				},
+				update: async ({ orgId, id, input }) => {
+					if (!await getProjectRepository({
+						orgId,
+						id
+					})) return null;
+					const patch = { updated_at: /* @__PURE__ */ new Date() };
+					if (input.branch !== void 0) patch.branch = input.branch;
+					if (input.sandboxProvider !== void 0) patch.sandbox_provider = input.sandboxProvider;
+					if (input.sandboxWorkdir !== void 0) patch.sandbox_workdir = input.sandboxWorkdir;
+					if (input.setupCommand !== void 0) patch.setup_command = input.setupCommand;
+					await db().updateMany(PROJECT_REPOSITORIES, { id }, patch);
+					return getProjectRepository({
+						orgId,
+						id
+					});
+				},
+				unlink: async ({ orgId, id }) => {
+					if (!await getProjectRepository({
+						orgId,
+						id
+					})) return false;
+					await db().deleteMany(SESSIONS, { project_repository_id: id });
+					await db().deleteMany(WORKTREES, { project_repository_id: id });
+					await db().deleteMany(SANDBOX_POOL, { project_repository_id: id });
+					await db().deleteMany(SANDBOXES, { project_repository_id: id });
+					await db().deleteMany(PROJECT_REPOSITORIES, { id });
+					return true;
+				}
+			},
+			sandboxes: {
+				getOrCreate: async ({ projectRepository, userId }) => {
+					await requireProjectRepositoryById(projectRepository.id);
+					const where = {
+						project_repository_id: projectRepository.id,
+						user_id: userId
+					};
+					const existing = await db().findOne(SANDBOXES, where);
+					if (existing) return toSandbox(existing);
+					try {
+						return toSandbox(await db().insertOne(SANDBOXES, {
+							...where,
+							sandbox_id: null,
+							sandbox_workdir: projectRepository.sandboxWorkdir,
+							materialized_at: null,
+							created_at: /* @__PURE__ */ new Date()
+						}));
+					} catch (error) {
+						if (!(error instanceof UniqueViolationError)) throw error;
+						const row = await db().findOne(SANDBOXES, where);
+						if (!row) throw error;
+						return toSandbox(row);
+					}
+				},
+				getById: ({ id }) => getSandbox(id),
+				setWorkdir: async ({ id, sandboxWorkdir }) => {
+					await requireSandbox(id);
+					await db().updateMany(SANDBOXES, { id }, {
+						sandbox_workdir: sandboxWorkdir,
+						materialized_at: null
+					});
+				},
+				setSandboxId: async ({ id, sandboxId }) => {
+					await requireSandbox(id);
+					await db().updateMany(SANDBOXES, { id }, { sandbox_id: sandboxId });
+				},
+				clearBinding: async ({ id }) => {
+					await requireSandbox(id);
+					await db().updateMany(SANDBOXES, { id }, {
+						sandbox_id: null,
+						materialized_at: null
+					});
+				},
+				markMaterialized: async ({ id }) => {
+					await requireSandbox(id);
+					await db().updateMany(SANDBOXES, { id }, { materialized_at: /* @__PURE__ */ new Date() });
+				}
+			},
+			sandboxPool: {
+				release: async (input) => {
+					if (!await getProjectRepositoryById(input.projectRepositoryId)) return;
+					try {
+						await db().insertOne(SANDBOX_POOL, {
+							org_id: input.orgId,
+							project_repository_id: input.projectRepositoryId,
+							user_id: input.userId,
+							sandbox_id: input.sandboxId,
+							sandbox_workdir: input.sandboxWorkdir,
+							released_at: /* @__PURE__ */ new Date()
+						});
+					} catch (error) {
+						if (!(error instanceof UniqueViolationError)) throw error;
+					}
+				},
+				claim: async ({ projectRepositoryId }) => {
+					if (!await getProjectRepositoryById(projectRepositoryId)) return null;
+					const rows = await db().findMany(SANDBOX_POOL, { project_repository_id: projectRepositoryId });
+					rows.sort((left, right) => right.released_at.getTime() - left.released_at.getTime());
+					for (const row of rows) if (await db().deleteMany(SANDBOX_POOL, { id: row.id }) === 1) return toPooledSandbox(row);
+					return null;
+				}
+			},
+			worktrees: {
+				upsert: async (input) => {
+					await requireProjectRepositoryById(input.projectRepositoryId);
+					await db().upsertOne(WORKTREES, [
+						"project_repository_id",
+						"user_id",
+						"branch"
+					], {
+						project_repository_id: input.projectRepositoryId,
+						user_id: input.userId,
+						branch: input.branch,
+						base_branch: input.baseBranch,
+						worktree_path: input.worktreePath,
+						created_at: /* @__PURE__ */ new Date()
+					});
+				},
+				list: async ({ projectRepositoryId, userId }) => {
+					if (!await getProjectRepositoryById(projectRepositoryId)) return [];
+					return (await db().findMany(WORKTREES, {
+						project_repository_id: projectRepositoryId,
+						user_id: userId
+					})).map(toWorktree);
+				},
+				get: async ({ projectRepositoryId, userId, branch }) => {
+					if (!await getProjectRepositoryById(projectRepositoryId)) return null;
+					const row = await db().findOne(WORKTREES, {
+						project_repository_id: projectRepositoryId,
+						user_id: userId,
+						branch
+					});
+					return row ? toWorktree(row) : null;
+				},
+				findByPath: async ({ projectRepositoryId, userId, worktreePath }) => {
+					if (!await getProjectRepositoryById(projectRepositoryId)) return null;
+					const row = await db().findOne(WORKTREES, {
+						project_repository_id: projectRepositoryId,
+						user_id: userId,
+						worktree_path: worktreePath
+					});
+					return row ? toWorktree(row) : null;
+				},
+				delete: async ({ projectRepositoryId, userId, branch }) => {
+					await requireProjectRepositoryById(projectRepositoryId);
+					await db().deleteMany(WORKTREES, {
+						project_repository_id: projectRepositoryId,
+						user_id: userId,
+						branch
+					});
+				}
+			},
+			sessions: {
+				list: async ({ projectRepositoryId, userId }) => {
+					if (!await getProjectRepositoryById(projectRepositoryId)) return [];
+					return (await db().findMany(SESSIONS, {
+						project_repository_id: projectRepositoryId,
+						user_id: userId
+					})).map(toSession);
+				},
+				getBySessionId: async (sessionId) => {
+					const row = await db().findOne(SESSIONS, { session_id: sessionId });
+					return row && await getProjectRepositoryById(row.project_repository_id) ? toSession(row) : null;
+				},
+				getForBranch: async ({ projectRepositoryId, userId, branch }) => {
+					if (!await getProjectRepositoryById(projectRepositoryId)) return null;
+					const row = await db().findOne(SESSIONS, {
+						project_repository_id: projectRepositoryId,
+						user_id: userId,
+						branch
+					});
+					return row ? toSession(row) : null;
+				},
+				create: async (input) => {
+					await requireProjectRepositoryById(input.projectRepositoryId);
+					const existing = await db().findOne(SESSIONS, {
+						project_repository_id: input.projectRepositoryId,
+						user_id: input.userId,
+						branch: input.branch
+					});
+					if (existing) return toSession(existing);
+					const now = /* @__PURE__ */ new Date();
+					try {
+						return toSession(await db().insertOne(SESSIONS, {
+							session_id: input.sessionId,
+							project_repository_id: input.projectRepositoryId,
+							org_id: input.orgId,
+							user_id: input.userId,
+							branch: input.branch,
+							base_branch: input.baseBranch,
+							sandbox_id: null,
+							sandbox_workdir: null,
+							materialized_at: null,
+							created_at: now,
+							updated_at: now
+						}));
+					} catch (error) {
+						if (!(error instanceof UniqueViolationError)) throw error;
+						const row = await db().findOne(SESSIONS, {
+							project_repository_id: input.projectRepositoryId,
+							user_id: input.userId,
+							branch: input.branch
+						});
+						if (!row) throw error;
+						return toSession(row);
+					}
+				},
+				setSandbox: async ({ id, sandboxId, sandboxWorkdir }) => {
+					await db().updateMany(SESSIONS, { id }, {
+						sandbox_id: sandboxId,
+						sandbox_workdir: sandboxWorkdir,
+						updated_at: /* @__PURE__ */ new Date()
+					});
+				},
+				markMaterialized: async ({ id }) => {
+					await db().updateMany(SESSIONS, { id }, {
+						materialized_at: /* @__PURE__ */ new Date(),
+						updated_at: /* @__PURE__ */ new Date()
+					});
+				},
+				delete: async (id) => {
+					await db().deleteMany(SESSIONS, { id });
+				}
+			}
+		};
+	}
+};
+//#endregion
+export { SOURCE_CONTROL_SCHEMAS, SourceControlStorage };
+
+//# sourceMappingURL=base.js.map