openship 0.1.0 → 0.1.1

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

@@ -0,0 +1,159 @@
+import { eq, and, isNull, desc, sql } from "drizzle-orm";
+import { generateId } from "@repo/core";
+import type { Database } from "../client";
+import { project, envVar } from "../schema";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type Project = typeof project.$inferSelect;
+export type NewProject = typeof project.$inferInsert;
+export type EnvVar = typeof envVar.$inferSelect;
+export type NewEnvVar = typeof envVar.$inferInsert;
+
+// ─── Repository ──────────────────────────────────────────────────────────────
+
+export function createProjectRepo(db: Database) {
+  return {
+    // ── Projects ───────────────────────────────────────────────────────
+
+    async findById(id: string) {
+      return db.query.project.findFirst({
+        where: and(eq(project.id, id), isNull(project.deletedAt)),
+      });
+    },
+
+    async findBySlug(userId: string, slug: string) {
+      return db.query.project.findFirst({
+        where: and(
+          eq(project.userId, userId),
+          eq(project.slug, slug),
+          isNull(project.deletedAt),
+        ),
+      });
+    },
+
+    async listByUser(userId: string, opts?: { page?: number; perPage?: number }) {
+      const page = opts?.page ?? 1;
+      const perPage = opts?.perPage ?? 20;
+      const offset = (page - 1) * perPage;
+
+      const rows = await db.query.project.findMany({
+        where: and(eq(project.userId, userId), isNull(project.deletedAt)),
+        orderBy: [desc(project.createdAt)],
+        limit: perPage,
+        offset,
+      });
+
+      const [{ value: total }] = await db
+        .select({ value: sql<number>`count(*)` })
+        .from(project)
+        .where(and(eq(project.userId, userId), isNull(project.deletedAt)));
+
+      return { rows, total: Number(total), page, perPage };
+    },
+
+    async create(data: Omit<NewProject, "id">) {
+      const id = generateId("proj");
+      const row = { id, ...data };
+      await db.insert(project).values(row);
+      return { ...row, createdAt: new Date(), updatedAt: new Date() } as Project;
+    },
+
+    async update(id: string, data: Partial<NewProject>) {
+      await db
+        .update(project)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(project.id, id));
+    },
+
+    /** Soft-delete a project */
+    async softDelete(id: string) {
+      await db
+        .update(project)
+        .set({ deletedAt: new Date(), updatedAt: new Date() })
+        .where(eq(project.id, id));
+    },
+
+    /** Set the active deployment for a project */
+    async setActiveDeployment(projectId: string, deploymentId: string | null) {
+      await db
+        .update(project)
+        .set({ activeDeploymentId: deploymentId, updatedAt: new Date() })
+        .where(eq(project.id, projectId));
+    },
+
+    // ── Environment variables ──────────────────────────────────────────
+
+    async listEnvVars(projectId: string, environment?: string) {
+      if (environment) {
+        return db.query.envVar.findMany({
+          where: and(
+            eq(envVar.projectId, projectId),
+            eq(envVar.environment, environment),
+          ),
+        });
+      }
+      return db.query.envVar.findMany({
+        where: eq(envVar.projectId, projectId),
+      });
+    },
+
+    async setEnvVar(data: Omit<NewEnvVar, "id">) {
+      const id = generateId("env");
+      const row = { id, ...data };
+      await db.insert(envVar).values(row);
+      return row;
+    },
+
+    async updateEnvVar(id: string, value: string) {
+      await db
+        .update(envVar)
+        .set({ value, updatedAt: new Date() })
+        .where(eq(envVar.id, id));
+    },
+
+    async deleteEnvVar(id: string) {
+      await db.delete(envVar).where(eq(envVar.id, id));
+    },
+
+    /** Bulk upsert env vars for a project + environment */
+    async bulkSetEnvVars(
+      projectId: string,
+      environment: string,
+      vars: { key: string; value: string; isSecret?: boolean }[],
+    ) {
+      // Delete existing for this project+environment, then re-insert
+      await db
+        .delete(envVar)
+        .where(and(eq(envVar.projectId, projectId), eq(envVar.environment, environment)));
+
+      if (vars.length === 0) return;
+
+      const rows = vars.map((v) => ({
+        id: generateId("env"),
+        projectId,
+        environment,
+        key: v.key,
+        value: v.value,
+        isSecret: v.isSecret ?? false,
+      }));
+
+      await db.insert(envVar).values(rows);
+    },
+
+    /** Get a map of env vars for injection into builds/containers */
+    async getEnvMap(projectId: string, environment: string): Promise<Record<string, string>> {
+      const rows = await db.query.envVar.findMany({
+        where: and(
+          eq(envVar.projectId, projectId),
+          eq(envVar.environment, environment),
+        ),
+      });
+      const map: Record<string, string> = {};
+      for (const row of rows) {
+        map[row.key] = row.value;
+      }
+      return map;
+    },
+  };
+}

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

