create-absolutejs 0.18.0 → 0.20.0

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);

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

@@ -0,0 +1,16 @@
+import type { AuthOption, DatabaseEngine, DatabaseHost } from '../../types';
+import { type PrismaTarget } from './prismaTargets';
+type ScaffoldPrismaDatabaseProps = {
+    authOption: AuthOption;
+    backendDirectory: string;
+    databaseDirectory: string;
+    databaseEngine: DatabaseEngine;
+    databaseHost: DatabaseHost;
+    projectName: string;
+    typesDirectory: string;
+    verifyLocalDatabase: boolean;
+};
+export declare const prismaMongoDBCompose = "services:\n    db:\n        image: mongo:7.0\n        restart: always\n        command: [\"--replSet\", \"rs0\", \"--bind_ip_all\"]\n        ports:\n            - \"27017:27017\"\n        healthcheck:\n            test: [\"CMD-SHELL\", \"mongosh --quiet --eval \\\"try { if (rs.status().myState !== 1) quit(1) } catch (error) { rs.initiate({ _id: 'rs0', members: [{ _id: 0, host: 'localhost:27017' }] }); quit(1) }\\\"\"]\n            interval: 2s\n            timeout: 5s\n            retries: 30\n            start_period: 5s\n        volumes:\n            - db_data:/data/db\n\nvolumes:\n    db_data:\n";
+export declare const getPrismaLocalDatabaseUrl: (target: PrismaTarget, databaseDirectory: string, databaseHost: DatabaseHost) => string | undefined;
+export declare const scaffoldPrismaDatabase: ({ authOption, backendDirectory, databaseDirectory, databaseEngine, databaseHost, projectName, typesDirectory, verifyLocalDatabase }: ScaffoldPrismaDatabaseProps) => Promise<boolean>;
+export {};

package/dist/generators/prisma/scaffoldPrismaDatabase.js

