create-absolutejs 0.5.1 → 0.6.0

package/dist/generators/db/scaffoldDatabase.js

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

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

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

package/dist/generators/db/scaffoldDocker.js

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

package/dist/generators/html/scaffoldHTML.js

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

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

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

package/dist/generators/project/collectDependencies.js

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

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

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

package/dist/generators/project/generateAbsoluteAuthConfig.js

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

package/dist/generators/project/generateDBBlock.js

@@ -21,7 +21,7 @@ const connectionMap = {
     },
     postgresql: {
         neon: {
-            expr: 'new Pool({ connectionString: getEnv("DATABASE_URL") })'
+            expr: 'neon(getEnv("DATABASE_URL"));'
         },
         none: { expr: 'new SQL(getEnv("DATABASE_URL"))' },
         planetscale: {
@@ -37,7 +37,7 @@ const connectionMap = {
     }
 };
 const remoteDrizzleInit = {
-    neon: 'new Pool({ connectionString: getEnv("DATABASE_URL") })',
+    neon: 'neon(getEnv("DATABASE_URL"));',
     planetscale: 'new Client({ url: getEnv("DATABASE_URL") })',
     turso: 'createClient({ url: getEnv("DATABASE_URL") })'
 };
@@ -64,6 +64,12 @@ export const generateDBBlock = ({ databaseEngine, orm, databaseHost }) => {
         return `
 const pool = createPool(getEnv("DATABASE_URL"))
 const db = drizzle(pool, { schema, mode: 'default' })
+`;
+    }
+    if (databaseEngine === 'postgresql' && databaseHost === 'neon') {
+        return `
+		const sql = neon(getEnv('DATABASE_URL'));
+const db = drizzle(sql, { schema });
 `;
     }
     return `

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

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

package/dist/generators/project/generateImportsBlock.js

@@ -1,7 +1,7 @@
 import { mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { isDrizzleDialect } from '../../typeGuards';
-export const generateImportsBlock = ({ backendDirectory, deps, flags, orm, authProvider, databaseEngine, databaseHost, frontendDirectories }) => {
+export const generateImportsBlock = ({ backendDirectory, deps, flags, orm, authOption, databaseEngine, databaseHost, frontendDirectories }) => {
     const rawImports = [];
     const pushHandler = (cond, name) => cond &&
         rawImports.push(`import { ${name} } from '@absolutejs/absolute'`);
@@ -38,12 +38,12 @@ export const generateImportsBlock = ({ backendDirectory, deps, flags, orm, authP
     if (flags.requiresVue && !flags.requiresSvelte && vueDir !== undefined)
         rawImports.push(`import VueExample from '${buildExamplePath(vueDir, 'VueExample.vue')}'`);
     const connectorImports = {
-        neon: [`import { Pool } from '@neondatabase/serverless'`],
+        neon: [`import { neon } from '@neondatabase/serverless'`],
         planetscale: [`import { Client } from '@planetscale/database'`],
         turso: [`import { createClient } from '@libsql/client'`]
     };
     const dialectImports = {
-        neon: [`import { drizzle } from 'drizzle-orm/neon-serverless'`],
+        neon: [`import { drizzle } from 'drizzle-orm/neon-http'`],
         planetscale: [
             `import { drizzle } from 'drizzle-orm/planetscale-serverless'`
         ],
@@ -58,11 +58,8 @@ export const generateImportsBlock = ({ backendDirectory, deps, flags, orm, authP
             ...(databaseEngine === 'sqlite' && !isRemoteHost
                 ? []
                 : [`import { getEnv } from '@absolutejs/absolute'`]),
-            ...(authProvider === 'absoluteAuth'
-                ? [
-                    `import { schema } from '../../db/schema'`,
-                    `import { User } from '../types/databaseTypes'`
-                ]
+            ...(authOption === 'abs'
+                ? [`import { schema } from '../../db/schema'`]
                 : [`import { schema } from '../../db/schema'`])
         ]
     };
@@ -171,13 +168,9 @@ export const generateImportsBlock = ({ backendDirectory, deps, flags, orm, authP
     if (noOrm && hasDatabase && noOrmImports[databaseEngine]) {
         rawImports.push(...noOrmImports[databaseEngine]);
     }
-    if (authProvider === 'absoluteAuth')
-        rawImports.push(`import { absoluteAuth, instantiateUserSession } from '@absolutejs/auth'`, ...(hasDatabase
-            ? [
-                `import { createUser, getUser } from './handlers/userHandlers'`
-            ]
-            : []));
-    if (hasDatabase && (authProvider === undefined || authProvider === 'none'))
+    if (authOption === 'abs')
+        rawImports.push(`import { absoluteAuthConfig } from './utils/absoluteAuthConfig'`, `import { t } from 'elysia'`, `import { authProviderOption, providers, userSessionIdTypebox, getStatus } from '@absolutejs/auth'`);
+    if (hasDatabase && (authOption === undefined || authOption === 'none'))
         rawImports.push(`import { getCountHistory, createCountHistory } from './handlers/countHistoryHandlers'`, `import { t } from 'elysia'`);
     if (flags.requiresVue && flags.requiresSvelte) {
         const utilsDir = join(backendDirectory, 'utils');

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

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

package/dist/generators/project/generateRoutesBlock.js

@@ -1,73 +1,84 @@
 import { isFrontend } from '../../typeGuards';
-export const generateRoutesBlock = ({ flags, frontendDirectories, authProvider, buildDirectory }) => {
+export const generateRoutesBlock = ({ flags, frontendDirectories, authOption, buildDirectory }) => {
     const routes = [];
+    const wrap = (handlerCall) => authOption === 'abs'
+        ? `async ({ cookie: { auth_provider, user_session_id }, store: { session }, status }) => {
+    const { user, error } = await getStatus(session, user_session_id);
+
+    if (error) {
+      return status(error.code, error.message);
+    }
+
+    const providerConfiguration =
+      auth_provider.value && providers[auth_provider.value];
+
+    return ${handlerCall};
+  }`
+        : `() => ${handlerCall}`;
     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')
+        if (frontend === 'react') {
+            const reactProps = authOption === 'abs'
+                ? `{ initialCount: 0, cssPath: asset(manifest, 'ReactExampleCSS'), user, providerConfiguration }`
+                : `{ initialCount: 0, cssPath: asset(manifest, 'ReactExampleCSS') }`;
             return `handleReactPageRequest(
-        ReactExample,
-        asset(manifest, 'ReactExampleIndex'),
-        { initialCount: 0, cssPath: asset(manifest, 'ReactExampleCSS') }
-      )`;
+    ReactExample,
+    asset(manifest, 'ReactExampleIndex'),
+    ${reactProps}
+  )`;
+        }
         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 }
