create-absolutejs 0.4.2 → 0.5.0

package/dist/generators/db/generateDrizzleSchema.js

@@ -1,12 +1,20 @@
 const DIALECTS = {
     gel: {
-        builders: ['text', 'gelTable', 'timestamp', 'integer'],
-        json: 'text()',
+        builders: ['text', 'gelTable', 'timestamp', 'integer', 'json'],
+        json: 'json()',
         pkg: 'gel-core',
         string: 'text()',
         table: 'gelTable',
         time: 'timestamp()'
     },
+    mariadb: {
+        builders: ['json', 'mysqlTable', 'timestamp', 'varchar', 'int'],
+        json: 'json()',
+        pkg: 'mysql-core',
+        string: 'varchar({ length: 255 })',
+        table: 'mysqlTable',
+        time: 'timestamp()'
+    },
     mysql: {
         builders: ['json', 'mysqlTable', 'timestamp', 'varchar', 'int'],
         json: 'json()',
@@ -41,9 +49,11 @@ const DIALECTS = {
     }
 };
 const builder = (expr) => expr.split('(')[0];
-export const generateDrizzleSchema = ({ databaseEngine, databaseHost, authProvider }) => {
+export const generateDrizzleSchema = ({ databaseEngine, authProvider }) => {
     const cfg = DIALECTS[databaseEngine];
-    const intBuilder = databaseEngine === 'mysql' || databaseEngine === 'singlestore'
+    const intBuilder = databaseEngine === 'mysql' ||
+        databaseEngine === 'singlestore' ||
+        databaseEngine === 'mariadb'
         ? 'int'
         : 'integer';
     const timeBuilder = builder(cfg.time);
@@ -57,23 +67,10 @@ export const generateDrizzleSchema = ({ databaseEngine, databaseHost, authProvid
     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') {
+    if (databaseEngine === 'mysql' ||
+        databaseEngine === 'singlestore' ||
+        databaseEngine === 'mariadb') {
         uidColumn = `${intBuilder}('uid').primaryKey().autoincrement()`;
     }
     else if (databaseEngine === 'sqlite') {
@@ -101,14 +98,8 @@ const MILLIS_PER_DAY = 86400000;\n\n`
   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}
 
@@ -117,6 +108,5 @@ export const schema = {
 };
 
 export type SchemaType = typeof schema;
-${dbTypeLine ? `${dbTypeLine}\n\n` : '\n'}${extraTypes}
 `;
 };

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

@@ -4,24 +4,30 @@ type QueryOperations = {
     selectHistory: string;
     insertHistory: string;
 };
-type HandlerType = {
-    CountHistoryRow: string;
-    UserRow: string;
-};
 declare const driverConfigurations: {
     readonly 'cockroachdb:sql:local': {
-        readonly dbType: "Pool";
-        readonly importLines: "import { Pool } from 'pg'";
+        readonly dbType: "SQL";
+        readonly importLines: "import { SQL } from 'bun'";
+        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 queries: QueryOperations;
     };
     readonly 'gel:sql:local': {
-        readonly dbType: "GelClient";
-        readonly importLines: "import { GelClient } from 'gel'";
+        readonly dbType: "Client";
+        readonly importLines: "import { Client } from 'gel'";
+        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 queries: QueryOperations;
     };
     readonly 'mariadb:sql:local': {
-        readonly dbType: "Pool";
-        readonly importLines: "import { Pool } from 'mariadb'";
+        readonly dbType: "SQL";
+        readonly importLines: "import { SQL } from 'bun'";
         readonly queries: QueryOperations;
     };
     readonly 'mongodb:native:local': {
@@ -40,13 +46,12 @@ declare const driverConfigurations: {
         readonly queries: QueryOperations;
     };
     readonly 'mysql:sql:local': {
-        readonly dbType: "Pool";
-        readonly handlerTypes: HandlerType;
-        readonly importLines: "import { Pool, ResultSetHeader, RowDataPacket } from 'mysql2/promise'";
+        readonly dbType: "SQL";
+        readonly importLines: "import { SQL } from 'bun'";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:drizzle:local': {
-        readonly dbType: "NodePgDatabase<SchemaType>";
+        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;
     };
@@ -61,13 +66,18 @@ declare const driverConfigurations: {
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:sql:neon': {
-        readonly dbType: "NeonQueryFunction<false, false>";
-        readonly importLines: "import { NeonQueryFunction } from '@neondatabase/serverless'";
+        readonly dbType: "Pool";
+        readonly importLines: "import { Pool } from '@neondatabase/serverless'";
         readonly queries: QueryOperations;
     };
     readonly 'singlestore:sql:local': {
-        readonly dbType: "Connection";
-        readonly importLines: "import { Connection } from '@singlestore/db-client'";
+        readonly dbType: "Pool";
+        readonly importLines: "import { Pool, RowDataPacket } from 'mysql2/promise'";
+        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 queries: QueryOperations;
     };
     readonly 'sqlite:drizzle:local': {

package/dist/generators/db/handlerTemplates.js

@@ -1,7 +1,6 @@
-const buildSqlAuthTemplate = ({ importLines, handlerTypes, dbType, queries }) => `
-import { isValidProviderOption, providers } from 'citra'
+const buildSqlAuthTemplate = ({ importLines, dbType, queries }) => `
+import { isValidProviderOption, providers, extractPropFromIdentity } from 'citra'
 ${importLines}
-${handlerTypes?.UserRow ? `\ntype UserRow = ${handlerTypes.UserRow}` : ''}
 type UserHandlerProps = {
   authProvider: string
   db: ${dbType}
@@ -9,22 +8,31 @@ type UserHandlerProps = {
 }
 
 export const getUser = async ({ authProvider, db, userIdentity }: UserHandlerProps) => {
-  if (!isValidProviderOption(authProvider)) throw new Error(\`Invalid auth provider: \${authProvider}\`)
-  const subject = providers[authProvider].extractSubjectFromIdentity(userIdentity)
-  const authSub = \`\${authProvider.toUpperCase()}|\${subject}\`
+	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) => {
-  if (!isValidProviderOption(authProvider)) throw new Error(\`Invalid auth provider: \${authProvider}\`)
-  const subject = providers[authProvider].extractSubjectFromIdentity(userIdentity)
-  const authSub = \`\${authProvider.toUpperCase()}|\${subject}\`
+	const providerConfiguration = providers[authProvider]
+
+	const subject = extractPropFromIdentity(
+		userIdentity,
+		providerConfiguration.subject,
+		providerConfiguration.subjectType
+	)
+	const authSub = \`\${authProvider.toUpperCase()}|\${subject}\`;
   ${queries.insertUser}
 }
 `;
-const buildSqlCountTemplate = ({ importLines, handlerTypes, dbType, queries }) => `
+const buildSqlCountTemplate = ({ importLines, dbType, queries }) => `
 ${importLines}
-${handlerTypes?.CountHistoryRow ? `\ntype CountHistoryRow = ${handlerTypes.CountHistoryRow}\n` : ''}
 export const getCountHistory = async (db: ${dbType}, uid: number) => {
   ${queries.selectHistory}
 }
@@ -73,6 +81,30 @@ const bunSqliteQueryOperations = {
   const [user] = statement.all(authSub)
   return user ?? null`
 };
+const postgresNeonQueryOperations = {
+    insertHistory: `const { rows } = await db.query(
+    'INSERT INTO count_history (count) VALUES ($1) RETURNING *',
+    [count]
+  )
+  return rows[0]`,
+    insertUser: `const { rows } = await db.query(
+    'INSERT INTO users (auth_sub, metadata) VALUES ($1, $2) RETURNING *',
+    [authSub, userIdentity]
+  )
+  const newUser = rows[0]
+  if (!newUser) throw new Error('Failed to create user')
+  return newUser`,
+    selectHistory: `const { rows } = await db.query(
+    'SELECT * FROM count_history WHERE uid = $1 LIMIT 1',
+    [uid]
+  )
+  return rows[0] ?? null`,
+    selectUser: `const { rows } = await db.query(
+    'SELECT * FROM users WHERE auth_sub = $1 LIMIT 1',
+    [authSub]
+  )
+  return rows[0] ?? null`
+};
 const postgresSqlQueryOperations = {
     insertHistory: `const [newHistory] = await db\`
     INSERT INTO count_history (count)
@@ -113,58 +145,40 @@ const mongodbQueryOperations = {
     selectUser: `const user = await db.collection('users').findOne({ auth_sub: authSub })
   return user ?? null`
 };
-const mariadbSqlQueryOperations = {
-    insertHistory: `await db.query('INSERT INTO count_history (count) VALUES (?)', [count])
-  const [rows] = await db.query('SELECT * FROM count_history ORDER BY uid DESC LIMIT 1')
-  return rows[0]`,
-    insertUser: `await db.query('INSERT INTO users (auth_sub, metadata) VALUES (?, ?)', [authSub, JSON.stringify(userIdentity)])
-  const [rows] = await db.query('SELECT * FROM users WHERE auth_sub = ? LIMIT 1', [authSub])
-  const newUser = rows[0]
-  if (!newUser) throw new Error('Failed to create user')
-  return newUser`,
-    selectHistory: `const [rows] = await db.query('SELECT * FROM count_history WHERE uid = ? LIMIT 1', [uid])
-  return rows[0] ?? null`,
-    selectUser: `const [rows] = await db.query('SELECT * FROM users WHERE auth_sub = ? LIMIT 1', [authSub])
-  return rows[0] ?? null`
-};
-const gelSqlQueryOperations = {
-    insertHistory: `await db.query('INSERT INTO count_history (count) VALUES (?)', [count])
-  const [rows] = await db.query('SELECT * FROM count_history ORDER BY uid DESC LIMIT 1')
-  return rows[0]`,
-    insertUser: `await db.query('INSERT INTO users (auth_sub, metadata) VALUES (?, ?)', [authSub, JSON.stringify(userIdentity)])
-  const [rows] = await db.query('SELECT * FROM users WHERE auth_sub = ? LIMIT 1', [authSub])
-  const newUser = rows[0]
-  if (!newUser) throw new Error('Failed to create user')
+const gelClientQueryOperations = {
+    insertHistory: `const newHistory = await db.queryRequiredSingle(
+    'select (insert count_history { count := <int16>$count }) { uid, count, created_at }',
+    { count }
+  )
+  return newHistory`,
+    insertUser: `const newUser = await db.queryRequiredSingle(
+    'select (insert users { auth_sub := <str>$authSub, metadata := <json>$metadata }) { auth_sub, created_at, metadata }',
+    { authSub, metadata: userIdentity }
+  )
   return newUser`,
-    selectHistory: `const [rows] = await db.query('SELECT * FROM count_history WHERE uid = ? LIMIT 1', [uid])
-  return rows[0] ?? null`,
-    selectUser: `const [rows] = await db.query('SELECT * FROM users WHERE auth_sub = ? LIMIT 1', [authSub])
-  return rows[0] ?? null`
+    selectHistory: `const history = await db.querySingle(
+    'select count_history { uid, count, created_at } filter .uid = <int64>$uid',
+    { uid }
+  )
+  return history ?? null`,
+    selectUser: `const user = await db.querySingle(
+    'select users { auth_sub, created_at, metadata } filter .auth_sub = <str>$authSub',
+    { authSub }
+  )
+  return user ?? null`
 };
 const singlestoreSqlQueryOperations = {
     insertHistory: `await db.query('INSERT INTO count_history (count) VALUES (?)', [count])
-  const [rows] = await db.query('SELECT * FROM count_history ORDER BY uid DESC LIMIT 1')
+  const [rows] = await db.query<RowDataPacket[]>('SELECT * FROM count_history ORDER BY uid DESC LIMIT 1')
   return rows[0]`,
     insertUser: `await db.query('INSERT INTO users (auth_sub, metadata) VALUES (?, ?)', [authSub, JSON.stringify(userIdentity)])
-  const [rows] = await db.query('SELECT * FROM users WHERE auth_sub = ? LIMIT 1', [authSub])
+  const [rows] = await db.query<RowDataPacket[]>('SELECT * FROM users WHERE auth_sub = ? LIMIT 1', [authSub])
   const newUser = rows[0]
   if (!newUser) throw new Error('Failed to create user')
   return newUser`,
-    selectHistory: `const [rows] = await db.query('SELECT * FROM count_history WHERE uid = ? LIMIT 1', [uid])
+    selectHistory: `const [rows] = await db.query<RowDataPacket[]>('SELECT * FROM count_history WHERE uid = ? LIMIT 1', [uid])
   return rows[0] ?? null`,
-    selectUser: `const [rows] = await db.query('SELECT * FROM users WHERE auth_sub = ? LIMIT 1', [authSub])
-  return rows[0] ?? null`
-};
-const cockroachdbPoolQueryOperations = {
-    insertHistory: `const { rows } = await db.query('INSERT INTO count_history (count) VALUES ($1) RETURNING *', [count])
-  return rows[0]`,
-    insertUser: `const { rows } = await db.query('INSERT INTO users (auth_sub, metadata) VALUES ($1, $2) RETURNING *', [authSub, userIdentity])
-  const newUser = rows[0]
-  if (!newUser) throw new Error('Failed to create user')
-  return newUser`,
-    selectHistory: `const { rows } = await db.query('SELECT * FROM count_history WHERE uid = $1 LIMIT 1', [uid])
-  return rows[0] ?? null`,
-    selectUser: `const { rows } = await db.query('SELECT * FROM users WHERE auth_sub = $1 LIMIT 1', [authSub])
+    selectUser: `const [rows] = await db.query<RowDataPacket[]>('SELECT * FROM users WHERE auth_sub = ? LIMIT 1', [authSub])
   return rows[0] ?? null`
 };
 const mssqlSqlQueryOperations = {
@@ -183,58 +197,62 @@ const mssqlSqlQueryOperations = {
 };
 const mysqlSqlQueryOperations = {
     insertHistory: `
-const [result] = await db.query<ResultSetHeader>(
-  'INSERT INTO count_history (count) VALUES (?)',
-  [count]
-);
-const insertId = result.insertId;
-const [rows] = await db.query<CountHistoryRow[]>(
-  'SELECT * FROM count_history WHERE uid = ? LIMIT 1',
-  [insertId]
-);
-if (!rows[0]) throw new Error('Could not retrieve the newly‑inserted history');
-return rows[0];
+    const result = await db\`
+      INSERT INTO count_history (count)
+      VALUES (\${count})
+    \`;
+
+    const insertId = result.lastInsertRowid;
+
+    const [row] = await db\`
+      SELECT *
+      FROM count_history
+      WHERE uid = \${insertId}
+      LIMIT 1
+    \`;
+
+    if (!row) throw new Error("Could not retrieve the newly-inserted history");
+    return row;
   `,
     insertUser: `
-const [result] = await db.query<ResultSetHeader>(
-  'INSERT INTO users (auth_sub, metadata) VALUES (?, ?)',
-  [authSub, JSON.stringify(userIdentity)]
-);
-const insertId = result.insertId;
-const [rows] = await db.query<UserRow[]>(
-  'SELECT * FROM users WHERE uid = ? LIMIT 1',
-  [insertId]
-);
-if (!rows[0]) throw new Error('Failed to create user');
-return rows[0];
+    const result = await db\`
+      INSERT INTO users (auth_sub, metadata)
+      VALUES (\${authSub}, \${JSON.stringify(userIdentity)})
+    \`;
+
+    const insertId = result.lastInsertRowid;
+
+    const [row] = await db\`
+      SELECT *
+      FROM users
+      WHERE uid = \${insertId}
+      LIMIT 1
+    \`;
+
+    if (!row) throw new Error("Failed to create user");
+    return row;
   `,
     selectHistory: `
-const [rows] = await db.query<CountHistoryRow[]>(
-  'SELECT * FROM count_history WHERE uid = ? LIMIT 1',
-  [uid]
-);
-return rows[0] ?? null;
+    const [row] = await db\`
+      SELECT *
+      FROM count_history
+      WHERE uid = \${uid}
+      LIMIT 1
+    \`;
+
+    return row ?? null;
   `,
     selectUser: `
-const [rows] = await db.query<UserRow[]>(
-  'SELECT * FROM users WHERE auth_sub = ? LIMIT 1',
-  [authSub]
-);
-return rows[0] ?? null;
+    const [row] = await db\`
+      SELECT *
+      FROM users
+      WHERE auth_sub = \${authSub}
+      LIMIT 1
+    \`;
+
+    return row ?? null;
   `
 };
-const mysqlHandlerTypes = {
-    CountHistoryRow: `RowDataPacket & {
-		uid: number;
-		count: number;
-		created_at: number;
-	}`,
-    UserRow: `RowDataPacket & {
-		uid: number;
-		auth_sub: string;
-		metadata: string;
-	}`
-};
 const mysqlDrizzleQueryOperations = {
     insertHistory: `const [row] = await db
     .insert(schema.countHistory)
@@ -270,19 +288,36 @@ const mysqlDrizzleQueryOperations = {
 };
 const driverConfigurations = {
     'cockroachdb:sql:local': {
-        dbType: 'Pool',
-        importLines: `import { Pool } from 'pg'`,
-        queries: cockroachdbPoolQueryOperations
+        dbType: 'SQL',
+        importLines: `import { SQL } from 'bun'`,
+        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'
+`,
+        queries: drizzleQueryOperations
     },
     'gel:sql:local': {
-        dbType: 'GelClient',
-        importLines: `import { GelClient } from 'gel'`,
-        queries: gelSqlQueryOperations
+        dbType: 'Client',
+        importLines: `import { Client } from 'gel'`,
+        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'`,
+        queries: mysqlDrizzleQueryOperations
     },
     'mariadb:sql:local': {
-        dbType: 'Pool',
-        importLines: `import { Pool } from 'mariadb'`,
-        queries: mariadbSqlQueryOperations
+        dbType: 'SQL',
+        importLines: `import { SQL } from 'bun'`,
+        queries: mysqlSqlQueryOperations
     },
     'mongodb:native:local': {
         dbType: 'Db',
@@ -303,13 +338,12 @@ import { schema, type SchemaType } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
     'mysql:sql:local': {
-        dbType: 'Pool',
-        handlerTypes: mysqlHandlerTypes,
-        importLines: `import { Pool, ResultSetHeader, RowDataPacket } from 'mysql2/promise'`,
+        dbType: 'SQL',
+        importLines: `import { SQL } from 'bun'`,
         queries: mysqlSqlQueryOperations
     },
     'postgresql:drizzle:local': {
-        dbType: 'NodePgDatabase<SchemaType>',
+        dbType: 'BunSQLDatabase<SchemaType>',
         importLines: `
 import { eq } from 'drizzle-orm'
 import { BunSQLDatabase } from 'drizzle-orm/bun-sql'
@@ -330,15 +364,23 @@ import { schema, type SchemaType } from '../../../db/schema'`,
         queries: postgresSqlQueryOperations
     },
     'postgresql:sql:neon': {
-        dbType: 'NeonQueryFunction<false, false>',
-        importLines: `import { NeonQueryFunction } from '@neondatabase/serverless'`,
-        queries: postgresSqlQueryOperations
+        dbType: 'Pool',
+        importLines: `import { Pool } from '@neondatabase/serverless'`,
+        queries: postgresNeonQueryOperations
     },
     'singlestore:sql:local': {
-        dbType: 'Connection',
-        importLines: `import { Connection } from '@singlestore/db-client'`,
+        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'`,
+        queries: mysqlDrizzleQueryOperations
+    },
     'sqlite:drizzle:local': {
         dbType: 'BunSQLiteDatabase<SchemaType>',
         importLines: `

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

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

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,32 @@
 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"))' },
+        none: { expr: 'new SQL(getEnv("DATABASE_URL"))' },
         planetscale: { expr: 'connect({ 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"))' }
     },
     singlestore: {
-        none: { expr: 'createClient({ url: getEnv("DATABASE_URL") })' }
+        none: { expr: 'createPool(getEnv("DATABASE_URL"))' }
     },
     sqlite: {
         none: { expr: 'new Database("db/database.sqlite")' },
@@ -49,28 +49,20 @@ 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') {
+        const mode = databaseHost === 'planetscale' && databaseEngine === 'mysql'
+            ? 'planetscale'
+            : 'default';
         return `
-const pool = ${expr}
+const pool = createPool(getEnv("DATABASE_URL"))
 const db = drizzle(pool, { schema, mode: '${mode}' })
-`;
-    }
-    if (databaseEngine === 'sqlite') {
-        return `
-const pool = ${expr}
-const db = drizzle(pool, { schema })
 `;
     }
     return `