create-absolutejs 0.3.9 → 0.3.10

package/README.md

@@ -51,10 +51,10 @@ Usage: create-absolute [project-name] [options]
 - `--angular`  
   Include an Angular frontend.
 
-- `--angular-dir <dir>`  
+- `--angular-dir <directory>`  
   Specify the directory for and use the Angular frontend.
 
-- `--assets <dir>`  
+- `--assets <directory>`  
   Directory name for your static assets.
 
 - `--auth <plugin|none>`  
@@ -63,31 +63,31 @@ Usage: create-absolute [project-name] [options]
 - `--biome`  
   Use Biome for code quality and formatting.
 
-- `--build <dir>`  
+- `--build <direrctory>`  
   Output directory for build artifacts.
 
-- `--database <dir>`  
+- `--db <engine|none>`  
+  Database engine (`postgresql` | `mysql` | `sqlite` | `mongodb` | `redis` | `singlestore` | `cockroachdb` | `mssql`) or `none`.
+
+- `--db-dir <directory>`  
   Directory name for your database files.
 
+- `--db-host <provider|none>`  
+  Database host provider (`neon` | `planetscale` | `supabase` | `turso` | `vercel` | `upstash` | `atlas`) or `none`.
+
 - `--directory <default|custom>`  
   Directory-naming strategy: `default` or `custom`.
 
-- `--engine <engine|none>`  
-  Database engine (`postgresql` | `mysql` | `sqlite` | `mongodb` | `redis` | `singlestore` | `cockroachdb` | `mssql`) or `none`.
-
 - `--eslint+prettier`  
   Use ESLint + Prettier for code quality and formatting.
 
 - `--git`  
   Initialize a Git repository.
 
-- `--host <provider|none>`  
-  Database host provider (`neon` | `planetscale` | `supabase` | `turso` | `vercel` | `upstash` | `atlas`) or `none`.
-
 - `--html`  
   Include a plain HTML frontend.
 
-- `--html-dir <dir>`  
+- `--html-dir <directory>`  
   Specify the directory for and use the HTML frontend.
 
 - `--html-scripts`  
@@ -96,7 +96,7 @@ Usage: create-absolute [project-name] [options]
 - `--htmx`  
   Include an HTMX frontend.
 
-- `--htmx-dir <dir>`  
+- `--htmx-dir <directory>`  
   Specify the directory for and use the HTMX frontend.
 
 - `--install`  
@@ -114,7 +114,7 @@ Usage: create-absolute [project-name] [options]
 - `--react`  
   Include a React frontend.
 
-- `--react-dir <dir>`  
+- `--react-dir <directory>`  
   Specify the directory for and use the React frontend.
 
 - `--skip`  
@@ -123,7 +123,7 @@ Usage: create-absolute [project-name] [options]
 - `--svelte`  
   Include a Svelte frontend.
 
-- `--svelte-dir <dir>`  
+- `--svelte-dir <directory>`  
   Specify the directory for and use the Svelte frontend.
 
 - `--tailwind`  
@@ -138,7 +138,7 @@ Usage: create-absolute [project-name] [options]
 - `--vue`  
   Include a Vue frontend.
 
-- `--vue-dir <dir>`  
+- `--vue-dir <directory>`  
   Specify the directory for and use the Vue frontend.
 
 ## Directory Configuration

package/dist/data.d.ts

@@ -1,10 +1,12 @@
 import type { FrontendLabels, AvailableDependency } from './types';
 export declare const availableFrontends: readonly ["react", "html", "svelte", "vue", "htmx"];
 export declare const availableAuthProviders: readonly ["absoluteAuth", "none"];
-export declare const availableDatabaseEngines: readonly ["postgresql", "mysql", "sqlite", "mongodb", "redis", "singlestore", "cockroachdb", "mssql", "none"];
+export declare const availableDrizzleDialects: readonly ["gel", "mysql", "postgresql", "sqlite", "singlestore"];
+export declare const availablePrismaDialects: readonly ["mysql", "postgresql", "sqlite", "mongodb", "mariadb", "cockroachdb", "mssql"];
+export declare const availableDatabaseEngines: readonly ["postgresql", "mysql", "sqlite", "mongodb", "mariadb", "gel", "singlestore", "cockroachdb", "mssql", "none"];
 export declare const availableDirectoryConfigurations: readonly ["default", "custom"];
 export declare const availableORMs: readonly ["drizzle", "prisma", "none"];
