openship 0.1.0 → 0.1.1

package/packages/db/src/index.ts

@@ -1,11 +1,60 @@
-import { PrismaClient } from "@prisma/client";
+// ─── Database client ─────────────────────────────────────────────────────────
+export { db, getDriver, type Database, type Driver } from "./client";
 
-const globalForPrisma = globalThis as unknown as { prisma: PrismaClient | undefined };
+// ─── Schema (table definitions) ──────────────────────────────────────────────
+export * as schema from "./schema";
 
-export const db = globalForPrisma.prisma ?? new PrismaClient();
+// ─── Repositories (all DB access goes through here) ──────────────────────────
+export {
+  repos,
+  createUserRepo,
+  createSessionRepo,
+  createAccountRepo,
+  createGitInstallationRepo,
+  createProjectRepo,
+  createDeploymentRepo,
+  createDomainRepo,
+  createSettingsRepo,
+  type User,
+  type NewUser,
+  type Session,
+  type Account,
+  type GitInstallation,
+  type NewGitInstallation,
+  type Project,
+  type NewProject,
+  type EnvVar,
+  type NewEnvVar,
+  type Deployment,
+  type NewDeployment,
+  type BuildSession,
+  type NewBuildSession,
+  type Domain,
+  type NewDomain,
+  type UserSettings,
+  type NewUserSettings,
+} from "./repos";
 
-if (process.env.NODE_ENV !== "production") {
-  globalForPrisma.prisma = db;
-}
-
-export * from "@prisma/client";
+// ─── Drizzle operators (re-exported for convenience) ─────────────────────────
+export {
+  eq,
+  ne,
+  and,
+  or,
+  not,
+  gt,
+  gte,
+  lt,
+  lte,
+  like,
+  ilike,
+  inArray,
+  notInArray,
+  isNull,
+  isNotNull,
+  between,
+  desc,
+  asc,
+  sql,
+  count,
+} from "drizzle-orm";

package/packages/db/src/repos/account.repo.ts

@@ -0,0 +1,92 @@
+import { eq, and, count } from "drizzle-orm";
+import type { Database } from "../client";
+import { account, user } from "../schema";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type Account = typeof account.$inferSelect;
+
+// ─── Repository ──────────────────────────────────────────────────────────────
+
+/**
+ * Account repository — OAuth account links.
+ *
+ * Better Auth manages account CRUD during OAuth flows.
+ * This repo is for admin queries: listing linked providers, unlinking, etc.
+ */
+export function createAccountRepo(db: Database) {
+  return {
+    /** List all linked accounts for a user */
+    async listByUser(userId: string) {
+      return db.query.account.findMany({
+        where: eq(account.userId, userId),
+      });
+    },
+
+    /** Find a specific provider link for a user */
+    async findByProvider(userId: string, providerId: string) {
+      return db.query.account.findFirst({
+        where: and(
+          eq(account.userId, userId),
+          eq(account.providerId, providerId)
+        ),
+      });
+    },
+
+    /** Check if user has a password (email+password account) */
+    async hasPassword(userId: string): Promise<boolean> {
+      const cred = await db.query.account.findFirst({
+        where: and(
+          eq(account.userId, userId),
+          eq(account.providerId, "credential")
+        ),
+        columns: { id: true },
+      });
+      return !!cred;
+    },
+
+    /** Count linked providers for a user */
+    async countProviders(userId: string): Promise<number> {
+      const [result] = await db
+        .select({ count: count() })
+        .from(account)
+        .where(eq(account.userId, userId));
+      return result?.count ?? 0;
+    },
+
+    /** Unlink an OAuth provider (admin action) */
+    async unlinkProvider(userId: string, providerId: string): Promise<boolean> {
+      const result = await db
+        .delete(account)
+        .where(
+          and(
+            eq(account.userId, userId),
+            eq(account.providerId, providerId)
+          )
+        )
+        .returning();
+      return result.length > 0;
+    },
+
+    /** Account with user info (join) */
+    async findWithUser(accountId: string) {
+      const rows = await db
+        .select({ account: account, user: user })
+        .from(account)
+        .innerJoin(user, eq(account.userId, user.id))
+        .where(eq(account.id, accountId))
+        .limit(1);
+      return rows[0];
+    },
+
+    /** Find account by provider + provider account ID (e.g. GitHub user id) */
+    async findByProviderAccountId(providerId: string, providerAccountId: string) {
+      return db.query.account.findFirst({
+        where: and(
+          eq(account.providerId, providerId),
+          eq(account.accountId, providerAccountId),
+        ),
+      });
+    },
+  };
+}

