@beignet/cli 0.0.9 → 0.0.11

package/src/templates/db/mysql.ts

@@ -0,0 +1,976 @@
+// 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 MySQL 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
+// createDrizzleMysqlIdempotencySetupStatements() from
+// @beignet/provider-db-drizzle/mysql 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: "mysql" }), then normalized to the starter's
+// conventions (tabs, no relations, no extra indexes, no column defaults).
+// MySQL cannot put UNIQUE constraints on bare text columns, so identity
+// columns are varchar: 36-char ids and foreign keys, 255-char unique email
+// and token.
+
+import { databaseLocalUrl, databaseStartCommand } from "../../choices.js";
+import type { TemplateContext } from "../shared.js";
+import type { DbTemplateFiles } from "./index.js";
+
+export function mysqlDbFiles(ctx: TemplateContext): DbTemplateFiles {
+  return {
+    drizzleConfig: `export default {
+	schema: "./infra/db/schema/index.ts",
+	out: "./drizzle",
+	dialect: "mysql",
+	dbCredentials: {
+		url: process.env.MYSQL_DB_URL ?? "${databaseLocalUrl("mysql", ctx.name)}",
+	},
+};
+`,
+    dbSchema: `import {
+	boolean,
+	index,
+	mysqlTable,
+	text,
+	timestamp,
+	varchar,
+} from "drizzle-orm/mysql-core";
+
+export const user = mysqlTable("user", {
+	id: varchar("id", { length: 36 }).primaryKey(),
+	name: varchar("name", { length: 255 }).notNull(),
+	email: varchar("email", { length: 255 }).notNull().unique(),
+	emailVerified: boolean("email_verified").notNull().default(false),
+	image: text("image"),
+	createdAt: timestamp("created_at", { fsp: 3 }).notNull(),
+	updatedAt: timestamp("updated_at", { fsp: 3 }).notNull(),
+});
+
+export const session = mysqlTable("session", {
+	id: varchar("id", { length: 36 }).primaryKey(),
+	expiresAt: timestamp("expires_at", { fsp: 3 }).notNull(),
+	token: varchar("token", { length: 255 }).notNull().unique(),
+	createdAt: timestamp("created_at", { fsp: 3 }).notNull(),
+	updatedAt: timestamp("updated_at", { fsp: 3 }).notNull(),
+	ipAddress: text("ip_address"),
+	userAgent: text("user_agent"),
+	userId: varchar("user_id", { length: 36 })
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const account = mysqlTable("account", {
+	id: varchar("id", { length: 36 }).primaryKey(),
+	accountId: text("account_id").notNull(),
+	providerId: text("provider_id").notNull(),
+	userId: varchar("user_id", { length: 36 })
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+	accessToken: text("access_token"),
+	refreshToken: text("refresh_token"),
+	idToken: text("id_token"),
+	accessTokenExpiresAt: timestamp("access_token_expires_at", { fsp: 3 }),
+	refreshTokenExpiresAt: timestamp("refresh_token_expires_at", { fsp: 3 }),
+	scope: text("scope"),
+	password: text("password"),
+	createdAt: timestamp("created_at", { fsp: 3 }).notNull(),
+	updatedAt: timestamp("updated_at", { fsp: 3 }).notNull(),
+});
+
+export const verification = mysqlTable("verification", {
+	id: varchar("id", { length: 36 }).primaryKey(),
+	identifier: varchar("identifier", { length: 255 }).notNull(),
+	value: text("value").notNull(),
+	expiresAt: timestamp("expires_at", { fsp: 3 }).notNull(),
+	createdAt: timestamp("created_at", { fsp: 3 }),
+	updatedAt: timestamp("updated_at", { fsp: 3 }),
+});
+
+export const todos = mysqlTable(
+	"todos",
+	{
+		id: varchar("id", { length: 36 }).primaryKey(),
+		userId: varchar("user_id", { length: 36 })
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		title: text("title").notNull(),
+		completed: boolean("completed").notNull().default(false),
+		// Kept as an ISO-8601 varchar column on purpose: TodoSchema validates
+		// createdAt with z.string().datetime(), repositories pass rows through
+		// unmapped, and list ordering compares the strings lexicographically.
+		createdAt: varchar("created_at", { length: 32 }).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 { DrizzleMysqlDatabase } from "@beignet/provider-db-drizzle/mysql";
+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: DrizzleMysqlDatabase<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) {
+			// MySQL has no INSERT ... RETURNING; the full row is known up front.
+			const todo = {
+				id: crypto.randomUUID(),
+				userId: input.userId,
+				title: input.title,
+				completed: false,
+				createdAt: new Date().toISOString(),
+			};
+			await db.insert(schema.todos).values(todo);
+
+			return todo;
+		},
+		async update(id: string, input: UpdateTodoData) {
+			// MySQL has no UPDATE ... RETURNING; re-read the row after writing.
+			await db
+				.update(schema.todos)
+				.set({ completed: input.completed })
+				.where(eq(schema.todos.id, id));
+			const [row] = await db
+				.select()
+				.from(schema.todos)
+				.where(eq(schema.todos.id, id))
+				.limit(1);
+
+			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 { DrizzleMysqlDatabase } from "@beignet/provider-db-drizzle/mysql";
+import { createDrizzleTodoRepository } from "@/infra/todos/drizzle-todo-repository";
+import type { AppTransactionPorts } from "@/ports";
+import * as schema from "./schema";
+
+export function createRepositories(
+	db: DrizzleMysqlDatabase<typeof schema>,
+): Omit<AppTransactionPorts, "idempotency"> {
+	return {
+		todos: createDrizzleTodoRepository(db),
+	};
+}
+`,
+    databaseReady: `import { drizzle } from "drizzle-orm/mysql2";
+import { migrate } from "drizzle-orm/mysql2/migrator";
+import type { Pool, RowDataPacket } from "mysql2/promise";
+
+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<RowDataPacket[]>(
+			"SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = 'user' LIMIT 1",
+		);
+		if (tables.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 {
+	createDrizzleMysqlIdempotencyPort,
+	createDrizzleMysqlUnitOfWork,
+	type DbPort,
+} from "@beignet/provider-db-drizzle/mysql";
+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 createDrizzleMysqlProvider({ schema }) before it.",
+			);
+		}
+
+		const repositories = createRepositories(dbPort.db);
+		const idempotency = createDrizzleMysqlIdempotencyPort(dbPort.db);
+
+		const providedPorts: Pick<AppPorts, "idempotency" | "todos" | "uow"> = {
+			...repositories,
+			idempotency,
+			uow: createDrizzleMysqlUnitOfWork({
+				db: dbPort.db,
+				createTransactionPorts: (tx) => ({
+					...createRepositories(tx),
+					idempotency: createDrizzleMysqlIdempotencyPort(tx),
+				}),
+			}),
+		};
+
+		return {
+			ports: providedPorts,
+			async start() {
+				await ensureDatabaseReady(dbPort.pool);
+			},
+		};
+	},
+});
+`,
+    dbReset: `import { drizzle } from "drizzle-orm/mysql2";
+import { migrate } from "drizzle-orm/mysql2/migrator";
+import mysql from "mysql2/promise";
+import { env } from "@/lib/env";
+
+const host = new URL(env.MYSQL_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",
+	"__drizzle_migrations",
+] as const;
+
+const pool = mysql.createPool({ uri: env.MYSQL_DB_URL });
+
+try {
+	await pool.query("SET FOREIGN_KEY_CHECKS = 0");
+	try {
+		for (const table of tables) {
+			await pool.query(\`DROP TABLE IF EXISTS \\\`\${table}\\\`\`);
+		}
+	} finally {
+		await pool.query("SET FOREIGN_KEY_CHECKS = 1");
+	}
+
+	await migrate(drizzle(pool), { migrationsFolder: "drizzle" });
+	console.log("Database reset.");
+} finally {
+	await pool.end();
+}
+`,
+    dbTestDatabase: `import { drizzle, type MySql2Database } from "drizzle-orm/mysql2";
+import { migrate } from "drizzle-orm/mysql2/migrator";
+import mysql, { type Pool } from "mysql2/promise";
+import { createRepositories } from "./repositories";
+import * as schema from "./schema";
+
+// Set MYSQL_TEST_URL to run database-backed tests against a real MySQL 8.0+
+// server. The starter's shipped tests use in-memory ports and do not need it.
+const MYSQL_TEST_URL = process.env.MYSQL_TEST_URL;
+
+/**
+ * Whether database-backed tests can run. Pair with \`test.skipIf\`:
+ *
+ * \`\`\`ts
+ * test.skipIf(!isMysqlTestDatabaseAvailable())("...", async () => { ... });
+ * \`\`\`
+ */
+export function isMysqlTestDatabaseAvailable(): boolean {
+	return Boolean(MYSQL_TEST_URL);
+}
+
+export type TestDatabase = {
+	pool: Pool;
+	db: MySql2Database<typeof schema>;
+	repositories: ReturnType<typeof createRepositories>;
+	databaseName: string;
+	close(): Promise<void>;
+};
+
+/**
+ * Create an isolated test database on the MYSQL_TEST_URL server.
+ *
+ * Each call creates a uniquely named database, applies the checked-in
+ * migrations into it, and drops it again on close, so parallel tests never
+ * share state.
+ */
+export async function createTestDatabase(): Promise<TestDatabase> {
+	if (!MYSQL_TEST_URL) {
+		throw new Error(
+			"MYSQL_TEST_URL is not set. Start MySQL with: " +
+				"${databaseStartCommand("mysql", ctx.name)} " +
+				"then run tests with MYSQL_TEST_URL=${databaseLocalUrl("mysql", ctx.name)}.",
+		);
+	}
+
+	const databaseName = \`beignet_test_\${crypto
+		.randomUUID()
+		.replaceAll("-", "")
+		.slice(0, 12)}\`;
+
+	const bootstrap = await mysql.createConnection({ uri: MYSQL_TEST_URL });
+	try {
+		await bootstrap.query(\`CREATE DATABASE \\\`\${databaseName}\\\`\`);
+	} finally {
+		await bootstrap.end();
+	}
+
+	const url = new URL(MYSQL_TEST_URL);
+	url.pathname = \`/\${databaseName}\`;
+	const pool = mysql.createPool({ uri: url.toString() });
+	const db = drizzle(pool, { schema, mode: "default" });
+	await migrate(db, { migrationsFolder: "drizzle" });
+
+	return {
+		pool,
+		db,
+		repositories: createRepositories(db),
+		databaseName,
+		close: async () => {
+			await pool.end();
+			const cleanup = await mysql.createConnection({ uri: MYSQL_TEST_URL });
+			try {
+				await cleanup.query(\`DROP DATABASE IF EXISTS \\\`\${databaseName}\\\`\`);
+			} finally {
+				await cleanup.end();
+			}
+		},
+	};
+}
+`,
+    ...mysqlStarterMigration,
+  };
+}
+
+const mysqlStarterMigration = {
+  // Generated by drizzle-kit generate --name starter against dbSchema
+  // above, with the provider idempotency setup statements appended.
+  starterMigrationSql: `CREATE TABLE \`account\` (
+	\`id\` varchar(36) NOT NULL,
+	\`account_id\` text NOT NULL,
+	\`provider_id\` text NOT NULL,
+	\`user_id\` varchar(36) NOT NULL,
+	\`access_token\` text,
+	\`refresh_token\` text,
+	\`id_token\` text,
+	\`access_token_expires_at\` timestamp(3),
+	\`refresh_token_expires_at\` timestamp(3),
+	\`scope\` text,
+	\`password\` text,
+	\`created_at\` timestamp(3) NOT NULL,
+	\`updated_at\` timestamp(3) NOT NULL,
+	CONSTRAINT \`account_id\` PRIMARY KEY(\`id\`)
+);
+--> statement-breakpoint
+CREATE TABLE \`session\` (
+	\`id\` varchar(36) NOT NULL,
+	\`expires_at\` timestamp(3) NOT NULL,
+	\`token\` varchar(255) NOT NULL,
+	\`created_at\` timestamp(3) NOT NULL,
+	\`updated_at\` timestamp(3) NOT NULL,
+	\`ip_address\` text,
+	\`user_agent\` text,
+	\`user_id\` varchar(36) NOT NULL,
+	CONSTRAINT \`session_id\` PRIMARY KEY(\`id\`),
+	CONSTRAINT \`session_token_unique\` UNIQUE(\`token\`)
+);
+--> statement-breakpoint
+CREATE TABLE \`todos\` (
+	\`id\` varchar(36) NOT NULL,
+	\`user_id\` varchar(36) NOT NULL,
+	\`title\` text NOT NULL,
+	\`completed\` boolean NOT NULL DEFAULT false,
+	\`created_at\` varchar(32) NOT NULL,
+	CONSTRAINT \`todos_id\` PRIMARY KEY(\`id\`)
+);
+--> statement-breakpoint
+CREATE TABLE \`user\` (
+	\`id\` varchar(36) NOT NULL,
+	\`name\` varchar(255) NOT NULL,
+	\`email\` varchar(255) NOT NULL,
+	\`email_verified\` boolean NOT NULL DEFAULT false,
+	\`image\` text,
+	\`created_at\` timestamp(3) NOT NULL,
+	\`updated_at\` timestamp(3) NOT NULL,
+	CONSTRAINT \`user_id\` PRIMARY KEY(\`id\`),
+	CONSTRAINT \`user_email_unique\` UNIQUE(\`email\`)
+);
+--> statement-breakpoint
+CREATE TABLE \`verification\` (
+	\`id\` varchar(36) NOT NULL,
+	\`identifier\` varchar(255) NOT NULL,
+	\`value\` text NOT NULL,
+	\`expires_at\` timestamp(3) NOT NULL,
+	\`created_at\` timestamp(3),
+	\`updated_at\` timestamp(3),
+	CONSTRAINT \`verification_id\` PRIMARY KEY(\`id\`)
+);
+--> statement-breakpoint
+ALTER TABLE \`account\` ADD CONSTRAINT \`account_user_id_user_id_fk\` FOREIGN KEY (\`user_id\`) REFERENCES \`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 \`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 \`user\`(\`id\`) ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX \`todos_user_idx\` ON \`todos\` (\`user_id\`,\`created_at\`);
+--> statement-breakpoint
+CREATE TABLE IF NOT EXISTS \`idempotency_records\` (
+      storage_key varchar(512) NOT NULL PRIMARY KEY,
+      namespace varchar(255) NOT NULL,
+      idempotency_key varchar(255) NOT NULL,
+      scope_key varchar(255) NOT NULL,
+      fingerprint varchar(255) NOT NULL,
+      status varchar(16) NOT NULL,
+      result_json longtext,
+      reserved_at varchar(32) NOT NULL,
+      completed_at varchar(32),
+      expires_at varchar(32),
+      updated_at varchar(32) NOT NULL,
+      INDEX \`idempotency_records_lookup_idx\` (namespace, scope_key, idempotency_key),
+      INDEX \`idempotency_records_expires_idx\` (expires_at)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_bin;
+`,
+  starterMigrationJournal: `{
+  "version": "7",
+  "dialect": "mysql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "5",
+      "when": 1781285557496,
+      "tag": "0000_starter",
+      "breakpoints": true
+    }
+  ]
+}`,
+  starterMigrationSnapshot: `{
+  "version": "5",
+  "dialect": "mysql",
+  "id": "597ed4cf-be53-41d9-9c60-d53032e7ca3f",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "account": {
+      "name": "account",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "varchar(36)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "account_id": {
+          "name": "account_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "varchar(36)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "id_token": {
+          "name": "id_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "access_token_expires_at": {
+          "name": "access_token_expires_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "refresh_token_expires_at": {
+          "name": "refresh_token_expires_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "password": {
+          "name": "password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "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": {
+        "account_id": {
+          "name": "account_id",
+          "columns": [
+            "id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraint": {}
+    },
+    "session": {
+      "name": "session",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "varchar(36)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "token": {
+          "name": "token",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ip_address": {
+          "name": "ip_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "varchar(36)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "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": {
+        "session_id": {
+          "name": "session_id",
+          "columns": [
+            "id"
+          ]
+        }
+      },
+      "uniqueConstraints": {
+        "session_token_unique": {
+          "name": "session_token_unique",
+          "columns": [
+            "token"
+          ]
+        }
+      },
+      "checkConstraint": {}
+    },
+    "todos": {
+      "name": "todos",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "varchar(36)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "varchar(36)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "completed": {
+          "name": "completed",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "varchar(32)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "todos_user_idx": {
+          "name": "todos_user_idx",
+          "columns": [
+            "user_id",
+            "created_at"
+          ],
+          "isUnique": false
+        }
+      },
+      "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": {
+        "todos_id": {
+          "name": "todos_id",
+          "columns": [
+            "id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraint": {}
+    },
+    "user": {
+      "name": "user",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "varchar(36)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "email_verified": {
+          "name": "email_verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "image": {
+          "name": "image",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "user_id": {
+          "name": "user_id",
+          "columns": [
+            "id"
+          ]
+        }
+      },
+      "uniqueConstraints": {
+        "user_email_unique": {
+          "name": "user_email_unique",
+          "columns": [
+            "email"
+          ]
+        }
+      },
+      "checkConstraint": {}
+    },
+    "verification": {
+      "name": "verification",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "varchar(36)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "identifier": {
+          "name": "identifier",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp(3)",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "verification_id": {
+          "name": "verification_id",
+          "columns": [
+            "id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraint": {}
+    }
+  },
+  "views": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "tables": {},
+    "indexes": {}
+  }
+}`,
+};