create-absolutejs 0.19.0 → 0.20.0

package/CHANGELOG.md

@@ -6,6 +6,12 @@ This file is generated by `absolute-changelog` from the entries in
 `changelog/`. Edit an entry, not this file — and add new ones under
 `changelog/unreleased/`.
 
+## 0.20.0 — 2026-09-27
+
+### Added
+
+- **Scaffold Prisma for every Prisma database (PostgreSQL, Neon, PlanetScale, CockroachDB, MySQL, MariaDB, SQLite, Turso, SQL Server on Prisma 7.10 driver adapters; MongoDB on Prisma 6.19.3) with a committed initial migration, typed handlers and prisma generate / db:migrate scripts**
+
 ## 0.19.0 — 2026-09-26
 
 ### Added

package/README.md

@@ -112,8 +112,9 @@ Usage: create-absolute [project-name] [options]
 - `--lts`  
   Use LTS versions of required packages.
 
-- `--orm <drizzle|none>`
-  ORM to configure: `drizzle` | `none`. Prisma scaffolding is not implemented and is rejected before files are written. Drizzle 1 no longer includes the Gel dialect; choose no ORM for Gel.
+- `--orm <drizzle|prisma|none>`
+  ORM to configure: `drizzle` | `prisma` | `none`. Drizzle 1 no longer includes the Gel dialect; choose no ORM for Gel.
+  Prisma supports PostgreSQL (local, Neon, PlanetScale), CockroachDB, MySQL (local, PlanetScale), MariaDB, SQLite (local, Turso), SQL Server and MongoDB; Gel and SingleStore are rejected before files are written. A Prisma project ships `prisma.config.ts`, `db/schema.prisma` and a committed initial migration; `postinstall` / `db:generate` run `prisma generate` into `src/generated/prisma` (git-ignored), and `db:migrate` applies the migrations (`prisma migrate deploy`; Turso through `db/migrate.ts`, since Prisma Migrate cannot reach libSQL URLs; MongoDB through `prisma db push`). `db:migrate:dev` authors new migrations.
 
 - `--plugin <plugin>`  
   Elysia plugin(s) to include (repeatable); `none` skips plugin setup. Select
@@ -206,6 +207,12 @@ switch a generated server back to Elysia 1.
 - TypeScript 5.9.3 and Angular's current 21 LTS patches match the framework's
   compiler peer dependencies. Newer incompatible compiler majors are not selected.
 - Drizzle ORM and Kit use the coordinated 1.0 release-candidate channel.