package/packages/db/src/repos/deployment.repo.ts

@@ -0,0 +1,168 @@
+import { eq, and, desc, sql } from "drizzle-orm";
+import { generateId } from "@repo/core";
+import type { Database } from "../client";
+import { deployment, buildSession } from "../schema";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type Deployment = typeof deployment.$inferSelect;
+export type NewDeployment = typeof deployment.$inferInsert;
+export type BuildSession = typeof buildSession.$inferSelect;
+export type NewBuildSession = typeof buildSession.$inferInsert;
+
+// ─── Repository ──────────────────────────────────────────────────────────────
+
+export function createDeploymentRepo(db: Database) {
+  return {
+    // ── Deployments ────────────────────────────────────────────────────
+
+    async findById(id: string) {
+      return db.query.deployment.findFirst({
+        where: eq(deployment.id, id),
+      });
+    },
+
+    async listByProject(
+      projectId: string,
+      opts?: { page?: number; perPage?: number; environment?: string },
+    ) {
+      const page = opts?.page ?? 1;
+      const perPage = opts?.perPage ?? 20;
+      const offset = (page - 1) * perPage;
+
+      const conditions = [eq(deployment.projectId, projectId)];
+      if (opts?.environment) {
+        conditions.push(eq(deployment.environment, opts.environment));
+      }
+
+      const rows = await db.query.deployment.findMany({
+        where: and(...conditions),
+        orderBy: [desc(deployment.createdAt)],
+        limit: perPage,
+        offset,
+      });
+
+      const [{ value: total }] = await db
+        .select({ value: sql<number>`count(*)` })
+        .from(deployment)
+        .where(and(...conditions));
+
+      return { rows, total: Number(total), page, perPage };
+    },
+
+    async listByUser(
+      userId: string,
+      opts?: { page?: number; perPage?: number },
+    ) {
+      const page = opts?.page ?? 1;
+      const perPage = opts?.perPage ?? 50;
+      const offset = (page - 1) * perPage;
+
+      const rows = await db.query.deployment.findMany({
+        where: eq(deployment.userId, userId),
+        orderBy: [desc(deployment.createdAt)],
+        limit: perPage,
+        offset,
+      });
+
+      const [{ value: total }] = await db
+        .select({ value: sql<number>`count(*)` })
+        .from(deployment)
+        .where(eq(deployment.userId, userId));
+
+      return { rows, total: Number(total), page, perPage };
+    },
+
+    async create(data: Omit<NewDeployment, "id">) {
+      const id = generateId("dep");
+      const row = { id, ...data };
+      await db.insert(deployment).values(row);
+      return { ...row, createdAt: new Date(), updatedAt: new Date() } as Deployment;
+    },
+
+    async updateStatus(id: string, status: string, extra?: Partial<NewDeployment>) {
+      await db
+        .update(deployment)
+        .set({ status, ...extra, updatedAt: new Date() })
+        .where(eq(deployment.id, id));
+    },
+
+    async setContainerId(id: string, containerId: string, url?: string) {
+      await db
+        .update(deployment)
+        .set({ containerId, url, updatedAt: new Date() })
+        .where(eq(deployment.id, id));
+    },
+
+    /** Find the most recent deployment for a project (any status) */
+    async findLatestByProject(projectId: string) {
+      return db.query.deployment.findFirst({
+        where: eq(deployment.projectId, projectId),
+        orderBy: [desc(deployment.createdAt)],
+      });
+    },
+
+    /** Find the most recent successful deployment for rollback */
+    async findLatestReady(projectId: string, environment: string) {
+      return db.query.deployment.findFirst({
+        where: and(
+          eq(deployment.projectId, projectId),
+          eq(deployment.environment, environment),
+          eq(deployment.status, "ready"),
+        ),
+        orderBy: [desc(deployment.createdAt)],
+      });
+    },
+
+    // ── Build sessions ─────────────────────────────────────────────────
+
+    async createBuildSession(data: Omit<NewBuildSession, "id">) {
+      const id = generateId("bld");
+      const row = { id, ...data };
+      await db.insert(buildSession).values(row);
+      return { ...row, createdAt: new Date() } as BuildSession;
+    },
+
+    async findBuildSession(id: string) {
+      return db.query.buildSession.findFirst({
+        where: eq(buildSession.id, id),
+      });
+    },
+
+    async findBuildSessionByDeploymentId(deploymentId: string) {
+      return db.query.buildSession.findFirst({
+        where: eq(buildSession.deploymentId, deploymentId),
+        orderBy: [desc(buildSession.createdAt)],
+      });
+    },
+
+    async updateBuildSession(id: string, data: Partial<NewBuildSession>) {
+      await db
+        .update(buildSession)
+        .set(data)
+        .where(eq(buildSession.id, id));
+    },
+
+    async finishBuildSession(id: string, status: string, durationMs: number, logs?: unknown[]) {
+      await db
+        .update(buildSession)
+        .set({
+          status,
+          durationMs,
+          logs: logs as never,
+          finishedAt: new Date(),
+        })
+        .where(eq(buildSession.id, id));
+    },
+
+    async deleteDeployment(id: string) {
+      await db.delete(buildSession).where(eq(buildSession.deploymentId, id));
+      await db.delete(deployment).where(eq(deployment.id, id));
+    },
+
+    async deleteByProjectId(projectId: string) {
+      await db.delete(buildSession).where(eq(buildSession.projectId, projectId));
+      await db.delete(deployment).where(eq(deployment.projectId, projectId));
+    },
+  };
+}

