@mastra/factory 0.21.1-alpha.3 → 0.22.0-alpha.4

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

@@ -1,3 +1,4 @@
+import { FACTORY_PROJECTS_SCHEMA } from "../projects/base.js";
 import { FactoryStorageDomain, UniqueViolationError } from "@mastra/core/storage";
 //#region src/storage/domains/source-control/base.ts
 const FACTORY_PROJECTS = "factory_projects";
@@ -6,6 +7,20 @@ const REPOSITORIES = "source_control_repositories";
 const CONNECTIONS = "factory_project_source_control_connections";
 const PROJECT_REPOSITORIES = "factory_project_repositories";
 const SESSIONS = "source_control_sessions";
+const SESSION_REPOSITORIES = "source_control_session_repositories";
+/**
+* The user already holds the branch on this link in a session without this
+* factory's ownership, left by the factory migration. It is never reused and
+* cannot be replaced while it holds the branch.
+*/
+var SessionOwnershipMismatchError = class extends Error {
+	sessionId;
+	constructor(sessionId) {
+		super(`Session ${sessionId} already holds this branch but does not belong to this factory.`);
+		this.sessionId = sessionId;
+		this.name = "SessionOwnershipMismatchError";
+	}
+};
 var SourceControlConnectionNotFoundError = class extends Error {
 	constructor() {
 		super("Project source-control connection not found for this organization and integration.");
@@ -109,6 +124,26 @@ const SOURCE_CONTROL_SCHEMAS = [
 				type: "text",
 				nullable: true
 			},
+			position: {
+				type: "integer",
+				default: 0
+			},
+			in_environment: {
+				type: "boolean",
+				default: true
+			},
+			last_build_status: {
+				type: "text",
+				default: "unbuilt"
+			},
+			last_build_error: {
+				type: "text",
+				nullable: true
+			},
+			last_built_at: {
+				type: "timestamp",
+				nullable: true
+			},
 			created_at: { type: "timestamp" },
 			updated_at: { type: "timestamp" }
 		},
@@ -127,6 +162,10 @@ const SOURCE_CONTROL_SCHEMAS = [
 			id: { type: "uuid-pk" },
 			session_id: { type: "text" },
 			project_repository_id: { type: "text" },
+			factory_project_id: {
+				type: "text",
+				nullable: true
+			},
 			org_id: { type: "text" },
 			user_id: { type: "text" },
 			branch: { type: "text" },
@@ -162,16 +201,59 @@ const SOURCE_CONTROL_SCHEMAS = [
 			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"
+				]
+			},
+			{
+				name: "source_control_sessions_project_user_branch_unique",
+				columns: [
+					"factory_project_id",
+					"user_id",
+					"branch"
+				]
+			}
+		],
+		indexes: [{
+			name: "source_control_sessions_project_idx",
+			columns: ["factory_project_id"]
+		}]
+	},
+	{
+		name: SESSION_REPOSITORIES,
+		columns: {
+			id: { type: "uuid-pk" },
+			session_id: { type: "text" },
+			project_repository_id: { type: "text" },
+			branch: { type: "text" },
+			change_request_id: {
+				type: "text",
+				nullable: true
+			},
+			change_request_url: {
+				type: "text",
+				nullable: true
+			},
+			pushed_at: { type: "timestamp" },
+			created_at: { type: "timestamp" },
+			updated_at: { type: "timestamp" }
+		},
 		uniqueIndexes: [{
-			name: "source_control_sessions_session_id_unique",
+			name: "source_control_session_repositories_session_link_unique",
+			columns: ["session_id", "project_repository_id"]
+		}],
+		indexes: [{
+			name: "source_control_session_repositories_session_idx",
 			columns: ["session_id"]
-		}, {
-			name: "source_control_sessions_repository_user_branch_unique",
-			columns: [
-				"project_repository_id",
-				"user_id",
-				"branch"
-			]
 		}]
 	}
 ];
