@zeno-lib/db 0.1.0 → 0.3.0

package/src/config.ts

@@ -2,6 +2,48 @@
 // https://orm.drizzle.team/docs/rls#migrations  (entities.roles.provider: "supabase")
 import { type Config, defineConfig } from "drizzle-kit"
 
+/**
+ * Roles a Supabase project ships that drizzle-kit's `provider: "supabase"` does
+ * not already exclude. That provider covers eight names (`anon`,
+ * `authenticator`, `authenticated`, `service_role`, `supabase_auth_admin`,
+ * `supabase_storage_admin`, `dashboard_user`, `supabase_admin`); a real
+ * instance has these too, and drizzle-kit manages every role it finds but
+ * cannot see declared, which means a `DROP ROLE` for each.
+ *
+ * The alternative is every consumer keeping a generated `roles.ts` nobody
+ * reads, or its own copy of this list, which rots as Supabase adds roles. That
+ * is the argument for it living in a versioned dependency.
+ *
+ * Verified against Supabase CLI 2.84.1 / Postgres 17.
+ */
+export const supabaseManagedRoles = [
+  "pg_checkpoint",
+  "pg_database_owner",
+  "pg_execute_server_program",
+  "pg_monitor",
+  "pg_read_all_data",
+  "pg_read_all_settings",
+  "pg_read_all_stats",
+  "pg_read_server_files",
+  "pg_signal_backend",
+  "pg_stat_scan_tables",
+  "pg_write_all_data",
+  "pg_write_server_files",
+  "pgbouncer",
+  "postgres",
+  "supabase_functions_admin",
+  "supabase_read_only_user",
+  "supabase_realtime_admin",
+  "supabase_replication_admin",
+] as const
+
+/**
+ * Schemas drizzle-kit is allowed to diff. Supabase owns `auth`, `storage`,
+ * `realtime` and the rest, and changes them on upgrades, so migrating them is
+ * never right. Add your own schemas here rather than dropping the filter.
+ */
+const DEFAULT_SCHEMA_FILTER = ["public"]
+
 export function defineDrizzleConfig(
   overrides: Partial<Config> = {}
 ): ReturnType<typeof defineConfig> {
@@ -16,13 +58,20 @@ export function defineDrizzleConfig(
     dbCredentials: { url: process.env.SUPABASE_DATABASE_URL ?? "" },
     dialect: "postgresql",
     // Tells drizzle-kit that Supabase's built-in roles (anon, authenticated,
-    // service_role, ...) already exist — don't try to CREATE or DROP them.
+    // service_role, ...) already exist, so it neither creates nor drops them.
+    // `provider` covers eight of them; `supabaseManagedRoles` covers the rest.
+    // A caller's own excludes are kept.
     entities: {
       ...entities,
-      roles: { ...roleOverrides, provider: "supabase" },
+      roles: {
+        ...roleOverrides,
+        exclude: [...(roleOverrides.exclude ?? []), ...supabaseManagedRoles],
+        provider: "supabase",
+      },
     },
     out: "./supabase/migrations",
     schema: "./src/schema.ts",
+    schemaFilter: DEFAULT_SCHEMA_FILTER,
     ...configOverrides,
   } as Config)
 }

package/src/schema.test-d.ts

