create-absolutejs 0.4.2 → 0.5.1

package/dist/generators/db/scaffoldDatabase.js

@@ -5,11 +5,12 @@ import { dim, yellow } from 'picocolors';
 import { isDrizzleDialect } from '../../typeGuards';
 import { checkSqliteInstalled } from '../../utils/checkSqliteInstalled';
 import { createDrizzleConfig } from '../configurations/generateDrizzleConfig';
+import { generateDatabaseTypes } from './generateDatabaseTypes';
 import { generateDrizzleSchema } from './generateDrizzleSchema';
 import { generateDBHandlers } from './generateHandlers';
 import { generateSqliteSchema } from './generateSqliteSchema';
 import { scaffoldDocker } from './scaffoldDocker';
-export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHost, databaseDirectory, backendDirectory, authProvider, orm }) => {
+export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHost, databaseDirectory, backendDirectory, authProvider, orm, typesDirectory }) => {
     const projectDatabaseDirectory = join(projectName, databaseDirectory);
     const handlerDirectory = join(backendDirectory, 'handlers');
     mkdirSync(projectDatabaseDirectory, { recursive: true });
@@ -49,11 +50,16 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         }
         const drizzleSchema = generateDrizzleSchema({
             authProvider,
-            databaseEngine,
-            databaseHost
+            databaseEngine
         });
         writeFileSync(join(projectDatabaseDirectory, 'schema.ts'), drizzleSchema);
         createDrizzleConfig({ databaseDirectory, databaseEngine, projectName });