@@ -0,0 +1,82 @@
+import { eq, and, lt, desc, count, sql } from "drizzle-orm";
+import type { Database } from "../client";
+import { session, user } from "../schema";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type Session = typeof session.$inferSelect;
+
+// ─── Repository ──────────────────────────────────────────────────────────────
+
+/**
+ * Session repository — query and manage auth sessions.
+ *
+ * Note: Better Auth handles session lifecycle (create, validate, refresh, revoke).
+ * This repo is for admin operations: listing, bulk cleanup, analytics, etc.
+ */
+export function createSessionRepo(db: Database) {
+  return {
+    /** Find session by ID */
+    async findById(id: string): Promise<Session | undefined> {
+      return db.query.session.findFirst({
+        where: eq(session.id, id),
+      });
+    },
+
+    /** Find session by token */
+    async findByToken(token: string): Promise<Session | undefined> {
+      return db.query.session.findFirst({
+        where: eq(session.token, token),
+      });
+    },
+
+    /** List active sessions for a user */
+    async listByUser(userId: string) {
+      return db.query.session.findMany({
+        where: eq(session.userId, userId),
+        orderBy: desc(session.createdAt),
+      });
+    },
+
+    /** Count active sessions for a user */
+    async countByUser(userId: string): Promise<number> {
+      const [result] = await db
+        .select({ count: count() })
+        .from(session)
+        .where(eq(session.userId, userId));
+      return result?.count ?? 0;
+    },
+
+    /** Delete all sessions for a user (force logout everywhere) */
+    async revokeAllForUser(userId: string): Promise<number> {
+      const result = await db
+        .delete(session)
+        .where(eq(session.userId, userId))
+        .returning();
+      return result.length;
+    },
+
+    /** Delete expired sessions (cleanup job) */
+    async purgeExpired(): Promise<number> {
+      const result = await db
+        .delete(session)
+        .where(lt(session.expiresAt, new Date()))
+        .returning();
+      return result.length;
+    },
+
+    /** Session with user info (join) */
+    async findWithUser(sessionId: string) {
+      const rows = await db
+        .select({
+          session: session,
+          user: user,
+        })
+        .from(session)
+        .innerJoin(user, eq(session.userId, user.id))
+        .where(eq(session.id, sessionId))
+        .limit(1);
+      return rows[0];
+    },
+  };
+}

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

