@beignet/cli 0.0.8 → 0.0.10

package/src/templates/db/postgres.ts

@@ -0,0 +1,867 @@
+// The starter ships its initial Drizzle migration inside the template so the
+// first run is `db migrate` with no generate step. `dbSchema` and the
+// `starterMigration*` files below pair together — regenerate together.
+//
+// To regenerate: scaffold a scratch app with `dbSchema` as
+// infra/db/schema/index.ts plus `drizzleConfig` as drizzle.config.ts, run
+// `drizzle-kit generate --name starter` with the drizzle-kit version pinned in
+// externalVersions (no Postgres server needed; generate diffs the schema
+// against an empty snapshot), paste drizzle/0000_starter.sql,
+// drizzle/meta/_journal.json, and drizzle/meta/0000_snapshot.json back here
+// verbatim, then append the output of
+// createDrizzlePostgresIdempotencySetupStatements() from
+// @beignet/provider-db-drizzle/postgres to the migration SQL, separated by
+// `--> statement-breakpoint`. The idempotency table is provider-owned and
+// lives outside the app schema, so `db generate` never diffs against it.
+//
+// The Better Auth tables were generated with
+// `bunx @better-auth/cli generate` against a scratch app configured with
+// drizzleAdapter(db, { provider: "pg" }), then normalized to the starter's
+// conventions (tabs, no relations, no extra indexes, no column defaults).
+
+import { databaseLocalUrl } from "../../choices.js";
+import type { TemplateContext } from "../shared.js";
+import type { DbTemplateFiles } from "./index.js";
+
+export function postgresDbFiles(ctx: TemplateContext): DbTemplateFiles {
+  return {
+    drizzleConfig: `export default {
+	schema: "./infra/db/schema/index.ts",
+	out: "./drizzle",
+	dialect: "postgresql",
+	dbCredentials: {
+		url: process.env.POSTGRES_DB_URL ?? "${databaseLocalUrl("postgres", ctx.name)}",
+	},
+};
+`,
+    dbSchema: `import { boolean, index, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+
+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"),
+	createdAt: timestamp("created_at").notNull(),
+	updatedAt: timestamp("updated_at").notNull(),
+});
+
+export const session = pgTable("session", {
+	id: text("id").primaryKey(),
+	expiresAt: timestamp("expires_at").notNull(),
+	token: text("token").notNull().unique(),
+	createdAt: timestamp("created_at").notNull(),
+	updatedAt: timestamp("updated_at").notNull(),
+	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(),
+	updatedAt: timestamp("updated_at").notNull(),
+});
+
+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"),
+	updatedAt: timestamp("updated_at"),
+});
+
+export const todos = pgTable(
+	"todos",
+	{
+		id: text("id").primaryKey(),
+		userId: text("user_id")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		title: text("title").notNull(),
+		completed: boolean("completed").notNull().default(false),
+		// Kept as an ISO-8601 text column on purpose: TodoSchema validates
+		// createdAt with z.string().datetime(), repositories pass rows through
+		// unmapped, and list ordering compares the strings lexicographically.
+		createdAt: text("created_at").notNull(),
+	},
+	(table) => ({
+		userIdx: index("todos_user_idx").on(table.userId, table.createdAt),
+	}),
+);
+`,
+    drizzleTodoRepository: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { offsetPageResult } from "@beignet/core/pagination";
+import type { DrizzlePostgresDatabase } from "@beignet/provider-db-drizzle/postgres";
+import { count, desc, eq } from "drizzle-orm";
+import type {
+	NewTodo,
+	TodoRepository,
+	UpdateTodoData,
+} from "@/features/todos/ports";
+import type { Todo } from "@/features/todos/schemas";
+import * as schema from "@/infra/db/schema";
+
+type TodoRow = typeof schema.todos.$inferSelect;
+
+function toTodo(row: TodoRow): Todo {
+	return {
+		id: row.id,
+		userId: row.userId,
+		title: row.title,
+		completed: row.completed,
+		createdAt: row.createdAt,
+	};
+}
+
+export function createDrizzleTodoRepository(
+	db: DrizzlePostgresDatabase<typeof schema>,
+): TodoRepository {
+	return {
+		async list(userId, page) {
+			const rows = await db
+				.select()
+				.from(schema.todos)
+				.where(eq(schema.todos.userId, userId))
+				.orderBy(desc(schema.todos.createdAt))
+				.limit(page.limit)
+				.offset(page.offset);
+			const [{ total }] = await db
+				.select({ total: count() })
+				.from(schema.todos)
+				.where(eq(schema.todos.userId, userId));
+
+			return offsetPageResult(rows.map(toTodo), page, total);
+		},
+		async findById(id: string) {
+			const [row] = await db
+				.select()
+				.from(schema.todos)
+				.where(eq(schema.todos.id, id))
+				.limit(1);
+
+			return row ? toTodo(row) : null;
+		},
+		async create(input: NewTodo) {
+			const todo = {
+				id: crypto.randomUUID(),
+				userId: input.userId,
+				title: input.title,
+				completed: false,
+				createdAt: new Date().toISOString(),
+			};
+			const [row] = await db.insert(schema.todos).values(todo).returning();
+
+			if (!row) {
+				throw new Error("Failed to create todo");
+			}
+
+			return toTodo(row);
+		},
+		async update(id: string, input: UpdateTodoData) {
+			const [row] = await db
+				.update(schema.todos)
+				.set({ completed: input.completed })
+				.where(eq(schema.todos.id, id))
+				.returning();
+
+			if (!row) {
+				throw new Error(\`Failed to update todo \${id}\`);
+			}
+
+			return toTodo(row);
+		},
+		async delete(id: string) {
+			await db.delete(schema.todos).where(eq(schema.todos.id, id));
+		},
+	};
+}
+`,
+    dbRepositories: `import type { DrizzlePostgresDatabase } from "@beignet/provider-db-drizzle/postgres";
+import { createDrizzleTodoRepository } from "@/infra/todos/drizzle-todo-repository";
+import type { AppTransactionPorts } from "@/ports";
+import * as schema from "./schema";
+
+export function createRepositories(
+	db: DrizzlePostgresDatabase<typeof schema>,
+): Omit<AppTransactionPorts, "idempotency"> {
+	return {
+		todos: createDrizzleTodoRepository(db),
+	};
+}
+`,
+    databaseReady: `import { drizzle } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import type { Pool } from "pg";
+
+let ready: Promise<void> | undefined;
+
+/**
+ * Make sure the database is usable before the first query runs.
+ *
+ * In development, pending migrations from \`drizzle/\` are applied
+ * automatically so a fresh clone works without remembering
+ * \`beignet db migrate\`. In production the schema is never mutated;
+ * an unmigrated database fails loudly with the command to run.
+ *
+ * Memoized per process so Next.js page-data workers that reach this in
+ * parallel share one preparation pass.
+ */
+export function ensureDatabaseReady(pool: Pool): Promise<void> {
+	ready ??= prepare(pool);
+	return ready;
+}
+
+async function prepare(pool: Pool): Promise<void> {
+	if (process.env.NODE_ENV === "production") {
+		const tables = await pool.query(
+			"SELECT table_name FROM information_schema.tables WHERE table_schema = current_schema() AND table_name = 'user' LIMIT 1",
+		);
+		if (tables.rows.length === 0) {
+			throw new Error(
+				"Database has no tables yet. Run \`beignet db migrate\` against this database before starting the app.",
+			);
+		}
+		return;
+	}
+
+	await migrate(drizzle(pool), { migrationsFolder: "drizzle" });
+}
+`,
+    dbProvider: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { createProvider } from "@beignet/core/providers";
+import {
+	createDrizzlePostgresIdempotencyPort,
+	createDrizzlePostgresUnitOfWork,
+	type DbPort,
+} from "@beignet/provider-db-drizzle/postgres";
+import type { AppPorts } from "@/ports";
+import { ensureDatabaseReady } from "./database-ready";
+import { createRepositories } from "./repositories";
+import type * as schema from "./schema";
+
+export const starterDatabaseProvider = createProvider<{
+	db: DbPort<typeof schema>;
+}>()({
+	name: "starter-database",
+
+	async setup({ ports }) {
+		const dbPort = ports.db;
+		if (!dbPort) {
+			throw new Error(
+				"starterDatabaseProvider requires a db port. Register createDrizzlePostgresProvider({ schema }) before it.",
+			);
+		}
+
+		const repositories = createRepositories(dbPort.db);
+		const idempotency = createDrizzlePostgresIdempotencyPort(dbPort.db);
+
+		const providedPorts: Pick<AppPorts, "idempotency" | "todos" | "uow"> = {
+			...repositories,
+			idempotency,
+			uow: createDrizzlePostgresUnitOfWork({
+				db: dbPort.db,
+				createTransactionPorts: (tx) => ({
+					...createRepositories(tx),
+					idempotency: createDrizzlePostgresIdempotencyPort(tx),
+				}),
+			}),
+		};
+
+		return {
+			ports: providedPorts,
+			async start() {
+				await ensureDatabaseReady(dbPort.pool);
+			},
+		};
+	},
+});
+`,
+    dbReset: `import { drizzle } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+import pg from "pg";
+import { env } from "@/lib/env";
+
+const host = new URL(env.POSTGRES_DB_URL).hostname;
+if (
+	host !== "localhost" &&
+	host !== "127.0.0.1" &&
+	process.env.BEIGNET_ALLOW_DATABASE_RESET !== "true"
+) {
+	throw new Error(
+		"Refusing to reset a non-local database. Set BEIGNET_ALLOW_DATABASE_RESET=true if this is intentional.",
+	);
+}
+
+const tables = [
+	"verification",
+	"account",
+	"session",
+	"todos",
+	"user",
+	"idempotency_records",
+] as const;
+
+const pool = new pg.Pool({ connectionString: env.POSTGRES_DB_URL });
+
+try {
+	for (const table of tables) {
+		await pool.query(\`DROP TABLE IF EXISTS "\${table}" CASCADE\`);
+	}
+	// drizzle-kit and the runtime migrator track applied migrations in the
+	// "drizzle" schema, so drop it to replay the checked-in migrations.
+	await pool.query('DROP SCHEMA IF EXISTS "drizzle" CASCADE');
+
+	await migrate(drizzle(pool), { migrationsFolder: "drizzle" });
+	console.log("Database reset.");
+} finally {
+	await pool.end();
+}
+`,
+    dbTestDatabase: `import { PGlite } from "@electric-sql/pglite";
+import { drizzle, type PgliteDatabase } from "drizzle-orm/pglite";
+import { migrate } from "drizzle-orm/pglite/migrator";
+import { createRepositories } from "./repositories";
+import * as schema from "./schema";
+
+export type TestDatabase = {
+	client: PGlite;
+	db: PgliteDatabase<typeof schema>;
+	repositories: ReturnType<typeof createRepositories>;
+	close(): Promise<void>;
+};
+
+/**
+ * In-process Postgres for tests, backed by PGlite — no server required.
+ * PGlite's drizzle instance satisfies the same Postgres database seam the
+ * app repositories use. Better Auth is not exercised through this helper;
+ * it connects through the pg pool in lib/better-auth.
+ */
+export async function createTestDatabase(): Promise<TestDatabase> {
+	const client = new PGlite();
+	const db = drizzle(client, { schema });
+	await migrate(db, { migrationsFolder: "drizzle" });
+
+	return {
+		client,
+		db,
+		repositories: createRepositories(db),
+		close: async () => {
+			await client.close();
+		},
+	};
+}
+`,
+    ...postgresStarterMigration,
+  };
+}
+
+const postgresStarterMigration = {
+  // Generated by drizzle-kit generate --name starter against dbSchema
+  // above, with the provider idempotency setup statements appended.
+  starterMigrationSql: `CREATE TABLE "account" (
+	"id" text PRIMARY KEY NOT NULL,
+	"account_id" text NOT NULL,
+	"provider_id" text NOT NULL,
+	"user_id" text NOT NULL,
+	"access_token" text,
+	"refresh_token" text,
+	"id_token" text,
+	"access_token_expires_at" timestamp,
+	"refresh_token_expires_at" timestamp,
+	"scope" text,
+	"password" text,
+	"created_at" timestamp NOT NULL,
+	"updated_at" timestamp NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "session" (
+	"id" text PRIMARY KEY NOT NULL,
+	"expires_at" timestamp NOT NULL,
+	"token" text NOT NULL,
+	"created_at" timestamp NOT NULL,
+	"updated_at" timestamp NOT NULL,
+	"ip_address" text,
+	"user_agent" text,
+	"user_id" text NOT NULL,
+	CONSTRAINT "session_token_unique" UNIQUE("token")
+);
+--> statement-breakpoint
+CREATE TABLE "todos" (
+	"id" text PRIMARY KEY NOT NULL,
+	"user_id" text NOT NULL,
+	"title" text NOT NULL,
+	"completed" boolean DEFAULT false NOT NULL,
+	"created_at" text NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "user" (
+	"id" text PRIMARY KEY NOT NULL,
+	"name" text NOT NULL,
+	"email" text NOT NULL,
+	"email_verified" boolean DEFAULT false NOT NULL,
+	"image" text,
+	"created_at" timestamp NOT NULL,
+	"updated_at" timestamp NOT NULL,
+	CONSTRAINT "user_email_unique" UNIQUE("email")
+);
+--> statement-breakpoint
+CREATE TABLE "verification" (
+	"id" text PRIMARY KEY NOT NULL,
+	"identifier" text NOT NULL,
+	"value" text NOT NULL,
+	"expires_at" timestamp NOT NULL,
+	"created_at" timestamp,
+	"updated_at" timestamp
+);
+--> statement-breakpoint
+ALTER TABLE "account" ADD CONSTRAINT "account_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "session" ADD CONSTRAINT "session_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "todos" ADD CONSTRAINT "todos_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "todos_user_idx" ON "todos" USING btree ("user_id","created_at");
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS "idempotency_records" (
+      storage_key text PRIMARY KEY NOT NULL,
+      namespace text NOT NULL,
+      idempotency_key text NOT NULL,
+      scope_key text NOT NULL,
+      fingerprint text NOT NULL,
+      status text NOT NULL,
+      result_json text,
+      reserved_at text NOT NULL,
+      completed_at text,
+      expires_at text,
+      updated_at text NOT NULL
+    );--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "idempotency_records_lookup_idx" ON "idempotency_records" (namespace, scope_key, idempotency_key);--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "idempotency_records_expires_idx" ON "idempotency_records" (expires_at);
+`,
+  starterMigrationJournal: `{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1781285555823,
+      "tag": "0000_starter",
+      "breakpoints": true
+    }
+  ]
+}`,
+  starterMigrationSnapshot: `{
+  "id": "33cd3ae7-5014-401d-abb0-a1eb69055b7e",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.account": {
+      "name": "account",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "id_token": {
+          "name": "id_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "access_token_expires_at": {
+          "name": "access_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "refresh_token_expires_at": {
+          "name": "refresh_token_expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "account_user_id_user_id_fk": {
+          "name": "account_user_id_user_id_fk",
+          "tableFrom": "account",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.session": {
+      "name": "session",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token": {
+          "name": "token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "session_user_id_user_id_fk": {
+          "name": "session_user_id_user_id_fk",
+          "tableFrom": "session",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "session_token_unique": {
+          "name": "session_token_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "token"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.todos": {
+      "name": "todos",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "completed": {
+          "name": "completed",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "todos_user_idx": {
+          "name": "todos_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "todos_user_id_user_id_fk": {
+          "name": "todos_user_id_user_id_fk",
+          "tableFrom": "todos",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user": {
+      "name": "user",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email_verified": {
+          "name": "email_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "image": {
+          "name": "image",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "user_email_unique": {
+          "name": "user_email_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "email"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.verification": {
+      "name": "verification",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "identifier": {
+          "name": "identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}`,
+};