+        const drizzleTypes = generateDatabaseTypes({
+            authProvider,
+            databaseEngine,
+            databaseHost
+        });
+        writeFileSync(join(typesDirectory, 'databaseTypes.ts'), drizzleTypes);
         return;
     }
     if (orm === 'prisma') {

package/dist/generators/project/generateDBBlock.js

@@ -1,32 +1,35 @@
 import { availableDrizzleDialects } from '../../data';
 const connectionMap = {
     cockroachdb: {
-        none: { expr: 'new Pool({ connectionString: getEnv("DATABASE_URL") })' }
+        none: { expr: 'new SQL(getEnv("DATABASE_URL"))' }
     },
     gel: {
-        none: { expr: 'gelClient({ url: getEnv("DATABASE_URL") })' }
+        none: { expr: 'createClient(getEnv("DATABASE_URL"))' }
     },
     mariadb: {
-        none: { expr: 'createPool(getEnv("DATABASE_URL"))' }
+        none: { expr: 'new SQL(getEnv("DATABASE_URL"))' }
     },
     mongodb: {
-        none: { expr: 'new MongoClient(getEnv("DATABASE_URL") })' }
+        none: { expr: 'new MongoClient(getEnv("DATABASE_URL"))' }
     },
     mssql: {
         none: { expr: 'await connect(getEnv("DATABASE_URL"))' }
     },
     mysql: {
-        none: { expr: 'createPool(getEnv("DATABASE_URL"))' },
-        planetscale: { expr: 'connect({ url: getEnv("DATABASE_URL") })' }
+        none: { expr: 'new SQL(getEnv("DATABASE_URL"))' },
+        planetscale: { expr: 'new Client({ url: getEnv("DATABASE_URL") })' }
     },
     postgresql: {
         neon: {
             expr: 'new Pool({ connectionString: getEnv("DATABASE_URL") })'
         },
-        none: { expr: 'new Pool({ connectionString: getEnv("DATABASE_URL") })' }
+        none: { expr: 'new SQL(getEnv("DATABASE_URL"))' },
+        planetscale: {
+            expr: 'new Pool({ connectionString: getEnv("DATABASE_URL") })'
+        }
     },
     singlestore: {
-        none: { expr: 'createClient({ url: getEnv("DATABASE_URL") })' }
+        none: { expr: 'createPool(getEnv("DATABASE_URL"))' }
     },
     sqlite: {
         none: { expr: 'new Database("db/database.sqlite")' },
@@ -35,7 +38,7 @@ const connectionMap = {
 };
 const remoteDrizzleInit = {
     neon: 'new Pool({ connectionString: getEnv("DATABASE_URL") })',
-    planetscale: 'connect({ url: getEnv("DATABASE_URL") })',
+    planetscale: 'new Client({ url: getEnv("DATABASE_URL") })',
     turso: 'createClient({ url: getEnv("DATABASE_URL") })'
 };
 const drizzleDialectSet = new Set([...availableDrizzleDialects]);
@@ -49,28 +52,18 @@ export const generateDBBlock = ({ databaseEngine, orm, databaseHost }) => {
         return '';
     if (orm !== 'drizzle') {
         const hostCfg = engineGroup[hostKey];
-        if (!hostCfg)
-            return '';
-        return `
-const pool = ${hostCfg.expr}
-`;
+        return hostCfg ? `const db = ${hostCfg.expr}` : '';
     }
     if (!drizzleDialectSet.has(databaseEngine))
         return '';
     const expr = engineGroup[hostKey]?.expr ?? remoteDrizzleInit[hostKey];
     if (!expr)
         return '';
-    if (databaseEngine === 'mysql') {
-        const mode = databaseHost === 'planetscale' ? 'planetscale' : 'default';
+    if ((databaseEngine === 'mysql' || databaseEngine === 'mariadb') &&
+        databaseHost !== 'planetscale') {
         return `
-const pool = ${expr}
-const db = drizzle(pool, { schema, mode: '${mode}' })
-`;
-    }
-    if (databaseEngine === 'sqlite') {
-        return `
-const pool = ${expr}
-const db = drizzle(pool, { schema })
+const pool = createPool(getEnv("DATABASE_URL"))
+const db = drizzle(pool, { schema, mode: 'default' })
 `;
     }
     return `

package/dist/generators/project/generateImportsBlock.js

@@ -1,5 +1,6 @@
 import { mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
+import { isDrizzleDialect } from '../../typeGuards';
 export const generateImportsBlock = ({ backendDirectory, deps, flags, orm, authProvider, databaseEngine, databaseHost, frontendDirectories }) => {
     const rawImports = [];
     const pushHandler = (cond, name) => cond &&
@@ -38,7 +39,7 @@ export const generateImportsBlock = ({ backendDirectory, deps, flags, orm, authP
         rawImports.push(`import VueExample from '${buildExamplePath(vueDir, 'VueExample.vue')}'`);
     const connectorImports = {
         neon: [`import { Pool } from '@neondatabase/serverless'`],
-        planetscale: [`import { connect } from '@planetscale/database'`],
+        planetscale: [`import { Client } from '@planetscale/database'`],
         turso: [`import { createClient } from '@libsql/client'`]
     };
     const dialectImports = {
@@ -51,44 +52,124 @@ export const generateImportsBlock = ({ backendDirectory, deps, flags, orm, authP
     const isRemoteHost = databaseHost !== undefined && databaseHost !== 'none';
     const hasDatabase = databaseEngine !== undefined && databaseEngine !== 'none';
     const noOrm = orm === undefined || orm === 'none';
-    if (orm === 'drizzle' && isRemoteHost) {
-        const key = databaseHost;
-        rawImports.push(...connectorImports[key], ...dialectImports[key]);
-    }
-    if (orm === 'drizzle' && !isRemoteHost && databaseEngine === 'postgresql')
-        rawImports.push(`import { Pool } from 'pg'`, `import { drizzle } from 'drizzle-orm/node-postgres'`);
-    if (orm === 'drizzle' && databaseEngine === 'sqlite' && !isRemoteHost)
-        rawImports.push(`import { Database } from 'bun:sqlite'`, `import { drizzle } from 'drizzle-orm/bun-sqlite'`);
-    if (noOrm && databaseEngine === 'sqlite')
-        rawImports.push(...(databaseHost === 'turso'
+    const ormImports = {
+        drizzle: [
+            `import { Elysia } from 'elysia'`,
+            ...(databaseEngine === 'sqlite' && !isRemoteHost
+                ? []
+                : [`import { getEnv } from '@absolutejs/absolute'`]),
+            ...(authProvider === 'absoluteAuth'
+                ? [
+                    `import { schema } from '../../db/schema'`,
+                    `import { User } from '../types/databaseTypes'`
+                ]
+                : [`import { schema } from '../../db/schema'`])
+        ]
+    };
+    const ormDatabaseImports = {
+        drizzle: {
+            gel: [
+                `import { createClient } from 'gel'`,
+                `import { drizzle } from 'drizzle-orm/gel'`
+            ],
+            mariadb: [
+                `import { drizzle } from 'drizzle-orm/mysql2'`,
+                `import { createPool } from 'mysql2/promise'`
+            ],
+            mysql: !isRemoteHost
+                ? [
+                    `import { drizzle } from 'drizzle-orm/mysql2'`,
+                    `import { createPool } from 'mysql2/promise'`
+                ]
+                : [],
+            postgresql: !isRemoteHost
+                ? [
+                    `import { SQL } from 'bun'`,
+                    `import { drizzle } from 'drizzle-orm/bun-sql'`
+                ]
+                : isRemoteHost && databaseHost === 'planetscale'
+                    ? [
+                        `import { drizzle } from 'drizzle-orm/node-postgres'`,
+                        `import { Pool } from 'pg'`
+                    ]
+                    : [],
+            singlestore: [
+                `import { drizzle } from 'drizzle-orm/singlestore'`,
+                `import { createPool } from 'mysql2/promise'`
+            ],
+            sqlite: !isRemoteHost
+                ? [
+                    `import { Database } from 'bun:sqlite'`,
+                    `import { drizzle } from 'drizzle-orm/bun-sqlite'`
+                ]
+                : []
+        }
+    };
+    const noOrmImports = {
+        cockroachdb: [
+            `import { SQL } from 'bun'`,
+            `import { getEnv } from '@absolutejs/absolute'`
+        ],
+        gel: [
+            `import { createClient } from 'gel'`,
+            `import { getEnv } from '@absolutejs/absolute'`
+        ],
+        mariadb: [
+            `import { SQL } from 'bun'`,
+            `import { getEnv } from '@absolutejs/absolute'`
+        ],
+        mongodb: [],
+        mssql: [
+            `import { connect } from 'mssql'`,
+            `import { getEnv } from '@absolutejs/absolute'`
+        ],
+        mysql: isRemoteHost
             ? [
-                `import { createClient } from '@libsql/client'`,
+                ...connectorImports[databaseHost],
                 `import { getEnv } from '@absolutejs/absolute'`
             ]
-            : [`import { Database } from 'bun:sqlite'`]));
-    if (databaseEngine === 'mysql' && isRemoteHost) {
-        const key = databaseHost;
-        rawImports.push(...connectorImports[key]);
-    }
-    if (databaseEngine === 'mysql' && !isRemoteHost) {
-        rawImports.push(`import { createPool } from 'mysql2/promise'`);
+            : [
+                `import { SQL } from 'bun'`,
+                `import { getEnv } from '@absolutejs/absolute'`
+            ],
+        postgresql: isRemoteHost && databaseHost === 'neon'
+            ? [
+                ...connectorImports[databaseHost],
+                `import { getEnv } from '@absolutejs/absolute'`
+            ]
+            : isRemoteHost && databaseHost === 'planetscale'
+                ? [
+                    `import { Pool } from 'pg'`,
+                    `import { getEnv } from '@absolutejs/absolute'`
+                ]
+                : [
+                    `import { SQL } from 'bun'`,
+                    `import { getEnv } from '@absolutejs/absolute'`
+                ],
+        singlestore: [
+            `import { createPool } from 'mysql2/promise'`,
+            `import { getEnv } from '@absolutejs/absolute'`
+        ],
+        sqlite: isRemoteHost
+            ? [
+                ...connectorImports[databaseHost],
+                `import { getEnv } from '@absolutejs/absolute'`
+            ]
+            : [`import { Database } from 'bun:sqlite'`]
+    };
+    if (orm === 'drizzle') {
+        rawImports.push(...ormImports[orm]);
     }
-    if (databaseEngine === 'mysql' && orm === 'drizzle') {
-        rawImports.push(`import { drizzle } from 'drizzle-orm/mysql2'`);
+    if (orm == 'drizzle' &&
+        isRemoteHost &&
+        !(databaseEngine === 'postgresql' && databaseHost === 'planetscale')) {
+        rawImports.push(...connectorImports[databaseHost], ...dialectImports[databaseHost]);
     }
-    if (databaseEngine === 'mysql') {
-        rawImports.push(`import { getEnv } from '@absolutejs/absolute'`);
+    if (orm === 'drizzle' && isDrizzleDialect(databaseEngine)) {
+        rawImports.push(...ormDatabaseImports[orm][databaseEngine]);
     }
-    if (noOrm && databaseEngine === 'postgresql')
-        rawImports.push(...(isRemoteHost
-            ? connectorImports[databaseHost]
-            : [`import { Pool } from 'pg'`]), `import { getEnv } from '@absolutejs/absolute'`);
-    if (orm === 'drizzle') {
-        rawImports.push(`import { Elysia } from 'elysia'`, ...(databaseEngine === 'sqlite' && !isRemoteHost
-            ? []
-            : [`import { getEnv } from '@absolutejs/absolute'`]), authProvider === 'absoluteAuth'
-            ? `import { schema, User } from '../../db/schema'`
-            : `import { schema } from '../../db/schema'`);
+    if (noOrm && hasDatabase && noOrmImports[databaseEngine]) {
+        rawImports.push(...noOrmImports[databaseEngine]);
     }
     if (authProvider === 'absoluteAuth')
         rawImports.push(`import { absoluteAuth, instantiateUserSession } from '@absolutejs/auth'`, ...(hasDatabase

package/dist/generators/project/generateUseBlock.js

@@ -12,7 +12,11 @@ export const generateUseBlock = ({ deps, databaseEngine, orm }) => deps
         const instantiate = 'instantiateUserSession';
         const pluginGeneric = hasOrm ? '<User>' : '';
         const callback = hasDatabase
-            ? `async ({ authProvider, providerInstance, tokenResponse, userSessionId, session }) => ${instantiate}({ authProvider, providerInstance, session, tokenResponse, userSessionId, createUser: (userIdentity) => createUser({ authProvider, db, userIdentity }), getUser: (userIdentity) => getUser({ authProvider, db, userIdentity }) })`
+            ? `async ({ authProvider, providerInstance, tokenResponse, unregisteredSession, cookie: { user_session_id }, session }) => ${instantiate}(
+						{ authProvider, providerInstance, session, tokenResponse, unregisteredSession, user_session_id, 
+						 	getUser: async (userIdentity) => getUser({ authProvider, db, userIdentity }),
+							onNewUser: async (userIdentity) => createUser({ authProvider, db, userIdentity })
+						})`
             : `({ authProvider, tokenResponse, userSessionId }) => { console.log(\`Successfully authorized OAuth2 with \${authProvider} (session: \${userSessionId})\`, tokenResponse); }`;
         const mergedConfig = `{ ${baseConfigString}${baseConfigString ? ',' : ''} onCallbackSuccess: ${callback} }`;
         return `.use(absoluteAuth${pluginGeneric}(${mergedConfig}))`;

package/dist/messages.js

@@ -34,7 +34,7 @@ Options:
   ${cyan('--plugin')} ${dim(cyan('<plugin>'))}               Elysia plugin(s) to include (repeatable); 'none' skips plugin setup
   ${cyan('--react')}                         Include a React frontend
   ${cyan('--react-dir')} ${dim(cyan('<directory>'))}         Specify the directory for and use the React frontend
-  ${cyan('--skip')}                          Skip non-required prompts; uses 'none' for all optional configs
+  ${cyan('--skip')}                          Skip non-required prompts; use 'none' for all optional configs and "absolutejs-project" when no project name is provided.
   ${cyan('--svelte')}                        Include a Svelte frontend
   ${cyan('--svelte-dir')} ${dim(cyan('<directory>'))}        Specify the directory for and use the Svelte frontend
   ${cyan('--tailwind')}                      Include Tailwind CSS setup

package/dist/questions/databaseEngine.d.ts

@@ -1 +1 @@
-export declare const getDatabaseEngine: () => Promise<"gel" | "mysql" | "postgresql" | "sqlite" | "singlestore" | "mongodb" | "mariadb" | "cockroachdb" | "mssql" | undefined>;
+export declare const getDatabaseEngine: () => Promise<"gel" | "mysql" | "postgresql" | "sqlite" | "singlestore" | "mariadb" | "mongodb" | "cockroachdb" | "mssql" | undefined>;

package/dist/questions/databaseHost.js

@@ -15,6 +15,18 @@ export const getDatabaseHost = async (databaseEngine) => {
             abort();
         return databaseHost === 'none' ? undefined : databaseHost;
     }
+    if (databaseEngine === 'mysql') {
+        const databaseHost = await select({
+            message: 'Select database host:',
+            options: [
+                { label: 'None', value: 'none' },
+                { label: cyan('PlanetScale'), value: 'planetscale' }
+            ]
+        });
+        if (isCancel(databaseHost))
+            abort();
+        return databaseHost === 'none' ? undefined : databaseHost;
+    }
     if (databaseEngine === 'sqlite') {
         const databaseHost = await select({
             message: 'Select database host:',

package/dist/scaffold.js

@@ -13,7 +13,7 @@ import { scaffoldFrontends } from './generators/project/scaffoldFrontends';
 export const scaffold = async ({ response: { projectName, codeQualityTool, initializeGitNow, databaseEngine, databaseHost, useHTMLScripts, useTailwind, databaseDirectory, orm, frontends, plugins, authProvider, buildDirectory, assetsDirectory, tailwind, installDependenciesNow, frontendDirectories }, latest, envVariables, packageManager }) => {
     const __dirname = dirname(fileURLToPath(import.meta.url));
     const templatesDirectory = join(__dirname, '/templates');
-    const { frontendDirectory, backendDirectory, projectAssetsDirectory } = initalizeRoot(projectName, templatesDirectory);
+    const { frontendDirectory, backendDirectory, projectAssetsDirectory, typesDirectory } = initalizeRoot(projectName, templatesDirectory);
     copyFileSync(join(templatesDirectory, 'README.md'), join(projectName, 'README.md'));
     scaffoldConfigurationFiles({
         codeQualityTool,
@@ -60,7 +60,8 @@ export const scaffold = async ({ response: { projectName, codeQualityTool, initi
             databaseEngine,
             databaseHost,
             orm,
-            projectName
+            projectName,
+            typesDirectory
         })));
     scaffoldFrontends({
         frontendDirectories,

package/dist/templates/styles/tailwind.css

@@ -0,0 +1 @@
+@import 'tailwindcss';

package/dist/utils/parseCommandLineOptions.js

@@ -46,7 +46,7 @@ export const parseCommandLineOptions = () => {
         }
     });
     const errors = [];
-    const projectName = positionals[0] ?? (values.skip ? undefined : 'absolutejs-project');
+    const projectName = positionals[0] ?? (values.skip ? 'absolutejs-project' : undefined);
     let authProvider;
     if (values.auth !== undefined && !isAuthProvider(values.auth)) {
         errors.push(`Invalid auth provider: "${values.auth}". Expected: [ ${availableAuthProviders.join(', ')} ]`);

package/package.json

@@ -47,5 +47,5 @@
 		"typecheck": "bun run tsc --noEmit"
 	},
 	"type": "module",
-	"version": "0.4.2"
+	"version": "0.5.1"
 }