-        )`;
+    SvelteExample,
+    asset(manifest, 'SvelteExample'),
+    asset(manifest, 'SvelteExampleIndex'),
+    { initialCount: 0, cssPath: asset(manifest, 'SvelteExampleCSS') }
+  )`;
+        if (frontend === 'vue') {
+            const vueComponent = flags.requiresSvelte
+                ? 'vueImports.VueExample'
+                : 'VueExample';
+            return `handleVuePageRequest(
+    ${vueComponent},
+    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 (!handlerCall)
+            return;
+        const handler = wrap(handlerCall);
+        if (entryIndex === 0) {
+            routes.push(`.get('/', ${handler})`);
+        }
         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)`);
+            routes.push(`.get('/htmx', ${handler})`);
+            routes.push(`.post('/htmx/reset', ({ resetScopedStore }) => resetScopedStore())`, `.get('/htmx/count', ({ scopedStore }) => scopedStore.count)`, `.post('/htmx/increment', ({ scopedStore }) => ++scopedStore.count)`);
         }
         else {
-            routes.push(`.get('/${frontend}', () => ${handlerCall})`);
+            routes.push(`.get('/${frontend}', ${handler})`);
         }
     });
-    if (authProvider === undefined || authProvider === 'none') {
+    if (authOption === undefined || authOption === 'none') {
         routes.push(`.get('/count/:uid', ({ params: { uid } }) => getCountHistory(db, uid), {
-    params: t.Object({
-      uid: t.Number()
-    })
+    params: t.Object({ uid: t.Number() })
   })`, `.post('/count', ({ body: { count } }) => createCountHistory(db, count), {
-    body: t.Object({
-      count: t.Number()
-    })
+    body: t.Object({ count: t.Number() })
   })`);
     }
     return routes.join('\n  ');

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

@@ -1,6 +1,6 @@
 import type { CreateConfiguration } from '../../types';
-type CreateServerFileProps = Pick<CreateConfiguration, 'tailwind' | 'authProvider' | 'databaseEngine' | 'plugins' | 'buildDirectory' | 'databaseHost' | 'orm' | 'assetsDirectory' | 'frontendDirectories'> & {
+type CreateServerFileProps = Pick<CreateConfiguration, 'tailwind' | 'authOption' | 'databaseEngine' | 'plugins' | 'buildDirectory' | 'databaseHost' | 'orm' | 'assetsDirectory' | 'frontendDirectories'> & {
     backendDirectory: string;
 };
-export declare const generateServerFile: ({ tailwind, authProvider, plugins, buildDirectory, databaseEngine, databaseHost, orm, assetsDirectory, frontendDirectories, backendDirectory }: CreateServerFileProps) => void;
+export declare const generateServerFile: ({ tailwind, authOption, plugins, buildDirectory, databaseEngine, databaseHost, orm, assetsDirectory, frontendDirectories, backendDirectory }: CreateServerFileProps) => void;
 export {};

package/dist/generators/project/generateServer.js

@@ -1,4 +1,4 @@
-import { writeFileSync, mkdirSync } from 'fs';
+import { writeFileSync } from 'fs';
 import { join } from 'path';
 import { collectDependencies } from './collectDependencies';
 import { computeFlags } from './computeFlags';
@@ -6,13 +6,12 @@ import { generateBuildBlock } from './generateBuildBlock';
 import { generateDBBlock } from './generateDBBlock';
 import { generateImportsBlock } from './generateImportsBlock';
 import { generateRoutesBlock } from './generateRoutesBlock';
-import { generateUseBlock } from './generateUseBlock';
-export const generateServerFile = ({ tailwind, authProvider, plugins, buildDirectory, databaseEngine, databaseHost, orm, assetsDirectory, frontendDirectories, backendDirectory }) => {
+export const generateServerFile = ({ tailwind, authOption, plugins, buildDirectory, databaseEngine, databaseHost, orm, assetsDirectory, frontendDirectories, backendDirectory }) => {
     const serverFilePath = join(backendDirectory, 'server.ts');
     const flags = computeFlags(frontendDirectories);
-    const deps = collectDependencies({ authProvider, flags, plugins });
+    const deps = collectDependencies({ authOption, flags, plugins });
     const importsBlock = generateImportsBlock({
-        authProvider,
+        authOption,
         backendDirectory,
         databaseEngine,
         databaseHost,
@@ -31,13 +30,30 @@ export const generateServerFile = ({ tailwind, authProvider, plugins, buildDirec
     if (databaseEngine && databaseEngine !== 'none') {
         dbBlock = generateDBBlock({ databaseEngine, databaseHost, orm });
     }
-    const useBlock = generateUseBlock({
-        databaseEngine,
-        deps,
-        orm
-    });
+    const useBlock = deps
+        .flatMap((dependency) => dependency.imports ?? [])
+        .filter((pluginImport) => pluginImport.isPlugin)
+        .map((pluginImport) => {
+        if (pluginImport.packageName === 'absoluteAuth') {
+            return `.use(absoluteAuth(absoluteAuthConfig(db)))`;
+        }
+        if (pluginImport.config === undefined) {
+            return `.use(${pluginImport.packageName})`;
+        }
+        if (pluginImport.config === null) {
+            return `.use(${pluginImport.packageName}())`;
+        }
+        return `.use(${pluginImport.packageName}(${JSON.stringify(pluginImport.config)}))`;
+    })
+        .join('\n');
+    const guardBlock = `.guard({
+			cookie: t.Cookie({
+				auth_provider: t.Optional(authProviderOption),
+				user_session_id: userSessionIdTypebox
+			})
+		})`;
     const routesBlock = generateRoutesBlock({
-        authProvider,
+        authOption,
         buildDirectory,
         flags,
         frontendDirectories
@@ -48,12 +64,12 @@ ${manifestBlock}
 ${dbBlock}
 new Elysia()
 ${useBlock}
+${authOption === 'abs' ? guardBlock : ''}
   ${routesBlock}
   .on('error', err => {
     const { request } = err
     console.error(\`Server error on \${request.method} \${request.url}: \${err.message}\`)
   });
 `;
-    mkdirSync(backendDirectory, { recursive: true });
     writeFileSync(serverFilePath, content);
 };

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

@@ -0,0 +1,6 @@
+import { CreateConfiguration } from '../../types';
+type ScaffoldBackendProps = Pick<CreateConfiguration, 'assetsDirectory' | 'absProviders' | 'authOption' | 'buildDirectory' | 'databaseEngine' | 'databaseHost' | 'frontendDirectories' | 'orm' | 'plugins' | 'tailwind'> & {
+    backendDirectory: string;
+};
+export declare const scaffoldBackend: ({ assetsDirectory, authOption, absProviders, backendDirectory, buildDirectory, databaseEngine, databaseHost, frontendDirectories, orm, plugins, tailwind }: ScaffoldBackendProps) => void;
+export {};

package/dist/generators/project/scaffoldBackend.js

@@ -0,0 +1,23 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { generateAbsoluteAuthConfig } from './generateAbsoluteAuthConfig';
+import { generateServerFile } from './generateServer';
+export const scaffoldBackend = ({ assetsDirectory, authOption, absProviders, backendDirectory, buildDirectory, databaseEngine, databaseHost, frontendDirectories, orm, plugins, tailwind }) => {
+    generateServerFile({
+        assetsDirectory,
+        authOption,
+        backendDirectory,
+        buildDirectory,
+        databaseEngine,
+        databaseHost,
+        frontendDirectories,
+        orm,
+        plugins,
+        tailwind
+    });
+    if (authOption === 'abs') {
+        mkdirSync(join(backendDirectory, 'utils'), { recursive: true });
+        const absoluteAuthConfig = generateAbsoluteAuthConfig(absProviders);
+        writeFileSync(join(backendDirectory, 'utils', 'absoluteAuthConfig.ts'), absoluteAuthConfig, 'utf-8');
+    }
+};

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

@@ -1,8 +1,8 @@
 import type { CreateConfiguration } from '../../types';
-type ScaffoldFrontendsProps = Pick<CreateConfiguration, 'useHTMLScripts' | 'frontendDirectories' | 'frontends'> & {
+type ScaffoldFrontendsProps = Pick<CreateConfiguration, 'useHTMLScripts' | 'frontendDirectories' | 'assetsDirectory' | 'frontends' | 'authOption' | 'absProviders'> & {
     frontendDirectory: string;
     templatesDirectory: string;
     projectAssetsDirectory: string;
 };
-export declare const scaffoldFrontends: ({ frontendDirectory, templatesDirectory, projectAssetsDirectory, useHTMLScripts, frontendDirectories, frontends }: ScaffoldFrontendsProps) => void;
+export declare const scaffoldFrontends: ({ frontendDirectory, assetsDirectory, absProviders, authOption, templatesDirectory, projectAssetsDirectory, useHTMLScripts, frontendDirectories, frontends }: ScaffoldFrontendsProps) => void;
 export {};