openship 0.1.1 → 0.1.8

package/packages/db/src/index.ts

@@ -1,60 +0,0 @@
-// ─── Database client ─────────────────────────────────────────────────────────
-export { db, getDriver, type Database, type Driver } from "./client";
-
-// ─── Schema (table definitions) ──────────────────────────────────────────────
-export * as schema from "./schema";
-
-// ─── 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";
-
-// ─── 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

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

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

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

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

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

@@ -1,43 +0,0 @@
-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));
-    },
-  };
-}