package/packages/db/src/repos/domain.repo.ts

@@ -0,0 +1,102 @@
+import { eq, and, lt } from "drizzle-orm";
+import { generateId } from "@repo/core";
+import type { Database } from "../client";
+import { domain } from "../schema";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type Domain = typeof domain.$inferSelect;
+export type NewDomain = typeof domain.$inferInsert;
+
+// ─── Repository ──────────────────────────────────────────────────────────────
+
+export function createDomainRepo(db: Database) {
+  return {
+    async findById(id: string) {
+      return db.query.domain.findFirst({
+        where: eq(domain.id, id),
+      });
+    },
+
+    async findByHostname(hostname: string) {
+      return db.query.domain.findFirst({
+        where: eq(domain.hostname, hostname.toLowerCase()),
+      });
+    },
+
+    async listByProject(projectId: string) {
+      return db.query.domain.findMany({
+        where: eq(domain.projectId, projectId),
+      });
+    },
+
+    async create(data: Omit<NewDomain, "id"> & { verificationToken?: string }) {
+      const id = generateId("dom");
+      const row = {
+        id,
+        ...data,
+        hostname: data.hostname.toLowerCase(),
+        verificationToken: data.verificationToken ?? id,
+      };
+      await db.insert(domain).values(row);
+      return { ...row, createdAt: new Date(), updatedAt: new Date() } as Domain;
+    },
+
+    async markVerified(id: string) {
+      await db
+        .update(domain)
+        .set({
+          verified: true,
+          verifiedAt: new Date(),
+          status: "active",
+          updatedAt: new Date(),
+        })
+        .where(eq(domain.id, id));
+    },
+
+    async updateSsl(
+      id: string,
+      data: { sslStatus: string; sslIssuer?: string; sslExpiresAt?: Date },
+    ) {
+      await db
+        .update(domain)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(domain.id, id));
+    },
+
+    async updateStatus(id: string, status: string) {
+      await db
+        .update(domain)
+        .set({ status, updatedAt: new Date() })
+        .where(eq(domain.id, id));
+    },
+
+    async remove(id: string) {
+      await db.delete(domain).where(eq(domain.id, id));
+    },
+
+    /** Find all domains needing SSL renewal */
+    async findExpiringSsl(beforeDate: Date) {
+      return db.query.domain.findMany({
+        where: and(
+          eq(domain.sslStatus, "active"),
+          lt(domain.sslExpiresAt, beforeDate),
+        ),
+      });
+    },
+
+    /** Set primary domain for a project (unsets previous primary) */
+    async setPrimary(projectId: string, domainId: string) {
+      // Unset current primary
+      await db
+        .update(domain)
+        .set({ isPrimary: false, updatedAt: new Date() })
+        .where(and(eq(domain.projectId, projectId), eq(domain.isPrimary, true)));
+      // Set new primary
+      await db
+        .update(domain)
+        .set({ isPrimary: true, updatedAt: new Date() })
+        .where(eq(domain.id, domainId));
+    },
+  };
+}

