create-absolutejs 0.3.9 → 0.3.10

package/dist/generators/db/handlerTemplates.js

@@ -0,0 +1,168 @@
+const buildSqlAuthTemplate = ({ importLines, dbType, queries }) => `
+import { isValidProviderOption, providers } from 'citra'
+${importLines}
+
+type UserHandlerProps = {
+    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}
+}
+
+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}
+}
+`;
+const buildSqlCountTemplate = ({ importLines, dbType, queries }) => `
+${importLines}
+
+export const getCountHistory = async (db: ${dbType}, uid: number) => {
+    ${queries.selectHistory}
+}
+
+export const createCountHistory = async (db: ${dbType}, count: number) => {
+    ${queries.insertHistory}
+}
+`;
+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`,
+    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`
+};
+const libsqlQueryOperations = {
+    insertHistory: `const { rows } = await db.execute({ sql: 'INSERT INTO count_history (count) VALUES (?) RETURNING *', args: [count] })
+  return rows[0]`,
+    insertUser: `const { rows } = await db.execute({ sql: 'INSERT INTO users (auth_sub, metadata) VALUES (?, ?) RETURNING *', args: [authSub, JSON.stringify(userIdentity)] })
+  const newUser = rows[0]
+  if (!newUser) throw new Error('Failed to create user')
+  return newUser`,
+    selectHistory: `const { rows } = await db.execute({ sql: 'SELECT * FROM count_history WHERE uid = ? LIMIT 1', args: [uid] })
+  return rows[0] ?? null`,
+    selectUser: `const { rows } = await db.execute({ sql: 'SELECT * FROM users WHERE auth_sub = ? LIMIT 1', args: [authSub] })
+  return rows[0] ?? null`
+};
+const bunSqliteQueryOperations = {
+    insertHistory: `db.run('INSERT INTO count_history (count) VALUES (?)', [count])
+  const statement = db.query('SELECT * FROM count_history ORDER BY rowid DESC LIMIT 1')
+  const [newHistory] = statement.all()
+  return newHistory`,
+    insertUser: `db.run('INSERT INTO users (auth_sub, metadata) VALUES (?, ?)', [authSub, JSON.stringify(userIdentity)])
+  const statement = db.query('SELECT * FROM users WHERE auth_sub = ? LIMIT 1')
+  const [newUser] = statement.all(authSub)
+  if (!newUser) throw new Error('Failed to create user')
+  return newUser`,
+    selectHistory: `const statement = db.query('SELECT * FROM count_history WHERE uid = ? LIMIT 1')
+  const [history] = statement.all(uid)
+  return history ?? null`,
+    selectUser: `const statement = db.query('SELECT * FROM users WHERE auth_sub = ? LIMIT 1')
+  const [user] = statement.all(authSub)
+  return user ?? null`
+};
+const postgresSqlQueryOperations = {
+    insertHistory: `const [newHistory] = await db\`
+    INSERT INTO count_history (count)
+    VALUES (\${count})
+    RETURNING *
+  \`
+  return newHistory`,
+    insertUser: `const [newUser] = await db\`
+    INSERT INTO users (auth_sub, metadata)
+    VALUES (\${authSub}, \${userIdentity})
+    RETURNING *
+  \`
+  if (!newUser) throw new Error('Failed to create user')
+  return newUser`,
+    selectHistory: `const [history] = await db\`
+    SELECT * FROM count_history
+    WHERE uid = \${uid}
+    LIMIT 1
+  \`
+  return history ?? null`,
+    selectUser: `const [user] = await db\`
+    SELECT * FROM users
+    WHERE auth_sub = \${authSub}
+    LIMIT 1
+  \`
+  return user ?? null`
+};
+const driverConfigurations = {
+    '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'`,
+        queries: drizzleQueryOperations
+    },
+    'postgresql:drizzle:neon': {
+        dbType: 'NeonHttpDatabase<SchemaType>',
+        importLines: `
+import { eq } from 'drizzle-orm'
+import { NeonHttpDatabase } from 'drizzle-orm/neon-http'
+import { schema, type SchemaType } from '../../../db/schema'`,
+        queries: drizzleQueryOperations
+    },
+    'postgresql:sql:local': {
+        dbType: 'SQL',
+        importLines: `import { SQL } from 'bun'`,
+        queries: postgresSqlQueryOperations
+    },
+    'postgresql:sql:neon': {
+        dbType: 'NeonQueryFunction<false, false>',
+        importLines: `import { NeonQueryFunction } from '@neondatabase/serverless'`,
+        queries: postgresSqlQueryOperations
+    },
+    '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'`,
+        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'`,
+        queries: drizzleQueryOperations
+    },
+    'sqlite:sql:local': {
+        dbType: 'Database',
+        importLines: `import { Database } from 'bun:sqlite'`,
+        queries: bunSqliteQueryOperations
+    },
+    'sqlite:sql:turso': {
+        dbType: 'Client',
+        importLines: `import { Client } from '@libsql/client'`,
+        queries: libsqlQueryOperations
+    }
+};
+export const getAuthTemplate = (key) => {
+    const configuration = driverConfigurations[key];
+    if (!configuration)
+        throw new Error(`Unsupported driver configuration: ${key}`);
+    return buildSqlAuthTemplate(configuration);
+};
+export const getCountTemplate = (key) => {
+    const configuration = driverConfigurations[key];
+    if (!configuration)
+        throw new Error(`Unsupported driver configuration: ${key}`);
+    return buildSqlCountTemplate(configuration);
+};

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

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

