@beignet/cli 0.0.9 → 0.0.10

package/dist/templates/db/sqlite.js

@@ -0,0 +1,878 @@
+// 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, paste drizzle/0000_starter.sql, drizzle/meta/_journal.json,
+// and drizzle/meta/0000_snapshot.json back here verbatim, then append the
+// output of createDrizzleSqliteIdempotencySetupStatements() from
+// @beignet/provider-db-drizzle/sqlite 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.
+const files = {
+    drizzleConfig: `export default {
+	schema: "./infra/db/schema/index.ts",
+	out: "./drizzle",
+	dialect: "sqlite",
+	dbCredentials: {
+		url: process.env.SQLITE_DB_URL ?? "file:local.db",
+		authToken: process.env.SQLITE_DB_AUTH_TOKEN,
+	},
+};
+`,
+    dbSchema: `import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const user = sqliteTable("user", {
+	id: text("id").primaryKey(),
+	name: text("name").notNull(),
+	email: text("email").notNull().unique(),
+	emailVerified: integer("email_verified", { mode: "boolean" })
+		.notNull()
+		.default(false),
+	image: text("image"),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+});
+
+export const session = sqliteTable("session", {
+	id: text("id").primaryKey(),
+	expiresAt: integer("expires_at", { mode: "timestamp" }).notNull(),
+	token: text("token").notNull().unique(),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+	ipAddress: text("ip_address"),
+	userAgent: text("user_agent"),
+	userId: text("user_id")
+		.notNull()
+		.references(() => user.id, { onDelete: "cascade" }),
+});
+
+export const account = sqliteTable("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: integer("access_token_expires_at", {
+		mode: "timestamp",
+	}),
+	refreshTokenExpiresAt: integer("refresh_token_expires_at", {
+		mode: "timestamp",
+	}),
+	scope: text("scope"),
+	password: text("password"),
+	createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+});
+
+export const verification = sqliteTable("verification", {
+	id: text("id").primaryKey(),
+	identifier: text("identifier").notNull(),
+	value: text("value").notNull(),
+	expiresAt: integer("expires_at", { mode: "timestamp" }).notNull(),
+	createdAt: integer("created_at", { mode: "timestamp" }),
+	updatedAt: integer("updated_at", { mode: "timestamp" }),
+});
+
+export const todos = sqliteTable(
+	"todos",
+	{
+		id: text("id").primaryKey(),
+		userId: text("user_id")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		title: text("title").notNull(),
+		completed: integer("completed", { mode: "boolean" })
+			.notNull()
+			.default(false),
+		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 { DrizzleSqliteDatabase } from "@beignet/provider-db-drizzle/sqlite";
+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: DrizzleSqliteDatabase<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 { DrizzleSqliteDatabase } from "@beignet/provider-db-drizzle/sqlite";
+import { createDrizzleTodoRepository } from "@/infra/todos/drizzle-todo-repository";
+import type { AppTransactionPorts } from "@/ports";
+import * as schema from "./schema";
+
+export function createRepositories(
+	db: DrizzleSqliteDatabase<typeof schema>,
+): Omit<AppTransactionPorts, "idempotency"> {
+	return {
+		todos: createDrizzleTodoRepository(db),
+	};
+}
+`,
+    databaseReady: `import type { Client } from "@libsql/client";
+import { drizzle } from "drizzle-orm/libsql";
+import { migrate } from "drizzle-orm/libsql/migrator";
+
+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. Next.js collects page data in parallel workers
+ * that can all reach this at once, so the busy timeout makes concurrent
+ * SQLite access wait instead of failing with SQLITE_BUSY.
+ */
+export function ensureDatabaseReady(client: Client): Promise<void> {
+	ready ??= prepare(client);
+	return ready;
+}
+
+async function prepare(client: Client): Promise<void> {
+	await client.execute("PRAGMA busy_timeout = 5000");
+
+	if (process.env.NODE_ENV === "production") {
+		const tables = await client.execute(
+			"SELECT name FROM sqlite_master WHERE type = 'table' AND 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(client), { migrationsFolder: "drizzle" });
+}
+`,
+    dbProvider: `import type { beignetServerOnly } from "@beignet/core/server-only";
+import { createProvider } from "@beignet/core/providers";
+import {
+	createDrizzleSqliteIdempotencyPort,
+	createDrizzleSqliteUnitOfWork,
+	type DbPort,
+} from "@beignet/provider-db-drizzle/sqlite";
+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 createDrizzleSqliteProvider({ schema }) before it.",
+			);
+		}
+
+		const repositories = createRepositories(dbPort.db);
+		const idempotency = createDrizzleSqliteIdempotencyPort(dbPort.db);
+
+		const providedPorts: Pick<AppPorts, "idempotency" | "todos" | "uow"> = {
+			...repositories,
+			idempotency,
+			uow: createDrizzleSqliteUnitOfWork({
+				db: dbPort.db,
+				createTransactionPorts: (tx) => ({
+					...createRepositories(tx),
+					idempotency: createDrizzleSqliteIdempotencyPort(tx),
+				}),
+			}),
+		};
+
+		return {
+			ports: providedPorts,
+			async start() {
+				await ensureDatabaseReady(dbPort.client);
+			},
+		};
+	},
+});
+`,
+    dbReset: `import { createClient } from "@libsql/client";
+import { drizzle } from "drizzle-orm/libsql";
+import { migrate } from "drizzle-orm/libsql/migrator";
+import { env } from "@/lib/env";
+
+if (
+	!env.SQLITE_DB_URL.startsWith("file:") &&
+	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 client = createClient({
+	url: env.SQLITE_DB_URL,
+	authToken: env.SQLITE_DB_AUTH_TOKEN,
+});
+
+try {
+	await client.execute("PRAGMA foreign_keys = OFF");
+	try {
+		for (const table of tables) {
+			await client.execute(\`DROP TABLE IF EXISTS \${table}\`);
+		}
+	} finally {
+		await client.execute("PRAGMA foreign_keys = ON");
+	}
+
+	await migrate(drizzle(client), { migrationsFolder: "drizzle" });
+	console.log("Database reset.");
+} finally {
+	client.close();
+}
+`,
+    dbTestDatabase: `import { existsSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { type Client, createClient } from "@libsql/client";
+import { drizzle, type LibSQLDatabase } from "drizzle-orm/libsql";
+import { migrate } from "drizzle-orm/libsql/migrator";
+import { createRepositories } from "./repositories";
+import * as schema from "./schema";
+
+export type TestDatabase = {
+	client: Client;
+	db: LibSQLDatabase<typeof schema>;
+	repositories: ReturnType<typeof createRepositories>;
+	path: string;
+	close(): Promise<void>;
+};
+
+export async function createTestDatabase(): Promise<TestDatabase> {
+	const path = join(tmpdir(), "beignet-test-" + crypto.randomUUID() + ".db");
+	const client = createClient({ url: "file:" + path });
+	const db = drizzle(client, { schema });
+	await migrate(db, { migrationsFolder: "drizzle" });
+
+	return {
+		client,
+		db,
+		repositories: createRepositories(db),
+		path,
+		close: async () => {
+			client.close();
+			if (existsSync(path)) {
+				unlinkSync(path);
+			}
+		},
+	};
+}
+`,
+    // 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\` integer,
+	\`refresh_token_expires_at\` integer,
+	\`scope\` text,
+	\`password\` text,
+	\`created_at\` integer NOT NULL,
+	\`updated_at\` integer NOT NULL,
+	FOREIGN KEY (\`user_id\`) REFERENCES \`user\`(\`id\`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE TABLE \`session\` (
+	\`id\` text PRIMARY KEY NOT NULL,
+	\`expires_at\` integer NOT NULL,
+	\`token\` text NOT NULL,
+	\`created_at\` integer NOT NULL,
+	\`updated_at\` integer NOT NULL,
+	\`ip_address\` text,
+	\`user_agent\` text,
+	\`user_id\` text NOT NULL,
+	FOREIGN KEY (\`user_id\`) REFERENCES \`user\`(\`id\`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`session_token_unique\` ON \`session\` (\`token\`);--> statement-breakpoint
+CREATE TABLE \`todos\` (
+	\`id\` text PRIMARY KEY NOT NULL,
+	\`user_id\` text NOT NULL,
+	\`title\` text NOT NULL,
+	\`completed\` integer DEFAULT false NOT NULL,
+	\`created_at\` text NOT NULL,
+	FOREIGN KEY (\`user_id\`) REFERENCES \`user\`(\`id\`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX \`todos_user_idx\` ON \`todos\` (\`user_id\`,\`created_at\`);--> statement-breakpoint
+CREATE TABLE \`user\` (
+	\`id\` text PRIMARY KEY NOT NULL,
+	\`name\` text NOT NULL,
+	\`email\` text NOT NULL,
+	\`email_verified\` integer DEFAULT false NOT NULL,
+	\`image\` text,
+	\`created_at\` integer NOT NULL,
+	\`updated_at\` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`user_email_unique\` ON \`user\` (\`email\`);--> statement-breakpoint
+CREATE TABLE \`verification\` (
+	\`id\` text PRIMARY KEY NOT NULL,
+	\`identifier\` text NOT NULL,
+	\`value\` text NOT NULL,
+	\`expires_at\` integer NOT NULL,
+	\`created_at\` integer,
+	\`updated_at\` integer
+);
+--> 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": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1781285554238,
+      "tag": "0000_starter",
+      "breakpoints": true
+    }
+  ]
+}`,
+    starterMigrationSnapshot: `{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "1fa6ba12-5a4d-4815-bda1-225734f18921",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "account": {
+      "name": "account",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "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": "text",
+          "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": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "refresh_token_expires_at": {
+          "name": "refresh_token_expires_at",
+          "type": "integer",
+          "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": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "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": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "session": {
+      "name": "session",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "token": {
+          "name": "token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "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": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "session_token_unique": {
+          "name": "session_token_unique",
+          "columns": [
+            "token"
+          ],
+          "isUnique": true
+        }
+      },
+      "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": {},
+      "checkConstraints": {}
+    },
+    "todos": {
+      "name": "todos",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "completed": {
+          "name": "completed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "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": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "user": {
+      "name": "user",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "email_verified": {
+          "name": "email_verified",
+          "type": "integer",
+          "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": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "user_email_unique": {
+          "name": "user_email_unique",
+          "columns": [
+            "email"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "verification": {
+      "name": "verification",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "identifier": {
+          "name": "identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}`,
+};
+export function sqliteDbFiles() {
+    return files;
+}
+//# sourceMappingURL=sqlite.js.map