package/packages/db/src/repos/git-installation.repo.ts

@@ -0,0 +1,95 @@
+import { eq, and } from "drizzle-orm";
+import { randomUUID } from "crypto";
+import type { Database } from "../client";
+import { gitInstallation } from "../schema";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type GitInstallation = typeof gitInstallation.$inferSelect;
+export type NewGitInstallation = typeof gitInstallation.$inferInsert;
+
+// ─── Repository ──────────────────────────────────────────────────────────────
+
+export function createGitInstallationRepo(db: Database) {
+  return {
+    /** Find installation by user + owner */
+    async findByOwner(userId: string, owner: string) {
+      return db.query.gitInstallation.findFirst({
+        where: and(
+          eq(gitInstallation.userId, userId),
+          eq(gitInstallation.provider, "github"),
+          eq(gitInstallation.owner, owner.toLowerCase()),
+        ),
+      });
+    },
+
+    /** Find all installations for a user */
+    async listByUser(userId: string) {
+      return db.query.gitInstallation.findMany({
+        where: and(
+          eq(gitInstallation.userId, userId),
+          eq(gitInstallation.provider, "github"),
+        ),
+      });
+    },
+
+    /** Upsert installation (create or update installation_id) */
+    async upsert(data: Omit<NewGitInstallation, "id">) {
+      const existing = await this.findByOwner(data.userId, data.owner);
+
+      if (existing) {
+        await db
+          .update(gitInstallation)
+          .set({
+            installationId: data.installationId,
+            updatedAt: new Date(),
+          })
+          .where(eq(gitInstallation.id, existing.id));
+        return { ...existing, installationId: data.installationId };
+      }
+
+      const id = randomUUID();
+      const row = { id, ...data, owner: data.owner.toLowerCase() };
+      await db.insert(gitInstallation).values(row);
+      return { ...row, createdAt: new Date(), updatedAt: new Date() };
+    },
+
+    /** Remove installation by user + owner */
+    async removeByOwner(userId: string, owner: string) {
+      return db
+        .delete(gitInstallation)
+        .where(
+          and(
+            eq(gitInstallation.userId, userId),
+            eq(gitInstallation.provider, "github"),
+            eq(gitInstallation.owner, owner.toLowerCase()),
+          ),
+        );
+    },
+
+    /** Remove installation by installation_id */
+    async removeByInstallationId(userId: string, installationId: number) {
+      return db
+        .delete(gitInstallation)
+        .where(
+          and(
+            eq(gitInstallation.userId, userId),
+            eq(gitInstallation.provider, "github"),
+            eq(gitInstallation.installationId, installationId),
+          ),
+        );
+    },
+
+    /** Remove all GitHub installations for a user */
+    async removeAllForUser(userId: string) {
+      return db
+        .delete(gitInstallation)
+        .where(
+          and(
+            eq(gitInstallation.userId, userId),
+            eq(gitInstallation.provider, "github"),
+          ),
+        );
+    },
+  };
+}

