create-absolutejs 0.17.3 → 0.19.0

package/dist/generators/db/generateDatabaseTypes.js

@@ -108,56 +108,53 @@ export const generateDatabaseTypes = ({ databaseEngine, databaseHost, authOption
     let dbImport = '';
     let dbTypeLine = '';
     if (databaseHost === 'neon') {
-        dbImport = `import { NeonHttpDatabase } from 'drizzle-orm/neon-http';`;
-        dbTypeLine = 'export type DatabaseType = NeonHttpDatabase<SchemaType>;';
+        dbImport = `import type { drizzle } from 'drizzle-orm/neon-http';`;
+        dbTypeLine = 'export type DatabaseType = ReturnType<typeof drizzle>;';
     }
     else if (databaseHost === 'planetscale' && databaseEngine === 'mysql') {
-        dbImport = `import { PlanetScaleDatabase } from 'drizzle-orm/planetscale-serverless';`;
-        dbTypeLine =
-            'export type DatabaseType = PlanetScaleDatabase<SchemaType>;';
+        dbImport = `import type { drizzle } from 'drizzle-orm/planetscale-serverless';`;
+        dbTypeLine = 'export type DatabaseType = ReturnType<typeof drizzle>;';
     }
     else if (databaseHost === 'planetscale' &&
         databaseEngine === 'postgresql') {
-        dbImport = `import { NodePgDatabase } from 'drizzle-orm/node-postgres';`;
-        dbTypeLine = 'export type DatabaseType = NodePgDatabase<SchemaType>;';
+        dbImport = `import type { drizzle } from 'drizzle-orm/node-postgres';`;
+        dbTypeLine = 'export type DatabaseType = ReturnType<typeof drizzle>;';
     }
     else if (databaseHost === 'turso') {
-        dbImport = `import { LibSQLDatabase } from 'drizzle-orm/libsql';`;
-        dbTypeLine = 'export type DatabaseType = LibSQLDatabase<SchemaType>;';
+        dbImport = `import type { drizzle } from 'drizzle-orm/libsql';`;
+        dbTypeLine = 'export type DatabaseType = ReturnType<typeof drizzle>;';
     }
     if ((!databaseHost || databaseHost === 'none') &&
         isDrizzleDialect(databaseEngine)) {
         switch (databaseEngine) {
-            case 'gel':
-                dbImport = `import { GelJsDatabase } from 'drizzle-orm/gel';`;
+            case 'cockroachdb':
+                dbImport = `import type { drizzle } from 'drizzle-orm/cockroach';`;
                 dbTypeLine =
-                    'export type DatabaseType = GelJsDatabase<SchemaType>;';
+                    'export type DatabaseType = ReturnType<typeof drizzle>;';
                 break;
             case 'mariadb':
             case 'mysql':
-                dbImport = `import { Mysql2Database } from 'drizzle-orm/mysql2';`;
-                dbTypeLine =
-                    'export type DatabaseType = Mysql2Database<SchemaType>;';
+                dbImport = `import type { MySql2Database } from 'drizzle-orm/mysql2';`;
+                dbTypeLine = 'export type DatabaseType = MySql2Database;';
                 break;
             case 'mssql':
-                dbImport = `import { NodeMssqlDatabase } from 'drizzle-orm/node-mssql';`;
-                dbTypeLine =
-                    'export type DatabaseType = NodeMssqlDatabase<SchemaType>;';
+                dbImport = `import type { NodeMsSqlDatabase } from 'drizzle-orm/node-mssql';`;
+                dbTypeLine = 'export type DatabaseType = NodeMsSqlDatabase;';
                 break;
             case 'postgresql':
-                dbImport = `import { BunSQLDatabase } from 'drizzle-orm/bun-sql';`;
+                dbImport = `import type { drizzle } from 'drizzle-orm/bun-sql';`;
                 dbTypeLine =
-                    'export type DatabaseType = BunSQLDatabase<SchemaType>;';
+                    'export type DatabaseType = ReturnType<typeof drizzle>;';
                 break;
             case 'singlestore':
-                dbImport = `import { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';`;
+                dbImport = `import type { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';`;
                 dbTypeLine =
-                    'export type DatabaseType = SingleStoreDriverDatabase<SchemaType>;';
+                    'export type DatabaseType = SingleStoreDriverDatabase;';
                 break;
             case 'sqlite':
-                dbImport = `import { BunSQLiteDatabase } from 'drizzle-orm/bun-sqlite';`;
+                dbImport = `import type { drizzle } from 'drizzle-orm/bun-sqlite';`;
                 dbTypeLine =
-                    'export type DatabaseType = BunSQLiteDatabase<SchemaType>;';
+                    'export type DatabaseType = ReturnType<typeof drizzle>;';
                 break;
         }
     }

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,117 +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' })"
+        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 = `import { ${uniqueBuilders.join(', ')} } from 'drizzle-orm/${cfg.pkg}';`;
-    const sqliteImports = databaseEngine === 'sqlite'
-        ? `import { sql } from 'drizzle-orm';\n`
-        : '';
-    let uidColumn;
-    if (databaseEngine === 'mariadb' ||
-        databaseEngine === 'mssql' ||
-        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`
-        : '';
-    const timestampColumn = databaseEngine === 'sqlite'
-        ? `${cfg.time}.notNull().default(sql\`(julianday('now') - \${JULIAN_DAY_UNIX_EPOCH_OFFSET}) * \${MILLIS_PER_DAY}\`)`
-        : `${cfg.time}.notNull().defaultNow()`;
-    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<Record<string, unknown>>().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/generateHandlers.js

@@ -1,4 +1,4 @@
-import { getAuthTemplate, getCountTemplate } from './handlerTemplates';
+import { getAuthTemplate, getCountTemplate, isDriverConfigurationKey } from './handlerTemplates';
 export const generateDBHandlers = ({ databaseEngine, databaseHost, orm, usesAuth }) => {
     if (databaseEngine === undefined || databaseEngine === 'none') {
         throw new Error('Internal Error: databaseEngine is undefined or "none".');
@@ -6,6 +6,7 @@ export const generateDBHandlers = ({ databaseEngine, databaseHost, orm, usesAuth
     const host = databaseHost && databaseHost !== 'none' ? databaseHost : 'local';
     const ormKey = orm === 'drizzle' ? 'drizzle' : 'sql';
     const key = `${databaseEngine}:${ormKey}:${host}`;
-    // @ts-expect-error - TODO: Finish the other templates
+    if (!isDriverConfigurationKey(key))
+        throw new Error(`Unsupported database configuration: ${key}`);
     return usesAuth ? getAuthTemplate(key) : getCountTemplate(key);
 };

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

@@ -1,3 +1,3 @@
 import { AuthOption, DatabaseEngine } from '../../types';
-export declare const supportsRelationalSchema: (engine: DatabaseEngine) => boolean;
 export declare const generateRelationalSchema: (databaseEngine: DatabaseEngine, authOption: AuthOption) => string;
+export declare const supportsRelationalSchema: (engine: DatabaseEngine) => boolean;

package/dist/generators/db/generateRelationalSchema.js

@@ -30,7 +30,6 @@ const DIALECTS = {
         timestamp: 'TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP'
     }
 };
-export const supportsRelationalSchema = (engine) => engine !== undefined && engine in DIALECTS;
 export const generateRelationalSchema = (databaseEngine, authOption) => {
     if (databaseEngine === undefined || !(databaseEngine in DIALECTS)) {
         throw new Error(`Internal error: no relational DDL for engine "${databaseEngine}"`);
@@ -50,3 +49,4 @@ export const generateRelationalSchema = (databaseEngine, authOption) => {
 );
 `;
 };
+export const supportsRelationalSchema = (engine) => engine !== undefined && engine in DIALECTS;

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': {
@@ -31,7 +31,12 @@ declare const driverConfigurations: {
     };
     readonly 'mssql:drizzle:local': {
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
-        readonly queries: QueryOperations;
+        readonly queries: {
+            readonly insertHistory: string;
+            readonly insertUser: string;
+            readonly selectUser: string;
+            readonly selectHistory: string;
+        };
     };
     readonly 'mssql:sql:local': {
         readonly importLines: "";
@@ -105,4 +110,5 @@ declare const driverConfigurations: {
 type DriverConfigurationKey = keyof typeof driverConfigurations;
 export declare const getAuthTemplate: (key: DriverConfigurationKey) => string;
 export declare const getCountTemplate: (key: DriverConfigurationKey) => string;
+export declare const isDriverConfigurationKey: (key: string) => key is DriverConfigurationKey;
 export {};

package/dist/generators/db/handlerTemplates.js

@@ -19,7 +19,7 @@ export const getUser = async (
 	((await selectUserRow(db, authSub)) as User | null) ?? null;`}
 
 export const createUser = async (db: DatabaseType, newUserData: NewUser) => {
-	const { auth_sub: authSub, metadata: userIdentity } = newUserData;
+	${rowsAreTyped ? '' : 'const { auth_sub: authSub, metadata: userIdentity } = newUserData;'}
 	${queries.insertUser}
 }`;
 /* Takes `db` as the `DatabaseType` alias rather than naming the driver type
@@ -269,14 +269,12 @@ const mysqlDrizzleQueryOperations = {
     .where(eq(schema.countHistory.uid, uid));
 
   return newHistory;`,
-    insertUser: `const [row] = await db
-    .insert(schema.users)
-    .values({ auth_sub: authSub, metadata: userIdentity });
+    insertUser: `await db.insert(schema.users).values(newUserData);
 
   const [newUser] = await db
     .select()
     .from(schema.users)
-    .where(eq(schema.users.auth_sub, authSub));
+    .where(eq(schema.users.auth_sub, newUserData.auth_sub));
 
   if (!newUser) throw new Error('Failed to create user');
   return newUser;`,
@@ -337,16 +335,15 @@ const mysqlPlanetScaleQueryOperations = {
   `
 };
 const driverConfigurations = {
+    'cockroachdb:drizzle:local': {
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'`,
+        queries: drizzleQueryOperations
+    },
     'cockroachdb:sql:local': {
         importLines: ``,
         queries: postgresSqlQueryOperations
     },
-    'gel:drizzle:local': {
-        importLines: `import { eq } from 'drizzle-orm'
-import { schema } from '../../../db/schema'
-`,
-        queries: drizzleQueryOperations
-    },
     'gel:sql:local': {
         importLines: ``,
         queries: gelClientQueryOperations
@@ -367,7 +364,11 @@ import { schema } from '../../../db/schema'`,
     'mssql:drizzle:local': {
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
-        queries: drizzleQueryOperations
+        queries: {
+            ...drizzleQueryOperations,
+            insertHistory: drizzleQueryOperations.insertHistory.replace('.values({ count }).returning()', '.output().values({ count })'),
+            insertUser: drizzleQueryOperations.insertUser.replace('.values(newUserData)\n\t\t.returning()', '.output()\n\t\t.values(newUserData)')
+        }
     },
     'mssql:sql:local': {
         importLines: ``,
@@ -462,3 +463,4 @@ export const getCountTemplate = (key) => {
         throw new Error(`Unsupported driver configuration: ${key}`);
     return buildSqlCountTemplate(configuration);
 };
+export const isDriverConfigurationKey = (key) => Object.hasOwn(driverConfigurations, key);

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

@@ -1,10 +1,11 @@
 import type { CreateConfiguration } from '../../types';
 type ScaffoldDatabaseProps = Pick<CreateConfiguration, 'projectName' | 'databaseHost' | 'orm' | 'databaseDirectory' | 'authOption' | 'databaseEngine'> & {
     databaseDirectory: string;
+    verifyLocalDatabase?: boolean;
     backendDirectory: string;
     typesDirectory: string;
 };
-export declare const scaffoldDatabase: ({ projectName, databaseEngine, databaseHost, databaseDirectory, backendDirectory, authOption, orm, typesDirectory }: ScaffoldDatabaseProps) => Promise<{
+export declare const scaffoldDatabase: ({ projectName, databaseEngine, databaseHost, databaseDirectory, backendDirectory, authOption, orm, typesDirectory, verifyLocalDatabase }: ScaffoldDatabaseProps) => Promise<{
     dockerFreshInstall: boolean;
 }>;
 export {};

package/dist/generators/db/scaffoldDatabase.js

@@ -1,16 +1,18 @@
-import { mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
+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 { getDrizzleKitDialect, getMigrationTemplateName } from './drizzleTargets';
 import { generateDatabaseTypes } from './generateDatabaseTypes';
 import { generateDrizzleSchema } from './generateDrizzleSchema';
 import { generateDBHandlers } from './generateHandlers';
 import { generateRelationalSchema, supportsRelationalSchema } from './generateRelationalSchema';
 import { generateSqliteSchema } from './generateSqliteSchema';
 import { scaffoldDocker } from './scaffoldDocker';
-export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHost, databaseDirectory, backendDirectory, authOption, orm, typesDirectory }) => {
+export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHost, databaseDirectory, backendDirectory, authOption, orm, typesDirectory, verifyLocalDatabase = true }) => {
     const projectDatabaseDirectory = join(projectName, databaseDirectory);
     const handlerDirectory = join(backendDirectory, 'handlers');
     mkdirSync(projectDatabaseDirectory, { recursive: true });
@@ -50,7 +52,10 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         supportsRelationalSchema(databaseEngine)) {
         writeFileSync(join(projectDatabaseDirectory, 'schema.sql'), generateRelationalSchema(databaseEngine, authOption));
     }
-    if (databaseEngine === 'sqlite') {
+    /* Drizzle projects get their tables from the committed initial migration
+       (`db:migrate`), never from hand-written DDL, so the migration history and
+       the database always agree. */
+    if (databaseEngine === 'sqlite' && orm !== 'drizzle') {
         // The sqlite3 CLI is a developer convenience (a db shell), never a
         // scaffold requirement — seeding goes through bun:sqlite below, which
         // ships with the runtime. The check only nudges interactive users;
@@ -64,17 +69,20 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         seeded.run(sqliteSchema);
         seeded.close();
     }
+    let dockerFreshInstall = false;
     if ((databaseHost === 'none' || databaseHost === undefined) &&
         databaseEngine !== 'sqlite' &&
         databaseEngine !== undefined &&
         databaseEngine !== 'none') {
-        const { dockerFreshInstall } = await scaffoldDocker({
+        const result = await scaffoldDocker({
             authOption,
             databaseEngine,
+            initializeSchema: orm !== 'drizzle',
             projectDatabaseDirectory,
-            projectName
+            projectName,
+            verifyLocalDatabase
         });
-        return { dockerFreshInstall };
+        ({ dockerFreshInstall } = result);
     }
     if (orm === 'drizzle') {
         if (!isDrizzleDialect(databaseEngine)) {
@@ -85,7 +93,14 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
             databaseEngine
         });
         writeFileSync(join(projectDatabaseDirectory, 'schema.ts'), drizzleSchema);
-        createDrizzleConfig({ databaseDirectory, databaseEngine, projectName });
+        createDrizzleConfig({
+            databaseDirectory,
+            databaseEngine,
+            databaseHost,
+            projectName
+        });
+        const templatesDirectory = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'templates');
+        cpSync(join(templatesDirectory, 'db', 'migrations', getMigrationTemplateName(getDrizzleKitDialect(databaseEngine, databaseHost), usesAuth)), join(projectDatabaseDirectory, 'migrations'), { recursive: true });
         const drizzleTypes = generateDatabaseTypes({
             authOption,
             databaseEngine,
@@ -93,10 +108,10 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
             orm
         });
         writeFileSync(join(typesDirectory, 'databaseTypes.ts'), drizzleTypes);
-        return { dockerFreshInstall: false };
+        return { dockerFreshInstall };
     }
     if (orm === 'prisma') {
         console.warn(`${dim('│')}\n${yellow('▲')}  Prisma support is not implemented yet`);
     }
-    return { dockerFreshInstall: false };
+    return { dockerFreshInstall };
 };

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

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

package/dist/generators/db/scaffoldDocker.js

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

package/dist/generators/htmx/scaffoldHTMX.js

@@ -6,6 +6,7 @@ import { generateHTMXPage } from './generateHTMXPage';
 export const scaffoldHTMX = ({ editBasePath, includeExamples, targetDirectory, templatesDirectory, projectAssetsDirectory, frontends, isSingleFrontend, stylesIndexesDirectory }) => {
     const pagesDirectory = join(targetDirectory, 'pages');
     const cssOutputFile = join(stylesIndexesDirectory, 'htmx-example.css');
+    copyFileSync(join(templatesDirectory, 'htmx', 'LICENSE'), join(targetDirectory, 'htmx.LICENSE'));
     // htmx.min.js is the framework runtime, copied in both modes.
     const glob = new Glob('htmx*.min.js');
     for (const relativePath of glob.scanSync({

package/dist/generators/project/generateAbsoluteAuthConfig.d.ts

@@ -1,3 +1,3 @@
 import { ProviderOption } from '@absolutejs/auth';
-export declare const generateSessionUserType: () => string;
 export declare const generateAbsoluteAuthConfig: (absProviders: ProviderOption[] | undefined, hasDatabase: boolean) => string;
+export declare const generateSessionUserType: () => string;