bopodev-db 0.1.28 → 0.1.30

package/src/client.ts

@@ -1,8 +1,16 @@
 import { existsSync, readFileSync, rmSync } from "node:fs";
-import { mkdir, open, readFile, rm, writeFile, type FileHandle } from "node:fs/promises";
-import { createServer } from "node:net";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+/** Default export is `lock()` — see proper-lockfile `index.js`. */
+const acquireProperLockfile = require("proper-lockfile") as (
+  path: string,
+  options?: Record<string, unknown>
+) => Promise<() => Promise<void>>;
+import detectPort from "detect-port";
 import EmbeddedPostgresModule from "embedded-postgres";
 import { drizzle, type PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import { migrate } from "drizzle-orm/postgres-js/migrator";
@@ -21,7 +29,11 @@ const DEFAULT_DB_NAME = "bopodev";
 const DEFAULT_DB_USER = "bopodev";
 const DEFAULT_DB_PASSWORD = "bopodev";
 const DEFAULT_DB_PORT = Number(process.env.BOPO_DB_PORT ?? "55432");
-const EMBEDDED_DB_START_TIMEOUT_MS = Number(process.env.BOPO_DB_START_TIMEOUT_MS ?? "15000");
+const EMBEDDED_DB_START_TIMEOUT_MS = Number(process.env.BOPO_DB_START_TIMEOUT_MS ?? "120000");
+const EMBEDDED_DB_LOCK_STALE_MS = Math.max(
+  5000,
+  Number(process.env.BOPO_DB_LOCK_STALE_MS ?? "60000")
+);
 const LOCAL_DB_STATE_VERSION = 1;
 type EmbeddedPostgresInstance = {
   initialise(): Promise<void>;
@@ -62,8 +74,7 @@ type LocalDbState = {
 };
 
 type LocalDbLock = {
-  path: string;
-  handle: FileHandle;
+  release: () => Promise<void>;
 };
 
 type MigrationVersion = {
@@ -198,53 +209,67 @@ export async function ensureDatabaseTarget(dbPath: string = defaultDbPath): Prom
 
 async function ensureEmbeddedPostgresTarget(dataPath: string): Promise<DatabaseTarget> {
   await mkdir(dataPath, { recursive: true });
-  const lock = await acquireLocalDbLock(dataPath, EMBEDDED_DB_START_TIMEOUT_MS);
   const statePath = resolveLocalDbStatePath(dataPath);
-  await writeLocalDbState(statePath, {
-    version: LOCAL_DB_STATE_VERSION,
-    source: "embedded-postgres",
-    phase: "initializing",
-    pid: process.pid,
-    port: DEFAULT_DB_PORT,
-    dataPath,
-    updatedAt: new Date().toISOString(),
-    expectedMigrationCount: EXPECTED_MIGRATION_VERSION.count,
-    lastError: null
-  });
+  const configuredPort = DEFAULT_DB_PORT;
+  const resolvedDataPath = resolve(dataPath);
 
-  const postmasterPidFile = resolve(dataPath, "postmaster.pid");
+  const reused = await tryReuseEmbeddedPostgres(resolvedDataPath, statePath, configuredPort);
+  if (reused) {
+    return reused;
+  }
+
+  const lock = await acquireLocalDbLock(dataPath, EMBEDDED_DB_START_TIMEOUT_MS);
+  let lockReleased = false;
   try {
-    const runningPid = readRunningPostmasterPid(postmasterPidFile);
-    if (runningPid) {
-      await waitForPostmasterExit(postmasterPidFile, EMBEDDED_DB_START_TIMEOUT_MS);
-      const activePid = readRunningPostmasterPid(postmasterPidFile);
-      if (activePid) {
-        throw new Error(
-          `Embedded Postgres data path '${dataPath}' is still in use by pid ${activePid}. Stop the other process or wait for it to exit.`
-        );
-      }
+    const reusedAfterLock = await tryReuseEmbeddedPostgres(resolvedDataPath, statePath, configuredPort);
+    if (reusedAfterLock) {
+      await releaseLocalDbLock(lock);
+      lockReleased = true;
+      return reusedAfterLock;
     }
+
+    const postmasterPidFile = resolve(resolvedDataPath, "postmaster.pid");
     if (existsSync(postmasterPidFile)) {
-      rmSync(postmasterPidFile, { force: true });
+      const pm = readPostmasterPidFile(postmasterPidFile);
+      if (!pm || !isPidAlive(pm.pid)) {
+        // eslint-disable-next-line no-console
+        console.warn("[bopodev-db] Removing stale embedded Postgres postmaster.pid");
+        rmSync(postmasterPidFile, { force: true });
+      }
     }
-    if (await isPortInUse(DEFAULT_DB_PORT)) {
-      throw new Error(
-        `Embedded Postgres port ${DEFAULT_DB_PORT} is already in use. Stop the process using that port or set BOPO_DB_PORT before retrying.`
+
+    const selectedPort = await detectPort(configuredPort);
+    if (selectedPort !== configuredPort) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[bopodev-db] Embedded Postgres port ${configuredPort} is in use; using ${selectedPort}. Set BOPO_DB_PORT to pin a port.`
       );
     }
 
+    await writeLocalDbState(statePath, {
+      version: LOCAL_DB_STATE_VERSION,
+      source: "embedded-postgres",
+      phase: "initializing",
+      pid: process.pid,
+      port: selectedPort,
+      dataPath: resolvedDataPath,
+      updatedAt: new Date().toISOString(),
+      expectedMigrationCount: EXPECTED_MIGRATION_VERSION.count,
+      lastError: null
+    });
+
     const instance = new EmbeddedPostgres({
-      databaseDir: dataPath,
+      databaseDir: resolvedDataPath,
       user: DEFAULT_DB_USER,
       password: DEFAULT_DB_PASSWORD,
-      port: DEFAULT_DB_PORT,
+      port: selectedPort,
       persistent: true,
       initdbFlags: ["--encoding=UTF8", "--locale=C"],
       onLog: () => {},
       onError: () => {}
     });
 
-    if (!existsSync(resolve(dataPath, "PG_VERSION"))) {
+    if (!existsSync(resolve(resolvedDataPath, "PG_VERSION"))) {
       await instance.initialise();
     }
 
@@ -256,7 +281,7 @@ async function ensureEmbeddedPostgresTarget(dataPath: string): Promise<DatabaseT
     await instance.start();
 
     try {
-      await ensurePostgresDatabase(connectionStringFor(DEFAULT_DB_PORT, "postgres"), DEFAULT_DB_NAME);
+      await ensurePostgresDatabase(connectionStringFor(selectedPort, "postgres"), DEFAULT_DB_NAME);
     } catch (error) {
       await instance.stop().catch(() => {});
       throw error;
@@ -268,10 +293,13 @@ async function ensureEmbeddedPostgresTarget(dataPath: string): Promise<DatabaseT
       lastError: null
     });
 
+    await releaseLocalDbLock(lock);
+    lockReleased = true;
+
     let stopped = false;
     return {
-      connectionString: connectionStringFor(DEFAULT_DB_PORT, DEFAULT_DB_NAME),
-      dataPath,
+      connectionString: connectionStringFor(selectedPort, DEFAULT_DB_NAME),
+      dataPath: resolvedDataPath,
       source: "embedded-postgres",
       stop: async () => {
         if (stopped) {
@@ -290,8 +318,8 @@ async function ensureEmbeddedPostgresTarget(dataPath: string): Promise<DatabaseT
             expectedMigrationCount: EXPECTED_MIGRATION_VERSION.count,
             lastError: null
           }).catch(() => {});
-        } finally {
-          await releaseLocalDbLock(lock);
+        } catch {
+          // Best-effort shutdown; process may already be stopping.
         }
       }
     };
@@ -301,69 +329,153 @@ async function ensureEmbeddedPostgresTarget(dataPath: string): Promise<DatabaseT
       expectedMigrationCount: EXPECTED_MIGRATION_VERSION.count,
       lastError: error instanceof Error ? error.message : String(error)
     }).catch(() => {});
-    await releaseLocalDbLock(lock).catch(() => {});
+    if (!lockReleased) {
+      await releaseLocalDbLock(lock).catch(() => {});
+    }
     throw error;
   }
 }
 
-async function ensurePostgresDatabase(adminConnectionString: string, databaseName: string) {
-  const sqlClient = postgres(adminConnectionString, {
+async function tryReuseEmbeddedPostgres(
+  resolvedDataPath: string,
+  statePath: string,
+  configuredPort: number
+): Promise<DatabaseTarget | null> {
+  const postmasterPidFile = resolve(resolvedDataPath, "postmaster.pid");
+  const pm = readPostmasterPidFile(postmasterPidFile);
+  if (pm && isPidAlive(pm.pid)) {
+    const port = pm.port ?? configuredPort;
+    const adminUrl = connectionStringFor(port, "postgres");
+    let dir: string | null;
+    try {
+      dir = await getPostgresDataDirectory(adminUrl);
+    } catch (error) {
+      throw new Error(
+        `Embedded Postgres data path '${resolvedDataPath}' has postmaster pid ${pm.pid}, but connecting on port ${port} failed: ` +
+          (error instanceof Error ? error.message : String(error))
+      );
+    }
+    if (!dir || resolve(dir) !== resolvedDataPath) {
+      throw new Error(
+        `Embedded Postgres data path '${resolvedDataPath}' has a live postmaster (pid ${pm.pid}), but the server reachable on port ${port} does not use this data directory.`
+      );
+    }
+    // eslint-disable-next-line no-console
+    console.warn(`[bopodev-db] Embedded Postgres already running; reusing (pid=${pm.pid}, port=${port}).`);
+    await writeLocalDbState(statePath, {
+      version: LOCAL_DB_STATE_VERSION,
+      source: "embedded-postgres",
+      phase: "running",
+      pid: process.pid,
+      port,
+      dataPath: resolvedDataPath,
+      updatedAt: new Date().toISOString(),
+      expectedMigrationCount: EXPECTED_MIGRATION_VERSION.count,
+      lastError: null
+    });
+    await ensurePostgresDatabase(adminUrl, DEFAULT_DB_NAME);
+    return {
+      connectionString: connectionStringFor(port, DEFAULT_DB_NAME),
+      dataPath: resolvedDataPath,
+      source: "embedded-postgres",
+      stop: async () => {}
+    };
+  }
+
+  try {
+    const adminUrl = connectionStringFor(configuredPort, "postgres");
+    const dir = await getPostgresDataDirectory(adminUrl);
+    if (dir && resolve(dir) === resolvedDataPath) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[bopodev-db] Embedded Postgres reachable without a postmaster.pid; reusing server on port ${configuredPort}.`
+      );
+      await writeLocalDbState(statePath, {
+        version: LOCAL_DB_STATE_VERSION,
+        source: "embedded-postgres",
+        phase: "running",
+        pid: process.pid,
+        port: configuredPort,
+        dataPath: resolvedDataPath,
+        updatedAt: new Date().toISOString(),
+        expectedMigrationCount: EXPECTED_MIGRATION_VERSION.count,
+        lastError: null
+      });
+      await ensurePostgresDatabase(adminUrl, DEFAULT_DB_NAME);
+      return {
+        connectionString: connectionStringFor(configuredPort, DEFAULT_DB_NAME),
+        dataPath: resolvedDataPath,
+        source: "embedded-postgres",
+        stop: async () => {}
+      };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+async function getPostgresDataDirectory(connectionString: string): Promise<string | null> {
+  const sqlClient = postgres(connectionString, {
     max: 1,
     onnotice: () => {}
   });
   try {
-    const rows = await sqlClient<{ exists: boolean }[]>`
-      SELECT EXISTS (
-        SELECT 1
-        FROM pg_database
-        WHERE datname = ${databaseName}
-      ) AS exists
+    const rows = await sqlClient<{ data_directory: string | null }[]>`
+      SELECT current_setting('data_directory', true) AS data_directory
     `;
-    if (!rows[0]?.exists) {
-      await sqlClient.unsafe(`CREATE DATABASE "${databaseName.replaceAll("\"", "\"\"")}"`);
-    }
+    const actual = rows[0]?.data_directory;
+    return typeof actual === "string" && actual.length > 0 ? actual : null;
   } finally {
     await sqlClient.end();
   }
 }
 
-function readRunningPostmasterPid(postmasterPidFile: string): number | null {
+function readPostmasterPidFile(postmasterPidFile: string): { pid: number; port: number | null } | null {
   if (!existsSync(postmasterPidFile)) {
     return null;
   }
   try {
-    const pid = Number(readFileSync(postmasterPidFile, "utf8").split("\n")[0]?.trim());
+    const raw = readFileSync(postmasterPidFile, "utf8");
+    const lines = raw.split(/\r?\n/);
+    const pid = Number(lines[0]?.trim());
     if (!Number.isInteger(pid) || pid <= 0) {
       return null;
     }
-    process.kill(pid, 0);
-    return pid;
+    let port: number | null = null;
+    if (lines.length >= 4) {
+      const parsedPort = Number(lines[3]?.trim());
+      if (Number.isInteger(parsedPort) && parsedPort > 0) {
+        port = parsedPort;
+      }
+    }
+    return { pid, port };
   } catch {
     return null;
   }
 }
 
-async function waitForPostmasterExit(postmasterPidFile: string, timeoutMs: number) {
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutMs) {
-    if (!readRunningPostmasterPid(postmasterPidFile)) {
-      return;
+async function ensurePostgresDatabase(adminConnectionString: string, databaseName: string) {
+  const sqlClient = postgres(adminConnectionString, {
+    max: 1,
+    onnotice: () => {}
+  });
+  try {
+    const rows = await sqlClient<{ exists: boolean }[]>`
+      SELECT EXISTS (
+        SELECT 1
+        FROM pg_database
+        WHERE datname = ${databaseName}
+      ) AS exists
+    `;
+    if (!rows[0]?.exists) {
+      await sqlClient.unsafe(`CREATE DATABASE "${databaseName.replaceAll("\"", "\"\"")}"`);
     }
-    await sleep(200);
+  } finally {
+    await sqlClient.end();
   }
 }
 
-function isPortInUse(port: number) {
-  return new Promise<boolean>((resolvePromise) => {
-    const server = createServer();
-    server.unref();
-    server.once("error", () => resolvePromise(true));
-    server.listen(port, "127.0.0.1", () => {
-      server.close(() => resolvePromise(false));
-    });
-  });
-}
-
 function connectionStringFor(port: number, databaseName: string) {
   return `postgres://${DEFAULT_DB_USER}:${DEFAULT_DB_PASSWORD}@127.0.0.1:${port}/${databaseName}`;
 }
@@ -374,54 +486,75 @@ function normalizeOptionalEnvValue(value: string | undefined) {
 }
 
 async function acquireLocalDbLock(dataPath: string, timeoutMs: number): Promise<LocalDbLock> {
-  const lockPath = resolveLocalDbLockPath(dataPath);
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  await waitForLegacyLockFileReleased(dataPath, deadline);
+  const lockDirPath = resolveEmbeddedPostgresLockDirPath(dataPath);
+  let lastError: Error | null = null;
+  while (Date.now() < deadline) {
     try {
-      const handle = await open(lockPath, "wx");
-      await handle.writeFile(
-        JSON.stringify(
-          {
-            pid: process.pid,
-            acquiredAt: new Date().toISOString(),
-            dataPath
-          },
-          null,
-          2
-        ),
-        "utf8"
-      );
-      return {
-        path: lockPath,
-        handle
-      };
+      const release = await acquireProperLockfile(dataPath, {
+        lockfilePath: lockDirPath,
+        stale: EMBEDDED_DB_LOCK_STALE_MS,
+        realpath: true
+      });
+      return { release };
     } catch (error) {
-      if (!isAlreadyExistsError(error)) {
-        throw error;
-      }
-      const owner = await readLockOwner(lockPath);
-      if (!owner || !isPidAlive(owner.pid)) {
-        await rm(lockPath, { force: true }).catch(() => {});
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+      if (code === "ELOCKED" || lastError.message.includes("already being held")) {
+        await sleep(200);
         continue;
       }
-      await sleep(200);
+      throw lastError;
     }
   }
-  const owner = await readLockOwner(lockPath);
-  if (owner?.pid) {
-    throw new Error(
-      `Timed out waiting for embedded Postgres lock at '${lockPath}'. Another process (pid ${owner.pid}) is starting or stopping the local database.`
-    );
-  }
-  throw new Error(`Timed out waiting for embedded Postgres lock at '${lockPath}'.`);
+  throw new Error(
+    `Timed out waiting for embedded Postgres lock at '${lockDirPath}' (${timeoutMs}ms). ` +
+      `Stop other API processes using this data path, or wait for them to finish. ` +
+      `If a process crashed, the lock becomes stale after ${EMBEDDED_DB_LOCK_STALE_MS}ms without updates; ` +
+      `you can lower BOPO_DB_LOCK_STALE_MS temporarily or remove '${lockDirPath}' if it is orphaned. ` +
+      (lastError ? `Last error: ${lastError.message}` : "")
+  );
 }
 
 async function releaseLocalDbLock(lock: LocalDbLock) {
-  await lock.handle.close().catch(() => {});
-  await rm(lock.path, { force: true }).catch(() => {});
+  await lock.release().catch(() => {});
 }
 
-async function readLockOwner(lockPath: string) {
+/**
+ * Older builds used a JSON file lock; wait until it is gone or clearly stale so we never
+ * run two embedded Postgres instances against the same data path during version skew.
+ */
+async function waitForLegacyLockFileReleased(dataPath: string, deadline: number) {
+  const legacyPath = resolveLegacyLocalDbLockFilePath(dataPath);
+  while (Date.now() < deadline) {
+    let st;
+    try {
+      st = await stat(legacyPath);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+    if (!st.isFile()) {
+      return;
+    }
+    const owner = await readLegacyLockOwner(legacyPath);
+    if (!owner || !isPidAlive(owner.pid)) {
+      await rm(legacyPath, { force: true }).catch(() => {});
+      return;
+    }
+    await sleep(200);
+  }
+  const owner = await readLegacyLockOwner(legacyPath);
+  throw new Error(
+    `Timed out waiting for legacy embedded Postgres lock at '${legacyPath}'.` +
+      (owner ? ` Another process (pid ${owner.pid}) is using the old lock format; stop it or upgrade it.` : "")
+  );
+}
+
+async function readLegacyLockOwner(lockPath: string) {
   try {
     const raw = await readFile(lockPath, "utf8");
     const parsed = JSON.parse(raw) as { pid?: unknown };
@@ -481,10 +614,6 @@ function readExpectedMigrationVersion(): MigrationVersion {
   }
 }
 
-function isAlreadyExistsError(error: unknown) {
-  return Boolean(error && typeof error === "object" && "code" in error && error.code === "EEXIST");
-}
-
 function isPidAlive(pid: number) {
   try {
     process.kill(pid, 0);
@@ -494,7 +623,13 @@ function isPidAlive(pid: number) {
   }
 }
 
-function resolveLocalDbLockPath(dataPath: string) {
+/** Directory lock used by proper-lockfile (mkdir + mtime heartbeat; stale locks self-heal). */
+function resolveEmbeddedPostgresLockDirPath(dataPath: string) {
+  return `${join(dirname(dataPath), basename(dataPath))}.embed.lock`;
+}
+
+/** Legacy JSON file lock path (pre proper-lockfile). */
+function resolveLegacyLocalDbLockFilePath(dataPath: string) {
   return `${join(dirname(dataPath), basename(dataPath))}.lock`;
 }
 

package/src/index.ts

@@ -1,6 +1,7 @@
-export { and, asc, desc, eq, gt, inArray, like, notInArray, sql } from "drizzle-orm";
+export { and, asc, desc, eq, gt, inArray, like, max, notInArray, sql } from "drizzle-orm";
 export * from "./bootstrap";
 export * from "./client";
 export { resolveDefaultDbPath, resolveBopoInstanceRoot } from "./default-paths";
+export * from "./ping";
 export * from "./repositories";
 export * from "./schema";

package/src/migrations/0001_issues_external_link.sql

@@ -0,0 +1 @@
+ALTER TABLE "issues" ADD COLUMN "external_link" text;

package/src/migrations/0002_issues_goal_goals_owner_agent.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "goals" ADD COLUMN "owner_agent_id" text REFERENCES "agents"("id") ON DELETE SET NULL;
+ALTER TABLE "issues" ADD COLUMN "goal_id" text REFERENCES "goals"("id") ON DELETE SET NULL;

package/src/migrations/0003_issue_goals_junction.sql

@@ -0,0 +1,12 @@
+CREATE TABLE "issue_goals" (
+  "issue_id" text NOT NULL REFERENCES "issues"("id") ON DELETE CASCADE,
+  "goal_id" text NOT NULL REFERENCES "goals"("id") ON DELETE CASCADE,
+  "company_id" text NOT NULL REFERENCES "companies"("id") ON DELETE CASCADE,
+  "created_at" timestamp DEFAULT CURRENT_TIMESTAMP NOT NULL,
+  PRIMARY KEY ("issue_id", "goal_id")
+);
+
+INSERT INTO "issue_goals" ("issue_id", "goal_id", "company_id")
+SELECT "id", "goal_id", "company_id" FROM "issues" WHERE "goal_id" IS NOT NULL;
+
+ALTER TABLE "issues" DROP COLUMN "goal_id";

package/src/migrations/0004_agents_capabilities.sql

@@ -0,0 +1 @@
+ALTER TABLE "agents" ADD COLUMN "capabilities" text;

package/src/migrations/meta/_journal.json

@@ -8,6 +8,34 @@
       "when": 1742500000000,
       "tag": "0000_initial",
       "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1742600000000,
+      "tag": "0001_issues_external_link",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "7",
+      "when": 1742700000000,
+      "tag": "0002_issues_goal_goals_owner_agent",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "7",
+      "when": 1742800000000,
+      "tag": "0003_issue_goals_junction",
+      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "7",
+      "when": 1742900000000,
+      "tag": "0004_agents_capabilities",
+      "breakpoints": true
     }
   ]
 }

package/src/ping.ts

@@ -0,0 +1,7 @@
+import { sql } from "drizzle-orm";
+import type { BopoDb } from "./client";
+
+/** Cheap connection liveness check (no table scan). Kept as SQL because Drizzle has no relational API for a table-free SELECT. */
+export async function pingDatabase(db: BopoDb): Promise<void> {
+  await db.execute(sql`SELECT 1`);
+}

package/src/repositories/companies.ts

@@ -0,0 +1,41 @@
+import { desc, eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import type { BopoDb } from "../client";
+import { companies } from "../schema";
+import { compactUpdate } from "./helpers";
+
+export async function createCompany(db: BopoDb, input: { name: string; mission?: string | null }) {
+  const id = nanoid(12);
+  await db.insert(companies).values({
+    id,
+    name: input.name,
+    mission: input.mission ?? null
+  });
+  return { id, ...input };
+}
+
+export async function listCompanies(db: BopoDb) {
+  return db.select().from(companies).orderBy(desc(companies.createdAt));
+}
+
+export async function getCompany(db: BopoDb, id: string) {
+  const [row] = await db.select().from(companies).where(eq(companies.id, id)).limit(1);
+  return row ?? null;
+}
+
+export async function updateCompany(
+  db: BopoDb,
+  input: { id: string; name?: string; mission?: string | null }
+) {
+  const [company] = await db
+    .update(companies)
+    .set(compactUpdate({ name: input.name, mission: input.mission }))
+    .where(eq(companies.id, input.id))
+    .returning();
+  return company ?? null;
+}
+
+export async function deleteCompany(db: BopoDb, id: string) {
+  const [deletedCompany] = await db.delete(companies).where(eq(companies.id, id)).returning({ id: companies.id });
+  return Boolean(deletedCompany);
+}