package/packages/db/src/repos/index.ts

@@ -0,0 +1,43 @@
+export { createUserRepo, type User, type NewUser } from "./user.repo";
+export { createSessionRepo, type Session } from "./session.repo";
+export { createAccountRepo, type Account } from "./account.repo";
+export { createGitInstallationRepo, type GitInstallation, type NewGitInstallation } from "./git-installation.repo";
+export { createProjectRepo, type Project, type NewProject, type EnvVar, type NewEnvVar } from "./project.repo";
+export { createDeploymentRepo, type Deployment, type NewDeployment, type BuildSession, type NewBuildSession } from "./deployment.repo";
+export { createDomainRepo, type Domain, type NewDomain } from "./domain.repo";
+export { createSettingsRepo, type UserSettings, type NewUserSettings } from "./settings.repo";
+export { createInstanceSettingsRepo, type InstanceSettings, type NewInstanceSettings } from "./instance-settings.repo";
+
+// ─── Convenience: pre-bound repos using the singleton db ─────────────────────
+
+import { db } from "../client";
+import { createUserRepo } from "./user.repo";
+import { createSessionRepo } from "./session.repo";
+import { createAccountRepo } from "./account.repo";
+import { createGitInstallationRepo } from "./git-installation.repo";
+import { createProjectRepo } from "./project.repo";
+import { createDeploymentRepo } from "./deployment.repo";
+import { createDomainRepo } from "./domain.repo";
+import { createSettingsRepo } from "./settings.repo";
+import { createInstanceSettingsRepo } from "./instance-settings.repo";
+
+/**
+ * Pre-bound repository instances using the singleton `db`.
+ *
+ * Usage:
+ *   import { repos } from "@repo/db";
+ *   const user = await repos.user.findByEmail("test@example.com");
+ *
+ * For testing, create isolated repos with `createUserRepo(testDb)` etc.
+ */
+export const repos = {
+  user: createUserRepo(db),
+  session: createSessionRepo(db),
+  account: createAccountRepo(db),
+  gitInstallation: createGitInstallationRepo(db),
+  project: createProjectRepo(db),
+  deployment: createDeploymentRepo(db),
+  domain: createDomainRepo(db),
+  settings: createSettingsRepo(db),
+  instanceSettings: createInstanceSettingsRepo(db),
+} as const;

package/packages/db/src/repos/instance-settings.repo.ts

@@ -0,0 +1,43 @@
+import { eq } from "drizzle-orm";
+import type { Database } from "../client";
+import { instanceSettings } from "../schema";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type InstanceSettings = typeof instanceSettings.$inferSelect;
+export type NewInstanceSettings = typeof instanceSettings.$inferInsert;
+
+// ─── Repository ──────────────────────────────────────────────────────────────
+
+const DEFAULT_ID = "default";
+
+export function createInstanceSettingsRepo(db: Database) {
+  return {
+    /** Get the singleton instance settings row */
+    async get(): Promise<InstanceSettings | undefined> {
+      return db.query.instanceSettings.findFirst({
+        where: eq(instanceSettings.id, DEFAULT_ID),
+      });
+    },
+
+    /** Create or update instance settings (upsert on the single row) */
+    async upsert(
+      data: Omit<NewInstanceSettings, "id" | "createdAt">,
+    ): Promise<InstanceSettings> {
+      const [row] = await db
+        .insert(instanceSettings)
+        .values({ id: DEFAULT_ID, ...data })
+        .onConflictDoUpdate({
+          target: instanceSettings.id,
+          set: { ...data, updatedAt: new Date() },
+        })
+        .returning();
+      return row;
+    },
+
+    /** Delete the singleton instance settings row (removes server) */
+    async delete(): Promise<void> {
+      await db.delete(instanceSettings).where(eq(instanceSettings.id, DEFAULT_ID));
+    },
+  };
+}