@mastra/factory 0.2.2-alpha.0 → 0.2.2-alpha.2

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

@@ -1,721 +1,796 @@
-// src/storage/domains/source-control/base.ts
 import { FactoryStorageDomain, UniqueViolationError } from "@mastra/core/storage";
-var FACTORY_PROJECTS = "factory_projects";
-var INSTALLATIONS = "source_control_installations";
-var REPOSITORIES = "source_control_repositories";
-var CONNECTIONS = "factory_project_source_control_connections";
-var PROJECT_REPOSITORIES = "factory_project_repositories";
-var SANDBOXES = "source_control_project_repository_sandboxes";
-var WORKTREES = "source_control_worktrees";
-var SESSIONS = "source_control_sessions";
-var 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: 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"]
-      }
-    ]
-  }
+//#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 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: 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
-  };
+	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
-  };
+	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
-  };
+	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
-  };
+	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
-  };
+	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 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
-  };
+	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
-  };
+	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(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;
-      const project = await db().findOne(FACTORY_PROJECTS, {
-        id: row.factory_project_id,
-        org_id: args.orgId
-      });
-      if (!project || !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;
-      const connection = await db().findOne(CONNECTIONS, {
-        id: row.connection_id,
-        integration_id: integrationId
-      });
-      return connection ? 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) => {
-          const row = 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()
-            }
-          );
-          return toInstallation(row);
-        },
-        delete: async ({ orgId, id }) => {
-          const installation = await getInstallation({ orgId, id });
-          if (!installation) 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();
-          const row = 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
-          });
-          return toRepository(row);
-        }
-      },
-      connections: {
-        list: async ({ orgId, factoryProjectId }) => {
-          const project = await db().findOne(FACTORY_PROJECTS, {
-            id: factoryProjectId,
-            org_id: orgId
-          });
-          if (!project) return [];
-          return (await db().findMany(CONNECTIONS, {
-            factory_project_id: factoryProjectId,
-            integration_id: integrationId
-          })).map(toConnection);
-        },
-        get: getConnection,
-        create: async (input) => {
-          const project = await db().findOne(FACTORY_PROJECTS, {
-            id: input.factoryProjectId,
-            org_id: input.orgId
-          });
-          if (!project) throw new Error("Factory project not found for this organization.");
-          await requireInstallation({ orgId: input.orgId, id: input.installationId });
-          try {
-            const row = 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()
-            });
-            return toConnection(row);
-          } 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 }) => {
-          const connection = await getConnection({ orgId, id });
-          if (!connection) 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(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);
-        },
-        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;
-              const project = await db().findOne(FACTORY_PROJECTS, {
-                id: connection.factory_project_id,
-                org_id: installation.org_id
-              });
-              if (!project) 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 });
-          const repository = await requireRepository({ orgId: input.orgId, id: input.repositoryId });
-          if (repository.installationId !== connection.installationId) {
-            throw new Error("Repository does not belong to the connection installation.");
-          }
-          const now = /* @__PURE__ */ new Date();
-          const row = 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
-            }
-          );
-          return toProjectRepository(row);
-        },
-        update: async ({ orgId, id, input }) => {
-          const existing = await getProjectRepository({ orgId, id });
-          if (!existing) 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 }) => {
-          const existing = await getProjectRepository({ orgId, id });
-          if (!existing) return false;
-          await db().deleteMany(SESSIONS, { project_repository_id: id });
-          await db().deleteMany(WORKTREES, { 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 {
-            const row = await db().insertOne(SANDBOXES, {
-              ...where,
-              sandbox_id: null,
-              sandbox_workdir: projectRepository.sandboxWorkdir,
-              materialized_at: null,
-              created_at: /* @__PURE__ */ new Date()
-            });
-            return toSandbox(row);
-          } 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),
-        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() });
-        }
-      },
-      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 [];
-          const rows = await db().findMany(WORKTREES, {
-            project_repository_id: projectRepositoryId,
-            user_id: userId
-          });
-          return rows.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 {
-            const row = 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
-            });
-            return toSession(row);
-          } 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 });
-        }
-      }
-    };
-  }
-};
-export {
-  SOURCE_CONTROL_SCHEMAS,
-  SourceControlStorage
+	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(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
+					}));
+				}
+			},
+			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(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);
+				},
+				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(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() });
+				}
+			},
+			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