create-absolutejs 0.5.1 → 0.6.1

package/dist/data.d.ts

@@ -1,6 +1,6 @@
 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 availableAuthProviders: readonly ["abs", "none"];
 export declare const availableDrizzleDialects: readonly ["gel", "mysql", "postgresql", "sqlite", "singlestore", "mariadb"];
 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"];

package/dist/data.js

@@ -7,7 +7,7 @@ export const availableFrontends = [
     'vue',
     'htmx'
 ];
-export const availableAuthProviders = ['absoluteAuth', 'none'];
+export const availableAuthProviders = ['abs', 'none'];
 export const availableDrizzleDialects = [
     'gel',
     'mysql',
@@ -86,7 +86,7 @@ export const absoluteAuthPlugin = {
             packageName: 'absoluteAuth'
         }
     ],
-    latestVersion: '0.20.3',
+    latestVersion: '0.21.1',
     value: '@absolutejs/auth'
 };
 export const scopedStatePlugin = {

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

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

package/dist/generators/configurations/generatePackageJson.js

@@ -36,7 +36,7 @@ const dbScripts = {
         waitCmd: initTemplates.singlestore.wait
     }
 };
-export const createPackageJson = ({ projectName, authProvider, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool }) => {
+export const createPackageJson = ({ projectName, authOption, plugins, databaseEngine, orm, databaseHost, useTailwind, latest, frontendDirectories, codeQualityTool }) => {
     const s = spinner();
     if (latest)
         s.start('Resolving package versions…');
@@ -51,7 +51,7 @@ export const createPackageJson = ({ projectName, authProvider, plugins, database
     for (const dep of defaultDependencies) {
         dependencies[dep.value] = resolveVersion(dep.value, dep.latestVersion);
     }
-    if (authProvider === 'absoluteAuth') {
+    if (authOption === 'abs') {
         dependencies[absoluteAuthPlugin.value] = resolveVersion(absoluteAuthPlugin.value, absoluteAuthPlugin.latestVersion);
     }
     for (const pluginValue of plugins) {
@@ -158,6 +158,10 @@ export const createPackageJson = ({ projectName, authProvider, plugins, database
         scripts['db:sqlite'] = 'sqlite3 db/database.sqlite';
         scripts['db:init'] = 'sqlite3 db/database.sqlite < db/init.sql';
     }
+    if (orm === 'drizzle') {
+        scripts['db:studio'] = 'drizzle-kit studio';
+        scripts['db:push'] = 'drizzle-kit push';
+    }
     const packageJson = {
         dependencies,
         devDependencies,

package/dist/generators/configurations/initializeRoot.js

@@ -1,5 +1,5 @@
-import { copyFileSync, existsSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { copyFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
 export const initalizeRoot = (projectName, templatesDirectory) => {
     if (existsSync(projectName)) {
         throw new Error(`Cannot create project "${projectName}": directory already exists.`);

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

@@ -1,8 +1,8 @@
-import { AuthProvider, DatabaseEngine, DatabaseHost } from '../../types';
+import { AuthOption, DatabaseEngine, DatabaseHost } from '../../types';
 type GenerateTypesProps = {
     databaseEngine: DatabaseEngine;
     databaseHost: DatabaseHost;
-    authProvider: AuthProvider;
+    authOption: AuthOption;
 };
-export declare const generateDatabaseTypes: ({ databaseEngine, databaseHost, authProvider }: GenerateTypesProps) => string;
+export declare const generateDatabaseTypes: ({ databaseEngine, databaseHost, authOption }: GenerateTypesProps) => string;
 export {};

package/dist/generators/db/generateDatabaseTypes.js

@@ -1,5 +1,5 @@
 import { isDrizzleDialect } from '../../typeGuards';
-export const generateDatabaseTypes = ({ databaseEngine, databaseHost, authProvider }) => {
+export const generateDatabaseTypes = ({ databaseEngine, databaseHost, authOption }) => {
     let dbImport = '';
     let dbTypeLine = '';
     if (databaseHost === 'neon') {
@@ -51,10 +51,10 @@ export const generateDatabaseTypes = ({ databaseEngine, databaseHost, authProvid
                 break;
         }
     }
-    const schemaImport = authProvider === 'absoluteAuth'
-        ? `import { users, SchemaType } from '../../db/schema';`
-        : `import { countHistory, SchemaType } from '../../db/schema';`;
-    const extraTypes = authProvider === 'absoluteAuth'
+    const schemaImport = authOption === 'abs'
+        ? `import { users, schema } from '../../db/schema';`
+        : `import { countHistory } from '../../db/schema';`;
+    const extraTypes = authOption === 'abs'
         ? `export type User = typeof users.$inferSelect;
 export type NewUser = typeof users.$inferInsert;`
         : `export type CountHistory = typeof countHistory.$inferSelect;
@@ -62,6 +62,6 @@ export type NewCountHistory = typeof countHistory.$inferInsert;`;
     return `${schemaImport}
 ${dbImport}
 
-${dbTypeLine ? `${dbTypeLine}\n\n` : '\n'}${extraTypes}
+${`${dbTypeLine}\n`}export type SchemaType = typeof schema;\n\n${extraTypes}
 `;
 };

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

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

package/dist/generators/db/generateDrizzleSchema.js

@@ -49,7 +49,7 @@ const DIALECTS = {
     }
 };
 const builder = (expr) => expr.split('(')[0];
-export const generateDrizzleSchema = ({ databaseEngine, authProvider }) => {
+export const generateDrizzleSchema = ({ databaseEngine, authOption }) => {
     const cfg = DIALECTS[databaseEngine];
     const intBuilder = databaseEngine === 'mysql' ||
         databaseEngine === 'singlestore' ||
@@ -59,7 +59,7 @@ export const generateDrizzleSchema = ({ databaseEngine, authProvider }) => {
     const timeBuilder = builder(cfg.time);
     const jsonBuilder = builder(cfg.json);
     const stringBuilder = builder(cfg.string);
-    const importBuilders = authProvider === 'absoluteAuth'
+    const importBuilders = authOption === 'abs'
         ? [cfg.table, stringBuilder, timeBuilder, jsonBuilder]
         : [cfg.table, intBuilder, timeBuilder];
     const uniqueBuilders = Array.from(new Set(importBuilders));
@@ -86,7 +86,7 @@ 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'
+    const tableBlock = authOption === 'abs'
         ? `export const users = ${cfg.table}('users', {
   auth_sub: ${cfg.string}.primaryKey(),
   created_at: ${timestampColumn},
@@ -97,7 +97,7 @@ const MILLIS_PER_DAY = 86400000;\n\n`
   count: ${intBuilder}('count').notNull(),
   created_at: ${timestampColumn}
 });`;
-    const schemaKey = authProvider === 'absoluteAuth' ? 'users' : 'countHistory';
+    const schemaKey = authOption === 'abs' ? 'users' : 'countHistory';
     return `
 ${sqliteImports}${builderImport}
 
@@ -106,7 +106,5 @@ ${constsBlock}${tableBlock}
 export const schema = {
   ${schemaKey}
 };
-
-export type SchemaType = typeof schema;
 `;
 };

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

@@ -1,2 +1,2 @@
-import { AuthProvider } from '../../types';
-export declare const generateSqliteSchema: (authProvider: AuthProvider) => "CREATE TABLE IF NOT EXISTS users (\n  auth_sub TEXT PRIMARY KEY,\n  created_at INTEGER NOT NULL DEFAULT ((julianday('now') - 2440587.5) * 86400000),\n  metadata TEXT DEFAULT '{}'\n);" | "CREATE TABLE IF NOT EXISTS count_history (\n  uid INTEGER PRIMARY KEY AUTOINCREMENT,\n  count INTEGER NOT NULL,\n  created_at INTEGER NOT NULL DEFAULT ((julianday('now') - 2440587.5) * 86400000)\n);";
+import { AuthOption } from '../../types';
+export declare const generateSqliteSchema: (authOption: AuthOption) => "CREATE TABLE IF NOT EXISTS users (\n  auth_sub TEXT PRIMARY KEY,\n  created_at INTEGER NOT NULL DEFAULT ((julianday('now') - 2440587.5) * 86400000),\n  metadata TEXT DEFAULT '{}'\n);" | "CREATE TABLE IF NOT EXISTS count_history (\n  uid INTEGER PRIMARY KEY AUTOINCREMENT,\n  count INTEGER NOT NULL,\n  created_at INTEGER NOT NULL DEFAULT ((julianday('now') - 2440587.5) * 86400000)\n);";

package/dist/generators/db/generateSqliteSchema.js

@@ -1,4 +1,4 @@
-export const generateSqliteSchema = (authProvider) => authProvider && authProvider !== 'none'
+export const generateSqliteSchema = (authOption) => authOption && authOption !== 'none'
     ? `CREATE TABLE IF NOT EXISTS users (
   auth_sub TEXT PRIMARY KEY,
   created_at INTEGER NOT NULL DEFAULT ((julianday('now') - 2440587.5) * 86400000),

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

@@ -7,117 +7,117 @@ type QueryOperations = {
 declare const driverConfigurations: {
     readonly 'cockroachdb:sql:local': {
         readonly dbType: "SQL";
-        readonly importLines: "import { SQL } from 'bun'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'gel:drizzle:local': {
         readonly dbType: "GelJsDatabase<SchemaType>";
-        readonly importLines: "\nimport { eq } from 'drizzle-orm'\nimport { GelJsDatabase } from 'drizzle-orm/gel'\nimport { schema, type SchemaType } from '../../../db/schema'\n";
+        readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'\n";
         readonly queries: QueryOperations;
     };
     readonly 'gel:sql:local': {
         readonly dbType: "Client";
-        readonly importLines: "import { Client } from 'gel'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mariadb:drizzle:local': {
         readonly dbType: "MySql2Database<SchemaType>";
-        readonly importLines: "\nimport { eq } from 'drizzle-orm'\nimport { MySql2Database } from 'drizzle-orm/mysql2'\nimport { schema, type SchemaType } from '../../../db/schema'";
+        readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'mariadb:sql:local': {
         readonly dbType: "SQL";
-        readonly importLines: "import { SQL } from 'bun'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mongodb:native:local': {
         readonly dbType: "Db";
-        readonly importLines: "import { Db } from 'mongodb'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mssql:sql:local': {
         readonly dbType: "ConnectionPool";
-        readonly importLines: "import { ConnectionPool } from 'mssql'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:drizzle:local': {
         readonly dbType: "MySql2Database<SchemaType>";
-        readonly importLines: "\nimport { eq } from 'drizzle-orm'\nimport { MySql2Database } from 'drizzle-orm/mysql2'\nimport { schema, type SchemaType } from '../../../db/schema'";
+        readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:drizzle:planetscale': {
         readonly dbType: "PlanetScaleDatabase<SchemaType>";
-        readonly importLines: "\nimport { eq } from 'drizzle-orm'\nimport { PlanetScaleDatabase } from 'drizzle-orm/planetscale-serverless'\nimport { schema, type SchemaType } from '../../../db/schema'";
+        readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:sql:local': {
         readonly dbType: "SQL";
-        readonly importLines: "import { SQL } from 'bun'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:sql:planetscale': {
         readonly dbType: "Client";
-        readonly importLines: "import { Client } from '@planetscale/database'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     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 importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:drizzle:neon': {
         readonly dbType: "NeonDatabase<SchemaType>";
-        readonly importLines: "\nimport { eq } from 'drizzle-orm'\nimport { NeonDatabase } from 'drizzle-orm/neon-serverless'\nimport { schema, type SchemaType } from '../../../db/schema'";
+        readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:drizzle:planetscale': {
         readonly dbType: "NodePgDatabase<SchemaType>";
-        readonly importLines: "\nimport { eq } from 'drizzle-orm'\nimport { NodePgDatabase } from 'drizzle-orm/node-postgres'\nimport { schema, type SchemaType } from '../../../db/schema'";
+        readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:sql:local': {
         readonly dbType: "SQL";
-        readonly importLines: "import { SQL } from 'bun'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:sql:neon': {
         readonly dbType: "Pool";
-        readonly importLines: "import { Pool } from '@neondatabase/serverless'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:sql:planetscale': {
         readonly dbType: "Pool";
-        readonly importLines: "import { Pool } from 'pg'";
-        readonly queries: QueryOperations;
-    };
-    readonly 'singlestore:sql:local': {
-        readonly dbType: "Pool";
-        readonly importLines: "import { Pool, RowDataPacket } from 'mysql2/promise'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'singlestore:drizzle:local': {
         readonly dbType: "SingleStoreDriverDatabase<SchemaType>";
-        readonly importLines: "\nimport { eq } from 'drizzle-orm'\nimport { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore'\nimport { schema, type SchemaType } from '../../../db/schema'";
+        readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'singlestore:sql:local': {
+        readonly dbType: "Pool";
+        readonly importLines: "import { RowDataPacket } from 'mysql2/promise'\n";
         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 importLines: "import { eq } from 'drizzle-orm'\nimport { schema } 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 importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'sqlite:sql:local': {
         readonly dbType: "Database";
-        readonly importLines: "import { Database } from 'bun:sqlite'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'sqlite:sql:turso': {
         readonly dbType: "Client";
-        readonly importLines: "import { Client } from '@libsql/client'";
+        readonly importLines: "";
         readonly queries: QueryOperations;
     };
 };

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] })
@@ -336,148 +322,129 @@ const mysqlPlanetScaleQueryOperations = {
 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 { PlanetScaleDatabase } from 'drizzle-orm/planetscale-serverless'
-import { schema, type SchemaType } from '../../../db/schema'`,
+        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: `import { Client } from '@planetscale/database'`,
+        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 { NodePgDatabase } from 'drizzle-orm/node-postgres'
-import { schema, type SchemaType } from '../../../db/schema'`,
+        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'`,
+        importLines: ``,
         queries: postgresQueryOperations
     },
     'postgresql:sql:planetscale': {
         dbType: 'Pool',
-        importLines: `import { Pool } from 'pg'`,
+        importLines: ``,
         queries: postgresQueryOperations
     },
-    'singlestore:sql:local': {
-        dbType: 'Pool',
-        importLines: `import { Pool, RowDataPacket } from 'mysql2/promise'`,
-        queries: singlestoreSqlQueryOperations
-    },
     '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 {};