create-absolutejs 0.17.2 → 0.18.0

package/dist/generators/configurations/generateEslintConfig.js

@@ -1,261 +1,53 @@
-export const generateEslintConfig = (frontends) => {
-    const hasReact = frontends.includes('react');
-    const reactImports = hasReact
-        ? `import jsxA11yPlugin from 'eslint-plugin-jsx-a11y';
-import reactPlugin from 'eslint-plugin-react';
-import reactCompilerPlugin from 'eslint-plugin-react-compiler';
-import reactHooksPlugin from 'eslint-plugin-react-hooks';
-`
-        : '';
-    const reactBlock = hasReact
-        ? `	{
-		files: ['example/**/*.{js,jsx,ts,tsx}'],
-		plugins: {
-			'jsx-a11y': fixupPluginRules(jsxA11yPlugin),
-			react: fixupPluginRules(reactPlugin),
-			'react-compiler': reactCompilerPlugin,
-			'react-hooks': reactHooksPlugin
-		},
-		rules: {
-			'jsx-a11y/prefer-tag-over-role': 'error',
-			'react-compiler/react-compiler': 'error',
-			'react-hooks/exhaustive-deps': 'warn',
-			'react-hooks/rules-of-hooks': 'error',
-			'react/checked-requires-onchange-or-readonly': 'error',
-			'react/destructuring-assignment': ['error', 'always'],
-			'react/jsx-filename-extension': ['error', { extensions: ['.tsx'] }],
-			'react/jsx-no-leaked-render': 'error',
-			'react/jsx-no-target-blank': 'error',
-			'react/jsx-no-useless-fragment': 'error',
-			'react/jsx-pascal-case': ['error', { allowAllCaps: true }],
-			'react/no-multi-comp': 'error',
-			'react/no-unknown-property': 'off',
-			'react/react-in-jsx-scope': 'off',
-			'react/self-closing-comp': 'error'
-		},
-		settings: {
-			react: { version: 'detect' }
-		}
-	},
-`
-        : '';
-    return `// eslint.config.mjs
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { fixupPluginRules } from '@eslint/compat';
-import pluginJs from '@eslint/js';
-import stylistic from '@stylistic/eslint-plugin';
-import tsParser from '@typescript-eslint/parser';
+/** Correctness defaults; project-specific formatting belongs in Prettier. */
+export const generateEslintConfig = (frontends) => `
 import { defineConfig } from 'eslint/config';
-import absolutePlugin from 'eslint-plugin-absolute';
-import importPlugin from 'eslint-plugin-import';
-${reactImports}import promisePlugin from 'eslint-plugin-promise';
-import securityPlugin from 'eslint-plugin-security';
-import globals from 'globals';
 import tseslint from 'typescript-eslint';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
+import absolute from 'eslint-plugin-absolute';
+${frontends.includes('react') ? "import reactHooks from 'eslint-plugin-react-hooks';" : ''}
 
 export default defineConfig([
-	pluginJs.configs.recommended,
-
-	...tseslint.configs.recommended,
-
-	{
-		files: ['**/*.{ts,tsx}'],
-		languageOptions: {
-			globals: globals.browser,
-			parser: tsParser,
-			parserOptions: {
-				createDefaultProgram: true,
-				project: './tsconfig.json',
-				tsconfigRootDir: __dirname
-			}
-		}
-	},
-
-	{
-		files: ['**/*.{ts,tsx}'],
-		plugins: { '@stylistic': stylistic },
-		rules: {
-			'@stylistic/padding-line-between-statements': [
-				'error',
-				{ blankLine: 'always', next: 'return', prev: '*' }
-			]
-		}
-	},
-
-	{
-		files: ['**/*.{js,mjs,cjs,ts,tsx,jsx}'],
-		ignores: ['example/build/**'],
-		plugins: {
-			absolute: fixupPluginRules(absolutePlugin),
-			import: fixupPluginRules(importPlugin),
-			promise: fixupPluginRules(promisePlugin),
-			security: fixupPluginRules(securityPlugin)
-		},
-		rules: {
-			'absolute/button-icon-is-hidden': 'error',
-			'absolute/explicit-object-types': 'error',
-			'absolute/icon-button-has-accessible-name': 'error',
-			'absolute/localize-react-props': 'error',
-			'absolute/max-depth-extended': ['error', 1],
-			'absolute/max-jsxnesting': ['error', 5],
-			'absolute/min-var-length': [
-				'error',
-				{ allowedVars: ['_', 'id', 'db', 'OK'], minLength: 3 }
-			],
-			'absolute/no-button-navigation': 'error',
-			'absolute/no-explicit-return-type': 'error',
-			'absolute/no-inline-prop-types': 'error',
-			'absolute/no-multi-style-objects': 'error',
-			'absolute/no-nested-jsx-return': 'error',
-			'absolute/no-or-none-component': 'error',
-			'absolute/no-transition-cssproperties': 'error',
-			'absolute/no-unnecessary-div': 'error',
-			'absolute/no-unnecessary-key': 'error',
-			'absolute/no-useless-function': 'error',
-			'absolute/seperate-style-files': 'error',
-			'absolute/sort-exports': [
-				'error',
-				{
-					caseSensitive: true,
-					natural: true,
-					order: 'asc',
-					variablesBeforeFunctions: true
-				}
-			],
-			'absolute/sort-keys-fixable': [
-				'error',
-				{
-					caseSensitive: true,
-					natural: true,
-					order: 'asc',
-					variablesBeforeFunctions: true
-				}
-			],
-			'arrow-body-style': ['error', 'as-needed'],
-			'consistent-return': 'error',
-			eqeqeq: 'error',
-			'func-style': [
-				'error',
-				'expression',
-				{ allowArrowFunctions: true }
-			],
-			'import/no-cycle': 'error',
-			'import/no-default-export': 'error',
-			'import/no-relative-packages': 'error',
-			'import/no-unused-modules': ['error', { missingExports: true }],
-			'import/order': ['error', { alphabetize: { order: 'asc' } }],
-			'no-await-in-loop': 'error',
-			'no-console': ['error', { allow: ['warn', 'error'] }],
-			'no-debugger': 'error',
-			'no-duplicate-case': 'error',
-			'no-duplicate-imports': 'error',
-			'no-else-return': 'error',
-			'no-empty-function': 'error',
-			'no-empty-pattern': 'error',
-			'no-empty-static-block': 'error',
-			'no-fallthrough': 'error',
-			'no-floating-decimal': 'error',
-			'no-global-assign': 'error',
-			'no-implicit-coercion': 'error',
-			'no-implicit-globals': 'error',
-			'no-loop-func': 'error',
-			'no-magic-numbers': [
-				'warn',
-				{ detectObjects: false, enforceConst: true, ignore: [0, 1] }
-			],
-			'no-misleading-character-class': 'error',
-			'no-nested-ternary': 'error',
-			'no-new-native-nonconstructor': 'error',
-			'no-new-wrappers': 'error',
-			'no-param-reassign': 'error',
-			'no-restricted-imports': [
-				'error',
-				{
-					paths: [
-						{
-							importNames: ['default'],
-							message:
-								'Import only named React exports for tree-shaking.',
-							name: 'react'
-						},
-						{
-							importNames: ['default'],
-							message: 'Import only the required Bun exports.',
-							name: 'bun'
-						}
-					]
-				}
-			],
-			'no-return-await': 'error',
-			'no-shadow': 'error',
-			'no-undef': 'error',
-			'no-unneeded-ternary': 'error',
-			'no-unreachable': 'error',
-			'no-useless-assignment': 'error',
-			'no-useless-concat': 'error',
-			'no-useless-return': 'error',
-			'no-var': 'error',
-			'prefer-arrow-callback': 'error',
-			'prefer-const': 'error',
-			'prefer-destructuring': [
-				'error',
-				{ array: true, object: true },
-				{ enforceForRenamedProperties: false }
-			],
-			'prefer-template': 'error',
-			'promise/always-return': 'warn',
-			'promise/avoid-new': 'warn',
-			'promise/catch-or-return': 'error',
-			'promise/no-callback-in-promise': 'warn',
-			'promise/no-nesting': 'warn',
-			'promise/no-promise-in-callback': 'warn',
-			'promise/no-return-wrap': 'error',
-			'promise/param-names': 'error'
-		}
-	},
-	{
-		files: ['**/*.{html,vue,svelte,gjs,gts}'],
-		ignores: ['example/build/**'],
-		plugins: { absolute: fixupPluginRules(absolutePlugin) },
-		processor: 'absolute/template-source'
-	},
-${reactBlock}	{
-		files: [
-			'example/server.ts',
-			'example/indexes/*.tsx',
-			'example/db/migrate.ts'
-		],
-		rules: {
-			'import/no-unused-modules': 'off'
-		}
-	},
-	{
-		files: ['example/db/migrate.ts', 'example/utils/absoluteAuthConfig.ts'],
-		rules: {
-			'no-console': 'off'
-		}
-	},
-	{
-		files: ['eslint.config.mjs'],
-		rules: {
-			'no-magic-numbers': 'off'
-		}
-	},
-	{
-		files: ['eslint.config.mjs'],
-		rules: {
-			'import/no-default-export': 'off'
-		}
-	},
-	{
-		files: ['example/db/schema.ts'],
-		rules: {
-			'absolute/explicit-object-types': 'off'
-		}
-	}
+  // 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/**'] },
+  { linterOptions: { noInlineConfig: true, reportUnusedDisableDirectives: 'error' } },
+  ...tseslint.configs.recommended,
+  {
+    files: ['**/*.{ts,tsx,js,jsx,mjs}'],
+    plugins: { absolute },
+    rules: {
+      '@typescript-eslint/ban-ts-comment': ['error', { 'ts-check': true, 'ts-expect-error': true, 'ts-ignore': true, 'ts-nocheck': true }],
+      'absolute/no-chained-type-assertions': 'error',
+      'absolute/no-unsafe-schema-types': 'error',
+      'absolute/prefer-drizzle-query-builders': 'error',
+      'absolute/elysia-composition-boundaries': 'error',
+      'absolute/no-nondeterministic-render': 'error',
+      'absolute/button-icon-is-hidden': 'error',
+      'absolute/icon-button-has-accessible-name': 'error',
+      'absolute/loading-indicator-has-aria-busy': 'error',
+      'absolute/progressbar-has-state': 'error',
+    },
+  },
+  {
+    files: ['src/backend/**/*.{ts,tsx}'],
+    rules: { 'absolute/elysia-no-response-return': 'error' },
+  },
+  {
+    files: ['src/frontend/**/*.{ts,tsx,js,jsx}'],
+    rules: {
+      'no-restricted-syntax': ['error',
+        { selector: "CallExpression[callee.name='fetch']", message: 'Use a directly typed Eden subapp client.' },
+        { selector: "CallExpression[callee.property.name='fetch']", message: 'Use a directly typed Eden subapp client.' },
+      ],
+      ${frontends.includes('react') ? "'absolute/eden-requires-react-query': 'error'," : ''}
+    },
+  },
+  { files: ['**/*.{html,vue,svelte,gjs,gts}'], plugins: { absolute }, processor: 'absolute/template-source' },
+  ${frontends.includes('react')
+    ? `{
+    // React Hooks rules do not apply to Angular's unrelated usePageContext API.
+    files: ['src/frontend/**/*.{tsx,jsx}', 'src/frontend/**/hooks/**/*.{ts,js}'],
+    plugins: { 'react-hooks': reactHooks },
+    rules: { 'react-hooks/rules-of-hooks': 'error', 'react-hooks/exhaustive-deps': 'error' },
+  },`
+    : ''}
 ]);
 `;
-};

package/dist/generators/configurations/generatePackageJson.js

@@ -147,7 +147,7 @@ export const createPackageJson = async ({ agentic, projectName, authOption, plug
         dependencies[absoluteAuthPlugin.value] = resolveVersion(absoluteAuthPlugin.value, absoluteAuthPlugin.latestVersion);
     }
     if (agentic) {
-        for (const name of [
+        [
             '@absolutejs/a2a',
             '@absolutejs/agency',
             '@absolutejs/agent-discovery',
@@ -166,9 +166,9 @@ export const createPackageJson = async ({ agentic, projectName, authOption, plug
             '@absolutejs/secrets',
             '@absolutejs/sync-bus-pg',
             '@absolutejs/wallet'
-        ]) {
+        ].forEach((name) => {
             dependencies[name] = resolveVersion(name, versions[name]);
-        }
+        });
         devDependencies['@absolutejs/agent-conformance'] = resolveVersion('@absolutejs/agent-conformance', versions['@absolutejs/agent-conformance']);
     }
     for (const pluginValue of plugins) {

package/dist/generators/db/generateDatabaseTypes.js

@@ -108,56 +108,49 @@ 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';`;
-                dbTypeLine =
-                    'export type DatabaseType = GelJsDatabase<SchemaType>;';
-                break;
             case 'mariadb':
             case 'mysql':
-                dbImport = `import { Mysql2Database } from 'drizzle-orm/mysql2';`;
+                dbImport = `import type { drizzle } from 'drizzle-orm/mysql2';`;
                 dbTypeLine =
-                    'export type DatabaseType = Mysql2Database<SchemaType>;';
+                    'export type DatabaseType = ReturnType<typeof drizzle>;';
                 break;
             case 'mssql':
-                dbImport = `import { NodeMssqlDatabase } from 'drizzle-orm/node-mssql';`;
+                dbImport = `import type { NodeMsSqlDatabase } from 'drizzle-orm/node-mssql';`;
                 dbTypeLine =
-                    'export type DatabaseType = NodeMssqlDatabase<SchemaType>;';
+                    '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';`;
-                dbTypeLine =
-                    'export type DatabaseType = SingleStoreDriverDatabase<SchemaType>;';
+                dbImport = `import type { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';`;
+                dbTypeLine = '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/generateDrizzleSchema.js

@@ -53,7 +53,7 @@ const DIALECTS = {
         pkg: 'sqlite-core',
         string: 'text()',
         table: 'sqliteTable',
-        time: "integer({ mode: 'timestamp' })"
+        time: "integer({ mode: 'timestamp_ms' })"
     }
 };
 const builder = (expr) => expr.split('(')[0];
@@ -72,13 +72,15 @@ export const generateDrizzleSchema = ({ databaseEngine, authOption }) => {
         ? [cfg.table, stringBuilder, timeBuilder, jsonBuilder]
         : [cfg.table, intBuilder, timeBuilder];
     const uniqueBuilders = Array.from(new Set(importBuilders));
-    const builderImport = `import { ${uniqueBuilders.join(', ')} } from 'drizzle-orm/${cfg.pkg}';`;
-    const sqliteImports = databaseEngine === 'sqlite'
+    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 === 'mariadb' ||
-        databaseEngine === 'mssql' ||
+    if (databaseEngine === 'mssql') {
+        uidColumn = `int('uid').identity().primaryKey()`;
+    }
+    else if (databaseEngine === 'mariadb' ||
         databaseEngine === 'mysql' ||
         databaseEngine === 'singlestore') {
         uidColumn = `${intBuilder}('uid').primaryKey().autoincrement()`;
@@ -93,14 +95,16 @@ export const generateDrizzleSchema = ({ databaseEngine, authOption }) => {
         ? `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()`;
+    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'
         ? `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>().default({})
 });`
         : `export const countHistory = ${cfg.table}('count_history', {
   uid: ${uidColumn},

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

@@ -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
@@ -367,7 +367,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 +466,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

@@ -10,7 +10,7 @@ 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 });
@@ -64,17 +64,19 @@ 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,
             projectDatabaseDirectory,
-            projectName
+            projectName,
+            verifyLocalDatabase
         });
-        return { dockerFreshInstall };
+        ({ dockerFreshInstall } = result);
     }
     if (orm === 'drizzle') {
         if (!isDrizzleDialect(databaseEngine)) {
@@ -93,10 +95,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,12 @@
 import { AuthOption, DatabaseEngine } from '../../types';
 type ScaffoldDockerProps = {
+    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, verifyLocalDatabase }: ScaffoldDockerProps) => Promise<{
     dockerFreshInstall: boolean;
 }>;
 export {};

package/dist/generators/db/scaffoldDocker.js

@@ -33,16 +33,18 @@ 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, 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');
+    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`);

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({