@@ -221,6 +303,31 @@ function toProjectRepository(row) {
 		sandboxWorkdir: row.sandbox_workdir,
 		setupCommand: row.setup_command,
 		teardownCommand: row.teardown_command,
+		position: row.position ?? 0,
+		inEnvironment: row.in_environment ?? true,
+		lastBuildStatus: toBuildStatus(row.last_build_status),
+		lastBuildError: row.last_build_error,
+		lastBuiltAt: row.last_built_at,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function toBuildStatus(value) {
+	return value === "configured" || value === "failed" ? value : "unbuilt";
+}
+/** Oldest first; ties (same millisecond) break on id so re-runs see one order. */
+function byCreatedAt(a, b) {
+	return a.created_at.getTime() - b.created_at.getTime() || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+}
+function toSessionRepository(row) {
+	return {
+		id: row.id,
+		sessionId: row.session_id,
+		projectRepositoryId: row.project_repository_id,
+		branch: row.branch,
+		changeRequestId: row.change_request_id,
+		changeRequestUrl: row.change_request_url,
+		pushedAt: row.pushed_at,
 		createdAt: row.created_at,
 		updatedAt: row.updated_at
 	};
@@ -230,6 +337,7 @@ function toSession(row) {
 		id: row.id,
 		sessionId: row.session_id,
 		projectRepositoryId: row.project_repository_id,
+		factoryProjectId: row.factory_project_id ?? null,
 		orgId: row.org_id,
 		userId: row.user_id,
 		branch: row.branch,
@@ -245,14 +353,162 @@ function toSession(row) {
 		updatedAt: row.updated_at
 	};
 }
+function projectRepositoryPatch(input) {
+	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;
+	if (input.teardownCommand !== void 0) patch.teardown_command = input.teardownCommand;
+	if (input.position !== void 0) patch.position = input.position;
+	if (input.inEnvironment !== void 0) patch.in_environment = input.inEnvironment;
+	return patch;
+}
 var SourceControlStorage = class extends FactoryStorageDomain {
 	constructor() {
 		super("source-control");
 	}
 	async init() {
 		await this.ensureCollections(SOURCE_CONTROL_SCHEMAS);
+		await this.#backfillEnvironment();
+		await this.#backfillSessionFactory();
+	}
+	/**
+	* Fill `factory_project_id` on sessions that predate the column, walking
+	* link → connection. The old constraint was per link, so two links of one
+	* factory may hold the same user and branch; the new per-factory index
+	* would reject the second write and a throwing `init()` only leaves the
+	* domain not-ready. Within such a group the oldest session wins and the
+	* others keep a null factory. Idempotent, O(rows), deletes nothing.
+	*/
+	async #backfillSessionFactory() {
+		let unresolved = 0;
+		let collisions = 0;
+		try {
+			const pending = await this.ops.findMany(SESSIONS, { factory_project_id: null });
+			if (pending.length === 0) return;
+			const connections = await this.ops.findMany(CONNECTIONS, {});
+			const links = await this.ops.findMany(PROJECT_REPOSITORIES, {});
+			const projectByConnectionId = new Map(connections.map((row) => [row.id, row.factory_project_id]));
+			const projectByLinkId = new Map(links.flatMap((link) => {
+				const projectId = projectByConnectionId.get(link.connection_id);
+				return projectId ? [[link.id, projectId]] : [];
+			}));
+			const keyOf = (projectId, row) => `${projectId}\u0000${row.user_id}\u0000${row.branch}`;
+			const taken = /* @__PURE__ */ new Set();
+			for (const row of await this.ops.findMany(SESSIONS, {})) if (row.factory_project_id) taken.add(keyOf(row.factory_project_id, row));
+			const ordered = [...pending].sort((a, b) => a.created_at.getTime() - b.created_at.getTime() || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+			for (const row of ordered) {
+				const projectId = projectByLinkId.get(row.project_repository_id);
+				if (!projectId) {
+					unresolved += 1;
+					continue;
+				}
+				const key = keyOf(projectId, row);
+				if (taken.has(key)) {
+					collisions += 1;
+					continue;
+				}
+				try {
+					await this.ops.updateMany(SESSIONS, { id: row.id }, { factory_project_id: projectId });
+					taken.add(key);
+				} catch (error) {
+					if (!(error instanceof UniqueViolationError)) throw error;
+					collisions += 1;
+				}
+			}
+		} catch (error) {
+			console.warn(`[factory] session backfill stopped early: ${error instanceof Error ? error.message : error}`);
+			return;
+		}
+		if (unresolved > 0 || collisions > 0) console.warn(`[factory] session backfill: ${unresolved} sessions have no resolvable factory, ${collisions} sessions collide on (factory, user, branch) and keep a null factory`);
+	}
+	/**
+	* One-time fill of the environment columns from the rows that predate them.
+	* Idempotent and non-destructive: a project is touched only while its
+	* `environment_backfilled_at` is null, every other write lands only where the
+	* stored value is still the column default, and nothing is deleted. Runs
+	* on every start; reports what it could not resolve instead of throwing,
+	* because a throwing `init()` only leaves the domain not-ready.
+	*/
+	async #backfillEnvironment() {
+		await this.ensureCollections([FACTORY_PROJECTS_SCHEMA]);
+		let missingRepositories = 0;
+		const failedProjects = [];
+		try {
+			const projects = await this.ops.findMany(FACTORY_PROJECTS, { environment_backfilled_at: null });
+			if (projects.length === 0) return;
+			const connections = await this.ops.findMany(CONNECTIONS, {});
+			const links = await this.ops.findMany(PROJECT_REPOSITORIES, {});
+			const repositories = await this.ops.findMany(REPOSITORIES, {});
+			const slugByRepositoryId = new Map(repositories.map((row) => [row.id, row.slug]));
+			const linksByConnectionId = /* @__PURE__ */ new Map();
+			for (const link of links) {
+				const bucket = linksByConnectionId.get(link.connection_id) ?? [];
+				bucket.push(link);
+				linksByConnectionId.set(link.connection_id, bucket);
+			}
+			const connectionsByProjectId = /* @__PURE__ */ new Map();
+			for (const connection of connections) {
+				const bucket = connectionsByProjectId.get(connection.factory_project_id) ?? [];
+				bucket.push(connection);
+				connectionsByProjectId.set(connection.factory_project_id, bucket);
+			}
+			for (const project of projects) try {
+				const projectLinks = (connectionsByProjectId.get(project.id) ?? []).flatMap((connection) => linksByConnectionId.get(connection.id) ?? []).sort(byCreatedAt);
+				const slugOf = (link) => {
+					const slug = slugByRepositoryId.get(link.repository_id);
+					if (slug !== void 0) return slug;
+					missingRepositories += 1;
+					return `missing-repository:${link.id}`;
+				};
+				let nextPosition = Math.max(0, ...projectLinks.map((link) => link.position ?? 0));
+				const seenSlugs = new Set(projectLinks.filter((link) => (link.position ?? 0) > 0 && link.in_environment !== false).map(slugOf));
+				for (const link of projectLinks) {
+					if ((link.position ?? 0) > 0) continue;
+					nextPosition += 1;
+					const slug = slugOf(link);
+					const inEnvironment = link.in_environment !== false && !seenSlugs.has(slug);
+					if (inEnvironment) seenSlugs.add(slug);
+					await this.ops.updateMany(PROJECT_REPOSITORIES, { id: link.id }, {
+						position: nextPosition,
+						in_environment: inEnvironment
+					});
+				}
+				await this.ops.updateMany(FACTORY_PROJECTS, { id: project.id }, { environment_backfilled_at: /* @__PURE__ */ new Date() });
+			} catch {
+				failedProjects.push(project.id);
+			}
+		} catch (error) {
+			console.warn(`[factory] environment backfill did not run: ${error instanceof Error ? error.message : error}`);
+			return;
+		}
+		if (missingRepositories > 0 || failedProjects.length > 0) console.warn(`[factory] environment backfill: ${missingRepositories} links point at a missing repository row, ${failedProjects.length} projects could not be updated${failedProjects.length > 0 ? ` (${failedProjects.join(", ")})` : ""}`);
+	}
+	/**
+	* Applies environment patches to a project's repository links through `ops`,
+	* normally a transaction that also holds the project row. Validates against
+	* the links as they are inside that transaction: every id must belong to the
+	* project, and a reorder must list every link so no two share a position.
+	* Nothing is written when validation fails.
+	*/
+	async updateEnvironmentRepositories(ops, args) {
+		const connections = args.integrationIds.length === 0 ? [] : await ops.findMany(CONNECTIONS, {
+			factory_project_id: args.factoryProjectId,
+			integration_id: { in: args.integrationIds }
+		});
+		const links = connections.length === 0 ? [] : await ops.findMany(PROJECT_REPOSITORIES, { connection_id: { in: connections.map((connection) => connection.id) } });
+		const linkIds = new Set(links.map((link) => link.id));
+		if (args.patches.some((patch) => !linkIds.has(patch.projectRepositoryId))) return "not_found";
+		if (args.patches.some((patch) => patch.position !== void 0) && args.patches.length !== linkIds.size) return "incomplete_reorder";
+		for (const { projectRepositoryId, ...input } of args.patches) {
+			if (Object.keys(input).length === 0) continue;
+			await ops.updateMany(PROJECT_REPOSITORIES, { id: projectRepositoryId }, projectRepositoryPatch(input));
+		}
+		return "updated";
 	}
 	async dangerouslyClearAll() {
+		await this.ops.deleteMany(SESSION_REPOSITORIES, {});
 		await this.ops.deleteMany(SESSIONS, {});
 		await this.ops.deleteMany(PROJECT_REPOSITORIES, {});
 		await this.ops.deleteMany(CONNECTIONS, {});
@@ -497,7 +753,11 @@ var SourceControlStorage = class extends FactoryStorageDomain {
 						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 });
+					for (const projectRepository of projectRepositories) {
+						for (const session of await db().findMany(SESSIONS, { project_repository_id: projectRepository.id })) await db().deleteMany(SESSION_REPOSITORIES, { session_id: session.session_id });
+						await db().deleteMany(SESSION_REPOSITORIES, { project_repository_id: projectRepository.id });
+						await db().deleteMany(SESSIONS, { project_repository_id: projectRepository.id });
+					}
 					await db().deleteMany(PROJECT_REPOSITORIES, { connection_id: id });
 					await db().deleteMany(CONNECTIONS, {
 						id,
@@ -568,16 +828,40 @@ var SourceControlStorage = class extends FactoryStorageDomain {
 					}
 					return targets;
 				},
+				listByProject: async ({ orgId, factoryProjectId }) => {
+					if (!await db().findOne(FACTORY_PROJECTS, {
+						id: factoryProjectId,
+						org_id: orgId
+					})) return [];
+					const connections = await db().findMany(CONNECTIONS, {
+						factory_project_id: factoryProjectId,
+						integration_id: integrationId
+					});
+					if (connections.length === 0) return [];
+					return (await db().findMany(PROJECT_REPOSITORIES, { connection_id: { in: connections.map((connection) => connection.id) } }, { orderBy: [["position", "asc"], ["created_at", "asc"]] })).map(toProjectRepository);
+				},
 				get: getProjectRepository,
 				link: async (input) => {
 					const connection = await requireConnection({
 						orgId: input.orgId,
 						id: input.connectionId
 					});
-					if ((await requireRepository({
+					const repository = await requireRepository({
 						orgId: input.orgId,
 						id: input.repositoryId
-					})).installationId !== connection.installationId) throw new Error("Repository does not belong to the connection installation.");
+					});
+					if (repository.installationId !== connection.installationId) throw new Error("Repository does not belong to the connection installation.");
+					const siblingConnections = await db().findMany(CONNECTIONS, { factory_project_id: connection.factoryProjectId });
+					const siblings = await db().findMany(PROJECT_REPOSITORIES, { connection_id: { in: siblingConnections.map((sibling) => sibling.id) } });
+					const position = 1 + Math.max(0, ...siblings.map((sibling) => sibling.position ?? 0));
+					let inEnvironment = true;
+					for (const sibling of siblings) {
+						if (sibling.in_environment === false) continue;
+						if ((await db().findOne(REPOSITORIES, { id: sibling.repository_id }))?.slug === repository.slug) {
+							inEnvironment = false;
+							break;
+						}
+					}
 					const now = /* @__PURE__ */ new Date();
 					try {
 						return toProjectRepository(await db().insertOne(PROJECT_REPOSITORIES, {
@@ -589,6 +873,11 @@ var SourceControlStorage = class extends FactoryStorageDomain {
 							sandbox_workdir: input.sandboxWorkdir,
 							setup_command: input.setupCommand ?? null,
 							teardown_command: input.teardownCommand ?? null,
+							position,
+							in_environment: inEnvironment,
+							last_build_status: "unbuilt",
+							last_build_error: null,
+							last_built_at: null,
 							created_at: now,
 							updated_at: now
 						}));
@@ -607,13 +896,23 @@ var SourceControlStorage = class extends FactoryStorageDomain {
 						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;
-					if (input.teardownCommand !== void 0) patch.teardown_command = input.teardownCommand;
-					await db().updateMany(PROJECT_REPOSITORIES, { id }, patch);
+					await db().updateMany(PROJECT_REPOSITORIES, { id }, projectRepositoryPatch(input));
+					return getProjectRepository({
+						orgId,
+						id
+					});
+				},
+				setBuildStatus: async ({ orgId, id, status, error, builtAt }) => {
+					if (!await getProjectRepository({
+						orgId,
+						id
+					})) return null;
+					await db().updateMany(PROJECT_REPOSITORIES, { id }, {
+						last_build_status: status,
+						last_build_error: error ?? null,
+						last_built_at: builtAt ?? null,
+						updated_at: /* @__PURE__ */ new Date()
+					});
 					return getProjectRepository({
 						orgId,
 						id
@@ -624,6 +923,8 @@ var SourceControlStorage = class extends FactoryStorageDomain {
 						orgId,
 						id
 					})) return false;
+					for (const session of await db().findMany(SESSIONS, { project_repository_id: id })) await db().deleteMany(SESSION_REPOSITORIES, { session_id: session.session_id });
+					await db().deleteMany(SESSION_REPOSITORIES, { project_repository_id: id });
 					await db().deleteMany(SESSIONS, { project_repository_id: id });
 					await db().deleteMany(PROJECT_REPOSITORIES, { id });
 					return true;
@@ -638,6 +939,19 @@ var SourceControlStorage = class extends FactoryStorageDomain {
 					if (!await getProjectRepositoryById(projectRepositoryId)) return [];
 					return (await db().findMany(SESSIONS, { project_repository_id: projectRepositoryId })).map(toSession);
 				},
+				listByProject: async ({ orgId, factoryProjectId, viewerUserId }) => {
+					const connections = await db().findMany(CONNECTIONS, {
+						factory_project_id: factoryProjectId,
+						integration_id: integrationId
+					});
+					if (connections.length === 0) return [];
+					const linkIds = /* @__PURE__ */ new Set();
+					for (const connection of connections) for (const link of await db().findMany(PROJECT_REPOSITORIES, { connection_id: connection.id })) linkIds.add(link.id);
+					return (await db().findMany(SESSIONS, {
+						factory_project_id: factoryProjectId,
+						org_id: orgId
+					})).filter((row) => linkIds.has(row.project_repository_id)).filter((row) => row.visibility !== "private" || row.user_id === viewerUserId).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;
@@ -648,28 +962,49 @@ var SourceControlStorage = class extends FactoryStorageDomain {
 						updated_at: /* @__PURE__ */ new Date()
 					}));
 				},
-				getForBranch: async ({ projectRepositoryId, userId, branch }) => {
-					if (!await getProjectRepositoryById(projectRepositoryId)) return null;
+				getForBranch: async (args) => {
+					if ("factoryProjectId" in args) {
+						const row = await db().findOne(SESSIONS, {
+							factory_project_id: args.factoryProjectId,
+							user_id: args.userId,
+							branch: args.branch
+						});
+						return row && await getProjectRepositoryById(row.project_repository_id) ? toSession(row) : null;
+					}
+					if (!await getProjectRepositoryById(args.projectRepositoryId)) return null;
 					const row = await db().findOne(SESSIONS, {
-						project_repository_id: projectRepositoryId,
-						user_id: userId,
-						branch
+						project_repository_id: args.projectRepositoryId,
+						user_id: args.userId,
+						branch: args.branch
 					});
 					return row ? toSession(row) : null;
 				},
 				create: async (input) => {
-					await requireProjectRepositoryById(input.projectRepositoryId);
-					const existing = await db().findOne(SESSIONS, {
+					const link = await requireProjectRepositoryById(input.projectRepositoryId);
+					const connection = await getConnection({
+						orgId: input.orgId,
+						id: link.connectionId
+					});
+					if (!connection) throw new Error("Project repository not found for this integration.");
+					if (input.factoryProjectId !== void 0 && input.factoryProjectId !== connection.factoryProjectId) throw new Error("Session factory does not match the repository link.");
+					const factoryProjectId = connection.factoryProjectId;
+					const reuse = (row) => {
+						if (row.factory_project_id !== factoryProjectId) throw new SessionOwnershipMismatchError(row.session_id);
+						return toSession(row);
+					};
+					const findExisting = async () => db().findOne(SESSIONS, {
 						project_repository_id: input.projectRepositoryId,
 						user_id: input.userId,
 						branch: input.branch
 					});
-					if (existing) return toSession(existing);
+					const existing = await findExisting();
+					if (existing) return reuse(existing);
 					const now = /* @__PURE__ */ new Date();
 					try {
 						return toSession(await db().insertOne(SESSIONS, {
 							session_id: input.sessionId,
 							project_repository_id: input.projectRepositoryId,
+							factory_project_id: factoryProjectId,
 							org_id: input.orgId,
 							user_id: input.userId,
 							branch: input.branch,
@@ -685,13 +1020,9 @@ var SourceControlStorage = class extends FactoryStorageDomain {
 						}));
 					} 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
-						});
+						const row = await findExisting();
 						if (!row) throw error;
-						return toSession(row);
+						return reuse(row);
 					}
 				},
 				setSandbox: async ({ id, sandboxId, sandboxWorkdir }) => {
@@ -729,13 +1060,55 @@ var SourceControlStorage = class extends FactoryStorageDomain {
 					});
 				},
 				delete: async (id) => {
+					const row = await db().findOne(SESSIONS, { id });
+					if (row) await db().deleteMany(SESSION_REPOSITORIES, { session_id: row.session_id });
 					await db().deleteMany(SESSIONS, { id });
 				}
+			},
+			sessionRepositories: {
+				upsert: async (input) => {
+					const key = {
+						session_id: input.sessionId,
+						project_repository_id: input.projectRepositoryId
+					};
+					const now = /* @__PURE__ */ new Date();
+					const changes = { updated_at: now };
+					if (input.branch !== void 0) {
+						changes.branch = input.branch;
+						changes.pushed_at = input.pushedAt ?? now;
+					} else if (input.pushedAt) changes.pushed_at = input.pushedAt;
+					if (input.changeRequestId !== void 0) changes.change_request_id = input.changeRequestId;
+					if (input.changeRequestUrl !== void 0) changes.change_request_url = input.changeRequestUrl;
+					const update = async () => {
+						await db().updateMany(SESSION_REPOSITORIES, key, changes);
+						const row = await db().findOne(SESSION_REPOSITORIES, key);
+						if (!row) throw new Error("Session repository row vanished during upsert.");
+						return toSessionRepository(row);
+					};
+					if (await db().findOne(SESSION_REPOSITORIES, key)) return update();
+					const branch = input.branch ?? input.fallbackBranch;
+					if (!branch) throw new Error("A session repository row needs a branch when it is first recorded.");
+					try {
+						return toSessionRepository(await db().insertOne(SESSION_REPOSITORIES, {
+							...key,
+							branch,
+							change_request_id: input.changeRequestId ?? null,
+							change_request_url: input.changeRequestUrl ?? null,
+							pushed_at: input.pushedAt ?? now,
+							updated_at: now,
+							created_at: now
+						}));
+					} catch (error) {
+						if (!(error instanceof UniqueViolationError)) throw error;
+						return update();
+					}
+				},
+				listBySession: async ({ sessionId }) => (await db().findMany(SESSION_REPOSITORIES, { session_id: sessionId }, { orderBy: [["created_at", "asc"]] })).map(toSessionRepository)
 			}
 		};
 	}
 };
 //#endregion
-export { SOURCE_CONTROL_SCHEMAS, SourceControlConnectionNotFoundError, SourceControlStorage };
+export { SOURCE_CONTROL_SCHEMAS, SessionOwnershipMismatchError, SourceControlConnectionNotFoundError, SourceControlStorage };
 
 //# sourceMappingURL=base.js.map