@mastra/factory 0.0.0 → 0.1.0-alpha.3

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

@@ -0,0 +1,722 @@
+// 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"]
+      }
+    ]
+  }
+];
+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 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(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, installationId, externalId }) => {
+          await requireInstallation({ orgId, id: installationId });
+          const row = await db().findOne(REPOSITORIES, {
+            installation_id: installationId,
+            external_id: externalId
+          });
+          return row ? toRepository(row) : 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
+};
+//# sourceMappingURL=base.js.map