@@ -0,0 +1,51 @@
+import { eq } from "drizzle-orm";
+import type { Database } from "../client";
+import { userSettings } from "../schema";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type UserSettings = typeof userSettings.$inferSelect;
+export type NewUserSettings = typeof userSettings.$inferInsert;
+
+// ─── Repository ──────────────────────────────────────────────────────────────
+
+export function createSettingsRepo(db: Database) {
+  return {
+    /** Get settings for a user (returns undefined if no row yet) */
+    async findByUser(userId: string): Promise<UserSettings | undefined> {
+      return db.query.userSettings.findFirst({
+        where: eq(userSettings.userId, userId),
+      });
+    },
+
+    /** Create or update (upsert) settings for a user */
+    async upsert(data: NewUserSettings): Promise<UserSettings> {
+      const [row] = await db
+        .insert(userSettings)
+        .values(data)
+        .onConflictDoUpdate({
+          target: userSettings.userId,
+          set: {
+            buildMode: data.buildMode,
+            cloudSessionToken: data.cloudSessionToken,
+            updatedAt: new Date(),
+          },
+        })
+        .returning();
+      return row;
+    },
+
+    /** Update a subset of settings fields */
+    async update(
+      userId: string,
+      data: Partial<Omit<NewUserSettings, "id" | "userId" | "createdAt">>,
+    ): Promise<UserSettings | undefined> {
+      const [row] = await db
+        .update(userSettings)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(userSettings.userId, userId))
+        .returning();
+      return row;
+    },
+  };
+}

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

@@ -0,0 +1,94 @@
+import { eq, and, ilike, count, desc, sql } from "drizzle-orm";
+import type { Database } from "../client";
+import { user } from "../schema";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type User = typeof user.$inferSelect;
+export type NewUser = typeof user.$inferInsert;
+
+// ─── Repository ──────────────────────────────────────────────────────────────
+
+/**
+ * User repository — all user-related database operations.
+ *
+ * Takes a `Database` instance so it works with any driver (pg or PGlite)
+ * and can be tested with a transaction-wrapped DB.
+ */
+export function createUserRepo(db: Database) {
+  return {
+    /** Find user by ID */
+    async findById(id: string): Promise<User | undefined> {
+      return db.query.user.findFirst({
+        where: eq(user.id, id),
+      });
+    },
+
+    /** Find user by email (case-insensitive) */
+    async findByEmail(email: string): Promise<User | undefined> {
+      return db.query.user.findFirst({
+        where: ilike(user.email, email),
+      });
+    },
+
+    /** List users with pagination */
+    async list(opts: { limit?: number; offset?: number; role?: string } = {}) {
+      const { limit = 50, offset = 0, role } = opts;
+      const where = role ? eq(user.role, role) : undefined;
+
+      const [rows, [total]] = await Promise.all([
+        db.query.user.findMany({
+          where,
+          limit,
+          offset,
+          orderBy: desc(user.createdAt),
+        }),
+        db.select({ count: count() }).from(user).where(where),
+      ]);
+
+      return { rows, total: total?.count ?? 0 };
+    },
+
+    /** Update user fields by ID */
+    async update(id: string, data: Partial<Omit<NewUser, "id">>) {
+      const [updated] = await db
+        .update(user)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(user.id, id))
+        .returning();
+      return updated;
+    },
+
+    /** Delete user by ID (cascades sessions & accounts via FK) */
+    async delete(id: string): Promise<boolean> {
+      const result = await db.delete(user).where(eq(user.id, id)).returning();
+      return result.length > 0;
+    },
+
+    /** Update user role */
+    async setRole(id: string, role: string) {
+      return db
+        .update(user)
+        .set({ role, updatedAt: new Date() })
+        .where(eq(user.id, id))
+        .returning();
+    },
+
+    /** Count users by role */
+    async countByRole(role: string): Promise<number> {
+      const [result] = await db
+        .select({ count: count() })
+        .from(user)
+        .where(eq(user.role, role));
+      return result?.count ?? 0;
+    },
+
+    /** Check if any user exists (useful for initial setup detection) */
+    async hasAnyUser(): Promise<boolean> {
+      const result = await db.query.user.findFirst({
+        columns: { id: true },
+      });
+      return !!result;
+    },
+  };
+}

package/packages/db/src/schema/auth.ts

