create-absolutejs 0.15.3 → 0.15.5

package/dist/data.js

@@ -7,7 +7,7 @@ export const absoluteAuthPlugin = {
                 providersConfiguration: {}
             },
             isPlugin: true,
-            packageName: 'absoluteAuth'
+            packageName: 'auth'
         }
     ],
     latestVersion: versions['@absolutejs/auth'],

package/dist/generators/configurations/generatePackageJson.js

@@ -134,6 +134,9 @@ export const createPackageJson = async ({ agentic, projectName, authOption, plug
     const dependencies = {};
     const devDependencies = {};
     devDependencies['typescript'] = resolveVersion('typescript', versions['typescript']);
+    /* Every scaffolded project runs on Bun, and the local database drivers type
+       against its built-in modules (`bun:sqlite`, `SQL` from `bun`). */
+    devDependencies['@types/bun'] = resolveVersion('@types/bun', versions['@types/bun']);
     for (const p of defaultPlugins) {
         dependencies[p.value] = resolveVersion(p.value, p.latestVersion);
     }
@@ -289,6 +292,8 @@ export const createPackageJson = async ({ agentic, projectName, authOption, plug
     if (orm === 'drizzle') {
         scripts['db:studio'] = 'drizzle-kit studio';
         scripts['db:push'] = 'drizzle-kit push';
+        /* `drizzle.config.ts` imports it and the scripts above shell out to it. */
+        devDependencies['drizzle-kit'] = resolveVersion('drizzle-kit', versions['drizzle-kit']);
     }
     const packageJson = {
         dependencies,

package/dist/generators/db/generateDatabaseTypes.js

@@ -163,7 +163,7 @@ export const generateDatabaseTypes = ({ databaseEngine, databaseHost, authOption
     }
     const schemaImport = authOption === 'abs'
         ? `import { users, schema } from '../../db/schema';`
-        : `import { countHistory } from '../../db/schema';`;
+        : `import { countHistory, schema } from '../../db/schema';`;
     const extraTypes = authOption === 'abs'
         ? `export type User = typeof users.$inferSelect;
 export type NewUser = typeof users.$inferInsert;`

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

@@ -6,122 +6,98 @@ type QueryOperations = {
 };
 declare const driverConfigurations: {
     readonly 'cockroachdb:sql:local': {
-        readonly dbType: "SQL";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'gel:drizzle:local': {
-        readonly dbType: "GelJsDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'\n";
         readonly queries: QueryOperations;
     };
     readonly 'gel:sql:local': {
-        readonly dbType: "Client";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mariadb:drizzle:local': {
-        readonly dbType: "MySql2Database<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'mariadb:sql:local': {
-        readonly dbType: "SQL";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mongodb:sql:local': {
-        readonly dbType: "Db";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mssql:drizzle:local': {
-        readonly dbType: "NodeMssqlDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'mssql:sql:local': {
-        readonly dbType: "ConnectionPool";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:drizzle:local': {
-        readonly dbType: "MySql2Database<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:drizzle:planetscale': {
-        readonly dbType: "PlanetScaleDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:sql:local': {
-        readonly dbType: "SQL";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'mysql:sql:planetscale': {
-        readonly dbType: "Client";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:drizzle:local': {
-        readonly dbType: "BunSQLDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:drizzle:neon': {
-        readonly dbType: "NeonDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:drizzle:planetscale': {
-        readonly dbType: "NodePgDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:sql:local': {
-        readonly dbType: "SQL";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:sql:neon': {
-        readonly dbType: "Pool";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'postgresql:sql:planetscale': {
-        readonly dbType: "Pool";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'singlestore:drizzle:local': {
-        readonly dbType: "SingleStoreDriverDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'singlestore:sql:local': {
-        readonly dbType: "Pool";
         readonly importLines: "import { RowDataPacket } from 'mysql2/promise'\n";
         readonly queries: QueryOperations;
     };
     readonly 'sqlite:drizzle:local': {
-        readonly dbType: "BunSQLiteDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'sqlite:drizzle:turso': {
-        readonly dbType: "LibSQLDatabase<SchemaType>";
         readonly importLines: "import { eq } from 'drizzle-orm'\nimport { schema } from '../../../db/schema'";
         readonly queries: QueryOperations;
     };
     readonly 'sqlite:sql:local': {
-        readonly dbType: "Database";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };
     readonly 'sqlite:sql:turso': {
-        readonly dbType: "Client";
         readonly importLines: "";
         readonly queries: QueryOperations;
     };

package/dist/generators/db/handlerTemplates.js

@@ -1,22 +1,38 @@
-const buildSqlAuthTemplate = ({ importLines, queries }) => `
-import { DatabaseType, NewUser } from '../../types/databaseTypes';
+const buildSqlAuthTemplate = ({ importLines, queries, rowsAreTyped }) => `
+import { DatabaseType, NewUser${rowsAreTyped ? '' : ', User'} } from '../../types/databaseTypes';
 ${importLines}
 
-export const getUser = async (db: DatabaseType, authSub: string) => {
+${rowsAreTyped
+    ? `export const getUser = async (db: DatabaseType, authSub: string) => {
+	${queries.selectUser}
+};`
+    : `const selectUserRow = async (db: DatabaseType, authSub: string) => {
 	${queries.selectUser}
 };
 
+/* The driver returns the row untyped, so it is asserted to the shape the query
+   above selects. */
+export const getUser = async (
+	db: DatabaseType,
+	authSub: string
+): Promise<User | null> =>
+	((await selectUserRow(db, authSub)) as User | null) ?? null;`}
+
 export const createUser = async (db: DatabaseType, newUserData: NewUser) => {
 	const { auth_sub: authSub, metadata: userIdentity } = newUserData;
 	${queries.insertUser}
 }`;
-const buildSqlCountTemplate = ({ importLines, dbType, queries }) => `
+/* Takes `db` as the `DatabaseType` alias rather than naming the driver type
+   inline, matching the auth template — the driver type is only ever spelled out
+   in types/databaseTypes, so it does not need importing at every call site. */
+const buildSqlCountTemplate = ({ importLines, queries }) => `
+import { DatabaseType } from '../../types/databaseTypes';
 ${importLines}
-export const getCountHistory = async (db: ${dbType}, uid: number) => {
+export const getCountHistory = async (db: DatabaseType, uid: number) => {
   ${queries.selectHistory}
 }
 
-export const createCountHistory = async (db: ${dbType}, count: number) => {
+export const createCountHistory = async (db: DatabaseType, count: number) => {
   ${queries.insertHistory}
 }
 `;
@@ -322,135 +338,111 @@ const mysqlPlanetScaleQueryOperations = {
 };
 const driverConfigurations = {
     'cockroachdb:sql:local': {
-        dbType: 'SQL',
         importLines: ``,
         queries: postgresSqlQueryOperations
     },
     'gel:drizzle:local': {
-        dbType: 'GelJsDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'
 `,
         queries: drizzleQueryOperations
     },
     'gel:sql:local': {
-        dbType: 'Client',
         importLines: ``,
         queries: gelClientQueryOperations
     },
     'mariadb:drizzle:local': {
-        dbType: 'MySql2Database<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
     'mariadb:sql:local': {
-        dbType: 'SQL',
         importLines: ``,
         queries: mysqlSqlQueryOperations
     },
     'mongodb:sql:local': {
-        dbType: 'Db',
         importLines: ``,
         queries: mongodbQueryOperations
     },
     'mssql:drizzle:local': {
-        dbType: 'NodeMssqlDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'mssql:sql:local': {
-        dbType: 'ConnectionPool',
         importLines: ``,
         queries: mssqlSqlQueryOperations
     },
     'mysql:drizzle:local': {
-        dbType: 'MySql2Database<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
     'mysql:drizzle:planetscale': {
-        dbType: 'PlanetScaleDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
     'mysql:sql:local': {
-        dbType: 'SQL',
         importLines: ``,
         queries: mysqlSqlQueryOperations
     },
     'mysql:sql:planetscale': {
-        dbType: 'Client',
         importLines: ``,
         queries: mysqlPlanetScaleQueryOperations
     },
     'postgresql:drizzle:local': {
-        dbType: 'BunSQLDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'postgresql:drizzle:neon': {
-        dbType: 'NeonDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'postgresql:drizzle:planetscale': {
-        dbType: 'NodePgDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'postgresql:sql:local': {
-        dbType: 'SQL',
         importLines: ``,
         queries: postgresSqlQueryOperations
     },
     'postgresql:sql:neon': {
-        dbType: 'Pool',
         importLines: ``,
         queries: postgresQueryOperations
     },
     'postgresql:sql:planetscale': {
-        dbType: 'Pool',
         importLines: ``,
         queries: postgresQueryOperations
     },
     'singlestore:drizzle:local': {
-        dbType: 'SingleStoreDriverDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: mysqlDrizzleQueryOperations
     },
     'singlestore:sql:local': {
-        dbType: 'Pool',
         importLines: `import { RowDataPacket } from 'mysql2/promise'
 `,
         queries: singlestoreSqlQueryOperations
     },
     'sqlite:drizzle:local': {
-        dbType: 'BunSQLiteDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'sqlite:drizzle:turso': {
-        dbType: 'LibSQLDatabase<SchemaType>',
         importLines: `import { eq } from 'drizzle-orm'
 import { schema } from '../../../db/schema'`,
         queries: drizzleQueryOperations
     },
     'sqlite:sql:local': {
-        dbType: 'Database',
         importLines: ``,
         queries: bunSqliteQueryOperations
     },
     'sqlite:sql:turso': {
-        dbType: 'Client',
         importLines: ``,
         queries: libsqlQueryOperations
     }
@@ -459,7 +451,10 @@ export const getAuthTemplate = (key) => {
     const configuration = driverConfigurations[key];
     if (!configuration)
         throw new Error(`Unsupported driver configuration: ${key}`);
-    return buildSqlAuthTemplate(configuration);
+    return buildSqlAuthTemplate({
+        ...configuration,
+        rowsAreTyped: key.includes(':drizzle:')
+    });
 };
 export const getCountTemplate = (key) => {
     const configuration = driverConfigurations[key];

package/dist/generators/db/scaffoldDatabase.js

@@ -26,12 +26,12 @@ export const scaffoldDatabase = async ({ projectName, databaseEngine, databaseHo
         usesAuth
     });
     writeFileSync(join(handlerDirectory, handlerFileName), dbHandlers, 'utf-8');
-    // Raw-SQL (no-ORM) auth handlers import `DatabaseType`/`NewUser` from
-    // types/databaseTypes (so do the auth config and the example page), but
-    // the drizzle-backed type module below is only written on the drizzle
-    // path. Generate a self-contained, driver-typed version here so the
-    // non-drizzle auth scaffold actually type-checks and builds.
-    if (usesAuth && orm !== 'drizzle') {
+    // Raw-SQL (no-ORM) handlers import `DatabaseType` (and `NewUser` on the auth
+    // path) from types/databaseTypes (so do the auth config and the example
+    // page), but the drizzle-backed type module below is only written on the
+    // drizzle path. Generate a self-contained, driver-typed version here so the
+    // non-drizzle scaffold actually type-checks and builds.
+    if (orm !== 'drizzle') {
         mkdirSync(typesDirectory, { recursive: true });
         const sqlTypes = generateDatabaseTypes({
             authOption,

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

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

package/dist/generators/project/generateAbsoluteAuthConfig.js

@@ -12,6 +12,15 @@ const defaultProviderConfigurations = {
         searchParams: [['access_type', 'offline']]
     }
 };
+/* Mirrors the `User` shape the raw-SQL path writes into types/databaseTypes, so
+   an auth scaffold without a database resolves the same type from the same
+   module the example page already imports. */
+export const generateSessionUserType = () => `export type User = {
+	auth_sub: string;
+	created_at: Date;
+	metadata: Record<string, unknown>;
+};
+`;
 export const generateAbsoluteAuthConfig = (absProviders, hasDatabase) => {
     const providerConfigs = (absProviders ?? [])
         .map((provider) => {
@@ -45,38 +54,46 @@ ${credentialsLines}
     if (!hasDatabase) {
         return `import { getEnv } from '@absolutejs/absolute';
 import {
-	AbsoluteAuthProps,
-	createInMemoryAuthSessionStore
+	createInMemoryAuthSessionStore,
+	defineAuthConfig
 } from '@absolutejs/auth';
+import { User } from '../../types/databaseTypes';
 
-export const absoluteAuthConfig = (): AbsoluteAuthProps => ({
-	authSessionStore: createInMemoryAuthSessionStore(),
-	providersConfiguration: {
+export const absoluteAuthConfig = () =>
+	defineAuthConfig<User>({
+		authSessionStore: createInMemoryAuthSessionStore(),
+		/* Without a database there is nowhere to persist users, so no user is
+		   ever registered and this resolver has nothing to look a subject up in.
+		   Scaffold with a database to persist users and resolve them here. */
+		getUser: () => null,
+		providersConfiguration: {
 ${providerConfigs}
-	}
-});
+		}
+	});
 `;
     }
     return `import { getEnv } from '@absolutejs/absolute';
 import {
-	AbsoluteAuthProps,
 	createInMemoryAuthSessionStore,
+	defineAuthConfig,
 	extractPropFromIdentity,
-	instantiateUserSession,
-	providers
+	instantiateUserSession
 } from '@absolutejs/auth';
 import { DatabaseType, User } from '../../types/databaseTypes';
 import { createUser, getUser } from '../handlers/userHandlers';
 
-export const absoluteAuthConfig = (
-	db: DatabaseType
-): AbsoluteAuthProps<User> => ({
+export const absoluteAuthConfig = (db: DatabaseType) =>
+	defineAuthConfig<User>({
 	authSessionStore: createInMemoryAuthSessionStore(),
+	getUser: async (sub) => (await getUser(db, sub)) ?? null,
 	providersConfiguration: {
 ${providerConfigs}
 	},
+	/* \`providerConfiguration\` is handed to the callback rather than looked up by
+	   name, so identity extraction also works for custom providers. */
 	onCallbackSuccess: async ({
 		authProvider,
+		providerConfiguration,
 		providerInstance,
 		tokenResponse,
 		unregisteredSession,
@@ -86,6 +103,7 @@ ${providerConfigs}
 	}) =>
 		instantiateUserSession({
 			authProvider,
+			providerConfiguration,
 			providerInstance,
 			session,
 			tokenResponse,
@@ -93,7 +111,6 @@ ${providerConfigs}
 			user_session_id,
 			getUser: async (userIdentity) => {
 				const provider = authProvider.toUpperCase();
-				const providerConfiguration = providers[authProvider];
 
 				const subject = extractPropFromIdentity(
 					userIdentity,
@@ -116,7 +133,6 @@ ${providerConfigs}
 			},
 			onNewUser: async (userIdentity) => {
 				const provider = authProvider.toUpperCase();
-				const providerConfiguration = providers[authProvider];
 
 				const subject = extractPropFromIdentity(
 					userIdentity,

package/dist/generators/project/generateRoutesBlock.js

@@ -10,8 +10,9 @@ export const generateRoutesBlock = ({ databaseEngine, frontendDirectories, authO
       return status(error.code, error.message);
     }
 
-    const providerConfiguration =
-      auth_client.value && providers[auth_client.value as ProviderOption];
+    const providerConfiguration = auth_client.value
+      ? providers[auth_client.value as ProviderOption]
+      : undefined;
 
     return ${handlerCall};
   }`

package/dist/generators/project/generateServer.js

@@ -36,11 +36,8 @@ export const generateServerFile = ({ tailwind, authOption, plugins, buildDirecto
         .filter((pluginImport) => pluginImport.isPlugin &&
         pluginImport.packageName !== 'networking')
         .map((pluginImport) => {
-        if (pluginImport.packageName === 'absoluteAuth') {
-            const hasDatabase = databaseEngine !== undefined && databaseEngine !== 'none';
-            return hasDatabase
-                ? `.use(absoluteAuth(absoluteAuthConfig(db)))`
-                : `.use(absoluteAuth(absoluteAuthConfig()))`;
+        if (pluginImport.packageName === 'auth') {
+            return `.use(authPlugin)`;
         }
         if (pluginImport.config === undefined) {
             return `.use(${pluginImport.packageName})`;
@@ -63,10 +60,16 @@ export const generateServerFile = ({ tailwind, authOption, plugins, buildDirecto
         databaseEngine,
         frontendDirectories
     });
+    const hasDatabase = databaseEngine !== undefined && databaseEngine !== 'none';
+    /* `auth()` is async, so it is hoisted out of the `.use()` chain rather than
+       inlined — Elysia accepts the promise as a plugin. */
+    const authBlock = authOption === 'abs'
+        ? `const authPlugin = auth(absoluteAuthConfig(${hasDatabase ? 'db' : ''}))\n`
+        : '';
     const content = `${importsBlock}
 
 ${manifestBlock}
-${dbBlock ? `${dbBlock}\n` : ''}
+${dbBlock ? `${dbBlock}\n` : ''}${authBlock}
 const server = new Elysia()
 .use(absolutejs)
 ${useBlock}${authOption === 'abs' ? `\n${guardBlock}` : ''}

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

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

package/dist/generators/project/scaffoldBackend.js

@@ -1,8 +1,8 @@
 import { mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { generateAbsoluteAuthConfig } from './generateAbsoluteAuthConfig';
+import { generateAbsoluteAuthConfig, generateSessionUserType } from './generateAbsoluteAuthConfig';
 import { generateServerFile } from './generateServer';
-export const scaffoldBackend = ({ assetsDirectory, authOption, absProviders, backendDirectory, buildDirectory, databaseEngine, databaseHost, frontendDirectories, orm, plugins, publicDirectory, tailwind }) => {
+export const scaffoldBackend = ({ assetsDirectory, authOption, absProviders, backendDirectory, buildDirectory, databaseEngine, databaseHost, frontendDirectories, orm, plugins, publicDirectory, tailwind, typesDirectory }) => {
     generateServerFile({
         assetsDirectory,
         authOption,
@@ -21,5 +21,13 @@ export const scaffoldBackend = ({ assetsDirectory, authOption, absProviders, bac
         const hasDatabase = databaseEngine !== undefined && databaseEngine !== 'none';
         const absoluteAuthConfig = generateAbsoluteAuthConfig(absProviders, hasDatabase);
         writeFileSync(join(backendDirectory, 'utils', 'absoluteAuthConfig.ts'), absoluteAuthConfig, 'utf-8');
+        /* The auth config and the example page both import `User` from
+           types/databaseTypes, which scaffoldDatabase only writes when there is
+           a database. Without one, emit the session user shape on its own so the
+           auth scaffold still type-checks. */
+        if (!hasDatabase) {
+            mkdirSync(typesDirectory, { recursive: true });
+            writeFileSync(join(typesDirectory, 'databaseTypes.ts'), generateSessionUserType(), 'utf-8');
+        }
     }
 };

package/dist/generators/project/scaffoldFrontends.js

@@ -40,6 +40,7 @@ export const scaffoldFrontends = ({ frontendDirectory, assetsDirectory, absProvi
                     absProviders,
                     assetsDirectory,
                     authOption,
+                    directory,
                     editBasePath,
                     frontends,
                     includeExamples,
@@ -56,6 +57,7 @@ export const scaffoldFrontends = ({ frontendDirectory, assetsDirectory, absProvi
                     absProviders,
                     assetsDirectory,
                     authOption,
+                    directory,
                     editBasePath,
                     frontends,
                     includeExamples,
@@ -72,6 +74,7 @@ export const scaffoldFrontends = ({ frontendDirectory, assetsDirectory, absProvi
                     absProviders,
                     assetsDirectory,
                     authOption,
+                    directory,
                     editBasePath,
                     frontends,
                     includeExamples,
@@ -88,6 +91,7 @@ export const scaffoldFrontends = ({ frontendDirectory, assetsDirectory, absProvi
                     absProviders,
                     assetsDirectory,
                     authOption,
+                    directory,
                     editBasePath,
                     frontends,
                     includeExamples,
@@ -104,6 +108,7 @@ export const scaffoldFrontends = ({ frontendDirectory, assetsDirectory, absProvi
                     absProviders,
                     assetsDirectory,
                     authOption,
+                    directory,
                     editBasePath,
                     frontends,
                     includeExamples,
@@ -121,6 +126,7 @@ export const scaffoldFrontends = ({ frontendDirectory, assetsDirectory, absProvi
                     absProviders,
                     assetsDirectory,
                     authOption,
+                    directory,
                     editBasePath,
                     frontends,
                     includeExamples,

package/dist/generators/react/generateReactComponents.d.ts

@@ -2,5 +2,5 @@ import { ProviderOption } from '@absolutejs/auth';
 import { AuthOption, Frontend } from '../../types';
 export declare const generateAppComponent: (frontends: Frontend[], editBasePath: string) => string;
 export declare const generateDropdownComponent: (frontends: Frontend[]) => string;
-export declare const generateReactExamplePage: (authOption: AuthOption, includeExamples: boolean) => string;
+export declare const generateReactExamplePage: (authOption: AuthOption, includeExamples: boolean, reactDirectory: string) => string;
 export declare const generateSignInComponent: (absProviders: ProviderOption[] | undefined) => string;

package/dist/generators/react/generateReactComponents.js

@@ -73,10 +73,14 @@ export const generateDropdownComponent = (frontends) => {
 );
 `;
 };
-export const generateReactExamplePage = (authOption, includeExamples) => {
+/* Pages live at `src/frontend/<reactDirectory>/pages`, but `reactDirectory` is
+   empty when React is the only frontend, which moves the page one level up. */
+const buildDatabaseTypesPath = (reactDirectory) => `${reactDirectory ? '../../../' : '../../'}types/databaseTypes`;
+export const generateReactExamplePage = (authOption, includeExamples, reactDirectory) => {
+    const databaseTypesPath = buildDatabaseTypesPath(reactDirectory);
     if (!includeExamples) {
         const authImports = authOption === 'abs'
-            ? `import type { User } from '../../../types/databaseTypes';\nimport type { ProviderConfiguration } from '@absolutejs/auth';\n`
+            ? `import type { User } from '${databaseTypesPath}';\nimport type { ProviderConfiguration } from '@absolutejs/auth';\n`
             : '';
         const authProps = authOption === 'abs'
             ? '\n\tuser: User | null;\n\tproviderConfiguration: ProviderConfiguration | undefined;'
@@ -146,7 +150,7 @@ export const ReactExample = ({ cssPath }: ReactExampleProps) => (
         : `<Dropdown />`;
     const closing = authOption === 'abs' ? `};` : `);`;
     return `
-${authOption === 'abs' ? `import type { User } from '../../../types/databaseTypes';\nimport { extractPropFromIdentity } from '@absolutejs/auth';\nimport type { ProviderConfiguration } from '@absolutejs/auth';` : ''}
+${authOption === 'abs' ? `import type { User } from '${databaseTypesPath}';\nimport { extractPropFromIdentity } from '@absolutejs/auth';\nimport type { ProviderConfiguration } from '@absolutejs/auth';` : ''}
 import { App } from '../components/App';
 import { Dropdown } from '../components/Dropdown';
 import { Head } from '../components/Head';

package/dist/generators/react/scaffoldReact.d.ts

@@ -1,2 +1,2 @@
 import { ScaffoldFrontendProps } from '../../types';
-export declare const scaffoldReact: ({ authOption, editBasePath, includeExamples, targetDirectory, templatesDirectory, frontends, projectAssetsDirectory, absProviders, stylesIndexesDirectory }: ScaffoldFrontendProps) => void;
+export declare const scaffoldReact: ({ authOption, directory, editBasePath, includeExamples, targetDirectory, templatesDirectory, frontends, projectAssetsDirectory, absProviders, stylesIndexesDirectory }: ScaffoldFrontendProps) => void;

package/dist/generators/react/scaffoldReact.js

@@ -1,20 +1,25 @@
 import { copyFileSync, cpSync, mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { basename, join } from 'path';
 import { generateMarkupCSS } from '../project/generateMarkupCSS';
 import { generateAppComponent, generateDropdownComponent, generateReactExamplePage, generateSignInComponent } from './generateReactComponents';
-export const scaffoldReact = ({ authOption, editBasePath, includeExamples, targetDirectory, templatesDirectory, frontends, projectAssetsDirectory, absProviders, stylesIndexesDirectory }) => {
+export const scaffoldReact = ({ authOption, directory, editBasePath, includeExamples, targetDirectory, templatesDirectory, frontends, projectAssetsDirectory, absProviders, stylesIndexesDirectory }) => {
     if (!includeExamples) {
         mkdirSync(join(targetDirectory, 'components'), { recursive: true });
         copyFileSync(join(templatesDirectory, 'react', 'components', 'Head.tsx'), join(targetDirectory, 'components', 'Head.tsx'));
         mkdirSync(join(targetDirectory, 'pages'), { recursive: true });
-        writeFileSync(join(targetDirectory, 'pages', 'ReactExample.tsx'), generateReactExamplePage(authOption, false), 'utf-8');
+        writeFileSync(join(targetDirectory, 'pages', 'ReactExample.tsx'), generateReactExamplePage(authOption, false, directory), 'utf-8');
         writeFileSync(join(stylesIndexesDirectory, 'react-example.css'), `@import url('../reset.css');`, 'utf-8');
         return;
     }
     mkdirSync(join(projectAssetsDirectory, 'svg'), { recursive: true });
     copyFileSync(join(templatesDirectory, 'assets', 'svg', 'react.svg'), join(projectAssetsDirectory, 'svg', 'react.svg'));
     copyFileSync(join(templatesDirectory, 'assets', 'svg', 'google-logo.svg'), join(projectAssetsDirectory, 'svg', 'google-logo.svg'));
+    /* `OAuthLink` is only rendered by the generated `SignIn` component, and it
+       types its provider against `citra`, which only ships as a transitive
+       dependency of `@absolutejs/auth`. Without Absolute Auth the import cannot
+       resolve, so the component is left out entirely. */
     cpSync(join(templatesDirectory, 'react'), targetDirectory, {
+        filter: (source) => authOption === 'abs' || basename(source) !== 'OAuthLink.tsx',
         recursive: true
     });
     const appComponent = generateAppComponent(frontends, editBasePath);
@@ -25,7 +30,7 @@ export const scaffoldReact = ({ authOption, editBasePath, includeExamples, targe
         const signInComponent = generateSignInComponent(absProviders);
         writeFileSync(join(targetDirectory, 'components', 'SignIn.tsx'), signInComponent, 'utf-8');
     }
-    const pageComponent = generateReactExamplePage(authOption, true);
+    const pageComponent = generateReactExamplePage(authOption, true, directory);
     mkdirSync(join(targetDirectory, 'pages'), { recursive: true });
     writeFileSync(join(targetDirectory, 'pages', 'ReactExample.tsx'), pageComponent, 'utf-8');
     const cssOutputFile = join(stylesIndexesDirectory, 'react-example.css');

package/dist/scaffold.js

@@ -53,7 +53,8 @@ export const scaffold = async ({ response: { agentic, projectName, codeQualityTo
         orm,
         plugins,
         publicDirectory: 'public',
-        tailwind
+        tailwind,
+        typesDirectory
     });
     if (agentic)
         scaffoldAgentic({ backendDirectory, projectName });

package/dist/types.d.ts

@@ -4,6 +4,9 @@ export type ScaffoldFrontendProps = {
     absProviders: ProviderOption[] | undefined;
     assetsDirectory: string;
     authOption: AuthOption;
+    /** Frontend's directory under `src/frontend`; empty when it is the only
+     *  frontend and no directory was configured for it. */
+    directory: string;
     editBasePath: string;
     includeExamples: boolean;
     targetDirectory: string;

package/dist/versions.d.ts

@@ -4,7 +4,7 @@
  * Run `bun run check-versions` to compare against latest npm versions.
  */
 export declare const versions: {
-    readonly '@absolutejs/absolute': "0.19.0-beta.1099";
+    readonly '@absolutejs/absolute': "0.19.0-beta.1108";
     readonly '@absolutejs/a2a': "0.1.0";
     readonly '@absolutejs/agency': "0.4.0";
     readonly '@absolutejs/agent-conformance': "0.3.0";
@@ -42,11 +42,13 @@ export declare const versions: {
     readonly '@planetscale/database': "1.19.0";
     readonly '@stylistic/eslint-plugin': "5.9.0";
     readonly '@tailwindcss/cli': "4.2.0";
+    readonly '@types/bun': "1.3.14";
     readonly '@types/mssql': "9.1.9";
     readonly '@types/pg': "8.16.0";
     readonly '@types/react': "19.2.14";
     readonly '@typescript-eslint/parser': "8.56.0";
     readonly autoprefixer: "10.4.24";
+    readonly 'drizzle-kit': "0.31.10";
     readonly 'drizzle-orm': "0.45.1";
     readonly elysia: "1.4.28";
     readonly 'elysia-rate-limit': "4.5.0";

package/dist/versions.js

@@ -5,7 +5,7 @@
  */
 export const versions = {
     /* ── Core ─────────────────────────────────────────────── */
-    '@absolutejs/absolute': '0.19.0-beta.1099',
+    '@absolutejs/absolute': '0.19.0-beta.1108',
     '@absolutejs/a2a': '0.1.0',
     '@absolutejs/agency': '0.4.0',
     '@absolutejs/agent-conformance': '0.3.0',
@@ -48,6 +48,8 @@ export const versions = {
     '@stylistic/eslint-plugin': '5.9.0',
     /* ── Tailwind CSS ─────────────────────────────────────── */
     '@tailwindcss/cli': '4.2.0',
+    /* ── Bun ──────────────────────────────────────────────── */
+    '@types/bun': '1.3.14',
     /* ── Database Drivers ─────────────────────────────────── */
     '@types/mssql': '9.1.9',
     '@types/pg': '8.16.0',
@@ -56,6 +58,7 @@ export const versions = {
     '@typescript-eslint/parser': '8.56.0',
     autoprefixer: '10.4.24',
     /* ── ORM ──────────────────────────────────────────────── */
+    'drizzle-kit': '0.31.10',
     'drizzle-orm': '0.45.1',
     elysia: '1.4.28',
     'elysia-rate-limit': '4.5.0',

package/package.json

@@ -10,7 +10,7 @@
 	},
 	"description": "A CLI tool to create a new AbsoluteJS project",
 	"devDependencies": {
-		"@absolutejs/absolute": "0.19.0-beta.1081",
+		"@absolutejs/absolute": "0.19.0-beta.1108",
 		"@eslint/compat": "2.0.2",
 		"@stylistic/eslint-plugin": "5.9.0",
 		"@types/bun": "1.3.8",
@@ -54,5 +54,5 @@
 		"typecheck": "bun run tsc --noEmit"
 	},
 	"type": "module",
-	"version": "0.15.3"
+	"version": "0.15.5"
 }