create-absolutejs 0.18.0 → 0.20.0

package/CHANGELOG.md

@@ -6,6 +6,22 @@ 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
+
+- **Scaffold Drizzle for every Drizzle 1.0 dialect (PostgreSQL, MySQL, MariaDB, SQLite, Turso/libSQL, SingleStore, SQL Server, CockroachDB) with a committed initial migration and db:generate / db:migrate scripts**
+
+### Fixed
+
+- **Accept --orm none as the help text documents, and refuse unsupported database, host and ORM combinations before writing any files**
+
 ## 0.18.0 — 2026-09-23
 
 ### Fixed

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,30 @@
 	"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": [
+				{
+					"kind": "fixed",
+					"summary": "Accept --orm none as the help text documents, and refuse unsupported database, host and ORM combinations before writing any files"
+				},
+				{
+					"kind": "added",
+					"summary": "Scaffold Drizzle for every Drizzle 1.0 dialect (PostgreSQL, MySQL, MariaDB, SQLite, Turso/libSQL, SingleStore, SQL Server, CockroachDB) with a committed initial migration and db:generate / db:migrate scripts"
+				}
+			],
+			"date": "2026-09-26",
+			"version": "0.19.0"
+		},
 		{
 			"changes": [
 				{

package/dist/commands/migrateDatabase.d.ts

@@ -0,0 +1,6 @@
+import type { CreateConfiguration } from '../types';
+type MigrateDatabaseProps = Pick<CreateConfiguration, 'databaseEngine' | 'databaseHost' | 'projectName'> & {
+    verifyLocalDatabase: boolean;
+};
+export declare const migrateDatabase: ({ databaseEngine, databaseHost, projectName, verifyLocalDatabase }: MigrateDatabaseProps) => Promise<boolean>;
+export {};

package/dist/commands/migrateDatabase.js

@@ -0,0 +1,53 @@
+import { spinner } from '@clack/prompts';
+import { $ } from 'bun';
+import { green, yellow } from 'picocolors';
+import { isDockerDaemonRunning, resolveDockerExe } from '../utils/checkDockerInstalled';
+const applyMigrations = async (projectName) => (await $ `bun run db:migrate`.cwd(projectName).quiet().nothrow())
+    .exitCode === 0;
+const migrateDockerDatabase = async (projectName, databaseEngine) => {
+    if (!(await isDockerDaemonRunning()))
+        return false;
+    const docker = resolveDockerExe();
+    const compose = [
+        'compose',
+        '-p',
+        databaseEngine,
+        '-f',
+        'db/docker-compose.db.yml'
+    ];
+    const started = await $ `${docker} ${compose} up -d --wait db`
+        .cwd(projectName)
+        .quiet()
+        .nothrow();
+    if (started.exitCode !== 0)
+        return false;
+    const migrated = await applyMigrations(projectName);
+    await $ `${docker} ${compose} down`.cwd(projectName).quiet().nothrow();
+    return migrated;
+};
+/* Applies the project's committed initial migration once dependencies are
+   installed, so a fresh Drizzle project's example tables exist on first run.
+   Local SQLite and the default local libSQL file for Turso migrate directly;
+   a Docker database is migrated only when the daemon is already up and the
+   scaffold verified it. Hosted databases are left to `db:migrate`, which needs
+   the real DATABASE_URL. Returns whether the migration ran. */
+export const migrateDatabase = async ({ databaseEngine, databaseHost, projectName, verifyLocalDatabase }) => {
+    const isLocal = databaseHost === undefined || databaseHost === 'none';
+    const isFileDatabase = databaseEngine === 'sqlite' && (isLocal || databaseHost === 'turso');
+    const isDockerDatabase = isLocal &&
+        verifyLocalDatabase &&
+        databaseEngine !== undefined &&
+        databaseEngine !== 'none' &&
+        databaseEngine !== 'sqlite';
+    if (!isFileDatabase && !isDockerDatabase)
+        return false;
+    const spin = spinner();
+    spin.start('Applying database migrations');
+    const migrated = isFileDatabase
+        ? await applyMigrations(projectName)
+        : await migrateDockerDatabase(projectName, databaseEngine ?? 'db');
+    spin.stop(migrated
+        ? green('Database migrated')
+        : yellow('Database not migrated — run db:migrate once it is up'));
+    return migrated;
+};

package/dist/data.d.ts

@@ -5,7 +5,7 @@ export declare const availableCodeQualityTools: readonly ["eslint+prettier", "bi
 export declare const availableDatabaseEngines: readonly ["postgresql", "mysql", "sqlite", "mongodb", "mariadb", "gel", "singlestore", "cockroachdb", "mssql", "none"];
 export declare const availableDatabaseHosts: readonly ["neon", "planetscale", "turso", "none"];
 export declare const availableDirectoryConfigurations: readonly ["default", "custom"];
-export declare const availableDrizzleDialects: readonly ["mariadb", "mssql", "mysql", "postgresql", "singlestore", "sqlite"];
+export declare const availableDrizzleDialects: readonly ["cockroachdb", "mariadb", "mssql", "mysql", "postgresql", "singlestore", "sqlite"];
 export declare const availableFrontends: readonly ["react", "html", "svelte", "vue", "htmx", "angular"];
 export declare const availableORMs: readonly ["drizzle", "prisma", "none"];
 export declare const availablePlugins: AvailableDependency[];

package/dist/data.js

@@ -35,6 +35,7 @@ export const availableDatabaseHosts = [
 ];
 export const availableDirectoryConfigurations = ['default', 'custom'];
 export const availableDrizzleDialects = [
+    'cockroachdb',
     'mariadb',
     'mssql',
     'mysql',

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

@@ -1,8 +1,10 @@
-import type { DatabaseEngine } from '../../types';
+import type { AvailableDrizzleDialect, DatabaseHost } from '../../types';
 type CreateDrizzleConfigProps = {
     projectName: string;
-    databaseEngine: DatabaseEngine;
+    databaseEngine: AvailableDrizzleDialect;
+    databaseHost: DatabaseHost;
     databaseDirectory: string;
 };
-export declare const createDrizzleConfig: ({ projectName, databaseDirectory, databaseEngine }: CreateDrizzleConfigProps) => void;
+export declare const createDrizzleConfig: ({ projectName, ...options }: CreateDrizzleConfigProps) => void;
+export declare const generateDrizzleConfig: ({ databaseDirectory, databaseEngine, databaseHost }: Omit<CreateDrizzleConfigProps, "projectName">) => string;
 export {};

package/dist/generators/configurations/generateDrizzleConfig.js

@@ -1,21 +1,47 @@
 import { writeFileSync } from 'fs';
 import { join } from 'path';
-export const createDrizzleConfig = ({ projectName, databaseDirectory, databaseEngine }) => {
-    const drizzleConfig = `import { defineConfig } from "drizzle-kit";
-	import { env } from 'process';
-
-    if (!env.DATABASE_URL) {
+import { getDrizzleKitDialect } from '../db/drizzleTargets';
+const requireDatabaseUrl = `if (!env.DATABASE_URL) {
 	throw new Error('DATABASE_URL must be set in the environment variables');
 }
+`;
+export const createDrizzleConfig = ({ projectName, ...options }) => {
+    writeFileSync(join(projectName, 'drizzle.config.ts'), generateDrizzleConfig(options));
+};
+export const generateDrizzleConfig = ({ databaseDirectory, databaseEngine, databaseHost }) => {
+    const dialect = getDrizzleKitDialect(databaseEngine, databaseHost);
+    const paths = `out: '${databaseDirectory}/migrations',
+	schema: '${databaseDirectory}/schema.ts'`;
+    /* Local SQLite lives in a file beside the schema — the same path the server
+       opens — so migrations need no environment at all. */
+    if (dialect === 'sqlite') {
+        return `import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+	dbCredentials: {
+		url: '${databaseDirectory}/database.sqlite'
+	},
+	dialect: 'sqlite',
+	${paths}
+});
+`;
+    }
+    /* Turso speaks libSQL: a \`libsql://\` URL plus an auth token in the cloud,
+       or a \`file:\` URL with no token for a local libSQL database. */
+    const credentials = dialect === 'turso'
+        ? `authToken: env.DATABASE_AUTH_TOKEN,
+		url: env.DATABASE_URL`
+        : 'url: env.DATABASE_URL';
+    return `import { env } from 'process';
+import { defineConfig } from 'drizzle-kit';
 
-	export default defineConfig({
-		dbCredentials: {
-			url: env.DATABASE_URL
-		},
-		dialect: '${databaseEngine === 'mariadb' ? 'mysql' : databaseEngine}',
-		out: '${databaseDirectory}/migrations',
-		schema: '${databaseDirectory}/schema.ts'
-	});
+${requireDatabaseUrl}
+export default defineConfig({
+	dbCredentials: {
+		${credentials}
+	},
+	dialect: '${dialect}',
+	${paths}
+});
 `;
-    writeFileSync(join(projectName, 'drizzle.config.ts'), drizzleConfig);
 };

package/dist/generators/configurations/generateEnv.js

@@ -18,6 +18,12 @@ export const generateEnv = ({ databaseEngine, databaseHost, envVariables = [], p
         (databaseHost === 'none' || databaseHost === undefined)) {
         vars.push(`DATABASE_URL=${databaseURLS[databaseEngine]}`);
     }
+    /* A Turso project starts on a local libSQL file so it runs (and migrates)
+       before a cloud database exists; pointing it at Turso is two variables. */
+    const setsDatabaseUrl = vars.some((entry) => entry.startsWith('DATABASE_URL='));
+    if (databaseHost === 'turso' && !setsDatabaseUrl) {
+        vars.push('# Local libSQL file. For Turso use DATABASE_URL=libsql://<database>.turso.io and set DATABASE_AUTH_TOKEN.', 'DATABASE_URL=file:db/database.db');
+    }
     if (vars.length === 0)
         return;
     const envPath = join(projectName, '.env');

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 ─────────── */
@@ -118,6 +121,19 @@ export const createPackageJson = async ({ agentic, projectName, authOption, plug
         packageNames.add('mssql');
         packageNames.add('@types/mssql');
     }
+    /* drizzle-orm/cockroach (and drizzle-kit's cockroach dialect) drive
+       CockroachDB through node-postgres. */
+    const usesCockroachDrizzle = isLocal && databaseEngine === 'cockroachdb' && orm === 'drizzle';
+    if (usesCockroachDrizzle) {
+        packageNames.add('pg');
+        packageNames.add('@types/pg');
+    }
+    /* drizzle-kit migrates through the first Postgres driver it can import,
+       trying pg before Neon's serverless driver (which @absolutejs/auth brings
+       in transitively and which cannot reach a local database). */
+    const needsKitPostgresDriver = isLocal && databaseEngine === 'postgresql' && orm === 'drizzle';
+    if (needsKitPostgresDriver)
+        packageNames.add('pg');
     if (isLocal && databaseEngine === 'gel')
         packageNames.add('gel');
     if (databaseEngine === 'mongodb')
@@ -279,6 +295,13 @@ export const createPackageJson = async ({ agentic, projectName, authOption, plug
         dependencies['mssql'] = resolveVersion('mssql', versions['mssql']);
         devDependencies['@types/mssql'] = resolveVersion('@types/mssql', versions['@types/mssql']);
     }
+    if (needsKitPostgresDriver) {
+        devDependencies['pg'] = resolveVersion('pg', versions['pg']);
+    }
+    if (usesCockroachDrizzle) {
+        dependencies['pg'] = resolveVersion('pg', versions['pg']);
+        devDependencies['@types/pg'] = resolveVersion('@types/pg', versions['@types/pg']);
+    }
     if (isLocalDb && databaseEngine === 'gel') {
         dependencies['gel'] = resolveVersion('gel', versions['gel']);
     }
@@ -287,14 +310,27 @@ export const createPackageJson = async ({ agentic, projectName, authOption, plug
     }
     if (isLocalDb && databaseEngine === 'sqlite') {
         scripts['db:sqlite'] = 'sqlite3 db/database.sqlite';
-        scripts['db:init'] = 'sqlite3 db/database.sqlite < db/init.sql';
+    }
+    if (isLocalDb && databaseEngine === 'sqlite' && orm !== 'drizzle') {
+        scripts['db:init'] = 'sqlite3 db/database.sqlite < db/schema.sql';
     }
     if (orm === 'drizzle') {
-        scripts['db:studio'] = 'drizzle-kit studio';
-        scripts['db:push'] = 'drizzle-kit push';
+        /* Migrations are the schema's source of truth: `db:generate` diffs
+           db/schema.ts into a new committed migration and `db:migrate` applies
+           pending ones. drizzle-kit runs on Bun so it can use Bun's own SQL and
+           SQLite drivers, exactly as the server does. */
+        scripts['db:generate'] = 'bun --bun drizzle-kit generate';
+        scripts['db:migrate'] = 'bun --bun drizzle-kit migrate';
+        scripts['db:studio'] = 'bun --bun drizzle-kit studio';
         /* `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/drizzleTargets.d.ts

@@ -0,0 +1,5 @@
+import type { AvailableDrizzleDialect, DatabaseHost } from '../../types';
+export declare const drizzleKitDialects: readonly ["cockroach", "mssql", "mysql", "postgresql", "singlestore", "sqlite", "turso"];
+export type DrizzleKitDialect = (typeof drizzleKitDialects)[number];
+export declare const getDrizzleKitDialect: (databaseEngine: AvailableDrizzleDialect, databaseHost: DatabaseHost) => "mssql" | "mysql" | "postgresql" | "singlestore" | "sqlite" | "turso" | "cockroach";
+export declare const getMigrationTemplateName: (kitDialect: DrizzleKitDialect, usesAuth: boolean) => string;

package/dist/generators/db/drizzleTargets.js

@@ -0,0 +1,27 @@
+/* The `dialect` values drizzle-kit 1.0 accepts in drizzle.config.ts. Turso is
+   its own kit dialect (libSQL over HTTP/WebSocket with an auth token), even
+   though its tables are written with sqlite-core. */
+export const drizzleKitDialects = [
+    'cockroach',
+    'mssql',
+    'mysql',
+    'postgresql',
+    'singlestore',
+    'sqlite',
+    'turso'
+];
+const engineKitDialects = {
+    cockroachdb: 'cockroach',
+    mariadb: 'mysql',
+    mssql: 'mssql',
+    mysql: 'mysql',
+    postgresql: 'postgresql',
+    singlestore: 'singlestore',
+    sqlite: 'sqlite'
+};
+export const getDrizzleKitDialect = (databaseEngine, databaseHost) => databaseEngine === 'sqlite' && databaseHost === 'turso'
+    ? 'turso'
+    : engineKitDialects[databaseEngine];
+/* The directory holding the committed initial migration for a kit dialect and
+   example table (users when auth is on, count_history otherwise). */
+export const getMigrationTemplateName = (kitDialect, usesAuth) => `${kitDialect}-${usesAuth ? 'users' : 'count-history'}`;

package/dist/generators/db/generateDatabaseTypes.js

@@ -127,16 +127,19 @@ export const generateDatabaseTypes = ({ databaseEngine, databaseHost, authOption
     if ((!databaseHost || databaseHost === 'none') &&
         isDrizzleDialect(databaseEngine)) {
         switch (databaseEngine) {
-            case 'mariadb':
-            case 'mysql':
-                dbImport = `import type { drizzle } from 'drizzle-orm/mysql2';`;
+            case 'cockroachdb':
+                dbImport = `import type { drizzle } from 'drizzle-orm/cockroach';`;
                 dbTypeLine =
                     'export type DatabaseType = ReturnType<typeof drizzle>;';
                 break;
+            case 'mariadb':
+            case 'mysql':
+                dbImport = `import type { MySql2Database } from 'drizzle-orm/mysql2';`;
+                dbTypeLine = 'export type DatabaseType = MySql2Database;';
+                break;
             case 'mssql':
                 dbImport = `import type { NodeMsSqlDatabase } from 'drizzle-orm/node-mssql';`;
-                dbTypeLine =
-                    'export type DatabaseType = NodeMsSqlDatabase;';
+                dbTypeLine = 'export type DatabaseType = NodeMsSqlDatabase;';
                 break;
             case 'postgresql':
                 dbImport = `import type { drizzle } from 'drizzle-orm/bun-sql';`;
@@ -145,7 +148,8 @@ export const generateDatabaseTypes = ({ databaseEngine, databaseHost, authOption
                 break;
             case 'singlestore':
                 dbImport = `import type { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';`;
-                dbTypeLine = 'export type DatabaseType = SingleStoreDriverDatabase;';
+                dbTypeLine =
+                    'export type DatabaseType = SingleStoreDriverDatabase;';
                 break;
             case 'sqlite':
                 dbImport = `import type { drizzle } from 'drizzle-orm/bun-sqlite';`;

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

@@ -1,2 +1,7 @@
 import { DatabaseEngine } from '../../types';
 export declare const generateDockerContainer: (databaseEngine: DatabaseEngine) => string;
+export declare const getDockerInitScript: (databaseEngine: DatabaseEngine) => {
+    fileName: string;
+    mountPath: string;
+    sql: string;
+} | undefined;

package/dist/generators/db/generateDockerContainer.js

@@ -6,7 +6,9 @@ const templates = {
         },
         healthcheck: {
             startPeriod: '5s',
-            test: 'cockroach sql --insecure -e "select 1" >/dev/null 2>&1'
+            /* Healthy once COCKROACH_DATABASE exists, not merely once the node
+               answers, so `db:up --wait` is followed safely by `db:migrate`. */
+            test: 'cockroach sql --insecure -e "SHOW DATABASES" 2>/dev/null | grep -q "^database"'
         },
         image: 'cockroachdb/cockroach:latest-v25.3',
         port: '26257:26257',
@@ -101,9 +103,17 @@ const templates = {
         },
         healthcheck: {
             startPeriod: '30s',
-            test: 'singlestore -u root -ppassword -e "SELECT 1" >/dev/null 2>&1'
+            /* Healthy once the init script has created the database. */
+            test: 'singlestore -u root -ppassword -D database -e "SELECT 1" >/dev/null 2>&1'
         },
         image: 'ghcr.io/singlestore-labs/singlestoredb-dev', // NOTE: No tag specified due to data persistence
+        /* The dev image has no "create this database" variable; without it the
+           DATABASE_URL's database would not exist until something created it. */
+        initScript: {
+            fileName: 'singlestore-init.sql',
+            mountPath: '/init.sql',
+            sql: 'CREATE DATABASE IF NOT EXISTS `database`;\n'
+        },
         platform: 'linux/amd64', // Required for ARM64 (Apple Silicon); no-op on amd64
         port: '3306:3306',
         volumePath: '/data'
@@ -115,7 +125,10 @@ export const generateDockerContainer = (databaseEngine) => {
         databaseEngine === 'sqlite') {
         throw new Error('Internal type error: Expected a valid local database engine');
     }
-    const { command, env, healthcheck, image, platform, port, volumePath } = templates[databaseEngine];
+    const { command, env, healthcheck, image, initScript, platform, port, volumePath } = templates[databaseEngine];
+    const initScriptLine = initScript
+        ? `\n            - ./${initScript.fileName}:${initScript.mountPath}:ro`
+        : '';
     const commandLine = command ? `\n        command: ${command}` : '';
     const platformLine = platform ? `\n        platform: ${platform}` : '';
     const envLines = Object.entries(env)
@@ -136,9 +149,14 @@ ${envLines}
             retries: 30
             start_period: ${healthcheck.startPeriod}
         volumes:
-            - db_data:${volumePath}
+            - db_data:${volumePath}${initScriptLine}
 
 volumes:
     db_data:
 `;
 };
+export const getDockerInitScript = (databaseEngine) => databaseEngine === undefined ||
+    databaseEngine === 'none' ||
+    databaseEngine === 'sqlite'
+    ? undefined
+    : templates[databaseEngine].initScript;