@@ -0,0 +1,136 @@
+import { cpSync, existsSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { spinner } from '@clack/prompts';
+import { $ } from 'bun';
+import { green, red } from 'picocolors';
+import { isPrismaDialect } from '../../typeGuards';
+import { checkDockerInstalled, ensureDockerDaemonRunning, resolveDockerExe, shutdownDockerDaemon } from '../../utils/checkDockerInstalled';
+import { scaffoldDocker } from '../db/scaffoldDocker';
+import { generatePrismaDatabaseTypes, generatePrismaHandlers } from './generatePrismaCode';
+import { generateLibsqlMigrateScript, generatePrismaConfig } from './generatePrismaConfig';
+import { generatePrismaSchema } from './generatePrismaSchema';
+import { getPrismaMigrationTemplateName, getPrismaTarget } from './prismaTargets';
+/* Prisma requires MongoDB to run as a replica set (it writes through
+   transactions). A single-node set is initiated by the healthcheck itself,
+   which only passes once the node is PRIMARY — so `db:up --wait` is followed
+   safely by `db:migrate`. */
+export const prismaMongoDBCompose = `services:
+    db:
+        image: mongo:7.0
+        restart: always
+        command: ["--replSet", "rs0", "--bind_ip_all"]
+        ports:
+            - "27017:27017"
+        healthcheck:
+            test: ["CMD-SHELL", "mongosh --quiet --eval \\"try { if (rs.status().myState !== 1) quit(1) } catch (error) { rs.initiate({ _id: 'rs0', members: [{ _id: 0, host: 'localhost:27017' }] }); quit(1) }\\""]
+            interval: 2s
+            timeout: 5s
+            retries: 30
+            start_period: 5s
+        volumes:
+            - db_data:/data/db
+
+volumes:
+    db_data:
+`;
+/* The local DATABASE_URL a Prisma project starts with, where it differs from
+   the no-ORM default generateEnv writes: SQLite needs a URL at all (the libSQL
+   adapter and Prisma Migrate both take one), MongoDB is the unauthenticated
+   replica set above, SQL Server uses Prisma's `sqlserver://` format and
+   MariaDB the `mysql://` scheme. */
+export const getPrismaLocalDatabaseUrl = (target, databaseDirectory, databaseHost) => {
+    const isLocal = databaseHost === undefined || databaseHost === 'none';
+    if (!isLocal)
+        return undefined;
+    switch (target.provider) {
+        case 'mongodb':
+            return 'mongodb://localhost:27017/database?replicaSet=rs0&directConnection=true';
+        /* MariaDB too: Prisma Migrate only accepts the mysql:// scheme, and the
+           mariadb driver adapter takes it as well. */
+        case 'mysql':
+            return 'mysql://user:userpassword@localhost:3306/database';
+        case 'sqlite':
+            return `file:./${databaseDirectory}/database.sqlite`;
+        case 'sqlserver':
+            return 'sqlserver://localhost:1433;database=master;user=sa;password=SApassword1;encrypt=true;trustServerCertificate=true';
+        default:
+            return undefined;
+    }
+};
+/* Sets DATABASE_URL in the project's own .env, keeping every other line. */
+const setProjectDatabaseUrl = (projectName, url) => {
+    const envPath = join(projectName, '.env');
+    const lines = existsSync(envPath)
+        ? readFileSync(envPath, 'utf8')
+            .split('\n')
+            .filter((line) => !line.startsWith('DATABASE_URL='))
+        : [];
+    writeFileSync(envPath, [...lines, `DATABASE_URL=${url}`].join('\n'));
+};
+const verifyMongoDBContainer = async (projectName, databaseDirectory) => {
+    const { freshInstall } = await checkDockerInstalled('mongodb');
+    const { daemonWasStarted } = await ensureDockerDaemonRunning();
+    const docker = resolveDockerExe();
+    const compose = [
+        'compose',
+        '-p',
+        'mongodb',
+        '-f',
+        `${databaseDirectory}/docker-compose.db.yml`
+    ];
+    const spin = spinner();
+    spin.start('Starting mongodb replica set');
+    try {
+        await $ `${docker} ${compose} up -d --wait db`.cwd(projectName).quiet();
+        await $ `${docker} ${compose} down`.cwd(projectName).quiet();
+        spin.stop(green('Docker container verified'));
+    }
+    catch (error) {
+        spin.cancel(red('Docker setup failed'));
+        throw error;
+    }
+    if (daemonWasStarted)
+        await shutdownDockerDaemon();
+    return freshInstall;
+};
+const templatesDirectory = () => join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'templates');
+/* Scaffolds a Prisma project's database layer: schema, prisma.config.ts, the
+   committed initial migration, typed handlers and types, local .env URL and
+   the Docker database. Everything is written under `projectName`. */
+export const scaffoldPrismaDatabase = async ({ authOption, backendDirectory, databaseDirectory, databaseEngine, databaseHost, projectName, typesDirectory, verifyLocalDatabase }) => {
+    if (!isPrismaDialect(databaseEngine))
+        throw new Error(`Internal type error: "${databaseEngine}" is not a Prisma database`);
+    const target = getPrismaTarget(databaseEngine, databaseHost);
+    const projectDatabaseDirectory = join(projectName, databaseDirectory);
+    const usesAuth = authOption === 'abs';
+    writeFileSync(join(projectDatabaseDirectory, 'schema.prisma'), generatePrismaSchema({ authOption, databaseDirectory, target }));
+    writeFileSync(join(projectName, 'prisma.config.ts'), generatePrismaConfig({ databaseDirectory, target }));
+    if (target.provider !== 'mongodb')
+        cpSync(join(templatesDirectory(), 'db', 'migrations', getPrismaMigrationTemplateName(target.provider, usesAuth)), join(projectDatabaseDirectory, 'migrations'), { recursive: true });
+    if (target.migration === 'libsql')
+        writeFileSync(join(projectDatabaseDirectory, 'migrate.ts'), generateLibsqlMigrateScript());
+    writeFileSync(join(backendDirectory, 'handlers', usesAuth ? 'userHandlers.ts' : 'countHistoryHandlers.ts'), generatePrismaHandlers(authOption, target));
+    writeFileSync(join(typesDirectory, 'databaseTypes.ts'), generatePrismaDatabaseTypes(authOption, target));
+    const localUrl = getPrismaLocalDatabaseUrl(target, databaseDirectory, databaseHost);
+    if (localUrl)
+        setProjectDatabaseUrl(projectName, localUrl);
+    const isLocal = databaseHost === undefined || databaseHost === 'none';
+    if (!isLocal || target.provider === 'sqlite')
+        return false;
+    if (target.provider === 'mongodb') {
+        writeFileSync(join(projectDatabaseDirectory, 'docker-compose.db.yml'), prismaMongoDBCompose);
+        return (verifyLocalDatabase &&
+            verifyMongoDBContainer(projectName, databaseDirectory));
+    }
+    /* Migrations own the schema, so the container is only verified. */
+    const { dockerFreshInstall } = await scaffoldDocker({
+        authOption,
+        databaseEngine,
+        initializeSchema: false,
+        projectDatabaseDirectory,
+        projectName,
+        verifyLocalDatabase
+    });
+    return dockerFreshInstall;
+};

