@effect-auth/core 0.1.0-alpha.18 → 0.1.0-alpha.19

package/dist/StorageSchemaGenerator.js

@@ -1,10 +1,40 @@
 import { postgresAuthStorageMigrations } from "./PostgresStorageMigrations.js";
+import { sqliteAuthStorageSchema } from "./SqliteStorageSchemaData.js";
 export const storageSchemaGeneratorApiVersion = "effect-auth.storage-schema-generator/v1";
-export const storageSchemaGeneratorVersion = "1.1.0";
-export const storageSchemaVersion = "0009_auth_permissions";
-export const supportedStorageDatabases = ["postgres"];
+export const storageSchemaGeneratorVersion = "1.5.0";
+export const storageSchemaVersion = "0010_auth_oauth_device_authorization";
+export const storageSchemaVersions = {
+    postgres: storageSchemaVersion,
+    sqlite: "0029_auth_oauth_device_authorization",
+};
+export const supportedStorageDatabases = ["postgres", "sqlite"];
 export const supportedStorageAdapters = ["effect-qb", "drizzle"];
 export const supportedStorageGeneratorModes = ["fresh"];
+export const supportedDevelopmentSeedTargets = [
+    "alchemy-d1",
+    "bun-sqlite",
+    "node-sqlite",
+    "postgres",
+];
+export const supportedDevelopmentSeedComplexities = ["medium", "low"];
+export const storageDatabaseAdapters = {
+    postgres: supportedStorageAdapters,
+    sqlite: supportedStorageAdapters,
+};
+export const developmentSeedTargetsByDatabase = {
+    postgres: ["postgres"],
+    sqlite: ["alchemy-d1", "bun-sqlite", "node-sqlite"],
+};
+export const developmentSeedTargetsByDatabaseAdapter = {
+    postgres: {
+        "effect-qb": ["postgres"],
+        drizzle: ["postgres"],
+    },
+    sqlite: {
+        "effect-qb": ["alchemy-d1"],
+        drizzle: ["alchemy-d1", "bun-sqlite", "node-sqlite"],
+    },
+};
 export const storageModuleCatalog = [
     {
         id: "core",
@@ -122,6 +152,7 @@ export const storageModuleCatalog = [
             "auth_oauth_client",
             "auth_oauth_consent",
             "auth_oauth_authorization_code",
+            "auth_oauth_device_authorization",
             "auth_oauth_client_secret",
             "auth_oauth_provider_mode_token",
         ],
@@ -261,16 +292,22 @@ export const storageSchemaGeneratorCatalog = {
     apiVersion: storageSchemaGeneratorApiVersion,
     generatorVersion: storageSchemaGeneratorVersion,
     schemaVersion: storageSchemaVersion,
+    schemaVersions: storageSchemaVersions,
     databases: supportedStorageDatabases,
     adapters: supportedStorageAdapters,
+    databaseAdapters: storageDatabaseAdapters,
     adapterOutputs: {
-        "effect-qb": ["migration-sql"],
-        drizzle: ["migration-sql", "drizzle-schema"],
+        "effect-qb": ["migration-sql", "development-seed"],
+        drizzle: ["migration-sql", "drizzle-schema", "development-seed"],
     },
     modes: supportedStorageGeneratorModes,
-    outputKinds: ["migration-sql", "drizzle-schema"],
+    outputKinds: ["migration-sql", "drizzle-schema", "development-seed"],
     sqlLayouts: ["single", "module"],
     drizzleLayouts: ["single", "module", "table"],
+    developmentSeedTargets: supportedDevelopmentSeedTargets,
+    developmentSeedTargetsByDatabase,
+    developmentSeedTargetsByDatabaseAdapter,
+    developmentSeedComplexities: supportedDevelopmentSeedComplexities,
     features: storageFeatureCatalog,
     modules: storageModuleCatalog,
 };
@@ -343,20 +380,20 @@ const splitSqlStatements = (sql) => {
     }
     return statements;
 };
-const canonicalTables = (() => {
+const buildCanonicalTables = (database, sqlSources) => {
     const creates = new Map();
     const indexes = new Map();
     let order = 0;
-    for (const migration of postgresAuthStorageMigrations) {
-        for (const statement of splitSqlStatements(migration.sql)) {
-            const createMatch = /^create table ([a-z0-9_]+)\s*\(/i.exec(statement);
+    for (const sql of sqlSources) {
+        for (const statement of splitSqlStatements(sql)) {
+            const createMatch = /^create table (?:if not exists )?([a-z0-9_]+)\s*\(/i.exec(statement);
             if (createMatch?.[1] !== undefined) {
                 creates.set(createMatch[1], { sql: statement, order });
                 indexes.set(createMatch[1], []);
                 order += 1;
                 continue;
             }
-            const indexMatch = /^create (?:unique )?index [a-z0-9_]+\s+on ([a-z0-9_]+)\s*\(/i.exec(statement);
+            const indexMatch = /^create (?:unique )?index (?:if not exists )?[a-z0-9_]+\s+on ([a-z0-9_]+)\s*\(/i.exec(statement);
             if (indexMatch?.[1] !== undefined) {
                 const tableIndexes = indexes.get(indexMatch[1]);
                 if (tableIndexes === undefined) {
@@ -366,6 +403,16 @@ const canonicalTables = (() => {
             }
         }
     }
+    const oauthClient = creates.get("auth_oauth_client");
+    if (database === "postgres" && oauthClient !== undefined) {
+        const previous = '@ != "client_credentials"))\'))';
+        const replacement = '@ != "client_credentials" && @ != "urn:ietf:params:oauth:grant-type:device_code"))\'))';
+        const sql = oauthClient.sql.replace(previous, replacement);
+        if (sql === oauthClient.sql) {
+            throw new Error("Unable to apply the OAuth device-code grant constraint");
+        }
+        creates.set("auth_oauth_client", { ...oauthClient, sql });
+    }
     const result = [];
     for (const [name, create] of creates) {
         const moduleId = tableModule.get(name);
@@ -387,7 +434,12 @@ const canonicalTables = (() => {
     }
     // oxlint-disable-next-line unicorn/no-array-sort -- ES2023 toSorted is outside the supported target.
     return result.sort((left, right) => left.order - right.order);
-})();
+};
+const canonicalTablesByDatabase = {
+    postgres: buildCanonicalTables("postgres", postgresAuthStorageMigrations.map((migration) => migration.sql)),
+    sqlite: buildCanonicalTables("sqlite", [sqliteAuthStorageSchema]),
+};
+const canonicalTables = canonicalTablesByDatabase.postgres;
 const splitTopLevel = (value) => {
     const parts = [];
     let depth = 0;
@@ -429,8 +481,9 @@ const splitTopLevel = (value) => {
     parts.push(value.slice(start).trim());
     return parts.filter((part) => part.length > 0);
 };
+// oxlint-disable-next-line eslint/complexity -- one pass handles both dialects' column and constraint syntax
 const parseCanonicalTable = (canonical) => {
-    const tableMatch = /^create table [a-z0-9_]+\s*\(([\s\S]*)\);$/i.exec(canonical.createTable);
+    const tableMatch = /^create table (?:if not exists )?[a-z0-9_]+\s*\(([\s\S]*)\);$/i.exec(canonical.createTable);
     if (tableMatch?.[1] === undefined) {
         throw new Error(`Unable to parse canonical table ${canonical.name}`);
     }
@@ -453,6 +506,24 @@ const parseCanonicalTable = (canonical) => {
                 });
             continue;
         }
+        const primaryKeyMatch = /^primary key\s*\(([\s\S]*)\)$/i.exec(definition);
+        if (primaryKeyMatch?.[1] !== undefined) {
+            constraints.push({
+                name: `${canonical.name}_pkey`,
+                kind: "primary-key",
+                columns: splitTopLevel(primaryKeyMatch[1]).map((column) => column.trim().split(/\s+/u)[0].toLowerCase()),
+            });
+            continue;
+        }
+        const tableCheckMatch = /^check\s*\(([\s\S]*)\)$/i.exec(definition);
+        if (tableCheckMatch?.[1] !== undefined) {
+            constraints.push({
+                name: `${canonical.name}_state_check`,
+                kind: "check",
+                expression: tableCheckMatch[1].trim(),
+            });
+            continue;
+        }
         const columnMatch = /^([a-z0-9_]+)\s+(text|bigint|integer|boolean|jsonb)\b([\s\S]*)$/i.exec(definition);
         if (columnMatch === null) {
             throw new Error(`Unable to parse column definition in ${canonical.name}: ${definition}`);
@@ -461,32 +532,58 @@ const parseCanonicalTable = (canonical) => {
         if (name === undefined || rawType === undefined) {
             throw new Error(`Unable to parse column in ${canonical.name}`);
         }
-        const inlinePrimaryKey = /constraint ([a-z0-9_]+) primary key/i.exec(modifiers);
-        if (inlinePrimaryKey?.[1] !== undefined) {
+        const inlinePrimaryKey = /\bprimary key\b/i.test(modifiers);
+        const namedPrimaryKey = /constraint ([a-z0-9_]+) primary key/i.exec(modifiers)?.[1];
+        if (inlinePrimaryKey) {
             constraints.push({
-                name: inlinePrimaryKey[1],
+                name: namedPrimaryKey ?? `${canonical.name}_pkey`,
                 kind: "primary-key",
                 columns: [name],
             });
         }
+        if (/\bunique\b/i.test(modifiers)) {
+            constraints.push({
+                name: `${canonical.name}_${name}_key`,
+                kind: "unique",
+                columns: [name],
+            });
+        }
+        const inlineCheck = /\bcheck\s*\(([\s\S]*)\)\s*$/i.exec(modifiers);
+        if (inlineCheck?.[1] !== undefined) {
+            constraints.push({
+                name: `${canonical.name}_${name}_check`,
+                kind: "check",
+                expression: inlineCheck[1].trim(),
+            });
+        }
         const defaultMatch = /\bdefault\s+(false|true|-?\d+|'(?:''|[^'])*')/i.exec(modifiers);
         const defaultValue = defaultMatch?.[1];
         columns.push({
             name,
             type: rawType.toLowerCase(),
-            notNull: /\bnot null\b/i.test(modifiers) || inlinePrimaryKey !== null,
+            notNull: /\bnot null\b/i.test(modifiers) || inlinePrimaryKey,
             defaultValue: defaultValue === undefined
                 ? undefined
                 : /^(?:false|true)$/iu.test(defaultValue)
                     ? defaultValue.toLowerCase()
                     : defaultValue,
             identity: /\bgenerated always as identity\b/i.test(modifiers),
+            autoincrement: /\bautoincrement\b/i.test(modifiers),
             collateC: /\bcollate "C"/i.test(modifiers),
         });
     }
     return { canonical, columns, constraints };
 };
-const parsedTableByName = new Map(canonicalTables.map((table) => [table.name, parseCanonicalTable(table)]));
+const parsedTableByDatabase = {
+    postgres: new Map(canonicalTablesByDatabase.postgres.map((table) => [
+        table.name,
+        parseCanonicalTable(table),
+    ])),
+    sqlite: new Map(canonicalTablesByDatabase.sqlite.map((table) => [
+        table.name,
+        parseCanonicalTable(table),
+    ])),
+};
 const compareByOrder = (order) => (left, right) => (order.get(left) ?? Number.MAX_SAFE_INTEGER) -
     (order.get(right) ?? Number.MAX_SAFE_INTEGER);
 const resolveModules = (directModules) => {
@@ -535,6 +632,21 @@ export const resolveStorageFeatures = (features) => {
         impliedModules: modules.filter((moduleId) => !directModules.has(moduleId)),
     };
 };
+const includeDevelopmentSeedRequirements = (selection) => {
+    if (selection.modules.includes("core")) {
+        return selection;
+    }
+    const modules = resolveModules(new Set([...selection.modules, "core"]));
+    const selectedModules = new Set(modules);
+    return {
+        ...selection,
+        modules,
+        tables: canonicalTables
+            .filter((table) => selectedModules.has(table.module))
+            .map((table) => table.name),
+        impliedModules: [...selection.impliedModules, "core"],
+    };
+};
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const assertKnownKeys = (value, keys, path, code) => {
     const allowed = new Set(keys);
@@ -551,9 +663,10 @@ const normalizeRequest = (input) => {
     }
     const request = input;
     assertKnownKeys(request, ["database", "adapter", "mode", "features", "outputs"], "$", "INVALID_REQUEST");
-    if (request.database !== "postgres") {
-        throw new StorageSchemaGeneratorError("UNSUPPORTED_DATABASE", "database", `Unsupported database ${JSON.stringify(request.database)}.`, ["postgres"]);
+    if (request.database !== "postgres" && request.database !== "sqlite") {
+        throw new StorageSchemaGeneratorError("UNSUPPORTED_DATABASE", "database", `Unsupported database ${JSON.stringify(request.database)}.`, supportedStorageDatabases);
     }
+    const { database } = request;
     if (request.adapter !== "effect-qb" && request.adapter !== "drizzle") {
         throw new StorageSchemaGeneratorError("UNSUPPORTED_ADAPTER", "adapter", `Unsupported adapter ${JSON.stringify(request.adapter)}.`, supportedStorageAdapters);
     }
@@ -573,7 +686,7 @@ const normalizeRequest = (input) => {
         features.push(feature);
     }
     if (!Array.isArray(request.outputs) || request.outputs.length === 0) {
-        throw new StorageSchemaGeneratorError("INVALID_REQUEST", "outputs", "At least one output is required.", ["migration-sql", "drizzle-schema"]);
+        throw new StorageSchemaGeneratorError("INVALID_REQUEST", "outputs", "At least one output is required.", ["migration-sql", "drizzle-schema", "development-seed"]);
     }
     const outputs = [];
     const outputKinds = new Set();
@@ -582,14 +695,15 @@ const normalizeRequest = (input) => {
         if (!isRecord(output)) {
             throw new StorageSchemaGeneratorError("INVALID_OUTPUT", path, "Each output must be an object.");
         }
-        assertKnownKeys(output, ["kind", "layout", "includeRelations"], path, "INVALID_OUTPUT");
         if (output.kind === "migration-sql") {
+            assertKnownKeys(output, ["kind", "layout"], path, "INVALID_OUTPUT");
             if (output.layout !== "single" && output.layout !== "module") {
                 throw new StorageSchemaGeneratorError("INVALID_OUTPUT", `${path}.layout`, `Invalid migration SQL layout ${JSON.stringify(output.layout)}.`, ["single", "module"]);
             }
             outputs.push({ kind: "migration-sql", layout: output.layout });
         }
         else if (output.kind === "drizzle-schema") {
+            assertKnownKeys(output, ["kind", "layout", "includeRelations"], path, "INVALID_OUTPUT");
             if (output.layout !== "single" &&
                 output.layout !== "module" &&
                 output.layout !== "table") {
@@ -605,8 +719,29 @@ const normalizeRequest = (input) => {
                 includeRelations: output.includeRelations === true,
             });
         }
+        else if (output.kind === "development-seed") {
+            assertKnownKeys(output, ["kind", "target", "complexity"], path, "INVALID_OUTPUT");
+            if (typeof output.target !== "string" ||
+                !supportedDevelopmentSeedTargets.includes(output.target)) {
+                throw new StorageSchemaGeneratorError("INVALID_OUTPUT", `${path}.target`, `Invalid development seed target ${JSON.stringify(output.target)}.`, supportedDevelopmentSeedTargets);
+            }
+            if (!developmentSeedTargetsByDatabaseAdapter[database][adapter].includes(output.target)) {
+                throw new StorageSchemaGeneratorError("INVALID_OUTPUT", `${path}.target`, `Development seed target ${JSON.stringify(output.target)} is not available for ${database}.`, developmentSeedTargetsByDatabaseAdapter[database][adapter]);
+            }
+            if (output.complexity !== undefined &&
+                output.complexity !== "medium" &&
+                output.complexity !== "low") {
+                throw new StorageSchemaGeneratorError("INVALID_OUTPUT", `${path}.complexity`, `Invalid development seed complexity ${JSON.stringify(output.complexity)}.`, supportedDevelopmentSeedComplexities);
+            }
+            outputs.push({
+                kind: "development-seed",
+                target: output.target,
+                complexity: output.complexity ??
+                    "medium",
+            });
+        }
         else {
-            throw new StorageSchemaGeneratorError("INVALID_OUTPUT", `${path}.kind`, `Unsupported output kind ${JSON.stringify(output.kind)}.`, ["migration-sql", "drizzle-schema"]);
+            throw new StorageSchemaGeneratorError("INVALID_OUTPUT", `${path}.kind`, `Unsupported output kind ${JSON.stringify(output.kind)}.`, ["migration-sql", "drizzle-schema", "development-seed"]);
         }
         if (outputKinds.has(output.kind)) {
             throw new StorageSchemaGeneratorError("DUPLICATE_OUTPUT", `${path}.kind`, `Only one ${String(output.kind)} output may be requested.`, ["Combine the requested files by choosing one layout."]);
@@ -614,20 +749,28 @@ const normalizeRequest = (input) => {
         outputKinds.add(output.kind);
     }
     if (adapter === "effect-qb") {
-        const unsupportedOutputIndex = outputs.findIndex((output) => output.kind !== "migration-sql");
+        const unsupportedOutputIndex = outputs.findIndex((output) => output.kind === "drizzle-schema");
         if (unsupportedOutputIndex !== -1) {
-            throw new StorageSchemaGeneratorError("UNSUPPORTED_OUTPUT_FOR_ADAPTER", `outputs[${unsupportedOutputIndex}].kind`, "The effect-qb adapter owns its table declarations and only requires migration SQL.", ["migration-sql"]);
+            throw new StorageSchemaGeneratorError("UNSUPPORTED_OUTPUT_FOR_ADAPTER", `outputs[${unsupportedOutputIndex}].kind`, "The effect-qb adapter owns its table declarations and does not generate a Drizzle schema.", ["migration-sql", "development-seed"]);
         }
     }
     // oxlint-disable-next-line unicorn/no-array-sort -- ES2023 toSorted is outside the supported target.
     outputs.sort((left, right) => {
         if (left.kind !== right.kind) {
-            return left.kind === "migration-sql" ? -1 : 1;
+            const order = new Map([
+                ["migration-sql", 0],
+                ["drizzle-schema", 1],
+                ["development-seed", 2],
+            ]);
+            return (order.get(left.kind) ?? 3) - (order.get(right.kind) ?? 3);
+        }
+        if (left.kind === "development-seed") {
+            return left.target.localeCompare(right.target);
         }
         return left.layout.localeCompare(right.layout);
     });
     return {
-        database: "postgres",
+        database,
         adapter,
         mode: "fresh",
         // oxlint-disable-next-line unicorn/no-array-sort -- ES2023 toSorted is outside the supported target.
@@ -639,9 +782,9 @@ const renderCanonicalSql = (tables) => `${tables
     .flatMap((table) => [table.createTable, ...table.indexes])
     .join("\n\n")}
 `;
-const sqlFiles = (layout, selection) => {
+const sqlFiles = (database, layout, selection) => {
     const selectedTables = new Set(selection.tables);
-    const tables = canonicalTables.filter((table) => selectedTables.has(table.name));
+    const tables = canonicalTablesByDatabase[database].filter((table) => selectedTables.has(table.name));
     if (layout === "single") {
         return [
             {
@@ -660,34 +803,42 @@ const sqlFiles = (layout, selection) => {
 const camelCase = (value) => value.replaceAll(/_([a-z0-9])/g, (_, character) => character.toUpperCase());
 const kebabCase = (value) => value.replaceAll("_", "-");
 const escapeTemplate = (value) => value.replaceAll("`", "\\`").replaceAll("${", "\\${");
-const renderColumn = (column) => {
+const renderColumn = (column, database) => {
     let expression;
-    switch (column.type) {
-        case "bigint": {
-            expression = `bigint(${JSON.stringify(column.name)}, { mode: "number" })`;
-            break;
-        }
-        case "boolean": {
-            expression = `boolean(${JSON.stringify(column.name)})`;
-            break;
-        }
-        case "integer": {
-            expression = `integer(${JSON.stringify(column.name)})`;
-            break;
-        }
-        case "jsonb": {
-            expression = `jsonb(${JSON.stringify(column.name)})`;
-            break;
-        }
-        case "text": {
-            expression = `${column.collateC ? "textC" : "text"}(${JSON.stringify(column.name)})`;
-            break;
+    if (database === "sqlite") {
+        expression = `${column.type === "integer" ? "integer" : "text"}(${JSON.stringify(column.name)})`;
+    }
+    else {
+        switch (column.type) {
+            case "bigint": {
+                expression = `bigint(${JSON.stringify(column.name)}, { mode: "number" })`;
+                break;
+            }
+            case "boolean": {
+                expression = `boolean(${JSON.stringify(column.name)})`;
+                break;
+            }
+            case "integer": {
+                expression = `integer(${JSON.stringify(column.name)})`;
+                break;
+            }
+            case "jsonb": {
+                expression = `jsonb(${JSON.stringify(column.name)})`;
+                break;
+            }
+            case "text": {
+                expression = `${column.collateC ? "textC" : "text"}(${JSON.stringify(column.name)})`;
+                break;
+            }
         }
     }
-    if (column.identity) {
+    if (column.autoincrement) {
+        expression += ".primaryKey({ autoIncrement: true })";
+    }
+    else if (column.identity) {
         expression += ".generatedAlwaysAsIdentity()";
     }
-    if (column.notNull && !column.identity) {
+    if (column.notNull && !column.identity && !column.autoincrement) {
         expression += ".notNull()";
     }
     if (column.defaultValue !== undefined) {
@@ -710,7 +861,7 @@ const renderIndexColumn = (value) => {
         : `t.${column}`;
 };
 const renderIndex = (statement) => {
-    const match = /^create (unique )?index ([a-z0-9_]+)\s+on [a-z0-9_]+\s*\(([\s\S]*?)\)(?:\s+where\s+([\s\S]+?))?;$/i.exec(statement);
+    const match = /^create (unique )?index (?:if not exists )?([a-z0-9_]+)\s+on [a-z0-9_]+\s*\(([\s\S]*?)\)(?:\s+where\s+([\s\S]+?))?;$/i.exec(statement);
     if (match === null || match[2] === undefined || match[3] === undefined) {
         throw new Error(`Unable to render canonical index: ${statement}`);
     }
@@ -738,16 +889,27 @@ const renderConstraint = (constraint) => {
         }
     }
 };
-const drizzleImports = (tables) => {
-    const imports = new Set(["pgTable"]);
+const isAutoincrementPrimaryKey = (table, constraint) => constraint.kind === "primary-key" &&
+    constraint.columns?.some((columnName) => table.columns.some((column) => column.name === columnName && column.autoincrement)) === true;
+const drizzleImports = (database, tables) => {
+    const imports = new Set([
+        database === "postgres" ? "pgTable" : "sqliteTable",
+    ]);
     for (const table of tables) {
         for (const column of table.columns) {
-            imports.add(column.type);
-            if (column.collateC) {
+            imports.add(database === "sqlite"
+                ? column.type === "integer"
+                    ? "integer"
+                    : "text"
+                : column.type);
+            if (database === "postgres" && column.collateC) {
                 imports.add("customType");
             }
         }
         for (const constraint of table.constraints) {
+            if (isAutoincrementPrimaryKey(table, constraint)) {
+                continue;
+            }
             imports.add(constraint.kind === "primary-key"
                 ? "primaryKey"
                 : constraint.kind === "unique"
@@ -767,31 +929,34 @@ const drizzleImports = (tables) => {
     // oxlint-disable-next-line unicorn/no-array-sort -- ES2023 toSorted is outside the supported target.
     return [...imports].sort();
 };
-const renderTable = (table) => {
+const renderTable = (database, table) => {
     const variable = camelCase(table.canonical.name);
     const extras = [
-        ...table.constraints.map(renderConstraint),
+        ...table.constraints
+            .filter((constraint) => !isAutoincrementPrimaryKey(table, constraint))
+            .map(renderConstraint),
         ...table.canonical.indexes.map(renderIndex),
     ];
-    return `export const ${variable} = pgTable(
+    return `export const ${variable} = ${database === "postgres" ? "pgTable" : "sqliteTable"}(
   ${JSON.stringify(table.canonical.name)},
   {
-${table.columns.map(renderColumn).join("\n")}
+${table.columns.map((column) => renderColumn(column, database)).join("\n")}
   },
   (t) => [
 ${extras.join("\n")}
   ]
 );`;
 };
-const renderDrizzleTables = (tables) => {
-    const imports = drizzleImports(tables);
+const renderDrizzleTables = (database, tables) => {
+    const imports = drizzleImports(database, tables);
     const usesSql = imports.includes("sql");
-    const pgImports = imports.filter((name) => name !== "sql");
+    const databaseImports = imports.filter((name) => name !== "sql");
     const importLines = [
         ...(usesSql ? ['import { sql } from "drizzle-orm";'] : []),
-        `import { ${pgImports.join(", ")} } from "drizzle-orm/pg-core";`,
+        `import { ${databaseImports.join(", ")} } from "drizzle-orm/${database === "postgres" ? "pg-core" : "sqlite-core"}";`,
     ];
-    const collatedText = tables.some((table) => table.columns.some((column) => column.collateC))
+    const collatedText = database === "postgres" &&
+        tables.some((table) => table.columns.some((column) => column.collateC))
         ? `
 const textC = customType<{ data: string }>({
   dataType: () => 'text collate "C"',
@@ -799,7 +964,7 @@ const textC = customType<{ data: string }>({
         : "";
     return `${importLines.join("\n")}${collatedText}
 
-${tables.map(renderTable).join("\n\n")}
+${tables.map((table) => renderTable(database, table)).join("\n\n")}
 `;
 };
 // oxlint-disable-next-line eslint/complexity -- each branch describes one canonical relation family
@@ -844,6 +1009,7 @@ const logicalRelations = (tables) => {
         for (const tableName of [
             "auth_oauth_consent",
             "auth_oauth_authorization_code",
+            "auth_oauth_device_authorization",
             "auth_oauth_client_secret",
             "auth_oauth_provider_mode_token",
         ]) {
@@ -886,7 +1052,7 @@ const logicalRelations = (tables) => {
     addRelation("auth_role_permission", "permission_id", "auth_permission_definition", "id", "permission");
     return relations;
 };
-const renderRelations = (tables, schemaExpression, importPath) => {
+const renderRelations = (database, tables, schemaExpression, importPath) => {
     const relations = logicalRelations(tables);
     const grouped = new Map();
     for (const relation of relations) {
@@ -916,7 +1082,7 @@ ${tableRelations
     ];
     return `${imports.join("\n")}
 
-// Drizzle relations are application-level only and do not create PostgreSQL foreign keys.
+// Drizzle relations are application-level only and do not create ${database === "postgres" ? "PostgreSQL" : "SQLite"} foreign keys.
 export const relations = defineRelations(${schemaExpression}, (r) => ({
 ${entries.join("\n")}
 }));
@@ -924,18 +1090,18 @@ ${entries.join("\n")}
 };
 const exportFile = (paths) => `${paths.map((path) => `export * from ${JSON.stringify(path)};`).join("\n")}
 `;
-const drizzleFiles = (layout, includeRelations, selection) => {
+const drizzleFiles = (database, layout, includeRelations, selection) => {
     const selected = new Set(selection.tables);
-    const tables = canonicalTables
+    const tables = canonicalTablesByDatabase[database]
         .filter((table) => selected.has(table.name))
-        .map((table) => parsedTableByName.get(table.name));
+        .map((table) => parsedTableByDatabase[database].get(table.name));
     if (layout === "single") {
-        let content = renderDrizzleTables(tables);
+        let content = renderDrizzleTables(database, tables);
         if (includeRelations) {
             const schema = `{ ${tables
                 .map((table) => camelCase(table.canonical.name))
                 .join(", ")} }`;
-            content += `\n${renderRelations(tables, schema)}`;
+            content += `\n${renderRelations(database, tables, schema)}`;
         }
         return [{ path: "schema.ts", mediaType: "text/typescript", content }];
     }
@@ -952,7 +1118,7 @@ const drizzleFiles = (layout, includeRelations, selection) => {
     const files = groups.map((group) => ({
         path: `${directory}/${group.name}.ts`,
         mediaType: "text/typescript",
-        content: renderDrizzleTables(group.tables),
+        content: renderDrizzleTables(database, group.tables),
     }));
     files.push({
         path: `${directory}/index.ts`,
@@ -963,7 +1129,7 @@ const drizzleFiles = (layout, includeRelations, selection) => {
         files.push({
             path: "relations.ts",
             mediaType: "text/typescript",
-            content: renderRelations(tables, "schema", `./${directory}/index.js`),
+            content: renderRelations(database, tables, "schema", `./${directory}/index.js`),
         });
     }
     files.push({
@@ -976,6 +1142,224 @@ const drizzleFiles = (layout, includeRelations, selection) => {
     });
     return files;
 };
+const developmentSeedCoreImports = (includePassword) => `import {
+  DevelopmentSeed,
+  DevelopmentSeedLive,
+} from "@effect-auth/core/DevelopmentSeed";
+import { IdentityKindRegistryDefaultLive } from "@effect-auth/core/Identity";
+${includePassword
+    ? `import { WebCryptoLive } from "@effect-auth/core/Crypto";
+import { Pbkdf2PasswordHasherLive } from "@effect-auth/core/Password";
+`
+    : ""}`;
+const developmentSeedDependenciesSource = (includePassword) => includePassword
+    ? `const DevelopmentSeedSupportLive = Layer.mergeAll(
+  IdentityKindRegistryDefaultLive,
+  Pbkdf2PasswordHasherLive().pipe(Layer.provide(WebCryptoLive())),
+);
+`
+    : `const DevelopmentSeedSupportLive = IdentityKindRegistryDefaultLive;
+`;
+const developmentSeedProgramSource = (includePassword) => `const developmentSeedProgram = Effect.gen(function* () {
+  const seed = yield* DevelopmentSeed;
+  const result = yield* seed.${includePassword ? "seedPasswordUsers" : "seedUsers"};
+  yield* Effect.logInfo(
+    \`Development auth seed complete: \${result.created} created, \${result.existing} existing.\`,
+  );
+  return result;
+});
+`;
+const developmentSeedConfigurationErrorSource = `export class DevelopmentSeedConfigurationError extends Data.TaggedError(
+  "DevelopmentSeedConfigurationError",
+)<{ readonly message: string }> {}
+`;
+const alchemyD1SeedSource = (adapter, includePassword, complexity) => {
+    const drizzle = adapter === "drizzle";
+    const storageModule = drizzle
+        ? "DrizzleD1SqliteStorage"
+        : "EffectQbSqliteStorage";
+    const storageType = drizzle
+        ? "DrizzleD1DatabaseLike"
+        : "D1EffectQbDatabaseLike";
+    const storageLayer = drizzle
+        ? "DrizzleD1SqliteAuthStorageLive"
+        : "D1EffectQbSqliteAuthStorageLive";
+    const medium = complexity === "medium";
+    return `import type { ${storageType} } from "@effect-auth/core/${storageModule}";
+import { ${storageLayer} } from "@effect-auth/core/${storageModule}";
+${developmentSeedCoreImports(includePassword)}import { Data, Effect, Layer } from "effect";
+
+${developmentSeedConfigurationErrorSource}
+${developmentSeedDependenciesSource(includePassword)}
+${developmentSeedProgramSource(includePassword)}
+${medium ? "export " : ""}const AppDevelopmentSeedLive = (database: ${storageType}) =>
+  DevelopmentSeedLive.pipe(
+    Layer.provideMerge(
+      Layer.mergeAll(
+        ${storageLayer}(database),
+        DevelopmentSeedSupportLive,
+      ),
+    ),
+  );
+
+${medium ? "export const runDevelopmentSeed" : "export const seedDevelopmentAuth"} = (
+  database: ${storageType},
+  isDevelopment: boolean,
+) =>
+  Effect.gen(function* () {
+    if (!isDevelopment) {
+      return yield* new DevelopmentSeedConfigurationError({
+        message: "Refusing to seed Effect Auth outside Alchemy development mode.",
+      });
+    }
+    return yield* developmentSeedProgram.pipe(
+      Effect.provide(AppDevelopmentSeedLive(database)),
+    );
+  });
+${medium
+        ? ""
+        : `
+// In alchemy.run.ts, after migrations:
+// const alchemy = yield* Alchemy.AlchemyContext;
+// yield* Database;
+// const client = yield* Cloudflare.D1.QueryDatabase(Database);
+// yield* seedDevelopmentAuth(yield* client.raw, alchemy.dev);
+`}`;
+};
+const standaloneConfigurationSource = (value) => {
+    const readValue = value === "sqlite"
+        ? 'const filename = process.env.EFFECT_AUTH_SQLITE_FILE ?? "./data/auth.sqlite";'
+        : `const databaseUrl = process.env.DATABASE_URL;
+  if (databaseUrl === undefined || databaseUrl.length === 0) {
+    return yield* new DevelopmentSeedConfigurationError({
+      message: "DATABASE_URL is required.",
+    });
+  }`;
+    const returned = value === "sqlite" ? "filename" : "databaseUrl";
+    return `const developmentSeedConfiguration = Effect.gen(function* () {
+  if (
+    process.env.NODE_ENV === "production" ||
+    process.env.EFFECT_AUTH_DEVELOPMENT_SEED !== "true"
+  ) {
+    return yield* new DevelopmentSeedConfigurationError({
+      message: "Set EFFECT_AUTH_DEVELOPMENT_SEED=true to run the development seed.",
+    });
+  }
+  ${readValue}
+  return ${returned};
+});
+`;
+};
+const sqliteSeedSource = (runtime, includePassword, complexity) => {
+    const storageModule = runtime === "bun" ? "DrizzleBunSqliteStorage" : "DrizzleNodeSqliteStorage";
+    const storageLayer = runtime === "bun"
+        ? "DrizzleBunSqliteAuthStorageLive"
+        : "DrizzleNodeSqliteAuthStorageLive";
+    const medium = complexity === "medium";
+    return `import { ${storageLayer} } from "@effect-auth/core/${storageModule}";
+${developmentSeedCoreImports(includePassword)}import { Data, Effect, Layer } from "effect";
+
+${developmentSeedConfigurationErrorSource}
+${developmentSeedDependenciesSource(includePassword)}
+${developmentSeedProgramSource(includePassword)}
+${standaloneConfigurationSource("sqlite")}
+${medium ? "export " : ""}const AppDevelopmentSeedLive = (filename: string) =>
+  DevelopmentSeedLive.pipe(
+    Layer.provideMerge(
+      Layer.mergeAll(
+        ${storageLayer}({ filename }),
+        DevelopmentSeedSupportLive,
+      ),
+    ),
+  );
+
+${medium ? "export " : ""}const runDevelopmentSeed = Effect.gen(function* () {
+  const filename = yield* developmentSeedConfiguration;
+  return yield* developmentSeedProgram.pipe(
+    Effect.provide(AppDevelopmentSeedLive(filename)),
+    Effect.scoped,
+  );
+});
+${medium ? "" : "\nawait Effect.runPromise(runDevelopmentSeed);\n"}`;
+};
+const postgresSeedSource = (adapter, includePassword, complexity) => {
+    const drizzle = adapter === "drizzle";
+    const medium = complexity === "medium";
+    const storageImports = drizzle
+        ? 'import { DrizzlePostgresAuthStorageLive } from "@effect-auth/core/DrizzlePostgresStorage";\n'
+        : `import * as PgClient from "@effect/sql-pg/PgClient";
+import { EffectQbPostgresCoreStoresLive } from "@effect-auth/core/EffectQbPostgresStorage";
+`;
+    const layerSource = drizzle
+        ? `${medium ? "export " : ""}const AppDevelopmentSeedLive = (databaseUrl: string) =>
+  DevelopmentSeedLive.pipe(
+    Layer.provideMerge(
+      Layer.mergeAll(
+        DrizzlePostgresAuthStorageLive({ url: Redacted.make(databaseUrl) }),
+        DevelopmentSeedSupportLive,
+      ),
+    ),
+  );`
+        : `${medium ? "export " : ""}const AppDevelopmentSeedLive = (sql: PgClient.PgClient) =>
+  DevelopmentSeedLive.pipe(
+    Layer.provideMerge(
+      Layer.mergeAll(
+        EffectQbPostgresCoreStoresLive(sql),
+        DevelopmentSeedSupportLive,
+      ),
+    ),
+  );`;
+    const runSource = drizzle
+        ? `const databaseUrl = yield* developmentSeedConfiguration;
+  return yield* developmentSeedProgram.pipe(
+    Effect.provide(AppDevelopmentSeedLive(databaseUrl)),
+    Effect.scoped,
+  );`
+        : `const databaseUrl = yield* developmentSeedConfiguration;
+  const PostgresClientLive = PgClient.layer({
+    url: Redacted.make(databaseUrl),
+  });
+  return yield* Effect.gen(function* () {
+    const sql = yield* PgClient.PgClient;
+    return yield* developmentSeedProgram.pipe(
+      Effect.provide(AppDevelopmentSeedLive(sql)),
+    );
+  }).pipe(Effect.provide(PostgresClientLive), Effect.scoped);`;
+    return `${storageImports}${developmentSeedCoreImports(includePassword)}import { Data, Effect, Layer, Redacted } from "effect";
+
+${developmentSeedConfigurationErrorSource}
+${developmentSeedDependenciesSource(includePassword)}
+${developmentSeedProgramSource(includePassword)}
+${standaloneConfigurationSource("postgres")}
+${layerSource}
+
+${medium ? "export " : ""}const runDevelopmentSeed = Effect.gen(function* () {
+  ${runSource}
+});
+${medium ? "" : "\nawait Effect.runPromise(runDevelopmentSeed);\n"}`;
+};
+const developmentSeedFiles = (adapter, target, includePassword, complexity) => {
+    let content;
+    switch (target) {
+        case "alchemy-d1": {
+            content = alchemyD1SeedSource(adapter, includePassword, complexity);
+            break;
+        }
+        case "bun-sqlite": {
+            content = sqliteSeedSource("bun", includePassword, complexity);
+            break;
+        }
+        case "node-sqlite": {
+            content = sqliteSeedSource("node", includePassword, complexity);
+            break;
+        }
+        case "postgres": {
+            content = postgresSeedSource(adapter, includePassword, complexity);
+            break;
+        }
+    }
+    return [{ path: "seed-auth.ts", mediaType: "text/typescript", content }];
+};
 const fingerprint = (value) => {
     let hash = 2_166_136_261;
     for (let index = 0; index < value.length; index += 1) {
@@ -988,21 +1372,33 @@ const fingerprint = (value) => {
 export const parseStorageSchemaGeneratorRequest = (request) => normalizeRequest(request);
 export const generateStorageArtifacts = (request) => {
     const normalized = normalizeRequest(request);
-    const resolved = resolveStorageFeatures(normalized.features);
+    const featureSelection = resolveStorageFeatures(normalized.features);
+    const resolved = normalized.outputs.some(({ kind }) => kind === "development-seed")
+        ? includeDevelopmentSeedRequirements(featureSelection)
+        : featureSelection;
+    const schemaVersion = storageSchemaVersions[normalized.database];
     const files = [];
     const warnings = [];
     for (const output of normalized.outputs) {
         if (output.kind === "migration-sql") {
-            files.push(...sqlFiles(output.layout, resolved));
+            files.push(...sqlFiles(normalized.database, output.layout, resolved));
         }
-        else {
-            files.push(...drizzleFiles(output.layout, output.includeRelations, resolved));
+        else if (output.kind === "drizzle-schema") {
+            files.push(...drizzleFiles(normalized.database, output.layout, output.includeRelations, resolved));
             if (output.includeRelations) {
-                warnings.push("Drizzle relations are application-level only and do not create PostgreSQL foreign keys.");
+                warnings.push(`Drizzle relations are application-level only and do not create ${normalized.database === "postgres" ? "PostgreSQL" : "SQLite"} foreign keys.`);
+            }
+        }
+        else {
+            files.push(...developmentSeedFiles(normalized.adapter, output.target, normalized.features.includes("password"), output.complexity));
+            warnings.push("The generated development seed creates public demo credentials and must never run against production data.");
+            if (!normalized.features.includes("password")) {
+                warnings.push("The selected features do not include password authentication, so the development seed does not create password credentials.");
             }
         }
     }
     const fingerprintInput = JSON.stringify({
+        schemaVersion,
         request: normalized,
         resolved,
         files,
@@ -1011,7 +1407,7 @@ export const generateStorageArtifacts = (request) => {
     return {
         apiVersion: storageSchemaGeneratorApiVersion,
         generatorVersion: storageSchemaGeneratorVersion,
-        schemaVersion: storageSchemaVersion,
+        schemaVersion,
         fingerprint: fingerprint(fingerprintInput),
         request: normalized,
         resolved,