-export declare const availableDatabaseHosts: readonly ["neon", "planetscale", "supabase", "turso", "vercel", "upstash", "atlas", "none"];
+export declare const availableDatabaseHosts: readonly ["neon", "planetscale", "turso", "none"];
 export declare const availableCodeQualityTools: readonly ["eslint+prettier", "biome"];
 export declare const frontendLabels: FrontendLabels;
 export declare const availablePlugins: AvailableDependency[];

package/dist/data.js

@@ -8,12 +8,29 @@ export const availableFrontends = [
     'htmx'
 ];
 export const availableAuthProviders = ['absoluteAuth', 'none'];
+export const availableDrizzleDialects = [
+    'gel',
+    'mysql',
+    'postgresql',
+    'sqlite',
+    'singlestore'
+];
+export const availablePrismaDialects = [
+    'mysql',
+    'postgresql',
+    'sqlite',
+    'mongodb',
+    'mariadb',
+    'cockroachdb',
+    'mssql'
+];
 export const availableDatabaseEngines = [
     'postgresql',
     'mysql',
     'sqlite',
     'mongodb',
-    'redis',
+    'mariadb',
+    'gel',
     'singlestore',
     'cockroachdb',
     'mssql',
@@ -24,11 +41,7 @@ export const availableORMs = ['drizzle', 'prisma', 'none'];
 export const availableDatabaseHosts = [
     'neon',
     'planetscale',
-    'supabase',
     'turso',
-    'vercel',
-    'upstash',
-    'atlas',
     'none'
 ];
 export const availableCodeQualityTools = ['eslint+prettier', 'biome'];
@@ -65,12 +78,14 @@ export const availablePlugins = [
 export const absoluteAuthPlugin = {
     imports: [
         {
-            config: { providersConfiguration: {} },
+            config: {
+                providersConfiguration: {}
+            },
             isPlugin: true,
             packageName: 'absoluteAuth'
         }
     ],
-    latestVersion: '0.3.2',
+    latestVersion: '0.14.4',
     value: '@absolutejs/auth'
 };
 export const scopedStatePlugin = {
@@ -108,7 +123,7 @@ export const defaultPlugins = [
             { isPlugin: false, packageName: 'build' },
             { isPlugin: true, packageName: 'networking' }
         ],
-        latestVersion: '0.12.2',
+        latestVersion: '0.12.3',
         value: '@absolutejs/absolute'
     },
     {

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

@@ -2,6 +2,7 @@ import type { DatabaseEngine } from '../../types';
 type CreateDrizzleConfigProps = {
     projectName: string;
     databaseEngine: DatabaseEngine;
+    databaseDirectory: string;
 };
-export declare const createDrizzleConfig: ({ projectName, databaseEngine }: CreateDrizzleConfigProps) => void;
+export declare const createDrizzleConfig: ({ projectName, databaseDirectory, databaseEngine }: CreateDrizzleConfigProps) => void;
 export {};

package/dist/generators/configurations/generateDrizzleConfig.js

@@ -1,11 +1,21 @@
 import { writeFileSync } from 'fs';
 import { join } from 'path';
-export const createDrizzleConfig = ({ projectName, databaseEngine }) => {
+export const createDrizzleConfig = ({ projectName, databaseDirectory, databaseEngine }) => {
     const drizzleConfig = `import { defineConfig } from "drizzle-kit";
-    
-    export default defineConfig({
-    dialect: '${databaseEngine}'
-    });
-    `;
+	import { env } from 'process';
+
+    if (!env.DATABASE_URL) {
+	throw new Error('DATABASE_URL must be set in the environment variables');
+}
+
+	export default defineConfig({
+		dbCredentials: {
+			url: env.DATABASE_URL
+		},
+		dialect: '${databaseEngine}',
+		out: '${databaseDirectory}/migrations',
+		schema: '${databaseDirectory}/schema.ts'
+	});
+`;
     writeFileSync(join(projectName, 'drizzle.config.ts'), drizzleConfig);
 };

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

@@ -1,7 +1,7 @@
 import type { CreateConfiguration } from '../../types';
-type CreatePackageJsonProps = Pick<CreateConfiguration, 'authProvider' | 'useTailwind' | 'plugins' | 'frontendDirectories' | 'codeQualityTool'> & {
+type CreatePackageJsonProps = Pick<CreateConfiguration, 'authProvider' | 'useTailwind' | 'databaseEngine' | 'databaseHost' | 'plugins' | 'orm' | 'frontendDirectories' | 'codeQualityTool'> & {
     projectName: string;
     latest: boolean;
 };
-export declare const createPackageJson: ({ projectName, authProvider, plugins, useTailwind, latest, frontendDirectories, codeQualityTool }: CreatePackageJsonProps) => void;
+export declare const createPackageJson: ({ projectName, authProvider, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool }: CreatePackageJsonProps) => void;
 export {};

package/dist/generators/configurations/generatePackageJson.js

@@ -4,17 +4,18 @@ import { spinner } from '@clack/prompts';
 import { green } from 'picocolors';
 import { absoluteAuthPlugin, availablePlugins, defaultPlugins, eslintAndPrettierDependencies } from '../../data';
 import { getPackageVersion } from '../../utils/getPackageVersion';
-export const createPackageJson = ({ projectName, authProvider, plugins, useTailwind, latest, frontendDirectories, codeQualityTool }) => {
+export const createPackageJson = ({ projectName, authProvider, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool }) => {
     const s = spinner();
-    void (latest && s.start('Resolving package versions…'));
+    if (latest)
+        s.start('Resolving package versions…');
     const resolveVersion = (name, listed) => latest ? (getPackageVersion(name) ?? listed) : listed;
     const dependencies = {};
     const devDependencies = {};
-    const requiresReact = frontendDirectories['react'] !== undefined;
-    const requiresSvelte = frontendDirectories['svelte'] !== undefined;
-    const requiresVue = frontendDirectories['vue'] !== undefined;
-    const requiresHtmx = frontendDirectories['htmx'] !== undefined;
-    const requiresHtml = frontendDirectories['html'] !== undefined;
+    const requiresReact = Boolean(frontendDirectories['react']);
+    const requiresSvelte = Boolean(frontendDirectories['svelte']);
+    const requiresVue = Boolean(frontendDirectories['vue']);
+    const requiresHtmx = Boolean(frontendDirectories['htmx']);
+    const requiresHtml = Boolean(frontendDirectories['html']);
     for (const p of defaultPlugins) {
         dependencies[p.value] = resolveVersion(p.value, p.latestVersion);
     }
@@ -46,8 +47,9 @@ export const createPackageJson = ({ projectName, authProvider, plugins, useTailw
     }
     if (requiresSvelte) {
         dependencies['svelte'] = resolveVersion('svelte', '5.34.7');
-        void (codeQualityTool === 'eslint+prettier' &&
-            (devDependencies['prettier-plugin-svelte'] = resolveVersion('prettier-plugin-svelte', '3.4.0')));
+    }
+    if (requiresSvelte && codeQualityTool === 'eslint+prettier') {
+        devDependencies['prettier-plugin-svelte'] = resolveVersion('prettier-plugin-svelte', '3.4.0');
     }
     if (requiresVue) {
         dependencies['vue'] = resolveVersion('vue', '3.5.17');
@@ -55,14 +57,39 @@ export const createPackageJson = ({ projectName, authProvider, plugins, useTailw
     if (requiresHtmx) {
         dependencies['elysia-scoped-state'] = resolveVersion('elysia-scoped-state', '0.1.1');
     }
-    void (latest && s.stop(green('Package versions resolved')));
+    if (orm === 'drizzle') {
+        dependencies['drizzle-orm'] = resolveVersion('drizzle-orm', '0.41.0');
+    }
+    switch (databaseHost) {
+        case 'neon':
+            dependencies['@neondatabase/serverless'] = resolveVersion('@neondatabase/serverless', '1.0.0');
+            break;
+        case 'planetscale':
+            dependencies['@planetscale/database'] = resolveVersion('@planetscale/database', '1.0.0');
+            break;
+        case 'turso':
+            dependencies['@libsql/client'] = resolveVersion('@libsql/client', '0.15.9');
+            break;
+    }
+    if (latest)
+        s.stop(green('Package versions resolved'));
     const scripts = {
-        dev: 'bun run --watch src/backend/server.ts',
+        dev: 'bash -c \'trap "exit 0" INT; bun run --watch src/backend/server.ts\'',
         format: `prettier --write "./**/*.{js,ts,css,json,mjs,md${requiresReact ? ',jsx,tsx' : ''}${requiresSvelte ? ',svelte' : ''}${requiresVue ? ',vue' : ''}${requiresHtml || requiresHtmx ? ',html' : ''}}"`,
         lint: 'eslint ./src',
         test: 'echo "Error: no test specified" && exit 1',
         typecheck: 'bun run tsc --noEmit'
     };
+    if (databaseEngine === 'postgresql' &&
+        (!databaseHost || databaseHost === 'none')) {
+        scripts['db:up'] =
+            'sh -c "docker info >/dev/null 2>&1 || sudo service docker start; docker compose -f db/docker-compose.db.yml up -d db"';
+        scripts['db:down'] = 'docker compose -f db/docker-compose.db.yml down';
+        scripts['db:psql'] =
+            'docker compose -f db/docker-compose.db.yml exec db psql -U postgres -d appdb';
+        scripts['predev'] = 'bun db:up';
+        scripts['postdev'] = 'bun db:down';
+    }
     const packageJson = {
         dependencies,
         devDependencies,
@@ -71,5 +98,5 @@ export const createPackageJson = ({ projectName, authProvider, plugins, useTailw
         type: 'module',
         version: '0.0.0'
     };
-    writeFileSync(join(projectName, 'package.json'), JSON.stringify(packageJson));
+    writeFileSync(join(projectName, 'package.json'), JSON.stringify(packageJson, null, 2));
 };

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

@@ -0,0 +1,6 @@
+import { CreateConfiguration } from '../../types';
+type GenerateDBHandlersProps = Pick<CreateConfiguration, 'databaseEngine' | 'databaseHost' | 'orm'> & {
+    usesAuth: boolean;
+};
+export declare const generateDBHandlers: ({ databaseEngine, databaseHost, orm, usesAuth }: GenerateDBHandlersProps) => string;
+export {};

package/dist/generators/db/generateDBHandlers.js

@@ -0,0 +1,11 @@
+import { getAuthTemplate, getCountTemplate } from './handlerTemplates';
+export const generateDBHandlers = ({ databaseEngine, databaseHost, orm, usesAuth }) => {
+    if (databaseEngine === undefined || databaseEngine === 'none') {
+        throw new Error('Internal Error: databaseEngine is undefined or "none".');
+    }
+    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
+    return usesAuth ? getAuthTemplate(key) : getCountTemplate(key);
+};

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

@@ -0,0 +1,8 @@
+import { AuthProvider, AvailableDrizzleDialect, DatabaseHost } from '../../types';
+type GenerateSchemaProps = {
+    databaseEngine: AvailableDrizzleDialect;
+    databaseHost: DatabaseHost;
+    authProvider: AuthProvider;
+};
+export declare const generateDrizzleSchema: ({ databaseEngine, databaseHost, authProvider }: GenerateSchemaProps) => string;
+export {};

package/dist/generators/db/generateDrizzleSchema.js

@@ -0,0 +1,122 @@
+const DIALECTS = {
+    gel: {
+        builders: ['text', 'gelTable', 'timestamp', 'integer'],
+        json: 'text()',
+        pkg: 'gel-core',
+        string: 'text()',
+        table: 'gelTable',
+        time: 'timestamp()'
+    },
+    mysql: {
+        builders: ['json', 'mysqlTable', 'timestamp', 'varchar', 'int'],
+        json: 'json()',
+        pkg: 'mysql-core',
+        string: 'varchar({ length: 255 })',
+        table: 'mysqlTable',
+        time: 'timestamp()'
+    },
+    postgresql: {
+        builders: ['jsonb', 'pgTable', 'timestamp', 'varchar', 'integer'],
+        json: 'jsonb()',
+        pkg: 'pg-core',
+        string: 'varchar({ length: 255 })',
+        table: 'pgTable',
+        time: 'timestamp()'
+    },
+    singlestore: {
+        builders: ['json', 'singlestoreTable', 'timestamp', 'varchar', 'int'],
+        json: 'json()',
+        pkg: 'singlestore-core',
+        string: 'varchar({ length: 255 })',
+        table: 'singlestoreTable',
+        time: 'timestamp()'
+    },
+    sqlite: {
+        builders: ['text', 'sqliteTable', 'integer'],
+        json: "text('', { mode: 'json' })",
+        pkg: 'sqlite-core',
+        string: 'text()',
+        table: 'sqliteTable',
+        time: "integer({ mode: 'timestamp' })"
+    }
+};
+const builder = (expr) => expr.split('(')[0];
+export const generateDrizzleSchema = ({ databaseEngine, databaseHost, authProvider }) => {
+    const cfg = DIALECTS[databaseEngine];
+    const intBuilder = databaseEngine === 'mysql' || databaseEngine === 'singlestore'
+        ? 'int'
+        : 'integer';
+    const timeBuilder = builder(cfg.time);
+    const jsonBuilder = builder(cfg.json);
+    const stringBuilder = builder(cfg.string);
+    const importBuilders = authProvider === 'absoluteAuth'
+        ? [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'
+        ? `import { sql } from 'drizzle-orm';\n`
+        : '';
+    let dbImport = '';
+    let dbTypeLine = '';
+    if (databaseHost === 'neon') {
+        dbImport = `import { NeonHttpDatabase } from 'drizzle-orm/neon-http';`;
+        dbTypeLine = 'export type DatabaseType = NeonHttpDatabase<SchemaType>;';
+    }
+    else if (databaseHost === 'planetscale') {
+        dbImport = `import { PlanetScaleDatabase } from 'drizzle-orm/planetscale-serverless';`;
+        dbTypeLine =
+            'export type DatabaseType = PlanetScaleDatabase<SchemaType>;';
+    }
+    else if (databaseHost === 'turso') {
+        dbImport = `import { LibSQLDatabase } from 'drizzle-orm/libsql';`;
+        dbTypeLine = 'export type DatabaseType = LibSQLDatabase<SchemaType>;';
+    }
+    let uidColumn;
+    if (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 = authProvider === 'absoluteAuth'
+        ? `export const users = ${cfg.table}('users', {
+  auth_sub: ${cfg.string}.primaryKey(),
+  created_at: ${timestampColumn},
+  metadata: ${cfg.json}.$type<Record<string, unknown>>().default({})
+});`
+        : `export const countHistory = ${cfg.table}('count_history', {
+  uid: ${uidColumn},
+  count: ${intBuilder}('count').notNull(),
+  created_at: ${timestampColumn}
+});`;
+    const schemaKey = authProvider === 'absoluteAuth' ? 'users' : 'countHistory';
+    const extraTypes = authProvider === 'absoluteAuth'
+        ? `export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;`
+        : `export type CountHistory = typeof countHistory.$inferSelect;
+export type NewCountHistory = typeof countHistory.$inferInsert;`;
+    return `
+${sqliteImports}${builderImport}
+${dbImport}
+
+${constsBlock}${tableBlock}
+
+export const schema = {
+  ${schemaKey}
+};
+
+export type SchemaType = typeof schema;
+${dbTypeLine ? `${dbTypeLine}\n\n` : '\n'}${extraTypes}
+`;
+};

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

@@ -0,0 +1,52 @@
+type QueryOperations = {
+    selectUser: string;
+    insertUser: string;
+    selectHistory: string;
+    insertHistory: string;
+};
+declare const driverConfigurations: {
+    readonly 'postgresql:drizzle:local': {
+        readonly dbType: "BunSQLDatabase<SchemaType>";
+        readonly importLines: "\nimport { eq } from 'drizzle-orm'\nimport { BunSQLDatabase } from 'drizzle-orm/bun-sql'\nimport { schema, type SchemaType } from '../../../db/schema'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'postgresql:drizzle:neon': {
+        readonly dbType: "NeonHttpDatabase<SchemaType>";
+        readonly importLines: "\nimport { eq } from 'drizzle-orm'\nimport { NeonHttpDatabase } from 'drizzle-orm/neon-http'\nimport { schema, type SchemaType } from '../../../db/schema'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'postgresql:sql:local': {
+        readonly dbType: "SQL";
+        readonly importLines: "import { SQL } from 'bun'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'postgresql:sql:neon': {
+        readonly dbType: "NeonQueryFunction<false, false>";
+        readonly importLines: "import { NeonQueryFunction } from '@neondatabase/serverless'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'sqlite:drizzle:local': {
+        readonly dbType: "BunSQLiteDatabase<SchemaType>";
+        readonly importLines: "\nimport { eq } from 'drizzle-orm'\nimport { BunSQLiteDatabase } from 'drizzle-orm/bun-sqlite'\nimport { schema, type SchemaType } from '../../../db/schema'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'sqlite:drizzle:turso': {
+        readonly dbType: "LibSQLDatabase<SchemaType>";
+        readonly importLines: "\nimport { eq } from 'drizzle-orm'\nimport { LibSQLDatabase } from 'drizzle-orm/libsql'\nimport { schema, type SchemaType } from '../../../db/schema'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'sqlite:sql:local': {
+        readonly dbType: "Database";
+        readonly importLines: "import { Database } from 'bun:sqlite'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'sqlite:sql:turso': {
+        readonly dbType: "Client";
+        readonly importLines: "import { Client } from '@libsql/client'";
+        readonly queries: QueryOperations;
+    };
+};
+type DriverConfigurationKey = keyof typeof driverConfigurations;
+export declare const getAuthTemplate: (key: DriverConfigurationKey) => string;
+export declare const getCountTemplate: (key: DriverConfigurationKey) => string;
+export {};