openship 0.1.1 → 0.1.7

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

@@ -1,159 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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";