+- Prisma uses 7.10 (the `prisma-client` generator with driver adapters) for every
+  SQL database. MongoDB projects pin Prisma 6.19.3, because Prisma 7 does not
+  support MongoDB yet (Prisma's documentation directs MongoDB users to v6.19).
+  They need a replica set, which the generated Docker database provides. The npm
+  `latest` tag for `prisma` currently points at an 8.0 release candidate, so
+  Prisma is always pinned, including under `--lts`.
 - All other pins are checked against their latest published release channel.
 
 Automatic authentication setup currently supplies a complete Google configuration

package/changelog.json

@@ -2,6 +2,16 @@
 	"contract": 1,
 	"name": "create-absolutejs",
 	"releases": [
+		{
+			"changes": [
+				{
+					"kind": "added",
+					"summary": "Scaffold Prisma for every Prisma database (PostgreSQL, Neon, PlanetScale, CockroachDB, MySQL, MariaDB, SQLite, Turso, SQL Server on Prisma 7.10 driver adapters; MongoDB on Prisma 6.19.3) with a committed initial migration, typed handlers and prisma generate / db:migrate scripts"
+				}
+			],
+			"date": "2026-09-27",
+			"version": "0.20.0"
+		},
 		{
 			"changes": [
 				{

package/dist/generators/configurations/generateEslintConfig.js

@@ -7,7 +7,7 @@ ${frontends.includes('react') ? "import reactHooks from 'eslint-plugin-react-hoo
 
 export default defineConfig([
   // The copied HTMX distribution is third-party minified runtime code.
-  { ignores: ['src/frontend/**/htmx.min.js', 'node_modules/**', 'build/**', 'dist/**', '.absolutejs/**', '.data/**', '**/.absolutejs-hmr-*', 'drizzle/**'] },
+  { ignores: ['src/frontend/**/htmx.min.js', 'node_modules/**', 'build/**', 'dist/**', '.absolutejs/**', '.data/**', '**/.absolutejs-hmr-*', 'drizzle/**', 'src/generated/**'] },
   { linterOptions: { noInlineConfig: true, reportUnusedDisableDirectives: 'error' } },
   ...tseslint.configs.recommended,
   {

package/dist/generators/configurations/generatePackageJson.d.ts

@@ -1,8 +1,9 @@
 import type { CreateConfiguration } from '../../types';
 type CreatePackageJsonProps = Pick<CreateConfiguration, 'authOption' | 'agentic' | 'useTailwind' | 'databaseEngine' | 'databaseHost' | 'plugins' | 'orm' | 'frontendDirectories' | 'codeQualityTool'> & {
     projectName: string;
+    databaseDirectory?: string;
     latest: boolean;
     repositoryUrl: string | undefined;
 };
-export declare const createPackageJson: ({ agentic, projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool, repositoryUrl }: CreatePackageJsonProps) => Promise<void>;
+export declare const createPackageJson: ({ agentic, projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool, databaseDirectory, repositoryUrl }: CreatePackageJsonProps) => Promise<void>;
 export {};

package/dist/generators/configurations/generatePackageJson.js

@@ -3,8 +3,11 @@ import { join } from 'path';
 import { spinner } from '@clack/prompts';
 import { green } from 'picocolors';
 import { absoluteAuthPlugin, availablePlugins, defaultDependencies, defaultPlugins, eslintAndPrettierDependencies, eslintReactDependencies } from '../../data';
+import { isPrismaDialect } from '../../typeGuards';
 import { getPackageVersions } from '../../utils/getPackageVersion';
 import { versions } from '../../versions';
+import { getPrismaPackageJson } from '../prisma/prismaPackageJson';
+import { getPrismaTarget } from '../prisma/prismaTargets';
 import { computeFlags } from '../project/computeFlags';
 const dbClientCommands = {
     cockroachdb: 'cockroach sql --insecure --database=database',
@@ -16,7 +19,7 @@ const dbClientCommands = {
     postgresql: 'psql -h localhost -U user -d database',
     singlestore: 'singlestore -u root -ppassword -D database'
 };
-export const createPackageJson = async ({ agentic, projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool, repositoryUrl }) => {
+export const createPackageJson = async ({ agentic, projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool, databaseDirectory = 'db', repositoryUrl }) => {
     const flags = computeFlags(frontendDirectories);
     const isLocal = !databaseHost || databaseHost === 'none';
     /* ── Collect all package names that need versions ─────────── */
@@ -322,6 +325,12 @@ export const createPackageJson = async ({ agentic, projectName, authOption, plug
         /* `drizzle.config.ts` imports it and the scripts above shell out to it. */
         devDependencies['drizzle-kit'] = resolveVersion('drizzle-kit', versions['drizzle-kit']);
     }
+    if (orm === 'prisma' && isPrismaDialect(databaseEngine)) {
+        const prisma = getPrismaPackageJson(getPrismaTarget(databaseEngine, databaseHost), databaseDirectory);
+        Object.assign(dependencies, prisma.dependencies);
+        Object.assign(devDependencies, prisma.devDependencies);
+        Object.assign(scripts, prisma.scripts);
+    }
     const packageJson = {
         dependencies,
         devDependencies,

package/dist/generators/db/scaffoldDatabase.js

@@ -1,10 +1,10 @@
 import { cpSync, mkdirSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { dim, yellow } from 'picocolors';
 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';
@@ -17,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'
@@ -110,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/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 {};

package/dist/generators/prisma/generatePrismaSchema.js

@@ -0,0 +1,80 @@
+import { posix } from 'path';
+import { prismaClientDirectory } from './prismaTargets';
+/* Mirrors the Drizzle example tables (count_history, or users with auth) so
+   both ORMs scaffold the same database. MongoDB documents are keyed by an
+   ObjectId, so the numeric `uid` the API exposes is a unique field there,
+   assigned from an atomic counter document. */
+/* CockroachDB only autoincrements BigInt; an Int key takes a sequence, so
+   the uid stays a JavaScript number like every other engine's. Its maximum is
+   pinned to INT4's, which is what CockroachDB gives the identity column —
+   otherwise Prisma reports the migrated table as drifted from the schema. */
+const countHistoryModel = ({ provider }) => provider === 'mongodb'
+    ? `model CountHistory {
+  id         String   @id @default(auto()) @map("_id") @db.ObjectId
+  uid        Int      @unique
+  count      Int
+  created_at DateTime @default(now())
+
+  @@map("count_history")
+}
+
+/// Hands out sequential count_history uids (MongoDB has no autoincrement).
+model Counter {
+  id    String @id @map("_id")
+  value Int
+
+  @@map("counters")
+}`
+    : `model CountHistory {
+  uid        Int      @id @default(${provider === 'cockroachdb' ? 'sequence(maxValue: 2147483647)' : 'autoincrement()'})
+  count      Int
+  created_at DateTime @default(now())
+
+  @@map("count_history")
+}`;
+/* The auth subject's column type: bounded like the Drizzle schema's
+   varchar(255) wherever the provider has a native type for it. */
+const authSubType = {
+    cockroachdb: ' @db.String(255)',
+    mongodb: '',
+    mysql: ' @db.VarChar(255)',
+    postgresql: ' @db.VarChar(255)',
+    sqlite: '',
+    sqlserver: ' @db.NVarChar(255)'
+};
+/* `metadata` has no database default: Prisma renders a Json default as
+   invalid SQLite DDL, so the handlers always write it instead. */
+const userModel = ({ provider, supportsJson }) => {
+    const metadataColumn = supportsJson
+        ? 'metadata   Json'
+        : 'metadata   String   @db.NVarChar(Max)';
+    const idColumns = provider === 'mongodb'
+        ? `id         String   @id @default(auto()) @map("_id") @db.ObjectId
+  auth_sub   String   @unique`
+        : `auth_sub   String   @id${authSubType[provider]}`;
+    return `model User {
+  ${idColumns}
+  created_at DateTime @default(now())
+  ${metadataColumn}
+
+  @@map("users")
+}`;
+};
+export const generatePrismaSchema = ({ authOption, databaseDirectory, target }) => {
+    const output = posix.relative(posix.normalize(databaseDirectory), prismaClientDirectory);
+    /* Prisma 7 takes the connection URL from prisma.config.ts; Prisma 6 (the
+       MongoDB line) still reads it from the schema. */
+    const url = target.line === 'prisma6' ? '\n  url      = env("DATABASE_URL")' : '';
+    const model = authOption === 'abs' ? userModel(target) : countHistoryModel(target);
+    return `generator client {
+  provider = "prisma-client"
+  output   = "${output}"
+}
+
+datasource db {
+  provider = "${target.provider}"${url}
+}
+
+${model}
+`;
+};

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

@@ -0,0 +1,8 @@
+import type { PrismaTarget } from './prismaTargets';
+type PrismaPackageJson = {
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    scripts: Record<string, string>;
+};
+export declare const getPrismaPackageJson: (target: PrismaTarget, databaseDirectory: string) => PrismaPackageJson;
+export {};

package/dist/generators/prisma/prismaPackageJson.js

@@ -0,0 +1,46 @@
+import { prismaMongoDBVersion, versions } from '../../versions';
+const migrationScripts = ({ migration }, databaseDirectory) => {
+    /* The Prisma MongoDB container is an unauthenticated single-node replica
+       set (see prismaMongoDBCompose), so its shell needs no credentials. */
+    if (migration === 'push')
+        return {
+            'db:migrate': 'prisma db push',
+            'db:mongodb': `docker compose -p mongodb -f ${databaseDirectory}/docker-compose.db.yml exec -it db mongosh database`
+        };
+    if (migration === 'libsql')
+        return {
+            'db:migrate': `bun ${databaseDirectory}/migrate.ts`,
+            'db:migrate:dev': 'prisma migrate dev'
+        };
+    return {
+        'db:migrate': 'prisma migrate deploy',
+        'db:migrate:dev': 'prisma migrate dev'
+    };
+};
+/* Dependencies and scripts a Prisma project adds. Versions are always the
+   pinned ones — never `--lts` resolved — because npm's `latest` dist-tag for
+   `prisma` currently points at a release candidate.
+
+   The client is generated by the project's own `postinstall` (a root package
+   script, which package managers always run) and by `db:generate`; it never
+   depends on a dependency's lifecycle script being trusted. */
+export const getPrismaPackageJson = (target, databaseDirectory) => {
+    const version = target.line === 'prisma6' ? prismaMongoDBVersion : versions.prisma;
+    const dependencies = {
+        '@prisma/client': version
+    };
+    if (target.adapter)
+        dependencies[target.adapter.packageName] = version;
+    if (target.migration === 'libsql')
+        dependencies['@libsql/client'] = versions['@libsql/client'];
+    return {
+        dependencies,
+        devDependencies: { prisma: version },
+        scripts: {
+            'db:generate': 'prisma generate',
+            'db:studio': 'prisma studio',
+            postinstall: 'prisma generate',
+            ...migrationScripts(target, databaseDirectory)
+        }
+    };
+};

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

@@ -0,0 +1,22 @@
+import type { AvailablePrismaDialect, DatabaseHost } from '../../types';
+export declare const prismaProviders: readonly ["cockroachdb", "mongodb", "mysql", "postgresql", "sqlite", "sqlserver"];
+export type PrismaProvider = (typeof prismaProviders)[number];
+export type PrismaMigrationStrategy = 'libsql' | 'migrate' | 'push';
+type PrismaAdapter = {
+    className: string;
+    expression: string;
+    packageName: string;
+};
+export type PrismaTarget = {
+    adapter: PrismaAdapter | undefined;
+    line: 'prisma6' | 'prisma7';
+    migration: PrismaMigrationStrategy;
+    provider: PrismaProvider;
+    supportsJson: boolean;
+};
+export declare const initialPrismaMigrationName = "20260926000000_init";
+export declare const prismaClientDirectory = "src/generated/prisma";
+export declare const getMigrationLockProvider: (provider: PrismaProvider) => "cockroachdb" | "mssql" | "mysql" | "postgresql" | "sqlite" | "mongodb";
+export declare const getPrismaMigrationTemplateName: (provider: PrismaProvider, usesAuth: boolean) => string;
+export declare const getPrismaTarget: (databaseEngine: AvailablePrismaDialect, databaseHost: DatabaseHost) => PrismaTarget;
+export {};

package/dist/generators/prisma/prismaTargets.js

@@ -0,0 +1,91 @@
+/* The `provider` values a Prisma schema's datasource accepts. MariaDB has no
+   provider of its own: Prisma drives it as MySQL. */
+export const prismaProviders = [
+    'cockroachdb',
+    'mongodb',
+    'mysql',
+    'postgresql',
+    'sqlite',
+    'sqlserver'
+];
+const databaseUrl = "getEnv('DATABASE_URL')";
+const pgAdapter = {
+    className: 'PrismaPg',
+    expression: `new PrismaPg({ connectionString: ${databaseUrl} })`,
+    packageName: '@prisma/adapter-pg'
+};
+const mariadbAdapter = {
+    className: 'PrismaMariaDb',
+    expression: `new PrismaMariaDb(${databaseUrl})`,
+    packageName: '@prisma/adapter-mariadb'
+};
+/* A local libSQL `file:` URL needs no token; a Turso database does. */
+const libsqlAdapter = {
+    className: 'PrismaLibSql',
+    expression: `new PrismaLibSql({ authToken: env.DATABASE_AUTH_TOKEN, url: ${databaseUrl} })`,
+    packageName: '@prisma/adapter-libsql'
+};
+const sqlTarget = (provider, adapter) => ({
+    adapter,
+    line: 'prisma7',
+    migration: 'migrate',
+    provider,
+    supportsJson: provider !== 'sqlserver'
+});
+const getPostgresqlTarget = (databaseHost) => {
+    if (databaseHost !== 'neon')
+        return sqlTarget('postgresql', pgAdapter);
+    return sqlTarget('postgresql', {
+        className: 'PrismaNeon',
+        expression: `new PrismaNeon({ connectionString: ${databaseUrl} })`,
+        packageName: '@prisma/adapter-neon'
+    });
+};
+const getMysqlTarget = (databaseHost) => {
+    if (databaseHost !== 'planetscale')
+        return sqlTarget('mysql', mariadbAdapter);
+    return sqlTarget('mysql', {
+        className: 'PrismaPlanetScale',
+        expression: `new PrismaPlanetScale({ url: ${databaseUrl} })`,
+        packageName: '@prisma/adapter-planetscale'
+    });
+};
+const engineTargets = {
+    mysql: getMysqlTarget,
+    postgresql: getPostgresqlTarget,
+    cockroachdb: () => sqlTarget('cockroachdb', pgAdapter),
+    mariadb: () => sqlTarget('mysql', mariadbAdapter),
+    mongodb: () => ({
+        adapter: undefined,
+        line: 'prisma6',
+        migration: 'push',
+        provider: 'mongodb',
+        supportsJson: true
+    }),
+    mssql: () => sqlTarget('sqlserver', {
+        className: 'PrismaMssql',
+        expression: `new PrismaMssql(${databaseUrl})`,
+        packageName: '@prisma/adapter-mssql'
+    }),
+    sqlite: (databaseHost) => ({
+        ...sqlTarget('sqlite', libsqlAdapter),
+        migration: databaseHost === 'turso' ? 'libsql' : 'migrate'
+    })
+};
+/* The initial migration's directory name, in Prisma Migrate's
+   `<timestamp>_<name>` format. */
+export const initialPrismaMigrationName = '20260926000000_init';
+/* Where `prisma generate` writes the client, relative to the project root.
+   Fixed (independent of --db-dir) so server, handlers and types import it by
+   a stable path. It is build output: ignored by git, ESLint and Prettier. */
+export const prismaClientDirectory = 'src/generated/prisma';
+/* The value Prisma Migrate records in migrations/migration_lock.toml. Prisma 7
+   names SQL Server `mssql` there, not by its schema provider name. */
+export const getMigrationLockProvider = (provider) => provider === 'sqlserver' ? 'mssql' : provider;
+/* The directory holding the committed initial migration for a provider and
+   example table (users when auth is on, count_history otherwise). */
+export const getPrismaMigrationTemplateName = (provider, usesAuth) => `prisma-${provider}-${usesAuth ? 'users' : 'count-history'}`;
+/* Resolves the provider, driver adapter and migration strategy for an
+   engine/host pair. Hosts are validated beforehand (validateDatabaseSelection),
+   so PlanetScale Postgres is plain Postgres over `pg` here. */
+export const getPrismaTarget = (databaseEngine, databaseHost) => engineTargets[databaseEngine](databaseHost);