create-absolutejs 0.18.0 → 0.19.0

package/CHANGELOG.md

@@ -6,6 +6,16 @@ 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.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/changelog.json

@@ -2,6 +2,20 @@
 	"contract": 1,
 	"name": "create-absolutejs",
 	"releases": [
+		{
+			"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/generatePackageJson.js

@@ -118,6 +118,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 +292,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,11 +307,18 @@ 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']);
     }

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;

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': {