package/dist/generators/db/scaffoldDatabase.js

@@ -1,14 +1,45 @@
-import { mkdirSync } from 'fs';
+import { copyFileSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { dim, yellow } from 'picocolors';
+import { isDrizzleDialect } from '../../typeGuards';
+import { checkDockerInstalled } from '../../utils/checkDockerInstalled';
 import { createDrizzleConfig } from '../configurations/generateDrizzleConfig';
-export const scaffoldDatabase = ({ projectName, databaseEngine, databaseDirectory, orm }) => {
-    mkdirSync(join(projectName, databaseDirectory), { recursive: true });
-    if (databaseEngine !== 'postgresql' && databaseEngine !== 'none') {
-        console.warn(`${dim('│')}\n${yellow('▲')}  Only PostgreSQL support is implemented so far`);
+import { generateDBHandlers } from './generateDBHandlers';
+import { generateDrizzleSchema } from './generateDrizzleSchema';
+export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHost, databaseDirectory, backendDirectory, templatesDirectory, authProvider, orm }) => {
+    const projectDatabaseDirectory = join(projectName, databaseDirectory);
+    const handlerDirectory = join(backendDirectory, 'handlers');
+    mkdirSync(projectDatabaseDirectory, { recursive: true });
+    mkdirSync(handlerDirectory, { recursive: true });
+    const usesAuth = authProvider !== undefined && authProvider !== 'none';
+    const handlerFileName = usesAuth
+        ? 'userHandlers.ts'
+        : 'countHistoryHandlers.ts';
+    const dbHandlers = generateDBHandlers({
+        databaseEngine,
+        databaseHost,
+        orm,
+        usesAuth
+    });
+    writeFileSync(join(handlerDirectory, handlerFileName), dbHandlers, 'utf-8');
+    if (databaseEngine === 'postgresql' &&
+        (databaseHost === undefined || databaseHost === 'none')) {
+        await checkDockerInstalled();
+        copyFileSync(join(templatesDirectory, 'db', 'docker-compose.db.yml'), join(projectDatabaseDirectory, 'docker-compose.db.yml'));
     }
     if (orm === 'drizzle') {
-        createDrizzleConfig({ databaseEngine, projectName });
+        if (!isDrizzleDialect(databaseEngine)) {
+            throw new Error('Internal type error: Expected a Drizzle dialect');
+        }
+        const drizzleSchema = generateDrizzleSchema({
+            authProvider,
+            databaseEngine,
+            databaseHost
+        });
+        const schemaFilePath = join(projectDatabaseDirectory, 'schema.ts');
+        writeFileSync(schemaFilePath, drizzleSchema);
+        createDrizzleConfig({ databaseDirectory, databaseEngine, projectName });
+        return;
     }
     if (orm === 'prisma') {
         console.warn(`${dim('│')}\n${yellow('▲')}  Prisma support is not implemented yet`);

package/dist/generators/html/generateHTMLPage.d.ts

@@ -1,2 +1,2 @@
-import { Frontend } from '../../types';
-export declare const generateHTMLPage: (frontends: Frontend[]) => string;
+import { CreateConfiguration, Frontend } from '../../types';
+export declare const generateHTMLPage: (frontends: Frontend[], useHTMLScripts: CreateConfiguration["useHTMLScripts"]) => string;

package/dist/generators/html/generateHTMLPage.js

@@ -1,6 +1,10 @@
 import { formatNavLink } from '../../utils/formatNavLink';
-export const generateHTMLPage = (frontends) => {
+export const generateHTMLPage = (frontends, useHTMLScripts) => {
     const navLinks = frontends.map(formatNavLink).join('\n\t\t\t');
+    const initialCount = useHTMLScripts ? '0' : 'disabled';
+    const scriptTagBlock = useHTMLScripts
+        ? `        <script src="../scripts/typescript-example.ts"></script>\n`
+        : '';
     return `<!doctype html>
 <html>
     <head>
@@ -44,7 +48,7 @@ export const generateHTMLPage = (frontends) => {
             </nav>
             <h1>AbsoluteJS + HTML</h1>
             <button id="counter-button">
-                count is <span id="counter">0</span>
+                count is <span id="counter">${initialCount}</span>
             </button>
             <p>
                 Edit <code>example/html/pages/HtmlExample.html</code> save and
@@ -59,8 +63,7 @@ export const generateHTMLPage = (frontends) => {
                 Click on the AbsoluteJS and HTML logos to learn more.
             </p>
         </main>
-        <script src="../scripts/typescript-example.ts"></script>
-    </body>
+${scriptTagBlock}    </body>
 </html>
 `;
 };

package/dist/generators/html/scaffoldHTML.js

@@ -4,7 +4,7 @@ import { generateMarkupCSS } from '../project/generateMarkupCSS';
 import { generateHTMLPage } from './generateHTMLPage';
 export const scaffoldHTML = ({ isSingleFrontend, targetDirectory, frontends, useHTMLScripts, templatesDirectory, projectAssetsDirectory }) => {
     copyFileSync(join(templatesDirectory, 'assets', 'svg', 'HTML5_Badge.svg'), join(projectAssetsDirectory, 'svg', 'HTML5_Badge.svg'));
-    const htmlPage = generateHTMLPage(frontends);
+    const htmlPage = generateHTMLPage(frontends, useHTMLScripts);
     const pagesDirectory = join(targetDirectory, 'pages');
     mkdirSync(pagesDirectory, { recursive: true });
     const htmlFilePath = join(pagesDirectory, 'HTMLExample.html');

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

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

package/dist/generators/project/collectDependencies.js

@@ -0,0 +1,16 @@
+import { defaultDependencies, defaultPlugins, absoluteAuthPlugin, scopedStatePlugin, availablePlugins } from '../../data';
+export const collectDependencies = ({ plugins, authProvider, flags }) => {
+    const customSelections = availablePlugins.filter((plugin) => plugins.includes(plugin.value));
+    const authPlugins = authProvider === 'absoluteAuth' ? [absoluteAuthPlugin] : [];
+    const htmxPlugins = flags.requiresHtmx ? [scopedStatePlugin] : [];
+    const allDeps = [
+        ...defaultDependencies,
+        ...defaultPlugins,
+        ...customSelections,
+        ...authPlugins,
+        ...htmxPlugins
+    ];
+    const uniqueDeps = Array.from(new Map(allDeps.map((dependency) => [dependency.value, dependency])).values());
+    uniqueDeps.sort((firstDep, secondDep) => firstDep.value.localeCompare(secondDep.value));
+    return uniqueDeps;
+};

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

@@ -0,0 +1,9 @@
+import type { FrontendDirectories } from '../../types';
+export type FrameworkFlags = ReturnType<typeof computeFlags>;
+export declare const computeFlags: (dirs: FrontendDirectories) => {
+    requiresHtml: boolean;
+    requiresHtmx: boolean;
+    requiresReact: boolean;
+    requiresSvelte: boolean;
+    requiresVue: boolean;
+};

package/dist/generators/project/computeFlags.js

@@ -0,0 +1,7 @@
+export const computeFlags = (dirs) => ({
+    requiresHtml: dirs.html !== undefined,
+    requiresHtmx: dirs.htmx !== undefined,
+    requiresReact: dirs.react !== undefined,
+    requiresSvelte: dirs.svelte !== undefined,
+    requiresVue: dirs.vue !== undefined
+});

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

@@ -0,0 +1,9 @@
+import type { CreateConfiguration, FrontendDirectories } from '../../types';
+type GenerateBuildBlockProps = {
+    assetsDirectory: string;
+    buildDirectory: string;
+    frontendDirectories: FrontendDirectories;
+    tailwind: CreateConfiguration['tailwind'];
+};
+export declare const generateBuildBlock: ({ assetsDirectory, buildDirectory, frontendDirectories, tailwind }: GenerateBuildBlockProps) => string;
+export {};

package/dist/generators/project/generateBuildBlock.js

@@ -0,0 +1,13 @@
+export const generateBuildBlock = ({ assetsDirectory, buildDirectory, frontendDirectories, tailwind }) => {
+    const opts = [
+        `assetsDirectory: '${assetsDirectory}'`,
+        `buildDirectory: '${buildDirectory}'`,
+        ...Object.entries(frontendDirectories).map(([f, dir]) => `${f}Directory: 'src/frontend${dir ? `/${dir}` : ''}'`),
+        tailwind ? `tailwind: ${JSON.stringify(tailwind)}` : ''
+    ]
+        .filter(Boolean)
+        .join(',\n  ');
+    const frameworks = ['react', 'svelte', 'vue'];
+    const nonFrameworkOnly = frameworks.every((f) => frontendDirectories[f] === undefined);
+    return `${nonFrameworkOnly ? '' : 'const manifest = '}await build({\n  ${opts}\n});`;
+};

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

@@ -0,0 +1,4 @@
+import type { CreateConfiguration } from '../../types';
+type GenerateDBBlockProps = Pick<CreateConfiguration, 'databaseEngine' | 'orm' | 'databaseHost'>;
+export declare const generateDBBlock: ({ databaseEngine, orm, databaseHost }: GenerateDBBlockProps) => string;
+export {};

package/dist/generators/project/generateDBBlock.js

@@ -0,0 +1,69 @@
+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 })
+`;
+    }
+    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("database.sqlite")
+const db = drizzle(sql, { schema })
+`;
+    }
+    if (isLocalSqlite) {
+        return `
+const db = new Database("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 })
+`;
+    }
+    if (isTursoSqlite) {
+        return `
+const db = createClient({ url: getEnv("DATABASE_URL") })
+`;
+    }
+    if (orm !== 'drizzle') {
+        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 db = drizzle(sql, { schema })
+`;
+};

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

@@ -0,0 +1,13 @@
+import type { AvailableDependency, CreateConfiguration } from '../../types';
+import type { FrameworkFlags } from './computeFlags';
+type GenerateImportsBlockProps = {
+    backendDirectory: string;
+    deps: AvailableDependency[];
+    flags: FrameworkFlags;
+    orm: CreateConfiguration['orm'];
+    authProvider: CreateConfiguration['authProvider'];
+    databaseEngine: CreateConfiguration['databaseEngine'];
+    databaseHost: CreateConfiguration['databaseHost'];
+};
+export declare const generateImportsBlock: ({ backendDirectory, deps, flags, orm, authProvider, databaseEngine, databaseHost }: GenerateImportsBlockProps) => string;
+export {};

package/dist/generators/project/generateImportsBlock.js

@@ -0,0 +1,124 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+export const generateImportsBlock = ({ backendDirectory, deps, flags, orm, authProvider, databaseEngine, databaseHost }) => {
+    const rawImports = [];
+    const pushHandler = (cond, name) => cond &&
+        rawImports.push(`import { ${name} } from '@absolutejs/absolute'`);
+    pushHandler(flags.requiresHtml, 'handleHTMLPageRequest');
+    pushHandler(flags.requiresReact, 'handleReactPageRequest');
+    pushHandler(flags.requiresSvelte, 'handleSveltePageRequest');
+    pushHandler(flags.requiresVue, 'handleVuePageRequest');
+    pushHandler(flags.requiresVue, 'generateHeadElement');
+    pushHandler(flags.requiresHtmx, 'handleHTMXPageRequest');
+    const nonFrameworkOnly = (flags.requiresHtml || flags.requiresHtmx) &&
+        !flags.requiresReact &&
+        !flags.requiresSvelte &&
+        !flags.requiresVue;
+    for (const dependency of deps) {
+        const importsList = dependency.imports ?? [];
+        const relevantImports = nonFrameworkOnly
+            ? importsList.filter((imp) => imp.packageName !== 'asset')
+            : importsList;
+        if (relevantImports.length === 0)
+            continue;
+        rawImports.push(`import { ${relevantImports
+            .map((imp) => imp.packageName)
+            .sort()
+            .join(', ')} } from '${dependency.value}'`);
+    }
+    if (flags.requiresReact)
+        rawImports.push(`import { ReactExample } from '../frontend/react/pages/ReactExample'`);
+    if (flags.requiresSvelte)
+        rawImports.push(`import SvelteExample from '../frontend/svelte/pages/SvelteExample.svelte'`);
+    if (flags.requiresVue && !flags.requiresSvelte)
+        rawImports.push(`import VueExample from '../frontend/vue/pages/VueExample.vue'`);
+    const connectorImports = {
+        neon: ["import { neon } from '@neondatabase/serverless'"],
+        planetscale: ["import { connect } from '@planetscale/database'"],
+        turso: ["import { createClient } from '@libsql/client'"]
+    };
+    const dialectImports = {
+        neon: ["import { drizzle } from 'drizzle-orm/neon-http'"],
+        planetscale: [
+            "import { drizzle } from 'drizzle-orm/planetscale-serverless'"
+        ],
+        turso: ["import { drizzle } from 'drizzle-orm/libsql'"]
+    };
+    const isRemoteHost = databaseHost !== undefined && databaseHost !== 'none';
+    if (orm === 'drizzle' && isRemoteHost) {
+        const key = databaseHost;
+        rawImports.push(...connectorImports[key], ...dialectImports[key]);
+    }
+    if (orm === 'drizzle' && !isRemoteHost && databaseEngine === 'postgresql')
+        rawImports.push(`import { SQL } from 'bun'`, `import { drizzle } from 'drizzle-orm/bun-sql'`);
+    if (orm === 'drizzle' && databaseEngine === 'sqlite' && !isRemoteHost)
+        rawImports.push(`import { Database } from 'bun:sqlite'`, `import { drizzle } from 'drizzle-orm/bun-sqlite'`);
+    if ((orm ?? 'none') === 'none' && databaseEngine === 'sqlite')
+        rawImports.push(...(databaseHost === 'turso'
+            ? [
+                `import { createClient } from '@libsql/client'`,
+                `import { getEnv } from '@absolutejs/absolute'`
+            ]
+            : [`import { Database } from 'bun:sqlite'`]));
+    if (orm === 'drizzle') {
+        rawImports.push(`import { Elysia } from 'elysia'`, ...(databaseEngine === 'sqlite' && !isRemoteHost
+            ? []
+            : [`import { getEnv } from '@absolutejs/absolute'`]), authProvider === 'absoluteAuth'
+            ? `import { schema, User } from '../../db/schema'`
+            : `import { schema } from '../../db/schema'`);
+    }
+    if ((orm === undefined || orm === 'none') &&
+        databaseEngine === 'postgresql')
+        rawImports.push(...(isRemoteHost
+            ? connectorImports[databaseHost]
+            : [`import { SQL } from 'bun'`]), `import { getEnv } from '@absolutejs/absolute'`);
+    if (authProvider === 'absoluteAuth')
+        rawImports.push(`import { absoluteAuth, instantiateUserSession } from '@absolutejs/auth'`, ...(databaseEngine && databaseEngine !== 'none'
+            ? [
+                `import { createUser, getUser } from './handlers/userHandlers'`
+            ]
+            : []));
+    if ((authProvider === undefined || authProvider === 'none') &&
+        databaseEngine !== undefined &&
+        databaseEngine !== 'none')
+        rawImports.push(`import { getCountHistory, createCountHistory } from './handlers/countHistoryHandlers'`, `import { t } from 'elysia'`);
+    if (flags.requiresVue && flags.requiresSvelte) {
+        const utilsDir = join(backendDirectory, 'utils');
+        mkdirSync(utilsDir, { recursive: true });
+        writeFileSync(join(utilsDir, 'vueImporter.ts'), `import VueExample from "../../frontend/vue/pages/VueExample.vue"\n\nexport const vueImports = { VueExample } as const\n`);
+        rawImports.push(`import { vueImports } from './utils/vueImporter'`);
+    }
+    const importMap = new Map();
+    for (const stmt of rawImports) {
+        const match = stmt.match(/^import\s+(.+)\s+from\s+['"](.+)['"];?/);
+        if (!match)
+            continue;
+        const [, importClause, modulePath] = match;
+        if (!importClause || !modulePath)
+            continue;
+        const entry = importMap.get(modulePath) ?? {
+            defaultImport: null,
+            namedImports: new Set()
+        };
+        importMap.set(modulePath, entry);
+        void (importClause.startsWith('{')
+            ? importClause
+                .slice(1, -1)
+                .split(',')
+                .map((segment) => segment.trim())
+                .filter(Boolean)
+                .forEach((name) => entry.namedImports.add(name))
+            : (entry.defaultImport = importClause.trim()));
+    }
+    return Array.from(importMap.entries())
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([path, { defaultImport, namedImports }]) => {
+        const parts = [];
+        if (defaultImport)
+            parts.push(defaultImport);
+        if (namedImports.size)
+            parts.push(`{ ${[...namedImports].sort().join(', ')} }`);
+        return `import ${parts.join(', ')} from '${path}'`;
+    })
+        .join('\n');
+};

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

@@ -0,0 +1,10 @@
+import type { AuthProvider, FrontendDirectories } from '../../types';
+import type { FrameworkFlags } from './computeFlags';
+type GenerateRoutesBlockProps = {
+    flags: FrameworkFlags;
+    frontendDirectories: FrontendDirectories;
+    authProvider: AuthProvider;
+    buildDirectory: string;
+};
+export declare const generateRoutesBlock: ({ flags, frontendDirectories, authProvider, buildDirectory }: GenerateRoutesBlockProps) => string;
+export {};

package/dist/generators/project/generateRoutesBlock.js

@@ -0,0 +1,74 @@
+import { isFrontend } from '../../typeGuards';
+export const generateRoutesBlock = ({ flags, frontendDirectories, authProvider, buildDirectory }) => {
+    const routes = [];
+    const createHandlerCall = (frontend, directory) => {
+        const base = `${buildDirectory}${directory ? `/${directory}` : ''}/pages`;
+        if (frontend === 'html')
+            return `handleHTMLPageRequest(\`${base}/HTMLExample.html\`)`;
+        if (frontend === 'htmx')
+            return `handleHTMXPageRequest(\`${base}/HTMXExample.html\`)`;
+        if (frontend === 'react')
+            return `handleReactPageRequest(
+        ReactExample,
+        asset(manifest, 'ReactExampleIndex'),
+        { initialCount: 0, cssPath: asset(manifest, 'ReactExampleCSS') }
+      )`;
+        if (frontend === 'svelte')
+            return `handleSveltePageRequest(
+        SvelteExample,
+        asset(manifest, 'SvelteExample'),
+        asset(manifest, 'SvelteExampleIndex'),
+        { initialCount: 0, cssPath: asset(manifest, 'SvelteExampleCSS') }
+      )`;
+        if (frontend === 'vue')
+            return flags.requiresSvelte
+                ? `handleVuePageRequest(
+          vueImports.VueExample,
+          asset(manifest, 'VueExample'),
+          asset(manifest, 'VueExampleIndex'),
+          generateHeadElement({
+            cssPath: asset(manifest, 'VueExampleCSS'),
+            title: 'AbsoluteJS + Vue',
+            description: 'A Vue.js example with AbsoluteJS'
+          }),
+          { initialCount: 0 }
+        )`
+                : `handleVuePageRequest(
+          VueExample,
+          asset(manifest, 'VueExample'),
+          asset(manifest, 'VueExampleIndex'),
+          generateHeadElement({
+            cssPath: asset(manifest, 'VueExampleCSS'),
+            title: 'AbsoluteJS + Vue',
+            description: 'A Vue.js example with AbsoluteJS'
+          }),
+          { initialCount: 0 }
+        )`;
+        return '';
+    };
+    Object.entries(frontendDirectories).forEach(([frontend, directory], entryIndex) => {
+        if (!isFrontend(frontend))
+            return;
+        const handlerCall = createHandlerCall(frontend, directory);
+        if (entryIndex === 0)
+            routes.push(`.get('/', () => ${handlerCall})`);
+        if (frontend === 'htmx') {
+            routes.push(`.get('/htmx', () => ${handlerCall})`, `.post('/htmx/reset', ({ resetScopedStore }) => resetScopedStore())`, `.get('/htmx/count', ({ scopedStore }) => scopedStore.count)`, `.post('/htmx/increment', ({ scopedStore }) => ++scopedStore.count)`);
+        }
+        else {
+            routes.push(`.get('/${frontend}', () => ${handlerCall})`);
+        }
+    });
+    if (authProvider === undefined || authProvider === 'none') {
+        routes.push(`.get('/count/:uid', ({ params: { uid } }) => getCountHistory(db, uid), {
+    params: t.Object({
+      uid: t.Number()
+    })
+  })`, `.post('/count', ({ body: { count } }) => createCountHistory(db, count), {
+    body: t.Object({
+      count: t.Number()
+    })
+  })`);
+    }
+    return routes.join('\n  ');
+};