package/dist/generators/project/generateDBBlock.js

@@ -1,4 +1,10 @@
 import { availableDrizzleDialects } from '../../data';
+import { isPrismaDialect } from '../../typeGuards';
+import { generatePrismaDBBlock } from '../prisma/generatePrismaCode';
+import { getPrismaTarget } from '../prisma/prismaTargets';
+/* A Turso database needs its auth token; a local libSQL `file:` URL has none,
+   so the token stays optional. */
+const tursoClient = 'createClient({ authToken: env.DATABASE_AUTH_TOKEN, url: getEnv("DATABASE_URL") })';
 const connectionMap = {
     cockroachdb: {
         none: { expr: 'new SQL(getEnv("DATABASE_URL"))' }
@@ -36,19 +42,21 @@ const connectionMap = {
     },
     sqlite: {
         none: { expr: 'new Database("db/database.sqlite")' },
-        turso: { expr: 'createClient({ url: getEnv("DATABASE_URL") })' }
+        turso: { expr: tursoClient }
     }
 };
 const remoteDrizzleInit = {
     neon: 'neon(getEnv("DATABASE_URL"));',
     planetscale: 'new Client({ url: getEnv("DATABASE_URL") })',
-    turso: 'createClient({ url: getEnv("DATABASE_URL") })'
+    turso: tursoClient
 };
 const drizzleDialectSet = new Set([...availableDrizzleDialects]);
 export const generateDBBlock = ({ databaseEngine, orm, databaseHost }) => {
     if (!databaseEngine || databaseEngine === 'none') {
         throw new Error('Internal type error: Expected a valid database engine');
     }
+    if (orm === 'prisma' && isPrismaDialect(databaseEngine))
+        return generatePrismaDBBlock(getPrismaTarget(databaseEngine, databaseHost));
     const hostKey = databaseHost ?? 'none';
     const engineGroup = connectionMap[databaseEngine];
     if (!engineGroup)
@@ -67,6 +75,12 @@ export const generateDBBlock = ({ databaseEngine, orm, databaseHost }) => {
         return `
 const pool = createPool(getEnv("DATABASE_URL"))
 const db = drizzle({ client: pool })
+`;
+    }
+    if (databaseEngine === 'cockroachdb') {
+        return `
+const pool = new Pool({ connectionString: getEnv("DATABASE_URL") })
+const db = drizzle({ client: pool })
 `;
     }
     if (databaseEngine === 'mssql' && hostKey === 'none') {

package/dist/generators/project/generateImportsBlock.js

@@ -1,4 +1,6 @@
-import { isDrizzleDialect } from '../../typeGuards';
+import { isDrizzleDialect, isPrismaDialect } from '../../typeGuards';
+import { getPrismaServerImports } from '../prisma/generatePrismaCode';
+import { getPrismaTarget } from '../prisma/prismaTargets';
 export const generateImportsBlock = ({ deps, flags, orm, authOption, databaseEngine, databaseHost, frontendDirectories }) => {
     const rawImports = [];
     const pushHandler = (cond, name, pkg = '@absolutejs/absolute') => cond && rawImports.push(`import { ${name} } from '${pkg}'`);
@@ -42,7 +44,10 @@ export const generateImportsBlock = ({ deps, flags, orm, authOption, databaseEng
     const connectorImports = {
         neon: [`import { neon } from '@neondatabase/serverless'`],
         planetscale: [`import { Client } from '@planetscale/database'`],
-        turso: [`import { createClient } from '@libsql/client'`]
+        turso: [
+            `import { createClient } from '@libsql/client'`,
+            `import { env } from 'bun'`
+        ]
     };
     const dialectImports = {
         neon: [`import { drizzle } from 'drizzle-orm/neon-http'`],
@@ -77,13 +82,15 @@ export const generateImportsBlock = ({ deps, flags, orm, authOption, databaseEng
     };
     const ormDatabaseImports = {
         drizzle: {
-            gel: [
-                `import { createClient } from 'gel'`,
-                `import { drizzle } from 'drizzle-orm/gel'`
+            cockroachdb: [
+                `import { drizzle } from 'drizzle-orm/cockroach'`,
+                `import { Pool } from 'pg'`
             ],
+            /* drizzle-orm/mysql2 1.0 sets options on the pool's `config`, which
+               only mysql2's callback pool has; it wraps it in .promise() itself. */
             mariadb: [
                 `import { drizzle } from 'drizzle-orm/mysql2'`,
-                `import { createPool } from 'mysql2/promise'`
+                `import { createPool } from 'mysql2'`
             ],
             mssql: [
                 `import { connect } from 'mssql'`,
@@ -92,7 +99,7 @@ export const generateImportsBlock = ({ deps, flags, orm, authOption, databaseEng
             mysql: !isRemoteHost
                 ? [
                     `import { drizzle } from 'drizzle-orm/mysql2'`,
-                    `import { createPool } from 'mysql2/promise'`
+                    `import { createPool } from 'mysql2'`
                 ]
                 : [],
             postgresql: getPostgresqlOrmDatabaseImports(),
@@ -180,6 +187,9 @@ export const generateImportsBlock = ({ deps, flags, orm, authOption, databaseEng
     if (orm === 'drizzle' && isDrizzleDialect(databaseEngine)) {
         rawImports.push(...ormDatabaseImports[orm][databaseEngine]);
     }
+    if (orm === 'prisma' && isPrismaDialect(databaseEngine)) {
+        rawImports.push(...getPrismaServerImports(getPrismaTarget(databaseEngine, databaseHost)));
+    }
     if (noOrm && hasDatabase && noOrmImports[databaseEngine]) {
         rawImports.push(...noOrmImports[databaseEngine]);
     }

package/dist/generators/project/generateServer.js

@@ -34,7 +34,8 @@ export const generateServerFile = ({ tailwind, authOption, plugins, buildDirecto
     const useBlock = deps
         .flatMap((dependency) => dependency.imports ?? [])
         .filter((pluginImport) => pluginImport.isPlugin &&
-        pluginImport.packageName !== 'networking' && pluginImport.packageName !== 'openapi')
+        pluginImport.packageName !== 'networking' &&
+        pluginImport.packageName !== 'openapi')
         .map((pluginImport) => {
         if (pluginImport.packageName === 'auth') {
             return 'authPlugin';

package/dist/index.js

@@ -14,7 +14,7 @@ if (help === true) {
     exit(0);
 }
 const response = await prompt(argumentConfiguration);
-const { dockerFreshInstall } = await scaffold({
+const { databaseMigrationPending, dockerFreshInstall } = await scaffold({
     envVariables,
     latest,
     packageManager,
@@ -27,6 +27,7 @@ const debugMessage = debug !== false
     })
     : '';
 const outroMessage = getOutroMessage({
+    databaseMigrationPending,
     installDependenciesNow: response.installDependenciesNow,
     packageManager,
     projectName: response.projectName

package/dist/messages.d.ts

@@ -4,8 +4,9 @@ type OutroMessageProps = {
     projectName: string;
     packageManager: string;
     installDependenciesNow: boolean;
+    databaseMigrationPending: boolean;
 };
-export declare const getOutroMessage: ({ projectName, packageManager, installDependenciesNow }: OutroMessageProps) => string;
+export declare const getOutroMessage: ({ databaseMigrationPending, projectName, packageManager, installDependenciesNow }: OutroMessageProps) => string;
 type DebugMessageProps = {
     response: CreateConfiguration;
     packageManager: string;

package/dist/messages.js

@@ -46,9 +46,10 @@ Options:
   ${cyan('--vue')}                           Include a Vue frontend
   ${cyan('--vue-dir')} ${dim(cyan('<directory>'))}           Specify the directory for and use the Vue frontend
 `;
-export const getOutroMessage = ({ projectName, packageManager, installDependenciesNow }) => `${green('Created successfully')}, you can now run:\n\n` +
+export const getOutroMessage = ({ databaseMigrationPending, projectName, packageManager, installDependenciesNow }) => `${green('Created successfully')}, you can now run:\n\n` +
     `${cyan('cd')} ${projectName}\n` +
     `${installDependenciesNow ? '' : `${cyan(`${packageManager} install`)}\n`}` +
+    `${databaseMigrationPending ? `${cyan(`${packageManager} run db:migrate`)}\n` : ''}` +
     `${cyan(`${packageManager} dev`)}`; // TODO: Some package managers need run
 export const getDebugMessage = ({ response: { agentic, projectName, codeQualityTool, directoryConfig, useTailwind, tailwind, frontends, includeExamples, useHTMLScripts, frontendDirectories, buildDirectory, assetsDirectory, databaseEngine, databaseHost, databaseDirectory, orm, authOption, plugins, initializeGitNow, installDependenciesNow }, packageManager }) => {
     const htmlScriptingValue = useHTMLScripts

package/dist/questions/authOption.js

@@ -6,7 +6,10 @@ export const getAuthOption = async () => {
         message: 'Auth provider:',
         options: [
             { label: 'None', value: 'none' },
-            { label: cyan('Absolute Auth (Google; requires a database)'), value: 'abs' }
+            {
+                label: cyan('Absolute Auth (Google; requires a database)'),
+                value: 'abs'
+            }
         ]
     });
     if (isCancel(authOption))

package/dist/questions/databaseEngine.d.ts

@@ -1 +1 @@
-export declare const getDatabaseEngine: () => Promise<"mariadb" | "mssql" | "mysql" | "postgresql" | "singlestore" | "sqlite" | "mongodb" | "cockroachdb" | "gel" | undefined>;
+export declare const getDatabaseEngine: () => Promise<"cockroachdb" | "mariadb" | "mssql" | "mysql" | "postgresql" | "singlestore" | "sqlite" | "mongodb" | "gel" | undefined>;

package/dist/questions/orm.js

@@ -1,6 +1,6 @@
 import { select, isCancel } from '@clack/prompts';
-import { cyan } from 'picocolors';
-import { isDrizzleDialect } from '../typeGuards';
+import { cyan, magenta } from 'picocolors';
+import { isDrizzleDialect, isPrismaDialect } from '../typeGuards';
 import { abort } from '../utils/abort';
 export const getORM = async (databaseEngine) => {
     const options = [
@@ -9,6 +9,9 @@ export const getORM = async (databaseEngine) => {
     if (isDrizzleDialect(databaseEngine)) {
         options.push({ label: cyan('Drizzle'), value: 'drizzle' });
     }
+    if (isPrismaDialect(databaseEngine)) {
+        options.push({ label: magenta('Prisma'), value: 'prisma' });
+    }
     const orm = await select({
         message: 'Choose an ORM for your database:',
         options

package/dist/scaffold.d.ts

@@ -7,6 +7,7 @@ type ScaffoldProps = {
     verifyLocalDatabase?: boolean;
 };
 export declare const scaffold: ({ response: { agentic, projectName, codeQualityTool, initializeGitNow, githubLink, githubRepoUrl, githubVisibility, databaseEngine, databaseHost, useHTMLScripts, useTailwind, databaseDirectory, absProviders, includeExamples, orm, frontends, plugins, authOption, buildDirectory, assetsDirectory, tailwind, installDependenciesNow, frontendDirectories }, latest, verifyLocalDatabase, envVariables, packageManager }: ScaffoldProps) => Promise<{
+    databaseMigrationPending: boolean;
     dockerFreshInstall: boolean;
 }>;
 export {};