@@ -0,0 +1,56 @@
+import { pgTable, text, timestamp, boolean } from "drizzle-orm/pg-core";
+
+// ─── Better Auth core tables ─────────────────────────────────────────────────
+// These tables are required by Better Auth. Column names must match exactly.
+
+export const user = pgTable("user", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  email: text("email").notNull().unique(),
+  emailVerified: boolean("email_verified").notNull().default(false),
+  image: text("image"),
+  role: text("role").notNull().default("user"), // custom: "user" | "admin"
+  autoProvisioned: boolean("auto_provisioned").notNull().default(false), // true for desktop local users
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+});
+
+export const session = pgTable("session", {
+  id: text("id").primaryKey(),
+  expiresAt: timestamp("expires_at").notNull(),
+  token: text("token").notNull().unique(),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+  ipAddress: text("ip_address"),
+  userAgent: text("user_agent"),
+  userId: text("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const account = pgTable("account", {
+  id: text("id").primaryKey(),
+  accountId: text("account_id").notNull(),
+  providerId: text("provider_id").notNull(),
+  userId: text("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+  accessToken: text("access_token"),
+  refreshToken: text("refresh_token"),
+  idToken: text("id_token"),
+  accessTokenExpiresAt: timestamp("access_token_expires_at"),
+  refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+  scope: text("scope"),
+  password: text("password"),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+});
+
+export const verification = pgTable("verification", {
+  id: text("id").primaryKey(),
+  identifier: text("identifier").notNull(),
+  value: text("value").notNull(),
+  expiresAt: timestamp("expires_at").notNull(),
+  createdAt: timestamp("created_at").defaultNow(),
+  updatedAt: timestamp("updated_at").defaultNow(),
+});

package/packages/db/src/schema/deployment.ts

@@ -0,0 +1,87 @@
+import {
+  pgTable,
+  text,
+  timestamp,
+  integer,
+  jsonb,
+} from "drizzle-orm/pg-core";
+import { project } from "./project";
+import { user } from "./auth";
+
+// ─── Deployments ─────────────────────────────────────────────────────────────
+
+/**
+ * Deployment records. Each deployment represents a single build → deploy cycle.
+ * Many deployments belong to one project. Only one is "active" at a time.
+ */
+export const deployment = pgTable("deployment", {
+  id: text("id").primaryKey(), // "dep_..."
+  projectId: text("project_id")
+    .notNull()
+    .references(() => project.id, { onDelete: "cascade" }),
+  userId: text("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+
+  /* ── Git snapshot ───────────────────────────────────────────────────── */
+  branch: text("branch").notNull(),
+  commitSha: text("commit_sha"),
+  commitMessage: text("commit_message"),
+
+  /* ── Build details ──────────────────────────────────────────────────── */
+  /** Environment: production | preview */
+  environment: text("environment").notNull().default("production"),
+  /** Detected or configured framework */
+  framework: text("framework"),
+  /** Build status */
+  status: text("status").notNull().default("queued"),
+  /** Image/snapshot reference produced by build */
+  imageRef: text("image_ref"),
+  /** Build duration in milliseconds */
+  buildDurationMs: integer("build_duration_ms"),
+
+  /* ── Container details ──────────────────────────────────────────────── */
+  /** Adapter container ID (for stop/start/destroy) */
+  containerId: text("container_id"),
+  /** External URL where deployment is reachable */
+  url: text("url"),
+
+  /* ── Metadata ───────────────────────────────────────────────────────── */
+  /** JSON: snapshot of build config used for this deployment */
+  meta: jsonb("meta"),
+  /** JSON: encrypted environment variables snapshot for this deployment */
+  envVars: jsonb("env_vars"),
+  /** Error message if failed */
+  errorMessage: text("error_message"),
+
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+});
+
+// ─── Build sessions ──────────────────────────────────────────────────────────
+
+/**
+ * Build session tracking — used for SSE log streaming.
+ * A build session maps 1:1 with a deployment during the build phase.
+ * Logs are stored here for replay after the session ends.
+ */
+export const buildSession = pgTable("build_session", {
+  id: text("id").primaryKey(), // "bld_..."
+  deploymentId: text("deployment_id")
+    .notNull()
+    .references(() => deployment.id, { onDelete: "cascade" }),
+  projectId: text("project_id")
+    .notNull()
+    .references(() => project.id, { onDelete: "cascade" }),
+
+  /** Build session status */
+  status: text("status").notNull().default("queued"),
+  /** JSON array of log entries for replay */
+  logs: jsonb("logs"),
+  /** Build duration in milliseconds */
+  durationMs: integer("duration_ms"),
+
+  startedAt: timestamp("started_at"),
+  finishedAt: timestamp("finished_at"),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+});

package/packages/db/src/schema/domain.ts

@@ -0,0 +1,46 @@
+import {
+  pgTable,
+  text,
+  timestamp,
+  boolean,
+} from "drizzle-orm/pg-core";
+import { project } from "./project";
+
+// ─── Domains ─────────────────────────────────────────────────────────────────
+
+/**
+ * Custom domains linked to projects.
+ * Each domain goes through a verification flow (DNS TXT record check)
+ * before becoming active and getting SSL provisioned.
+ */
+export const domain = pgTable("domain", {
+  id: text("id").primaryKey(), // "dom_..."
+  projectId: text("project_id")
+    .notNull()
+    .references(() => project.id, { onDelete: "cascade" }),
+
+  /** The custom domain (e.g. "app.example.com") */
+  hostname: text("hostname").notNull().unique(),
+  /** Is this the primary domain for the project? */
+  isPrimary: boolean("is_primary").notNull().default(false),
+
+  /* ── Verification ───────────────────────────────────────────────────── */
+  /** Domain status: pending | active | failed | removing */
+  status: text("status").notNull().default("pending"),
+  /** DNS TXT verification value (e.g. "openship-verify=abc123") */
+  verificationToken: text("verification_token"),
+  /** Whether DNS verification has passed */
+  verified: boolean("verified").notNull().default(false),
+  verifiedAt: timestamp("verified_at"),
+
+  /* ── SSL ─────────────────────────────────────────────────────────────── */
+  /** SSL status: none | provisioning | active | expired | error */
+  sslStatus: text("ssl_status").notNull().default("none"),
+  /** Issuer (e.g. "letsencrypt", "oblien") */
+  sslIssuer: text("ssl_issuer"),
+  /** When the current certificate expires */
+  sslExpiresAt: timestamp("ssl_expires_at"),
+
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+});

package/packages/db/src/schema/github.ts

@@ -0,0 +1,24 @@
+import { pgTable, text, timestamp, boolean, integer } from "drizzle-orm/pg-core";
+import { user } from "./auth";
+
+// ─── GitHub App installation tracking ────────────────────────────────────────
+
+/**
+ * Tracks GitHub App installations per user.
+ * Each row represents one installation (user or org account).
+ */
+export const gitInstallation = pgTable("git_installation", {
+  id: text("id").primaryKey(),
+  userId: text("user_id")
+    .notNull()
+    .references(() => user.id, { onDelete: "cascade" }),
+  provider: text("provider").notNull().default("github"), // future: gitlab, bitbucket
+  installationId: integer("installation_id").notNull(),
+  owner: text("owner").notNull(), // GitHub account login (user or org)
+  ownerType: text("owner_type").notNull().default("User"), // "User" | "Organization"
+  providerUserId: text("provider_user_id"), // GitHub sender.id
+  providerOwnerId: text("provider_owner_id"), // GitHub account.id
+  isOrg: boolean("is_org").notNull().default(false),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+});

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

@@ -0,0 +1,6 @@
+export { user, session, account, verification } from "./auth";
+export { gitInstallation } from "./github";
+export { project, envVar } from "./project";
+export { deployment, buildSession } from "./deployment";
+export { domain } from "./domain";
+export { userSettings, instanceSettings } from "./settings";