create-absolutejs 0.5.0 → 0.6.0

package/dist/generators/db/handlerTemplates.js

@@ -1,36 +1,14 @@
-const buildSqlAuthTemplate = ({ importLines, dbType, queries }) => `
-import { isValidProviderOption, providers, extractPropFromIdentity } from 'citra'
+const buildSqlAuthTemplate = ({ importLines, queries }) => `
+import { DatabaseType, NewUser } from '../../types/databaseTypes';
 ${importLines}
-type UserHandlerProps = {
-  authProvider: string
-  db: ${dbType}
-  userIdentity: Record<string, unknown>
-}
-
-export const getUser = async ({ authProvider, db, userIdentity }: UserHandlerProps) => {
-	const providerConfiguration = providers[authProvider]
-
-	const subject = extractPropFromIdentity(
-		userIdentity,
-		providerConfiguration.subject,
-		providerConfiguration.subjectType
-	)
-	const authSub = \`\${authProvider.toUpperCase()}|\${subject}\`;
-  ${queries.selectUser}
-}
 
-export const createUser = async ({ authProvider, db, userIdentity }: UserHandlerProps) => {
-	const providerConfiguration = providers[authProvider]
+export const getUser = async (db: DatabaseType, authSub: string) => {
+	${queries.selectUser}
+};
 
-	const subject = extractPropFromIdentity(
-		userIdentity,
-		providerConfiguration.subject,
-		providerConfiguration.subjectType
-	)
-	const authSub = \`\${authProvider.toUpperCase()}|\${subject}\`;
-  ${queries.insertUser}
-}
-`;
+export const createUser = async (db: DatabaseType, newUserData: NewUser) => {
+	${queries.insertUser}
+}`;
 const buildSqlCountTemplate = ({ importLines, dbType, queries }) => `
 ${importLines}
 export const getCountHistory = async (db: ${dbType}, uid: number) => {
@@ -44,13 +22,21 @@ export const createCountHistory = async (db: ${dbType}, count: number) => {
 const drizzleQueryOperations = {
     insertHistory: `const [newHistory] = await db.insert(schema.countHistory).values({ count }).returning()
   return newHistory`,
-    insertUser: `const [newUser] = await db.insert(schema.users).values({ auth_sub: authSub, metadata: userIdentity }).returning()
-  if (!newUser) throw new Error('Failed to create user')
-  return newUser`,
+    insertUser: `const [newUser] = await db
+		.insert(schema.users)
+		.values(newUserData)
+		.returning();
+	if (!newUser) throw new Error('Failed to create user');
+	return newUser;
+`,
     selectHistory: `const [history] = await db.select().from(schema.countHistory).where(eq(schema.countHistory.uid, uid)).execute()
   return history`,
-    selectUser: `const [user] = await db.select().from(schema.users).where(eq(schema.users.auth_sub, authSub)).execute()
-  return user`
+    selectUser: `const [user] = await db
+		.select()
+		.from(schema.users)
+		.where(eq(schema.users.auth_sub, authSub))
+		.execute();
+	return user;`
 };
 const libsqlQueryOperations = {
     insertHistory: `const { rows } = await db.execute({ sql: 'INSERT INTO count_history (count) VALUES (?) RETURNING *', args: [count] })
@@ -81,7 +67,7 @@ const bunSqliteQueryOperations = {
   const [user] = statement.all(authSub)
   return user ?? null`
 };
-const postgresNeonQueryOperations = {
+const postgresQueryOperations = {
     insertHistory: `const { rows } = await db.query(
     'INSERT INTO count_history (count) VALUES ($1) RETURNING *',
     [count]
@@ -220,12 +206,10 @@ const mysqlSqlQueryOperations = {
       VALUES (\${authSub}, \${JSON.stringify(userIdentity)})
     \`;
 
-    const insertId = result.lastInsertRowid;
-
     const [row] = await db\`
       SELECT *
       FROM users
-      WHERE uid = \${insertId}
+      WHERE auth_sub = \${authSub}
       LIMIT 1
     \`;
 
@@ -270,141 +254,197 @@ const mysqlDrizzleQueryOperations = {
   return newHistory;`,
     insertUser: `const [row] = await db
     .insert(schema.users)
-    .values({ auth_sub: authSub, metadata: userIdentity })
-    .$returningId();
-
-  if (!row) throw new Error('insert failed: no uid returned');
-  const { uid } = row;
+    .values({ auth_sub: authSub, metadata: userIdentity });
 
   const [newUser] = await db
     .select()
     .from(schema.users)
-    .where(eq(schema.users.uid, uid));
+    .where(eq(schema.users.auth_sub, authSub));
 
   if (!newUser) throw new Error('Failed to create user');
   return newUser;`,
     selectHistory: drizzleQueryOperations.selectHistory,
     selectUser: drizzleQueryOperations.selectUser
 };
+const mysqlPlanetScaleQueryOperations = {
+    insertHistory: `
+    const result = await db.execute(
+      \`INSERT INTO count_history (count) VALUES (?)\`,
+      [count]
+    );
+
+    const insertId = result.insertId;
+    if (!insertId) throw new Error("Could not insert count history");
+
+    const { rows } = await db.execute(
+      \`SELECT * FROM count_history WHERE uid = ? LIMIT 1\`,
+      [insertId]
+    );
+
+    const row = rows[0] ?? null;
+    if (!row) throw new Error("Could not retrieve the newly-inserted history");
+
+    return row;
+  `,
+    insertUser: `
+    const result = await db.execute(
+      \`INSERT INTO users (auth_sub, metadata) VALUES (?, ?)\`,
+      [authSub, JSON.stringify(userIdentity)]
+    );
+
+    const { rows } = await db.execute(
+      \`SELECT * FROM users WHERE auth_sub = ? LIMIT 1\`,
+      [authSub]
+    );
+
+    const row = rows[0] ?? null;
+    if (!row) throw new Error("Failed to create user");
+
+    return row;
+  `,
+    selectHistory: `
+    const { rows } = await db.execute(
+      \`SELECT * FROM count_history WHERE uid = ? LIMIT 1\`,
+      [uid]
+    );
+
+    return rows[0] ?? null;
+  `,
+    selectUser: `
+    const { rows } = await db.execute(
+      \`SELECT * FROM users WHERE auth_sub = ? LIMIT 1\`,
+      [authSub]
+    );
+
+    return rows[0] ?? null;
+  `
+};
 const driverConfigurations = {
     'cockroachdb:sql:local': {
         dbType: 'SQL',
-        importLines: `import { SQL } from 'bun'`,
+        importLines: ``,
         queries: postgresSqlQueryOperations
     },
     'gel:drizzle:local': {
         dbType: 'GelJsDatabase<SchemaType>',
-        importLines: `
-import { eq } from 'drizzle-orm'
-import { GelJsDatabase } from 'drizzle-orm/gel'
-import { schema, type SchemaType } from '../../../db/schema'
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'
 `,
         queries: drizzleQueryOperations
     },
     'gel:sql:local': {
         dbType: 'Client',
-        importLines: `import { Client } from 'gel'`,
+        importLines: ``,
         queries: gelClientQueryOperations
     },
     'mariadb:drizzle:local': {
         dbType: 'MySql2Database<SchemaType>',
-        importLines: `
-import { eq } from 'drizzle-orm'
-import { MySql2Database } from 'drizzle-orm/mysql2'
-import { schema, type SchemaType } from '../../../db/schema'`,
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
     'mariadb:sql:local': {
         dbType: 'SQL',
-        importLines: `import { SQL } from 'bun'`,
+        importLines: ``,
         queries: mysqlSqlQueryOperations
     },
     'mongodb:native:local': {
         dbType: 'Db',
-        importLines: `import { Db } from 'mongodb'`,
+        importLines: ``,
         queries: mongodbQueryOperations
     },
     'mssql:sql:local': {
         dbType: 'ConnectionPool',
-        importLines: `import { ConnectionPool } from 'mssql'`,
+        importLines: ``,
         queries: mssqlSqlQueryOperations
     },
     'mysql:drizzle:local': {
         dbType: 'MySql2Database<SchemaType>',
-        importLines: `
-import { eq } from 'drizzle-orm'
-import { MySql2Database } from 'drizzle-orm/mysql2'
-import { schema, type SchemaType } from '../../../db/schema'`,
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'`,
+        queries: mysqlDrizzleQueryOperations
+    },
+    'mysql:drizzle:planetscale': {
+        dbType: 'PlanetScaleDatabase<SchemaType>',
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
     'mysql:sql:local': {
         dbType: 'SQL',
-        importLines: `import { SQL } from 'bun'`,
+        importLines: ``,
         queries: mysqlSqlQueryOperations
     },
+    'mysql:sql:planetscale': {
+        dbType: 'Client',
+        importLines: ``,
+        queries: mysqlPlanetScaleQueryOperations
+    },
     'postgresql:drizzle:local': {
         dbType: 'BunSQLDatabase<SchemaType>',
-        importLines: `
-import { eq } from 'drizzle-orm'
-import { BunSQLDatabase } from 'drizzle-orm/bun-sql'
-import { schema, type SchemaType } from '../../../db/schema'`,
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'postgresql:drizzle:neon': {
         dbType: 'NeonDatabase<SchemaType>',
-        importLines: `
-import { eq } from 'drizzle-orm'
-import { NeonDatabase } from 'drizzle-orm/neon-serverless'
-import { schema, type SchemaType } from '../../../db/schema'`,
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'`,
+        queries: drizzleQueryOperations
+    },
+    'postgresql:drizzle:planetscale': {
+        dbType: 'NodePgDatabase<SchemaType>',
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'postgresql:sql:local': {
         dbType: 'SQL',
-        importLines: `import { SQL } from 'bun'`,
+        importLines: ``,
         queries: postgresSqlQueryOperations
     },
     'postgresql:sql:neon': {
         dbType: 'Pool',
-        importLines: `import { Pool } from '@neondatabase/serverless'`,
-        queries: postgresNeonQueryOperations
+        importLines: ``,
+        queries: postgresQueryOperations
     },
-    'singlestore:sql:local': {
+    'postgresql:sql:planetscale': {
         dbType: 'Pool',
-        importLines: `import { Pool, RowDataPacket } from 'mysql2/promise'`,
-        queries: singlestoreSqlQueryOperations
+        importLines: ``,
+        queries: postgresQueryOperations
     },
     'singlestore:drizzle:local': {
         dbType: 'SingleStoreDriverDatabase<SchemaType>',
-        importLines: `
-import { eq } from 'drizzle-orm'
-import { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore'
-import { schema, type SchemaType } from '../../../db/schema'`,
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
+    'singlestore:sql:local': {
+        dbType: 'Pool',
+        importLines: `import { RowDataPacket } from 'mysql2/promise'
+`,
+        queries: singlestoreSqlQueryOperations
+    },
     'sqlite:drizzle:local': {
         dbType: 'BunSQLiteDatabase<SchemaType>',
-        importLines: `
-import { eq } from 'drizzle-orm'
-import { BunSQLiteDatabase } from 'drizzle-orm/bun-sqlite'
-import { schema, type SchemaType } from '../../../db/schema'`,
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'sqlite:drizzle:turso': {
         dbType: 'LibSQLDatabase<SchemaType>',
-        importLines: `
-import { eq } from 'drizzle-orm'
-import { LibSQLDatabase } from 'drizzle-orm/libsql'
-import { schema, type SchemaType } from '../../../db/schema'`,
+        importLines: `import { eq } from 'drizzle-orm'
+import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'sqlite:sql:local': {
         dbType: 'Database',
-        importLines: `import { Database } from 'bun:sqlite'`,
+        importLines: ``,
         queries: bunSqliteQueryOperations
     },
     'sqlite:sql:turso': {
         dbType: 'Client',
-        importLines: `import { Client } from '@libsql/client'`,
+        importLines: ``,
         queries: libsqlQueryOperations
     }
 };

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

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

package/dist/generators/db/scaffoldDatabase.js

@@ -10,12 +10,12 @@ 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, typesDirectory }) => {
+export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHost, databaseDirectory, backendDirectory, authOption, orm, typesDirectory }) => {
     const projectDatabaseDirectory = join(projectName, databaseDirectory);
     const handlerDirectory = join(backendDirectory, 'handlers');
     mkdirSync(projectDatabaseDirectory, { recursive: true });
     mkdirSync(handlerDirectory, { recursive: true });
-    const usesAuth = authProvider !== undefined && authProvider !== 'none';
+    const usesAuth = authOption !== undefined && authOption !== 'none';
     const handlerFileName = usesAuth
         ? 'userHandlers.ts'
         : 'countHistoryHandlers.ts';
@@ -29,7 +29,7 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
     if (databaseEngine === 'sqlite') {
         void ((orm === undefined || orm === 'none') &&
             (await checkSqliteInstalled()));
-        const sqliteSchema = generateSqliteSchema(authProvider);
+        const sqliteSchema = generateSqliteSchema(authOption);
         writeFileSync(join(projectDatabaseDirectory, 'schema.sql'), sqliteSchema);
         await $ `sqlite3 ${databaseDirectory}/database.sqlite ".read ${join(databaseDirectory, 'schema.sql')}"`.cwd(projectName);
     }
@@ -38,7 +38,7 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         databaseEngine !== undefined &&
         databaseEngine !== 'none') {
         await scaffoldDocker({
-            authProvider,
+            authOption,
             databaseEngine,
             projectDatabaseDirectory,
             projectName
@@ -49,13 +49,13 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
             throw new Error('Internal type error: Expected a Drizzle dialect');
         }
         const drizzleSchema = generateDrizzleSchema({
-            authProvider,
+            authOption,
             databaseEngine
         });
         writeFileSync(join(projectDatabaseDirectory, 'schema.ts'), drizzleSchema);
         createDrizzleConfig({ databaseDirectory, databaseEngine, projectName });
         const drizzleTypes = generateDatabaseTypes({
-            authProvider,
+            authOption,
             databaseEngine,
             databaseHost
         });

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

@@ -1,9 +1,9 @@
-import { AuthProvider, DatabaseEngine } from '../../types';
+import { AuthOption, DatabaseEngine } from '../../types';
 type ScaffoldDockerProps = {
     databaseEngine: DatabaseEngine;
     projectDatabaseDirectory: string;
-    authProvider: AuthProvider;
+    authOption: AuthOption;
     projectName: string;
 };
-export declare const scaffoldDocker: ({ databaseEngine, projectDatabaseDirectory, projectName, authProvider }: ScaffoldDockerProps) => Promise<void>;
+export declare const scaffoldDocker: ({ databaseEngine, projectDatabaseDirectory, projectName, authOption }: ScaffoldDockerProps) => Promise<void>;
 export {};

package/dist/generators/db/scaffoldDocker.js

@@ -4,7 +4,7 @@ import { $ } from 'bun';
 import { checkDockerInstalled } from '../../utils/checkDockerInstalled';
 import { countHistoryTables, initTemplates, userTables } from './dockerInitTemplates';
 import { generateDockerContainer } from './generateDockerContainer';
-export const scaffoldDocker = async ({ databaseEngine, projectDatabaseDirectory, projectName, authProvider }) => {
+export const scaffoldDocker = async ({ databaseEngine, projectDatabaseDirectory, projectName, authOption }) => {
     if (databaseEngine === undefined ||
         databaseEngine === 'none' ||
         databaseEngine === 'sqlite') {
@@ -17,7 +17,7 @@ export const scaffoldDocker = async ({ databaseEngine, projectDatabaseDirectory,
     }
     else {
         const { wait, cli } = initTemplates[databaseEngine];
-        const usesAuth = authProvider !== undefined && authProvider !== 'none';
+        const usesAuth = authOption !== undefined && authOption !== 'none';
         const dbCommand = usesAuth
             ? userTables[databaseEngine]
             : countHistoryTables[databaseEngine];

package/dist/generators/html/scaffoldHTML.js

@@ -1,5 +1,5 @@
-import { copyFileSync, cpSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { copyFileSync, cpSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
 import { generateMarkupCSS } from '../project/generateMarkupCSS';
 import { generateHTMLPage } from './generateHTMLPage';
 export const scaffoldHTML = ({ isSingleFrontend, targetDirectory, frontends, useHTMLScripts, templatesDirectory, projectAssetsDirectory }) => {

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

@@ -2,8 +2,8 @@ import type { CreateConfiguration } from '../../types';
 import type { FrameworkFlags } from './computeFlags';
 type CollectDependenciesProps = {
     plugins: string[];
-    authProvider: CreateConfiguration['authProvider'];
+    authOption: CreateConfiguration['authOption'];
     flags: FrameworkFlags;
 };
-export declare const collectDependencies: ({ plugins, authProvider, flags }: CollectDependenciesProps) => import("../../types").AvailableDependency[];
+export declare const collectDependencies: ({ plugins, authOption, flags }: CollectDependenciesProps) => import("../../types").AvailableDependency[];
 export {};

package/dist/generators/project/collectDependencies.js

@@ -1,7 +1,7 @@
 import { defaultDependencies, defaultPlugins, absoluteAuthPlugin, scopedStatePlugin, availablePlugins } from '../../data';
-export const collectDependencies = ({ plugins, authProvider, flags }) => {
+export const collectDependencies = ({ plugins, authOption, flags }) => {
     const customSelections = availablePlugins.filter((plugin) => plugins.includes(plugin.value));
-    const authPlugins = authProvider === 'absoluteAuth' ? [absoluteAuthPlugin] : [];
+    const authPlugins = authOption === 'abs' ? [absoluteAuthPlugin] : [];
     const htmxPlugins = flags.requiresHtmx ? [scopedStatePlugin] : [];
     const allDeps = [
         ...defaultDependencies,

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

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

package/dist/generators/project/generateAbsoluteAuthConfig.js

@@ -0,0 +1,128 @@
+const defaultProviderConfigurations = {
+    google: {
+        credentials: {
+            clientId: "getEnv('GOOGLE_CLIENT_ID')",
+            clientSecret: "getEnv('GOOGLE_CLIENT_SECRET')"
+        },
+        scope: [
+            'openid',
+            'https://www.googleapis.com/auth/userinfo.profile',
+            'https://www.googleapis.com/auth/userinfo.email'
+        ],
+        searchParams: [['access_type', 'offline']]
+    }
+};
+export const generateAbsoluteAuthConfig = (absProviders) => {
+    const providerConfigs = (absProviders ?? [])
+        .map((provider) => {
+        const config = defaultProviderConfigurations[provider];
+        if (!config) {
+            console.warn(`No default OAuth2 configuration has been defined for provider "${provider}". ` +
+                `Please add a default entry to ` +
+                '`defaultProviderConfigurations` or configure this provider manually in `src/backend/utils/absoluteAuthConfig.ts`.');
+            return null;
+        }
+        const credentialsLines = [
+            ...Object.entries(config.credentials).map(([key, value]) => `                ${key}: ${value}`),
+            `                redirectUri: getEnv('OAUTH2_CALLBACK_URI')`
+        ].join(',\n');
+        const scopePart = config.scope
+            ? `,
+			scope: ${JSON.stringify(config.scope)}`
+            : '';
+        const searchParamsPart = config.searchParams && config.searchParams.length > 0
+            ? `,
+			searchParams: ${JSON.stringify(config.searchParams)}`
+            : '';
+        return `        ${provider}: {
+			credentials: {
+${credentialsLines}
+			}${scopePart}${searchParamsPart}
+		}`;
+    })
+        .filter((entry) => entry !== null)
+        .join(',\n');
+    return `import { getEnv } from '@absolutejs/absolute';
+import {
+	AbsoluteAuthProps,
+	extractPropFromIdentity,
+	instantiateUserSession,
+	providers
+} from '@absolutejs/auth';
+import { DatabaseType, User } from '../../types/databaseTypes';
+import { createUser, getUser } from '../handlers/userHandlers';
+
+export const absoluteAuthConfig = (
+	db: DatabaseType
+): AbsoluteAuthProps<User> => ({
+	providersConfiguration: {
+${providerConfigs}
+	},
+	onCallbackSuccess: async ({
+		authProvider,
+		providerInstance,
+		tokenResponse,
+		unregisteredSession,
+		cookie: { user_session_id },
+		status,
+		session
+	}) =>
+		instantiateUserSession({
+			authProvider,
+			providerInstance,
+			session,
+			tokenResponse,
+			unregisteredSession,
+			user_session_id,
+			getUser: async (userIdentity) => {
+				const provider = authProvider.toUpperCase();
+				const providerConfiguration = providers[authProvider];
+
+				const subject = extractPropFromIdentity(
+					userIdentity,
+					providerConfiguration.subject,
+					providerConfiguration.subjectType
+				);
+				const authSub = \`\${provider}|\${subject}\`;
+
+				try {
+					const user = await getUser(db, authSub);
+
+					return user;
+				} catch (error) {
+					console.error('Error fetching user:', error);
+					return status(
+						'Internal Server Error',
+						'Could not fetch user data.'
+					);
+				}
+			},
+			onNewUser: async (userIdentity) => {
+				const provider = authProvider.toUpperCase();
+				const providerConfiguration = providers[authProvider];
+
+				const subject = extractPropFromIdentity(
+					userIdentity,
+					providerConfiguration.subject,
+					providerConfiguration.subjectType
+				);
+				const authSub = \`\${provider}|\${subject}\`;
+
+				try {
+					const newUser = await createUser(db, {
+						auth_sub: authSub,
+						metadata: userIdentity
+					});
+					return newUser;
+				} catch (error) {
+					console.error('Error creating user:', error);
+					return status(
+						'Internal Server Error',
+						'Could not create new user.'
+					);
+				}
+			}
+		})
+});
+`;
+};

package/dist/generators/project/generateDBBlock.js

@@ -17,13 +17,16 @@ const connectionMap = {
     },
     mysql: {
         none: { expr: 'new SQL(getEnv("DATABASE_URL"))' },
-        planetscale: { expr: 'connect({ url: getEnv("DATABASE_URL") })' }
+        planetscale: { expr: 'new Client({ url: getEnv("DATABASE_URL") })' }
     },
     postgresql: {
         neon: {
-            expr: 'new Pool({ connectionString: getEnv("DATABASE_URL") })'
+            expr: 'neon(getEnv("DATABASE_URL"));'
         },
-        none: { expr: 'new SQL(getEnv("DATABASE_URL"))' }
+        none: { expr: 'new SQL(getEnv("DATABASE_URL"))' },
+        planetscale: {
+            expr: 'new Pool({ connectionString: getEnv("DATABASE_URL") })'
+        }
     },
     singlestore: {
         none: { expr: 'createPool(getEnv("DATABASE_URL"))' }
@@ -34,8 +37,8 @@ const connectionMap = {
     }
 };
 const remoteDrizzleInit = {
-    neon: 'new Pool({ connectionString: getEnv("DATABASE_URL") })',
-    planetscale: 'connect({ url: getEnv("DATABASE_URL") })',
+    neon: 'neon(getEnv("DATABASE_URL"));',
+    planetscale: 'new Client({ url: getEnv("DATABASE_URL") })',
     turso: 'createClient({ url: getEnv("DATABASE_URL") })'
 };
 const drizzleDialectSet = new Set([...availableDrizzleDialects]);
@@ -56,13 +59,17 @@ export const generateDBBlock = ({ databaseEngine, orm, databaseHost }) => {
     const expr = engineGroup[hostKey]?.expr ?? remoteDrizzleInit[hostKey];
     if (!expr)
         return '';
-    if (databaseEngine === 'mysql' || databaseEngine === 'mariadb') {
-        const mode = databaseHost === 'planetscale' && databaseEngine === 'mysql'
-            ? 'planetscale'
-            : 'default';
+    if ((databaseEngine === 'mysql' || databaseEngine === 'mariadb') &&
+        databaseHost !== 'planetscale') {
         return `
 const pool = createPool(getEnv("DATABASE_URL"))
-const db = drizzle(pool, { schema, mode: '${mode}' })
+const db = drizzle(pool, { schema, mode: 'default' })
+`;
+    }
+    if (databaseEngine === 'postgresql' && databaseHost === 'neon') {
+        return `
+		const sql = neon(getEnv('DATABASE_URL'));
+const db = drizzle(sql, { schema });
 `;
     }
     return `

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

@@ -5,10 +5,10 @@ type GenerateImportsBlockProps = {
     deps: AvailableDependency[];
     flags: FrameworkFlags;
     orm: CreateConfiguration['orm'];
-    authProvider: CreateConfiguration['authProvider'];
+    authOption: CreateConfiguration['authOption'];
     databaseEngine: CreateConfiguration['databaseEngine'];
     databaseHost: CreateConfiguration['databaseHost'];
     frontendDirectories: CreateConfiguration['frontendDirectories'];
 };
-export declare const generateImportsBlock: ({ backendDirectory, deps, flags, orm, authProvider, databaseEngine, databaseHost, frontendDirectories }: GenerateImportsBlockProps) => string;
+export declare const generateImportsBlock: ({ backendDirectory, deps, flags, orm, authOption, databaseEngine, databaseHost, frontendDirectories }: GenerateImportsBlockProps) => string;
 export {};