create-absolutejs 0.18.0 → 0.20.0

package/dist/generators/db/generateDrizzleSchema.js

@@ -1,121 +1,105 @@
+const mysqlFamily = {
+    int: 'int',
+    json: 'json()',
+    string: 'varchar({ length: 255 })',
+    time: 'timestamp()',
+    timestampDefault: '.defaultNow()',
+    uid: "int('uid').primaryKey().autoincrement()"
+};
 const DIALECTS = {
-    gel: {
-        builders: ['text', 'gelTable', 'timestamp', 'integer', 'json'],
-        json: 'json()',
-        pkg: 'gel-core',
-        string: 'text()',
-        table: 'gelTable',
-        time: 'timestamp()'
-    },
-    mariadb: {
-        builders: ['json', 'mysqlTable', 'timestamp', 'varchar', 'int'],
-        json: 'json()',
-        pkg: 'mysql-core',
+    cockroachdb: {
+        int: 'int4',
+        json: 'jsonb()',
+        pkg: 'cockroach-core',
         string: 'varchar({ length: 255 })',
-        table: 'mysqlTable',
-        time: 'timestamp()'
+        table: 'cockroachTable',
+        time: 'timestamp()',
+        timestampDefault: '.defaultNow()',
+        uid: "int4('uid').primaryKey().generatedAlwaysAsIdentity()"
     },
+    mariadb: { ...mysqlFamily, pkg: 'mysql-core', table: 'mysqlTable' },
     mssql: {
-        builders: ['datetime2', 'int', 'mssqlTable', 'nvarchar', 'json'],
+        int: 'int',
         json: "nvarchar({ length: 'max', mode: 'json' })",
         pkg: 'mssql-core',
         string: 'nvarchar({ length: 255 })',
         table: 'mssqlTable',
-        time: 'datetime2()'
-    },
-    mysql: {
-        builders: ['json', 'mysqlTable', 'timestamp', 'varchar', 'int'],
-        json: 'json()',
-        pkg: 'mysql-core',
-        string: 'varchar({ length: 255 })',
-        table: 'mysqlTable',
-        time: 'timestamp()'
+        time: 'datetime2()',
+        timestampDefault: '.default(sql`sysdatetime()`)',
+        uid: "int('uid').identity().primaryKey()"
     },
+    mysql: { ...mysqlFamily, pkg: 'mysql-core', table: 'mysqlTable' },
     postgresql: {
-        builders: ['jsonb', 'pgTable', 'timestamp', 'varchar', 'integer'],
+        int: 'integer',
         json: 'jsonb()',
         pkg: 'pg-core',
         string: 'varchar({ length: 255 })',
         table: 'pgTable',
-        time: 'timestamp()'
+        time: 'timestamp()',
+        timestampDefault: '.defaultNow()',
+        uid: "integer('uid').primaryKey().generatedAlwaysAsIdentity()"
     },
     singlestore: {
-        builders: ['json', 'singlestoreTable', 'timestamp', 'varchar', 'int'],
-        json: 'json()',
+        ...mysqlFamily,
+        /* SingleStore rejects MySQL's parenthesised expression default
+           (DEFAULT ('{}')), which is what drizzle-kit emits for .default({}). */
+        jsonDefault: ".default(sql`'{}'`)",
         pkg: 'singlestore-core',
-        string: 'varchar({ length: 255 })',
-        table: 'singlestoreTable',
-        time: 'timestamp()'
+        table: 'singlestoreTable'
     },
     sqlite: {
-        builders: ['text', 'sqliteTable', 'integer'],
+        int: 'integer',
         json: "text('', { mode: 'json' })",
         pkg: 'sqlite-core',
         string: 'text()',
         table: 'sqliteTable',
-        time: "integer({ mode: 'timestamp_ms' })"
+        time: "integer({ mode: 'timestamp_ms' })",
+        /* Milliseconds since the Unix epoch: julianday() counts days from
+           2440587.5 (the epoch's Julian day). drizzle-kit only accepts a
+           parameter-free SQL default, so the constants are inline. */
+        timestampDefault: ".default(sql`((julianday('now') - 2440587.5) * 86400000)`)",
+        uid: "integer('uid').primaryKey({ autoIncrement: true })"
     }
 };
-const builder = (expr) => expr.split('(')[0];
+const builder = (expr) => expr.split('(')[0] ?? expr;
 export const generateDrizzleSchema = ({ databaseEngine, authOption }) => {
     const cfg = DIALECTS[databaseEngine];
-    const intBuilder = databaseEngine === 'mariadb' ||
-        databaseEngine === 'mssql' ||
-        databaseEngine === 'mysql' ||
-        databaseEngine === 'singlestore'
-        ? 'int'
-        : 'integer';
-    const timeBuilder = builder(cfg.time);
-    const jsonBuilder = builder(cfg.json);
-    const stringBuilder = builder(cfg.string);
-    const importBuilders = authOption === 'abs'
-        ? [cfg.table, stringBuilder, timeBuilder, jsonBuilder]
-        : [cfg.table, intBuilder, timeBuilder];
+    const usesAuth = authOption === 'abs';
+    const importBuilders = usesAuth
+        ? [cfg.table, builder(cfg.string), builder(cfg.time), builder(cfg.json)]
+        : [cfg.table, cfg.int, builder(cfg.time)];
     const uniqueBuilders = Array.from(new Set(importBuilders));
-    const builderImport = `${authOption === 'abs' ? "import type { UserIdentity } from '../src/types/userIdentity';\n" : ''}import { ${uniqueBuilders.join(', ')} } from 'drizzle-orm/${cfg.pkg}';`;
-    const sqliteImports = databaseEngine === 'sqlite' || databaseEngine === 'mssql'
-        ? `import { sql } from 'drizzle-orm';\n`
-        : '';
-    let uidColumn;
-    if (databaseEngine === 'mssql') {
-        uidColumn = `int('uid').identity().primaryKey()`;
-    }
-    else if (databaseEngine === 'mariadb' ||
-        databaseEngine === 'mysql' ||
-        databaseEngine === 'singlestore') {
-        uidColumn = `${intBuilder}('uid').primaryKey().autoincrement()`;
-    }
-    else if (databaseEngine === 'sqlite') {
-        uidColumn = `integer('uid').primaryKey({ autoIncrement: true })`;
-    }
-    else {
-        uidColumn = `integer('uid').primaryKey().generatedAlwaysAsIdentity()`;
-    }
-    const constsBlock = databaseEngine === 'sqlite'
-        ? `const JULIAN_DAY_UNIX_EPOCH_OFFSET = 2440587.5;
-const MILLIS_PER_DAY = 86400000;\n\n`
-        : '';
-    let timestampColumn = `${cfg.time}.notNull().defaultNow()`;
-    if (databaseEngine === 'sqlite')
-        timestampColumn = `${cfg.time}.notNull().default(sql\`(julianday('now') - \${JULIAN_DAY_UNIX_EPOCH_OFFSET}) * \${MILLIS_PER_DAY}\`)`;
-    if (databaseEngine === 'mssql')
-        timestampColumn = `${cfg.time}.notNull().default(sql\`sysdatetime()\`)`;
-    const tableBlock = authOption === 'abs'
+    const jsonDefault = cfg.jsonDefault ?? '.default({})';
+    const usesSqlDefault = [
+        cfg.timestampDefault,
+        usesAuth ? jsonDefault : ''
+    ].some((expression) => expression.includes('sql`'));
+    const imports = [
+        usesSqlDefault ? "import { sql } from 'drizzle-orm';" : '',
+        usesAuth
+            ? "import type { UserIdentity } from '../src/types/userIdentity';"
+            : '',
+        `import { ${uniqueBuilders.join(', ')} } from 'drizzle-orm/${cfg.pkg}';`
+    ]
+        .filter(Boolean)
+        .join('\n');
+    const timestampColumn = `${cfg.time}.notNull()${cfg.timestampDefault}`;
+    const tableBlock = usesAuth
         ? `export const users = ${cfg.table}('users', {
   auth_sub: ${cfg.string}.primaryKey(),
   created_at: ${timestampColumn},
-  metadata: ${cfg.json}.$type<UserIdentity>().default({})
+  metadata: ${cfg.json}.$type<UserIdentity>()${jsonDefault}
 });`
         : `export const countHistory = ${cfg.table}('count_history', {
-  uid: ${uidColumn},
-  count: ${intBuilder}('count').notNull(),
+  uid: ${cfg.uid},
+  count: ${cfg.int}('count').notNull(),
   created_at: ${timestampColumn}
 });`;
-    const schemaKey = authOption === 'abs' ? 'users' : 'countHistory';
+    const schemaKey = usesAuth ? 'users' : 'countHistory';
     return `
-${sqliteImports}${builderImport}
+${imports}
 
-${constsBlock}${tableBlock}
+${tableBlock}
 
 export const schema = {
   ${schemaKey}

package/dist/generators/db/handlerTemplates.d.ts

@@ -5,12 +5,12 @@ type QueryOperations = {
     insertHistory: string;
 };
 declare const driverConfigurations: {
-    readonly 'cockroachdb:sql:local': {
-        readonly importLines: "";
+    readonly 'cockroachdb:drizzle:local': {
+        readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
-    readonly 'gel:drizzle:local': {
-        readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'\n";
+    readonly 'cockroachdb:sql:local': {
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'gel:sql:local': {

package/dist/generators/db/handlerTemplates.js

@@ -269,14 +269,12 @@ const mysqlDrizzleQueryOperations = {
     .where(eq(schema.countHistory.uid, uid));
 
   return newHistory;`,
-    insertUser: `const [row] = await db
-    .insert(schema.users)
-    .values({ auth_sub: authSub, metadata: userIdentity });
+    insertUser: `await db.insert(schema.users).values(newUserData);
 
   const [newUser] = await db
     .select()
     .from(schema.users)
-    .where(eq(schema.users.auth_sub, authSub));
+    .where(eq(schema.users.auth_sub, newUserData.auth_sub));
 
   if (!newUser) throw new Error('Failed to create user');
   return newUser;`,
@@ -337,16 +335,15 @@ const mysqlPlanetScaleQueryOperations = {
   `
 };
 const driverConfigurations = {
+    'cockroachdb:drizzle:local': {
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'`,
+        queries: drizzleQueryOperations
+    },
     'cockroachdb:sql:local': {
         importLines: ``,
         queries: postgresSqlQueryOperations
     },
-    'gel:drizzle:local': {
-        importLines: `import { eq } from 'drizzle-orm'
-import { schema } from '../../../db/schema'
-`,
-        queries: drizzleQueryOperations
-    },
     'gel:sql:local': {
         importLines: ``,
         queries: gelClientQueryOperations

package/dist/generators/db/scaffoldDatabase.js

@@ -1,9 +1,11 @@
-import { mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { dim, yellow } from 'picocolors';
+import { cpSync, mkdirSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { isDrizzleDialect } from '../../typeGuards';
 import { checkSqliteInstalled } from '../../utils/checkSqliteInstalled';
 import { createDrizzleConfig } from '../configurations/generateDrizzleConfig';
+import { scaffoldPrismaDatabase } from '../prisma/scaffoldPrismaDatabase';
+import { getDrizzleKitDialect, getMigrationTemplateName } from './drizzleTargets';
 import { generateDatabaseTypes } from './generateDatabaseTypes';
 import { generateDrizzleSchema } from './generateDrizzleSchema';
 import { generateDBHandlers } from './generateHandlers';
@@ -15,6 +17,19 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
     const handlerDirectory = join(backendDirectory, 'handlers');
     mkdirSync(projectDatabaseDirectory, { recursive: true });
     mkdirSync(handlerDirectory, { recursive: true });
+    if (orm === 'prisma') {
+        const dockerFreshInstall = await scaffoldPrismaDatabase({
+            authOption,
+            backendDirectory,
+            databaseDirectory,
+            databaseEngine,
+            databaseHost,
+            projectName,
+            typesDirectory,
+            verifyLocalDatabase
+        });
+        return { dockerFreshInstall };
+    }
     const usesAuth = authOption !== undefined && authOption !== 'none';
     const handlerFileName = usesAuth
         ? 'userHandlers.ts'
@@ -50,7 +65,10 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         supportsRelationalSchema(databaseEngine)) {
         writeFileSync(join(projectDatabaseDirectory, 'schema.sql'), generateRelationalSchema(databaseEngine, authOption));
     }
-    if (databaseEngine === 'sqlite') {
+    /* Drizzle projects get their tables from the committed initial migration
+       (`db:migrate`), never from hand-written DDL, so the migration history and
+       the database always agree. */
+    if (databaseEngine === 'sqlite' && orm !== 'drizzle') {
         // The sqlite3 CLI is a developer convenience (a db shell), never a
         // scaffold requirement — seeding goes through bun:sqlite below, which
         // ships with the runtime. The check only nudges interactive users;
@@ -72,6 +90,7 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         const result = await scaffoldDocker({
             authOption,
             databaseEngine,
+            initializeSchema: orm !== 'drizzle',
             projectDatabaseDirectory,
             projectName,
             verifyLocalDatabase
@@ -87,7 +106,14 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
             databaseEngine
         });
         writeFileSync(join(projectDatabaseDirectory, 'schema.ts'), drizzleSchema);
-        createDrizzleConfig({ databaseDirectory, databaseEngine, projectName });
+        createDrizzleConfig({
+            databaseDirectory,
+            databaseEngine,
+            databaseHost,
+            projectName
+        });
+        const templatesDirectory = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'templates');
+        cpSync(join(templatesDirectory, 'db', 'migrations', getMigrationTemplateName(getDrizzleKitDialect(databaseEngine, databaseHost), usesAuth)), join(projectDatabaseDirectory, 'migrations'), { recursive: true });
         const drizzleTypes = generateDatabaseTypes({
             authOption,
             databaseEngine,
@@ -97,8 +123,5 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         writeFileSync(join(typesDirectory, 'databaseTypes.ts'), drizzleTypes);
         return { dockerFreshInstall };
     }
-    if (orm === 'prisma') {
-        console.warn(`${dim('│')}\n${yellow('▲')}  Prisma support is not implemented yet`);
-    }
     return { dockerFreshInstall };
 };

package/dist/generators/db/scaffoldDocker.d.ts

@@ -1,12 +1,13 @@
 import { AuthOption, DatabaseEngine } from '../../types';
 type ScaffoldDockerProps = {
+    initializeSchema?: boolean;
     verifyLocalDatabase?: boolean;
     databaseEngine: DatabaseEngine;
     projectDatabaseDirectory: string;
     authOption: AuthOption;
     projectName: string;
 };
-export declare const scaffoldDocker: ({ databaseEngine, projectDatabaseDirectory, projectName, authOption, verifyLocalDatabase }: ScaffoldDockerProps) => Promise<{
+export declare const scaffoldDocker: ({ databaseEngine, projectDatabaseDirectory, projectName, authOption, initializeSchema, verifyLocalDatabase }: ScaffoldDockerProps) => Promise<{
     dockerFreshInstall: boolean;
 }>;
 export {};

package/dist/generators/db/scaffoldDocker.js

@@ -5,7 +5,7 @@ import { $ } from 'bun';
 import { green, red } from 'picocolors';
 import { checkDockerInstalled, ensureDockerDaemonRunning, resolveDockerExe, shutdownDockerDaemon } from '../../utils/checkDockerInstalled';
 import { countHistoryTables, initTemplates, userTables } from './dockerInitTemplates';
-import { generateDockerContainer } from './generateDockerContainer';
+import { generateDockerContainer, getDockerInitScript } from './generateDockerContainer';
 const initDockerSchema = async ({ authOption, databaseEngine, docker, projectName, spin }) => {
     const dbKey = databaseEngine;
     const { wait, cli } = initTemplates[dbKey];
@@ -33,7 +33,7 @@ const verifyDockerContainer = async ({ databaseEngine, docker, projectName, spin
         .cwd(projectName)
         .quiet();
 };
-export const scaffoldDocker = async ({ databaseEngine, projectDatabaseDirectory, projectName, authOption, verifyLocalDatabase = true }) => {
+export const scaffoldDocker = async ({ databaseEngine, projectDatabaseDirectory, projectName, authOption, initializeSchema = true, verifyLocalDatabase = true }) => {
     if (databaseEngine === undefined ||
         databaseEngine === 'none' ||
         databaseEngine === 'sqlite') {
@@ -41,6 +41,10 @@ export const scaffoldDocker = async ({ databaseEngine, projectDatabaseDirectory,
     }
     const dbContainer = generateDockerContainer(databaseEngine);
     writeFileSync(join(projectDatabaseDirectory, 'docker-compose.db.yml'), dbContainer, 'utf-8');
+    const initScript = getDockerInitScript(databaseEngine);
+    if (initScript) {
+        writeFileSync(join(projectDatabaseDirectory, initScript.fileName), initScript.sql, 'utf-8');
+    }
     if (!verifyLocalDatabase)
         return { dockerFreshInstall: false };
     const { freshInstall } = await checkDockerInstalled(databaseEngine);
@@ -48,7 +52,7 @@ export const scaffoldDocker = async ({ databaseEngine, projectDatabaseDirectory,
     const docker = resolveDockerExe();
     const spin = spinner();
     spin.start(`Starting ${databaseEngine} container`);
-    const dockerAction = databaseEngine in userTables
+    const dockerAction = initializeSchema && databaseEngine in userTables
         ? () => initDockerSchema({
             authOption,
             databaseEngine,

package/dist/generators/prisma/generatePrismaCode.d.ts

@@ -0,0 +1,6 @@
+import type { AuthOption } from '../../types';
+import type { PrismaTarget } from './prismaTargets';
+export declare const generatePrismaDatabaseTypes: (authOption: AuthOption, { provider }: PrismaTarget) => string;
+export declare const generatePrismaDBBlock: ({ adapter }: PrismaTarget) => string;
+export declare const getPrismaServerImports: ({ adapter }: PrismaTarget) => string[];
+export declare const generatePrismaHandlers: (authOption: AuthOption, target: PrismaTarget) => string;

package/dist/generators/prisma/generatePrismaCode.js

@@ -0,0 +1,148 @@
+/* The generated client's entry, as imported from src/backend/server.ts,
+   src/backend/handlers/* and src/types/* (see prismaClientDirectory). */
+const clientFromBackend = '../generated/prisma/client';
+const clientFromTypes = '../generated/prisma/client';
+/* src/types/databaseTypes.ts. Rows are the client's own model types; the
+   user's metadata is narrowed to the identity shape the auth flow stores. */
+export const generatePrismaDatabaseTypes = (authOption, { provider }) => {
+    if (authOption === 'abs')
+        return `import type { PrismaClient } from '${clientFromTypes}';
+import type { UserIdentity } from './userIdentity';
+
+export type DatabaseType = PrismaClient;
+
+export type User = {
+	auth_sub: string;
+	created_at: Date;
+	metadata: UserIdentity;
+};
+
+export type NewUser = {
+	auth_sub: string;
+	metadata?: UserIdentity;
+};
+`;
+    const countHistory = provider === 'mongodb'
+        ? `/* The document's ObjectId stays internal; the API is keyed by uid. */
+export type CountHistory = Omit<CountHistoryModel, 'id'>;`
+        : 'export type CountHistory = CountHistoryModel;';
+    return `import type {
+	CountHistory as CountHistoryModel,
+	PrismaClient
+} from '${clientFromTypes}';
+
+export type DatabaseType = PrismaClient;
+
+${countHistory}
+
+export type NewCountHistory = {
+	count: number;
+};
+`;
+};
+/* Prisma 7 queries through the driver adapter; Prisma 6 (MongoDB) connects
+   with its own engine, given the URL explicitly so a missing one fails fast. */
+export const generatePrismaDBBlock = ({ adapter }) => adapter
+    ? `const db = new PrismaClient({ adapter: ${adapter.expression} })`
+    : `const db = new PrismaClient({ datasourceUrl: getEnv('DATABASE_URL') })`;
+/* server.ts imports for the Prisma client and its driver adapter. */
+export const getPrismaServerImports = ({ adapter }) => [
+    `import { PrismaClient } from '${clientFromBackend}'`,
+    `import { getEnv } from '@absolutejs/absolute'`,
+    ...(adapter
+        ? [`import { ${adapter.className} } from '${adapter.packageName}'`]
+        : []),
+    ...(adapter?.expression.includes('env.')
+        ? [`import { env } from 'bun'`]
+        : [])
+];
+/* Prisma queries return a lazy PrismaPromise that only runs when awaited;
+   Elysia serializes a returned non-Promise object as-is. Every handler is
+   async and awaits, so routes always receive a real Promise of the row. */
+const countHistoryHandlers = ({ provider }) => provider === 'mongodb'
+    ? `import type { CountHistory, DatabaseType } from '../../types/databaseTypes';
+
+export const getCountHistory = async (
+	db: DatabaseType,
+	uid: number
+): Promise<CountHistory | null> =>
+	await db.countHistory.findUnique({ omit: { id: true }, where: { uid } });
+
+/* MongoDB has no autoincrement: the next uid comes from an atomic increment
+   on a counter document. */
+export const createCountHistory = async (
+	db: DatabaseType,
+	count: number
+): Promise<CountHistory> => {
+	const { value: uid } = await db.counter.upsert({
+		create: { id: 'count_history', value: 1 },
+		update: { value: { increment: 1 } },
+		where: { id: 'count_history' }
+	});
+
+	return await db.countHistory.create({
+		data: { count, uid },
+		omit: { id: true }
+	});
+};
+`
+    : `import type { CountHistory, DatabaseType } from '../../types/databaseTypes';
+
+export const getCountHistory = async (
+	db: DatabaseType,
+	uid: number
+): Promise<CountHistory | null> =>
+	await db.countHistory.findUnique({ where: { uid } });
+
+export const createCountHistory = async (
+	db: DatabaseType,
+	count: number
+): Promise<CountHistory> => await db.countHistory.create({ data: { count } });
+`;
+/* Json columns hand back Prisma's JsonValue; SQL Server stores the metadata as
+   JSON text. Either way it is validated back into a UserIdentity. */
+const userHandlers = ({ supportsJson }) => {
+    const readMetadata = supportsJson ? 'metadata' : 'JSON.parse(metadata)';
+    const writeMetadata = supportsJson
+        ? 'metadata'
+        : 'metadata: JSON.stringify(metadata)';
+    return `import type { DatabaseType, NewUser, User } from '../../types/databaseTypes';
+import { parseUserIdentity } from '../../types/userIdentity';
+
+type UserRow = {
+	auth_sub: string;
+	created_at: Date;
+	metadata: ${supportsJson ? 'unknown' : 'string'};
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+	typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const toUser = ({ auth_sub, created_at, metadata }: UserRow): User => {
+	const identity: unknown = ${readMetadata};
+
+	return {
+		auth_sub,
+		created_at,
+		metadata: isRecord(identity) ? parseUserIdentity(identity) : {}
+	};
+};
+
+export const getUser = async (
+	db: DatabaseType,
+	authSub: string
+): Promise<User | null> => {
+	const user = await db.user.findUnique({ where: { auth_sub: authSub } });
+
+	return user ? toUser(user) : null;
+};
+
+export const createUser = async (
+	db: DatabaseType,
+	{ auth_sub, metadata = {} }: NewUser
+): Promise<User> =>
+	toUser(await db.user.create({ data: { auth_sub, ${writeMetadata} } }));
+`;
+};
+/* src/backend/handlers/{countHistory,user}Handlers.ts */
+export const generatePrismaHandlers = (authOption, target) => authOption === 'abs' ? userHandlers(target) : countHistoryHandlers(target);

package/dist/generators/prisma/generatePrismaConfig.d.ts

@@ -0,0 +1,8 @@
+import type { PrismaTarget } from './prismaTargets';
+type GeneratePrismaConfigProps = {
+    databaseDirectory: string;
+    target: PrismaTarget;
+};
+export declare const generateLibsqlMigrateScript: () => string;
+export declare const generatePrismaConfig: ({ databaseDirectory, target }: GeneratePrismaConfigProps) => string;
+export {};

package/dist/generators/prisma/generatePrismaConfig.js

@@ -0,0 +1,68 @@
+/* Prisma reads no .env file on its own once a prisma.config.ts exists, and its
+   CLI may run under Node, so the config loads the project's .env itself (never
+   overriding variables already set in the environment). */
+const loadEnv = `/* Prisma does not load .env by itself; variables already set win. */
+if (existsSync('.env')) process.loadEnvFile('.env');
+`;
+/* Applies the committed Prisma migrations to a libSQL/Turso database, in
+   order, once each, recording them in their own table. */
+export const generateLibsqlMigrateScript = () => `import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createClient } from '@libsql/client';
+import { env } from 'bun';
+
+const url = env.DATABASE_URL;
+if (!url) throw new Error('DATABASE_URL must be set in the environment variables');
+
+const client = createClient({ authToken: env.DATABASE_AUTH_TOKEN, url });
+const migrationsDirectory = join(import.meta.dir, 'migrations');
+
+await client.execute(
+	'CREATE TABLE IF NOT EXISTS "_libsql_migrations" ("name" TEXT PRIMARY KEY, "applied_at" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP)'
+);
+const { rows } = await client.execute('SELECT "name" FROM "_libsql_migrations"');
+const applied = new Set(rows.map((row) => String(row.name)));
+const pending = readdirSync(migrationsDirectory, { withFileTypes: true })
+	.filter((entry) => entry.isDirectory() && !applied.has(entry.name))
+	.map((entry) => entry.name)
+	.sort();
+
+for (const name of pending) {
+	const sql = readFileSync(join(migrationsDirectory, name, 'migration.sql'), 'utf8');
+	await client.executeMultiple(sql);
+	await client.execute({ args: [name], sql: 'INSERT INTO "_libsql_migrations" ("name") VALUES (?)' });
+	console.log(\`Applied \${name}\`);
+}
+
+console.log(pending.length ? \`\${pending.length} migration(s) applied\` : 'No pending migrations');
+client.close();
+`;
+export const generatePrismaConfig = ({ databaseDirectory, target }) => {
+    const schema = `schema: '${databaseDirectory}/schema.prisma'`;
+    if (target.line === 'prisma6') {
+        return `import { existsSync } from 'node:fs';
+import { defineConfig } from 'prisma/config';
+
+${loadEnv}
+export default defineConfig({
+	${schema}
+});
+`;
+    }
+    /* Prisma Migrate cannot reach libSQL/Turso URLs. \`db:migrate:dev\` authors
+       new migrations against a scratch SQLite file instead, and \`db:migrate\`
+       applies them to DATABASE_URL through ${databaseDirectory}/migrate.ts. */
+    const url = target.migration === 'libsql'
+        ? `'file:./${databaseDirectory}/prisma-migrate-dev.db'`
+        : "process.env.DATABASE_URL ?? ''";
+    return `import { existsSync } from 'node:fs';
+import { defineConfig } from 'prisma/config';
+
+${loadEnv}
+export default defineConfig({
+	datasource: { url: ${url} },
+	migrations: { path: '${databaseDirectory}/migrations' },
+	${schema}
+});
+`;
+};

package/dist/generators/prisma/generatePrismaSchema.d.ts

@@ -0,0 +1,9 @@
+import type { AuthOption } from '../../types';
+import { type PrismaTarget } from './prismaTargets';
+type GeneratePrismaSchemaProps = {
+    authOption: AuthOption;
+    databaseDirectory: string;
+    target: PrismaTarget;
+};
+export declare const generatePrismaSchema: ({ authOption, databaseDirectory, target }: GeneratePrismaSchemaProps) => string;
+export {};