create-absolutejs 0.3.13 → 0.3.14

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

@@ -1,7 +1,8 @@
 import type { CreateConfiguration } from '../../types';
-type AddConfigurationProps = Pick<CreateConfiguration, 'tailwind' | 'initializeGitNow' | 'codeQualityTool' | 'frontends'> & {
+type AddConfigurationProps = Pick<CreateConfiguration, 'tailwind' | 'initializeGitNow' | 'codeQualityTool' | 'frontends' | 'projectName' | 'databaseEngine' | 'orm'> & {
     templatesDirectory: string;
     projectName: string;
+    envVariables: string[] | undefined;
 };
-export declare const addConfigurationFiles: ({ tailwind, templatesDirectory, codeQualityTool, frontends, initializeGitNow, projectName }: AddConfigurationProps) => void;
+export declare const addConfigurationFiles: ({ tailwind, templatesDirectory, orm, databaseEngine, envVariables, codeQualityTool, frontends, initializeGitNow, projectName }: AddConfigurationProps) => void;
 export {};

package/dist/generators/configurations/addConfigurationFiles.js

@@ -1,8 +1,9 @@
 import { copyFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { dim, yellow } from 'picocolors';
+import { generateEnv } from './generateEnv';
 import { generatePrettierrc } from './generatePrettierrc';
-export const addConfigurationFiles = ({ tailwind, templatesDirectory, codeQualityTool, frontends, initializeGitNow, projectName }) => {
+export const addConfigurationFiles = ({ tailwind, templatesDirectory, orm, databaseEngine, envVariables, codeQualityTool, frontends, initializeGitNow, projectName }) => {
     copyFileSync(join(templatesDirectory, 'configurations', 'tsconfig.example.json'), join(projectName, 'tsconfig.json'));
     if (tailwind) {
         copyFileSync(join(templatesDirectory, 'tailwind', 'postcss.config.ts'), join(projectName, 'postcss.config.ts'));
@@ -18,4 +19,10 @@ export const addConfigurationFiles = ({ tailwind, templatesDirectory, codeQualit
     }
     else
         console.warn(`${dim('│')}\n${yellow('▲')}  Biome support not implemented yet`);
+    generateEnv({
+        databaseEngine,
+        envVariables,
+        orm,
+        projectName
+    });
 };

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

@@ -0,0 +1,6 @@
+import { CreateConfiguration } from '../../types';
+type GenerateEnvProps = Pick<CreateConfiguration, 'databaseEngine' | 'orm' | 'projectName'> & {
+    envVariables?: string[];
+};
+export declare const generateEnv: ({ databaseEngine, orm, envVariables, projectName }: GenerateEnvProps) => void;
+export {};

package/dist/generators/configurations/generateEnv.js

@@ -0,0 +1,25 @@
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+const databaseURLS = {
+    cockroachdb: 'cockroachdb://user:password@localhost:26257/database',
+    gel: 'gel://user:password@localhost:5432/database',
+    mariadb: 'mariadb://user:password@localhost:3306/database',
+    mongodb: 'mongodb://user:password@localhost:27017/database',
+    mssql: 'mssql://user:password@localhost:1433/database',
+    mysql: 'mysql://user:password@localhost:3306/database',
+    postgresql: 'postgresql://user:password@localhost:5432/database',
+    singlestore: 'singlestore://user:password@localhost:3306/database'
+};
+export const generateEnv = ({ databaseEngine, orm, envVariables = [], projectName }) => {
+    const vars = [...envVariables];
+    if (databaseEngine !== 'sqlite' &&
+        databaseEngine !== 'none' &&
+        databaseEngine !== undefined &&
+        (orm === 'none' || orm === undefined)) {
+        vars.push(`DATABASE_URL=${databaseURLS[databaseEngine]}`);
+    }
+    if (vars.length === 0)
+        return;
+    const envPath = join(projectName, '.env');
+    writeFileSync(envPath, vars.join('\n'), 'utf8');
+};

package/dist/generators/configurations/generatePackageJson.js

@@ -80,11 +80,26 @@ export const createPackageJson = ({ projectName, authProvider, plugins, database
         scripts['db:up'] =
             'sh -c "docker info >/dev/null 2>&1 || sudo service docker start; docker compose -f db/docker-compose.db.yml up -d db"';
         scripts['db:down'] = 'docker compose -f db/docker-compose.db.yml down';
+        scripts['db:reset'] =
+            'docker compose -f db/docker-compose.db.yml down -v';
         scripts['db:psql'] =
-            'docker compose -f db/docker-compose.db.yml exec db psql -U postgres -d appdb';
+            'docker compose -f db/docker-compose.db.yml exec db psql -U postgres';
         scripts['predev'] = 'bun db:up';
         scripts['postdev'] = 'bun db:down';
     }
+    if (databaseEngine === 'mysql') {
+        dependencies['mysql2'] = resolveVersion('mysql2', '3.14.2');
+    }
+    if (databaseEngine === 'mysql' &&
+        (!databaseHost || databaseHost === 'none')) {
+        scripts['db:up'] =
+            'sh -c "docker info >/dev/null 2>&1 || sudo service docker start; docker compose -f db/docker-compose.db.yml up -d db"';
+        scripts['db:down'] = 'docker compose -f db/docker-compose.db.yml down';
+        scripts['predev'] = 'bun db:up';
+        scripts['postdev'] = 'bun db:down';
+        scripts['db:mysql'] =
+            'docker compose -f db/docker-compose.db.yml exec db mysql -u appuser -pappuser appdb';
+    }
     if (databaseEngine === 'sqlite' &&
         (!databaseHost || databaseHost === 'none')) {
         scripts['db:sqlite'] = 'sqlite3 db/database.sqlite';

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

@@ -0,0 +1,2 @@
+import { DatabaseEngine } from '../../types';
+export declare const generateDatabaseContainer: (databaseEngine: DatabaseEngine) => string;

package/dist/generators/db/generateDBContainer.js

@@ -0,0 +1,105 @@
+const templates = {
+    cockroachdb: {
+        env: {
+            COCKROACH_INSECURE: 'true'
+        },
+        image: 'cockroachdb/cockroach:v24.1.0',
+        port: '26257:26257',
+        volumePath: '/cockroach/cockroach-data'
+    },
+    gel: {
+        env: {
+            GEL_DB: 'database',
+            GEL_PASSWORD: 'password',
+            GEL_USER: 'user'
+        },
+        image: 'gel:latest',
+        port: '4000:4000',
+        volumePath: '/var/lib/gel'
+    },
+    mariadb: {
+        env: {
+            MYSQL_DATABASE: 'database',
+            MYSQL_PASSWORD: 'userpassword',
+            MYSQL_ROOT_PASSWORD: 'rootpassword',
+            MYSQL_USER: 'user'
+        },
+        image: 'mariadb:11.4',
+        port: '3306:3306',
+        volumePath: '/var/lib/mysql'
+    },
+    mongodb: {
+        env: {
+            MONGO_INITDB_DATABASE: 'database',
+            MONGO_INITDB_ROOT_PASSWORD: 'password',
+            MONGO_INITDB_ROOT_USERNAME: 'user'
+        },
+        image: 'mongo:7.0',
+        port: '27017:27017',
+        volumePath: '/data/db'
+    },
+    mssql: {
+        env: {
+            ACCEPT_EULA: 'Y',
+            MSSQL_PID: 'Express',
+            SA_PASSWORD: 'Strong_Passw0rd'
+        },
+        image: 'mcr.microsoft.com/mssql/server:2022-latest',
+        port: '1433:1433',
+        volumePath: '/var/opt/mssql'
+    },
+    mysql: {
+        env: {
+            MYSQL_DATABASE: 'database',
+            MYSQL_PASSWORD: 'userpassword',
+            MYSQL_ROOT_PASSWORD: 'rootpassword',
+            MYSQL_USER: 'user'
+        },
+        image: 'mysql:8.0',
+        port: '3306:3306',
+        volumePath: '/var/lib/mysql'
+    },
+    postgresql: {
+        env: {
+            POSTGRES_DB: 'database',
+            POSTGRES_PASSWORD: 'password',
+            POSTGRES_USER: 'user'
+        },
+        image: 'postgres:15',
+        port: '5432:5432',
+        volumePath: '/var/lib/postgresql/data'
+    },
+    singlestore: {
+        env: {
+            ROOT_PASSWORD: 'password'
+        },
+        image: 'singlestore/cluster-in-a-box:latest',
+        port: '3306:3306',
+        volumePath: '/var/lib/memsql'
+    }
+};
+export const generateDatabaseContainer = (databaseEngine) => {
+    if (databaseEngine === undefined ||
+        databaseEngine === 'none' ||
+        databaseEngine === 'sqlite') {
+        throw new Error('Internal type error: Expected a valid local database engine');
+    }
+    const { image, port, env, volumePath } = templates[databaseEngine];
+    const envLines = Object.entries(env)
+        .map(([key, value]) => `            ${key}: ${value}`)
+        .join('\n');
+    return `services:
+    db:
+        image: ${image}
+        restart: always
+        environment:
+${envLines}
+        ports:
+            - "${port}"
+        volumes:
+            - db_data:${volumePath}
+
+volumes:
+    db_data:
+`;
+};

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

@@ -4,7 +4,42 @@ 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 queries: QueryOperations;
+    };
+    readonly 'gel:sql:local': {
+        readonly dbType: "GelClient";
+        readonly importLines: "import { GelClient } from 'gel'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'mariadb:sql:local': {
+        readonly dbType: "Pool";
+        readonly importLines: "import { Pool } from 'mariadb'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'mongodb:native:local': {
+        readonly dbType: "Db";
+        readonly importLines: "import { Db } from 'mongodb'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'mssql:sql:local': {
+        readonly dbType: "ConnectionPool";
+        readonly importLines: "import { ConnectionPool } from 'mssql'";
+        readonly queries: QueryOperations;
+    };
+    readonly 'mysql:sql:local': {
+        readonly dbType: "Pool";
+        readonly handlerTypes: HandlerType;
+        readonly importLines: "import { Pool, ResultSetHeader, RowDataPacket } from 'mysql2/promise'";
+        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'";
@@ -25,6 +60,11 @@ declare const driverConfigurations: {
         readonly importLines: "import { NeonQueryFunction } from '@neondatabase/serverless'";
         readonly queries: QueryOperations;
     };
+    readonly 'singlestore:sql:local': {
+        readonly dbType: "Connection";
+        readonly importLines: "import { Connection } from '@singlestore/db-client'";
+        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'";

package/dist/generators/db/handlerTemplates.js

@@ -1,36 +1,36 @@
-const buildSqlAuthTemplate = ({ importLines, dbType, queries }) => `
+const buildSqlAuthTemplate = ({ importLines, handlerTypes, dbType, queries }) => `
 import { isValidProviderOption, providers } from 'citra'
 ${importLines}
-
+${handlerTypes?.UserRow ? `\ntype UserRow = ${handlerTypes.UserRow}` : ''}
 type UserHandlerProps = {
-    authProvider: string
-    db: ${dbType}
-    userIdentity: Record<string, unknown>
+  authProvider: string
+  db: ${dbType}
+  userIdentity: Record<string, unknown>
 }
 
 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}\`
-    ${queries.selectUser}
+  if (!isValidProviderOption(authProvider)) throw new Error(\`Invalid auth provider: \${authProvider}\`)
+  const subject = providers[authProvider].extractSubjectFromIdentity(userIdentity)
+  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}\`
-    ${queries.insertUser}
+  if (!isValidProviderOption(authProvider)) throw new Error(\`Invalid auth provider: \${authProvider}\`)
+  const subject = providers[authProvider].extractSubjectFromIdentity(userIdentity)
+  const authSub = \`\${authProvider.toUpperCase()}|\${subject}\`
+  ${queries.insertUser}
 }
 `;
-const buildSqlCountTemplate = ({ importLines, dbType, queries }) => `
+const buildSqlCountTemplate = ({ importLines, handlerTypes, dbType, queries }) => `
 ${importLines}
-
+${handlerTypes?.CountHistoryRow ? `\ntype CountHistoryRow = ${handlerTypes.CountHistoryRow}\n` : ''}
 export const getCountHistory = async (db: ${dbType}, uid: number) => {
-    ${queries.selectHistory}
+  ${queries.selectHistory}
 }
 
 export const createCountHistory = async (db: ${dbType}, count: number) => {
-    ${queries.insertHistory}
+  ${queries.insertHistory}
 }
 `;
 const drizzleQueryOperations = {
@@ -100,7 +100,173 @@ const postgresSqlQueryOperations = {
   \`
   return user ?? null`
 };
+const mongodbQueryOperations = {
+    insertHistory: `const { insertedId } = await db.collection('count_history').insertOne({ count })
+  const newHistory = await db.collection('count_history').findOne({ _id: insertedId })
+  return newHistory`,
+    insertUser: `const { insertedId } = await db.collection('users').insertOne({ auth_sub: authSub, metadata: userIdentity })
+  const newUser = await db.collection('users').findOne({ _id: insertedId })
+  if (!newUser) throw new Error('Failed to create user')
+  return newUser`,
+    selectHistory: `const history = await db.collection('count_history').findOne({ uid })
+  return history ?? null`,
+    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')
+  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 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')
+  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 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])
+  return rows[0] ?? null`
+};
+const mssqlSqlQueryOperations = {
+    insertHistory: `await db.request().input('count', count).query('INSERT INTO count_history (count) VALUES (@count)')
+  const result = await db.request().query('SELECT TOP 1 * FROM count_history ORDER BY uid DESC')
+  return result.recordset[0]`,
+    insertUser: `await db.request().input('authSub', authSub).input('metadata', JSON.stringify(userIdentity)).query('INSERT INTO users (auth_sub, metadata) VALUES (@authSub, @metadata)')
+  const result = await db.request().input('authSub', authSub).query('SELECT TOP 1 * FROM users WHERE auth_sub = @authSub')
+  const newUser = result.recordset[0]
+  if (!newUser) throw new Error('Failed to create user')
+  return newUser`,
+    selectHistory: `const result = await db.request().input('uid', uid).query('SELECT TOP 1 * FROM count_history WHERE uid = @uid')
+  return result.recordset[0] ?? null`,
+    selectUser: `const result = await db.request().input('authSub', authSub).query('SELECT TOP 1 * FROM users WHERE auth_sub = @authSub')
+  return result.recordset[0] ?? null`
+};
+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];
+  `,
+    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];
+  `,
+    selectHistory: `
+const [rows] = await db.query<CountHistoryRow[]>(
+  'SELECT * FROM count_history WHERE uid = ? LIMIT 1',
+  [uid]
+);
+return rows[0] ?? null;
+  `,
+    selectUser: `
+const [rows] = await db.query<UserRow[]>(
+  'SELECT * FROM users WHERE auth_sub = ? LIMIT 1',
+  [authSub]
+);
+return rows[0] ?? null;
+  `
+};
+const mysqlHandlerTypes = {
+    CountHistoryRow: `RowDataPacket & {
+		uid: number;
+		count: number;
+		created_at: number;
+	}`,
+    UserRow: `RowDataPacket & {
+		uid: number;
+		auth_sub: string;
+		metadata: string;
+	}`
+};
 const driverConfigurations = {
+    'cockroachdb:sql:local': {
+        dbType: 'Pool',
+        importLines: `import { Pool } from 'pg'`,
+        queries: cockroachdbPoolQueryOperations
+    },
+    'gel:sql:local': {
+        dbType: 'GelClient',
+        importLines: `import { GelClient } from 'gel'`,
+        queries: gelSqlQueryOperations
+    },
+    'mariadb:sql:local': {
+        dbType: 'Pool',
+        importLines: `import { Pool } from 'mariadb'`,
+        queries: mariadbSqlQueryOperations
+    },
+    'mongodb:native:local': {
+        dbType: 'Db',
+        importLines: `import { Db } from 'mongodb'`,
+        queries: mongodbQueryOperations
+    },
+    'mssql:sql:local': {
+        dbType: 'ConnectionPool',
+        importLines: `import { ConnectionPool } from 'mssql'`,
+        queries: mssqlSqlQueryOperations
+    },
+    'mysql:sql:local': {
+        dbType: 'Pool',
+        handlerTypes: mysqlHandlerTypes,
+        importLines: `import { Pool, ResultSetHeader, RowDataPacket } from 'mysql2/promise'`,
+        queries: mysqlSqlQueryOperations
+    },
     'postgresql:drizzle:local': {
         dbType: 'BunSQLDatabase<SchemaType>',
         importLines: `
@@ -127,6 +293,11 @@ import { schema, type SchemaType } from '../../../db/schema'`,
         importLines: `import { NeonQueryFunction } from '@neondatabase/serverless'`,
         queries: postgresSqlQueryOperations
     },
+    'singlestore:sql:local': {
+        dbType: 'Connection',
+        importLines: `import { Connection } from '@singlestore/db-client'`,
+        queries: singlestoreSqlQueryOperations
+    },
     'sqlite:drizzle:local': {
         dbType: 'BunSQLiteDatabase<SchemaType>',
         importLines: `

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

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

package/dist/generators/db/scaffoldDatabase.js

@@ -1,4 +1,4 @@
-import { copyFileSync, mkdirSync, writeFileSync } from 'fs';
+import { mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { $ } from 'bun';
 import { dim, yellow } from 'picocolors';
@@ -6,10 +6,11 @@ import { isDrizzleDialect } from '../../typeGuards';
 import { checkDockerInstalled } from '../../utils/checkDockerInstalled';
 import { checkSqliteInstalled } from '../../utils/checkSqliteInstalled';
 import { createDrizzleConfig } from '../configurations/generateDrizzleConfig';
+import { generateDatabaseContainer } from './generateDBContainer';
 import { generateDBHandlers } from './generateDBHandlers';
 import { generateDrizzleSchema } from './generateDrizzleSchema';
 import { generateSqliteSchema } from './generateSqliteSchema';
-export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHost, databaseDirectory, backendDirectory, templatesDirectory, authProvider, orm }) => {
+export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHost, databaseDirectory, backendDirectory, authProvider, orm }) => {
     const projectDatabaseDirectory = join(projectName, databaseDirectory);
     const handlerDirectory = join(backendDirectory, 'handlers');
     mkdirSync(projectDatabaseDirectory, { recursive: true });
@@ -51,8 +52,9 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         console.warn(`${dim('│')}\n${yellow('▲')}  Prisma support is not implemented yet`);
         return;
     }
-    if (databaseEngine === 'postgresql') {
+    if (databaseEngine !== 'sqlite' && (orm === undefined || orm === 'none')) {
         await checkDockerInstalled();
-        copyFileSync(join(templatesDirectory, 'db', 'docker-compose.db.yml'), join(projectDatabaseDirectory, 'docker-compose.db.yml'));
+        const dbContainer = generateDatabaseContainer(databaseEngine);
+        writeFileSync(join(projectDatabaseDirectory, 'docker-compose.db.yml'), dbContainer, 'utf-8');
     }
 };

package/dist/generators/project/generateDBBlock.js

@@ -1,69 +1,66 @@
-export const generateDBBlock = ({ databaseEngine, orm, databaseHost }) => {
-    const isLocalPostgres = databaseEngine === 'postgresql' &&
-        (!databaseHost || databaseHost === 'none');
-    if (isLocalPostgres && orm === 'drizzle') {
-        return `
-const sql = new SQL(getEnv("DATABASE_URL"))
-const db = drizzle(sql, { schema })
-`;
+import { availableDrizzleDialects } from '../../data';
+const connectionMap = {
+    cockroachdb: {
+        none: { connect: true, expr: 'new SQL(getEnv("DATABASE_URL"))' }
+    },
+    gel: {
+        none: { expr: 'gelClient({ url: getEnv("DATABASE_URL") })' }
+    },
+    mariadb: {
+        none: { expr: 'createPool(getEnv("DATABASE_URL"))' }
+    },
+    mongodb: {
+        none: { expr: 'new MongoClient(getEnv("DATABASE_URL"))' }
+    },
+    mssql: {
+        none: { expr: 'connect(getEnv("DATABASE_URL"))' }
+    },
+    mysql: {
+        none: { expr: 'createPool(getEnv("DATABASE_URL"))' },
+        planetscale: { expr: 'connect({ url: getEnv("DATABASE_URL") })' }
+    },
+    postgresql: {
+        neon: { expr: 'neon(getEnv("DATABASE_URL"))' },
+        none: { connect: true, expr: 'new SQL(getEnv("DATABASE_URL"))' }
+    },
+    singlestore: {
+        none: { expr: 'createClient({ url: getEnv("DATABASE_URL") })' }
+    },
+    sqlite: {
+        none: { expr: 'new Database("db/database.sqlite")' },
+        turso: { expr: 'createClient({ url: getEnv("DATABASE_URL") })' }
     }
-    if (isLocalPostgres) {
-        return `
-const db = new SQL(getEnv("DATABASE_URL"))
-await db.connect();
-`;
-    }
-    const isNeonPostgres = databaseEngine === 'postgresql' && databaseHost === 'neon';
-    if (isNeonPostgres && orm === 'drizzle') {
-        return `
-const sql = neon(getEnv("DATABASE_URL"))
-const db = drizzle(sql, { schema })
-`;
-    }
-    if (isNeonPostgres) {
-        return `
-const db = neon(getEnv("DATABASE_URL"))
-`;
-    }
-    const isLocalSqlite = databaseEngine === 'sqlite' &&
-        (!databaseHost || databaseHost === 'none');
-    if (isLocalSqlite && orm === 'drizzle') {
-        return `
-const sql = new Database("db/database.sqlite")
-const db = drizzle(sql, { schema })
-`;
-    }
-    if (isLocalSqlite) {
-        return `
-const db = new Database("db/database.sqlite")
-`;
-    }
-    const isTursoSqlite = databaseEngine === 'sqlite' && databaseHost === 'turso';
-    if (isTursoSqlite && orm === 'drizzle') {
-        return `
-const sql = createClient({ url: getEnv("DATABASE_URL") })
-const db = drizzle(sql, { schema })
-`;
+};
+const remoteDrizzleInit = {
+    neon: 'neon(getEnv("DATABASE_URL"))',
+    planetscale: 'connect({ url: getEnv("DATABASE_URL") })',
+    turso: 'createClient({ url: getEnv("DATABASE_URL") })'
+};
+const drizzleDialectSet = new Set([...availableDrizzleDialects]);
+export const generateDBBlock = ({ databaseEngine, orm, databaseHost }) => {
+    if (!databaseEngine || databaseEngine === 'none') {
+        throw new Error('Internal type error: Expected a valid database engine');
     }
-    if (isTursoSqlite) {
+    const hostKey = databaseHost ?? 'none';
+    const engineGroup = connectionMap[databaseEngine];
+    if (!engineGroup)
+        return '';
+    if (orm !== 'drizzle') {
+        const hostCfg = engineGroup[hostKey];
+        if (!hostCfg)
+            return '';
         return `
-const db = createClient({ url: getEnv("DATABASE_URL") })
+const db = ${hostCfg.expr}
+${hostCfg.connect ? 'await db.connect();\n' : ''}
 `;
     }
-    if (orm !== 'drizzle') {
+    if (!drizzleDialectSet.has(databaseEngine))
+        return '';
+    const expr = engineGroup[hostKey]?.expr ?? remoteDrizzleInit[hostKey];
+    if (!expr)
         return '';
-    }
-    const clientInitMap = {
-        neon: 'const sql = neon(getEnv("DATABASE_URL"))',
-        planetscale: 'const sql = connect({ url: getEnv("DATABASE_URL") })',
-        turso: 'const sql = createClient({ url: getEnv("DATABASE_URL") })'
-    };
-    if (databaseHost === 'none' || databaseHost === undefined) {
-        return ``;
-    }
-    const initLine = clientInitMap[databaseHost];
     return `
-${initLine}
+const sql = ${expr}
 const db = drizzle(sql, { schema })
 `;
 };

package/dist/generators/project/generateImportsBlock.js

@@ -66,6 +66,11 @@ export const generateImportsBlock = ({ backendDirectory, deps, flags, orm, authP
                 `import { getEnv } from '@absolutejs/absolute'`
             ]
             : [`import { Database } from 'bun:sqlite'`]));
+    if (noOrm && databaseEngine === 'mysql') {
+        rawImports.push(...(isRemoteHost
+            ? connectorImports[databaseHost]
+            : [`import { createPool } from 'mysql2/promise'`]), `import { getEnv } from '@absolutejs/absolute'`);
+    }
     if (noOrm && databaseEngine === 'postgresql')
         rawImports.push(...(isRemoteHost
             ? connectorImports[databaseHost]

package/dist/index.js

@@ -7,13 +7,13 @@ import { scaffold } from './scaffold';
 import { parseCommandLineOptions } from './utils/parseCommandLineOptions';
 import { getUserPackageManager } from './utils/t3-utils';
 const packageManager = getUserPackageManager();
-const { help, argumentConfiguration, latest, debug } = parseCommandLineOptions();
+const { help, argumentConfiguration, latest, debug, envVariables } = parseCommandLineOptions();
 if (help === true) {
     console.log(helpMessage);
     exit(0);
 }
 const response = await prompt(argumentConfiguration);
-await scaffold({ latest, packageManager, response });
+await scaffold({ envVariables, latest, packageManager, response });
 const debugMessage = debug !== false
     ? getDebugMessage({
         packageManager,

package/dist/scaffold.d.ts

@@ -3,6 +3,7 @@ type ScaffoldProps = {
     response: CreateConfiguration;
     packageManager: PackageManager;
     latest: boolean;
+    envVariables: string[] | undefined;
 };
-export declare const scaffold: ({ response: { projectName, codeQualityTool, initializeGitNow, databaseEngine, databaseHost, useHTMLScripts, useTailwind, databaseDirectory, orm, frontends, plugins, authProvider, buildDirectory, assetsDirectory, tailwind, installDependenciesNow, frontendDirectories }, latest, packageManager }: ScaffoldProps) => Promise<void>;
+export declare const scaffold: ({ response: { projectName, codeQualityTool, initializeGitNow, databaseEngine, databaseHost, useHTMLScripts, useTailwind, databaseDirectory, orm, frontends, plugins, authProvider, buildDirectory, assetsDirectory, tailwind, installDependenciesNow, frontendDirectories }, latest, envVariables, packageManager }: ScaffoldProps) => Promise<void>;
 export {};

package/dist/scaffold.js

@@ -10,15 +10,18 @@ import { initalizeRoot } from './generators/configurations/initializeRoot';
 import { scaffoldDatabase } from './generators/db/scaffoldDatabase';
 import { generateServerFile } from './generators/project/generateServer';
 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, packageManager }) => {
+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);
     copyFileSync(join(templatesDirectory, 'README.md'), join(projectName, 'README.md'));
     addConfigurationFiles({
         codeQualityTool,
+        databaseEngine,
+        envVariables,
         frontends,
         initializeGitNow,
+        orm,
         projectName,
         tailwind,
         templatesDirectory
@@ -57,8 +60,7 @@ export const scaffold = async ({ response: { projectName, codeQualityTool, initi
             databaseEngine,
             databaseHost,
             orm,
-            projectName,
-            templatesDirectory
+            projectName
         })));
     scaffoldFrontends({
         frontendDirectories,

package/dist/utils/parseCommandLineOptions.d.ts

@@ -2,6 +2,7 @@ import type { ArgumentConfiguration } from '../types';
 export declare const parseCommandLineOptions: () => {
     argumentConfiguration: ArgumentConfiguration;
     debug: boolean;
+    envVariables: string[] | undefined;
     help: boolean;
     latest: boolean;
 };

package/dist/utils/parseCommandLineOptions.js

@@ -20,6 +20,7 @@ export const parseCommandLineOptions = () => {
             'db-host': { type: 'string' },
             debug: { default: false, short: 'd', type: 'boolean' },
             directory: { type: 'string' },
+            env: { multiple: true, type: 'string' },
             'eslint+prettier': { type: 'boolean' },
             git: { type: 'boolean' },
             help: { default: false, short: 'h', type: 'boolean' },
@@ -197,6 +198,23 @@ export const parseCommandLineOptions = () => {
         console.warn('Warning: Tailwind CSS input/output files are specified but Tailwind is disabled.');
         tailwind = undefined;
     }
+    const rawEnv = values.env ?? [];
+    const validEnv = [];
+    for (const entry of rawEnv) {
+        const idx = entry.indexOf('=');
+        const key = idx > 0 ? entry.slice(0, idx) : '';
+        const badFormat = idx <= 0;
+        const badKey = !badFormat && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+        const errorMsg = (badFormat &&
+            `Invalid --env entry: "${entry}". Expected KEY=VALUE`) ||
+            (badKey && `Invalid env var name: "${key}"`) ||
+            undefined;
+        void (errorMsg && console.error(errorMsg));
+        if (errorMsg)
+            continue;
+        validEnv.push(entry);
+    }
+    values.env = validEnv.length ? validEnv : undefined;
     const argumentConfiguration = {
         assetsDirectory: values.assets,
         authProvider,
@@ -220,6 +238,7 @@ export const parseCommandLineOptions = () => {
     return {
         argumentConfiguration,
         debug: values.debug,
+        envVariables: values.env,
         help: values.help,
         latest: values.lts
     };

package/package.json

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

package/dist/templates/db/drizzle-schema.ts

@@ -1,20 +0,0 @@
-import { pgTable, timestamp, varchar } from 'drizzle-orm/pg-core';
-
-export const users = pgTable('users', {
-	auth_sub: varchar('auth_sub', { length: 255 }).primaryKey(),
-	created_at: timestamp('created_at').notNull().defaultNow(),
-	email: varchar('email', { length: 255 }).notNull().unique(),
-	family_name: varchar('family_name', { length: 255 }),
-	given_name: varchar('given_name', { length: 255 }),
-	picture: varchar('picture', { length: 255 })
-});
-
-export const schema = {
-	users
-};
-
-// Type Definitions
-export type SchemaType = typeof schema;
-
-export type User = typeof users.$inferSelect;
-export type NewUser = typeof users.$inferInsert;

package/dist/templates/db/schema.prisma

@@ -1,18 +0,0 @@
-datasource db {
-    provider = "postgresql"
-    url      = env("DATABASE_URL")
-}
-
-generator client {
-    provider = "prisma-client-js"
-    output   = "./src/generated/prisma-client"
-}
-
-model User {
-    authSub String @id
-    createdAt DateTime @default(now())
-    email String @unique
-    familyName String
-    givenName String
-    picture String
-}