@@ -0,0 +1,121 @@
+import { expectTypeOf, test } from "vitest"
+
+import {
+  auditColumns,
+  authorship,
+  authUserId,
+  primaryId,
+  sequentialPrimaryId,
+  table,
+  userId,
+  uuidPrimaryId,
+} from "./schema.ts"
+
+test("primaryId infers each kind, and falls back to sequential", () => {
+  const fallback = table("fallback", { id: primaryId() })
+  const sequential = table("sequential", { id: primaryId("sequential") })
+  const uuid = table("uuid", { id: primaryId("uuid") })
+  const assigned = table("assigned", { id: primaryId("assigned") })
+
+  // Sequential keys are `number`, not `bigint`, because PostgREST serialises
+  // to JSON numbers. The bare call is sequential, matching the dashboard.
+  expectTypeOf<
+    (typeof fallback)["$inferSelect"]["id"]
+  >().toEqualTypeOf<number>()
+  expectTypeOf<
+    (typeof sequential)["$inferSelect"]["id"]
+  >().toEqualTypeOf<number>()
+  expectTypeOf<(typeof uuid)["$inferSelect"]["id"]>().toEqualTypeOf<string>()
+  expectTypeOf<
+    (typeof assigned)["$inferSelect"]["id"]
+  >().toEqualTypeOf<string>()
+})
+
+test("sequential options change the inferred JavaScript type", () => {
+  const int = table("int", { id: sequentialPrimaryId({ type: "integer" }) })
+  const big = table("big", { id: sequentialPrimaryId({ mode: "bigint" }) })
+  const always = table("always", {
+    id: sequentialPrimaryId({ generated: "always" }),
+  })
+
+  expectTypeOf<(typeof int)["$inferSelect"]["id"]>().toEqualTypeOf<number>()
+  expectTypeOf<(typeof big)["$inferSelect"]["id"]>().toEqualTypeOf<bigint>()
+  expectTypeOf<(typeof always)["$inferSelect"]["id"]>().toEqualTypeOf<number>()
+})
+
+test("mode is rejected for integer, which has one JavaScript representation", () => {
+  // @ts-expect-error mode applies to bigint only
+  sequentialPrimaryId({ mode: "bigint", type: "integer" })
+})
+
+test("dropping the random default makes a uuid key required on insert", () => {
+  const posts = table("posts", { id: primaryId("uuid") })
+  const profiles = table("profiles", {
+    id: uuidPrimaryId({ defaultRandom: false }),
+  })
+
+  // gen_random_uuid() supplies the id, so callers may omit it.
+  expectTypeOf<(typeof posts)["$inferInsert"]>().toEqualTypeOf<{
+    id?: string
+  }>()
+  // An auth.users mirror takes its id from the referenced row.
+  expectTypeOf<(typeof profiles)["$inferInsert"]>().toEqualTypeOf<{
+    id: string
+  }>()
+})
+
+test("author columns are nullable unless asked to be required", () => {
+  const posts = table("posts", { ownerId: authUserId() })
+  const required = table("required", {
+    ownerId: authUserId({ notNull: true }),
+  })
+
+  expectTypeOf<(typeof posts)["$inferSelect"]["ownerId"]>().toEqualTypeOf<
+    string | null
+  >()
+  expectTypeOf<
+    (typeof required)["$inferSelect"]["ownerId"]
+  >().toEqualTypeOf<string>()
+})
+
+test("authorship options reach both columns", () => {
+  const audited = table("audited", { ...auditColumns({ notNull: true }) })
+  const loose = table("loose", { ...authorship() })
+
+  expectTypeOf<
+    (typeof audited)["$inferSelect"]["createdBy"]
+  >().toEqualTypeOf<string>()
+  expectTypeOf<
+    (typeof audited)["$inferSelect"]["updatedBy"]
+  >().toEqualTypeOf<string>()
+  expectTypeOf<(typeof loose)["$inferSelect"]["createdBy"]>().toEqualTypeOf<
+    string | null
+  >()
+})
+
+test("author columns default on insert, so they stay optional", () => {
+  const posts = table("posts", { ...authorship({ notNull: true }) })
+
+  expectTypeOf<(typeof posts)["$inferInsert"]>().toEqualTypeOf<{
+    createdBy?: string
+    updatedBy?: string
+  }>()
+})
+
+test("userId narrows the same way against its own reference", () => {
+  const profiles = table("profiles", {
+    id: uuidPrimaryId({ defaultRandom: false }),
+  })
+  const posts = table("posts", {
+    ownerId: userId(() => profiles.id, { notNull: true }),
+  })
+
+  expectTypeOf<
+    (typeof posts)["$inferSelect"]["ownerId"]
+  >().toEqualTypeOf<string>()
+})
+
+test("reference actions are rejected when there is no reference", () => {
+  // @ts-expect-error actions are meaningless without a foreign key
+  authUserId({ actions: { onDelete: "cascade" }, reference: null })
+})