@baseplate-dev/plugin-auth 0.6.17 → 0.6.19

package/dist/local-auth/core/generators/react-session/templates/src/services/user-session-client.ts

@@ -1,122 +1,188 @@
 // @ts-nocheck
 
+import type { SessionData } from '%authHooksImports';
+import type { AuthRole } from '%graphqlImports';
+
 import { getSafeLocalStorage } from '%reactUtilsImports';
 
 /**
- * Callback function for user ID change events
+ * Callback function for session change events
  */
-type UserIdChangeCallback = (userId: string | undefined) => void;
+type SessionChangeCallback = () => void;
 
-/**
- * User session client for managing session persistence using localStorage
- * Handles session state persistence and cross-tab synchronization
- */
-export class UserSessionClient {
-  private static readonly USER_ID_STORAGE_KEY = 'APP_USER_ID';
-  private readonly storage = getSafeLocalStorage();
-  private readonly callbacks = new Set<UserIdChangeCallback>();
-  private cleanupListener?: () => void;
-
-  constructor() {
-    // Initialize storage listener for cross-tab synchronization
-    this.setupStorageListener();
-  }
+const USER_ID_STORAGE_KEY = 'APP_USER_ID';
+
+const PUBLIC_SESSION: SessionData = {
+  userId: undefined,
+  isAuthenticated: false,
+  roles: ['public'],
+  isPending: false,
+};
+
+function areSessionsEqual(a: SessionData, b: SessionData): boolean {
+  return (
+    a.userId === b.userId &&
+    a.isPending === b.isPending &&
+    a.roles.length === b.roles.length &&
+    a.roles.every((role, idx) => role === b.roles[idx])
+  );
+}
 
+export interface UserSessionClient {
   /**
-   * Sign in a user with the given user ID
+   * Get the current session, or `undefined` if it is not known yet.
+   *
+   * Returns a stable reference that only changes when the session itself changes,
+   * so it is safe to use as a `useSyncExternalStore` snapshot.
+   */
+  getSession: () => SessionData | undefined;
+  /**
+   * Subscribe to session changes
+   * @param callback - Function to call when the session changes
+   * @returns Cleanup function to unsubscribe
+   */
+  subscribe: (callback: SessionChangeCallback) => () => void;
+  /**
+   * Sign in a user with a session the server has already returned
    * @param userId - The user ID to sign in
+   * @param roles - The roles the server issued alongside the session
    */
-  signIn(userId: string): void {
-    const existingUserId = this.getUserId();
-    this.setUserId(userId);
-    if (existingUserId !== userId) {
-      this.notifyCallbacks();
-    }
-  }
-
+  signIn: (userId: string, roles: AuthRole[]) => void;
   /**
    * Sign out the current user
    */
-  signOut(): void {
-    const existingUserId = this.getUserId();
-    this.setUserId(null);
-    if (existingUserId) {
-      this.notifyCallbacks();
-    }
-  }
-
+  signOut: () => void;
   /**
-   * Subscribe to user ID changes
-   * @param callback - Function to call when user ID changes
-   * @returns Cleanup function to unsubscribe
+   * Apply the session reported by the server, confirming or replacing whatever was
+   * published locally
+   * @param session - The session from the server, or undefined if signed out
    */
-  onUserIdChange(callback: UserIdChangeCallback): () => void {
-    this.callbacks.add(callback);
-    return () => {
-      this.callbacks.delete(callback);
-    };
-  }
-
+  setServerSession: (
+    session: { userId: string; roles: AuthRole[] } | undefined,
+  ) => void;
   /**
-   * Clean up resources when the client is no longer needed
+   * Get the user ID persisted in storage, which may not be confirmed yet
+   * @returns User ID or undefined if not signed in
    */
-  destroy(): void {
-    this.cleanupListener?.();
-    this.callbacks.clear();
-  }
-
+  getPersistedUserId: () => string | undefined;
   /**
-   * Get the current user ID from storage
-   * @returns User ID or null if not authenticated
+   * Clean up resources when the client is no longer needed
    */
-  getUserId(): string | undefined {
-    return (
-      this.storage.getItem(UserSessionClient.USER_ID_STORAGE_KEY) ?? undefined
-    );
+  destroy: () => void;
+}
+
+/**
+ * Creates the client-side source of truth for the current user session.
+ *
+ * The session is published synchronously when it is known locally (sign in / sign
+ * out) and refined asynchronously when the server confirms it. It is deliberately
+ * not derived from the Apollo cache, since signing in clears that cache.
+ *
+ * The user ID is persisted to localStorage for cold starts and cross-tab
+ * synchronisation. Roles are never persisted — they are only ever trusted from the
+ * server, and are enforced there regardless.
+ */
+export function createUserSessionClient(): UserSessionClient {
+  const storage = getSafeLocalStorage();
+  const callbacks = new Set<SessionChangeCallback>();
+
+  function getPersistedUserId(): string | undefined {
+    return storage.getItem(USER_ID_STORAGE_KEY) ?? undefined;
   }
 
-  /**
-   * Set the user ID in storage
-   * @param userId - User ID to store, or null to clear
-   */
-  private setUserId(userId: string | null): void {
-    const currentUserId = this.getUserId();
-    const userIdChanged = userId !== currentUserId;
+  // A persisted user ID means we expect a session, so hold off publishing until the
+  // server confirms it. With no persisted user ID there is nothing to wait for and
+  // the public session can be published immediately.
+  let session: SessionData | undefined = getPersistedUserId()
+    ? undefined
+    : PUBLIC_SESSION;
+
+  function publish(newSession: SessionData): void {
+    if (session && areSessionsEqual(session, newSession)) {
+      return;
+    }
+    session = newSession;
+    for (const callback of callbacks) {
+      callback();
+    }
+  }
 
-    if (!userIdChanged) {
+  function persistUserId(userId: string | undefined): void {
+    if (userId === getPersistedUserId()) {
       return;
     }
 
     if (userId) {
-      this.storage.setItem(UserSessionClient.USER_ID_STORAGE_KEY, userId);
+      storage.setItem(USER_ID_STORAGE_KEY, userId);
     } else {
-      this.storage.removeItem(UserSessionClient.USER_ID_STORAGE_KEY);
+      storage.removeItem(USER_ID_STORAGE_KEY);
     }
   }
 
-  /**
-   * Set up storage listener for cross-tab synchronization
-   */
-  private setupStorageListener(): void {
-    this.cleanupListener = this.storage.addEventListener((key) => {
-      if (key === UserSessionClient.USER_ID_STORAGE_KEY) {
-        this.notifyCallbacks();
-      }
+  function signIn(userId: string, roles: AuthRole[]): void {
+    publish({
+      userId,
+      isAuthenticated: true,
+      roles,
+      isPending: false,
     });
+    persistUserId(userId);
   }
 
-  /**
-   * Notify all registered callbacks of session changes
-   */
-  private notifyCallbacks(): void {
-    const userId = this.getUserId();
-    for (const callback of this.callbacks) {
-      callback(userId);
-    }
+  function signOut(): void {
+    publish(PUBLIC_SESSION);
+    persistUserId(undefined);
   }
+
+  const cleanupListener = storage.addEventListener((key, newValue) => {
+    if (key !== USER_ID_STORAGE_KEY) {
+      return;
+    }
+
+    const userId = newValue ?? undefined;
+    // Writes from this tab publish the session themselves before persisting it, so
+    // anything already matching is our own write echoing back. A session that is
+    // not known yet never matches, since no session has been published.
+    if (session && userId === session.userId) {
+      return;
+    }
+
+    // Another tab changed the identity. Publish it right away so we never render
+    // one user's identity with another's data, with roles marked pending until the
+    // server confirms them.
+    publish(
+      userId
+        ? { userId, isAuthenticated: true, roles: [], isPending: true }
+        : PUBLIC_SESSION,
+    );
+  });
+
+  return {
+    getSession: () => session,
+    subscribe(callback) {
+      callbacks.add(callback);
+      return () => {
+        callbacks.delete(callback);
+      };
+    },
+    signIn,
+    signOut,
+    setServerSession(serverSession) {
+      if (serverSession) {
+        signIn(serverSession.userId, serverSession.roles);
+      } else {
+        signOut();
+      }
+    },
+    getPersistedUserId,
+    destroy() {
+      cleanupListener();
+      callbacks.clear();
+    },
+  };
 }
 
 /**
  * Global user session client instance
  */
-export const userSessionClient = new UserSessionClient();
+export const userSessionClient = createUserSessionClient();

package/dist/local-auth/core/generators/seed-initial-user/generated/index.d.ts

@@ -14,7 +14,6 @@ export declare const LOCAL_AUTH_CORE_SEED_INITIAL_USER_GENERATED: {
         }, {
             authEmailPasswordImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                 authenticateUserWithEmailAndPassword: {};
-                cleanupExpiredPasswordResetTokens: {};
                 completePasswordReset: {};
                 createUserWithEmailAndPassword: {};
                 PASSWORD_MAX_LENGTH: {};
@@ -54,7 +53,6 @@ export declare const LOCAL_AUTH_CORE_SEED_INITIAL_USER_GENERATED: {
         }, {
             authEmailPasswordImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                 authenticateUserWithEmailAndPassword: {};
-                cleanupExpiredPasswordResetTokens: {};
                 completePasswordReset: {};
                 createUserWithEmailAndPassword: {};
                 PASSWORD_MAX_LENGTH: {};

package/dist/local-auth/core/generators/seed-initial-user/generated/template-renderers.d.ts

@@ -13,7 +13,6 @@ export declare const LOCAL_AUTH_CORE_SEED_INITIAL_USER_RENDERERS: {
     }, {
         authEmailPasswordImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
             authenticateUserWithEmailAndPassword: {};
-            cleanupExpiredPasswordResetTokens: {};
             completePasswordReset: {};
             createUserWithEmailAndPassword: {};
             PASSWORD_MAX_LENGTH: {};

package/dist/local-auth/core/generators/seed-initial-user/generated/typed-templates.d.ts

@@ -4,7 +4,6 @@ export declare const LOCAL_AUTH_CORE_SEED_INITIAL_USER_TEMPLATES: {
     }, {
         authEmailPasswordImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
             authenticateUserWithEmailAndPassword: {};
-            cleanupExpiredPasswordResetTokens: {};
             completePasswordReset: {};
             createUserWithEmailAndPassword: {};
             PASSWORD_MAX_LENGTH: {};

package/dist/local-auth/core/generators/seed-initial-user/seed-initial-user.generator.d.ts

@@ -14,7 +14,6 @@ export declare const seedInitialUserGenerator: import("@baseplate-dev/sync").Gen
     }, {
         authEmailPasswordImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
             authenticateUserWithEmailAndPassword: {};
-            cleanupExpiredPasswordResetTokens: {};
             completePasswordReset: {};
             createUserWithEmailAndPassword: {};
             PASSWORD_MAX_LENGTH: {};

package/dist/local-auth/core/node.js

@@ -1,6 +1,6 @@
 import { appModuleGenerator, passwordHasherServiceGenerator, } from '@baseplate-dev/fastify-generators';
 import { emailTemplateSpec } from '@baseplate-dev/plugin-email';
-import { appCompilerSpec, backendAppEntryType, createPluginModule, PluginUtils, webAppEntryType, } from '@baseplate-dev/project-builder-lib';
+import { appCompilerSpec, backendAppEntryType, createPluginModule, getAppUrls, pluginAppCompiler, PluginUtils, webAppEntryType, } from '@baseplate-dev/project-builder-lib';
 import { getAuthPluginDefinition } from '#src/auth/index.js';
 import { authApolloGenerator } from './generators/auth-apollo/auth-apollo.generator.js';
 import { authEmailPasswordGenerator } from './generators/auth-email-password/auth-email-password.generator.js';
@@ -9,6 +9,7 @@ import { authHooksGenerator } from './generators/auth-hooks/auth-hooks.generator
 import { authRoutesGenerator } from './generators/auth-routes/auth-routes.generator.js';
 import { authModuleGenerator, reactAuthGenerator, seedInitialUserGenerator, } from './generators/index.js';
 import { reactSessionGenerator } from './generators/react-session/react-session.generator.js';
+import { getLocalAuthWebAppData } from './schema/web-app-schema.js';
 export default createPluginModule({
     name: 'node',
     dependencies: {
@@ -16,8 +17,12 @@ export default createPluginModule({
         emailTemplate: emailTemplateSpec,
     },
     initialize: ({ appCompiler, emailTemplate }, { pluginKey }) => {
-        // Register auth email templates with the transactional lib
-        emailTemplate.generators.push(authEmailTemplatesGenerator({}));
+        // Register auth email templates with the transactional lib. Resolved lazily
+        // so the sign-in code email is only emitted when that flow is enabled.
+        emailTemplate.generators.push(({ projectDefinition }) => {
+            const { emailOtp } = PluginUtils.configByKeyOrThrow(projectDefinition, pluginKey);
+            return authEmailTemplatesGenerator({ emailOtp });
+        });
         // register backend compiler
         appCompiler.compilers.push({
             pluginKey,
@@ -25,11 +30,18 @@ export default createPluginModule({
             compile: ({ projectDefinition, definitionContainer, appCompiler }) => {
                 const localAuthDefinition = PluginUtils.configByKeyOrThrow(projectDefinition, pluginKey);
                 const authDefinition = getAuthPluginDefinition(projectDefinition);
-                // Get web app ports
                 const webApps = projectDefinition.apps.filter((app) => app.type === 'web');
-                const devWebPorts = webApps.map((app) => app.devPort);
-                const devWebDomainPort = devWebPorts[0] ??
-                    projectDefinition.settings.general.portOffset + 30;
+                const { webApps: webAppUrls } = getAppUrls(projectDefinition);
+                const authWebApp = webAppUrls.find((app) => app.isDefault);
+                if (!authWebApp) {
+                    throw new Error('Unable to determine which web app auth emails should link to');
+                }
+                // The register mutation is shared by every web app on this
+                // backend, so it can only be dropped once none of them allow
+                // self-service registration.
+                const disableRegistration = webApps.length > 0 &&
+                    webApps.every((app) => getLocalAuthWebAppData(app, pluginKey)?.disableRegistration ??
+                        false);
                 const additionalAdminRoles = localAuthDefinition.additionalUserAdminRoles.map((role) => definitionContainer.nameFromId(role));
                 // 'admin' is always included since it is now a built-in role guaranteed to exist
                 const adminRoles = [...new Set(['admin', ...additionalAdminRoles])];
@@ -39,7 +51,7 @@ export default createPluginModule({
                     }),
                     authModule: authModuleGenerator({
                         userAdminRoles: adminRoles,
-                        devWebPorts,
+                        emailOtp: localAuthDefinition.emailOtp,
                     }),
                     emailPassword: appModuleGenerator({
                         id: 'email-password',
@@ -47,19 +59,23 @@ export default createPluginModule({
                         children: {
                             module: authEmailPasswordGenerator({
                                 adminRoles,
-                                devWebDomainPort,
+                                webAppName: authWebApp.name,
                                 requireNameOnRegistration: localAuthDefinition.requireNameOnRegistration,
+                                emailOtp: localAuthDefinition.emailOtp,
+                                disableRegistration,
                             }),
                             hasher: passwordHasherServiceGenerator({}),
                         },
                     }),
                 });
             },
-        }, {
+        }, pluginAppCompiler({
             pluginKey,
             appType: webAppEntryType,
-            compile: ({ projectDefinition, appCompiler }) => {
+            compile: ({ projectDefinition, appDefinition, appCompiler }) => {
                 const localAuthDefinition = PluginUtils.configByKeyOrThrow(projectDefinition, pluginKey);
+                const disableRegistration = getLocalAuthWebAppData(appDefinition, pluginKey)
+                    ?.disableRegistration ?? false;
                 appCompiler.addRootChildren({
                     authApollo: authApolloGenerator({}),
                     reactAuth: reactAuthGenerator({}),
@@ -67,10 +83,12 @@ export default createPluginModule({
                     reactSession: reactSessionGenerator({}),
                     authRoutes: authRoutesGenerator({
                         requireNameOnRegistration: localAuthDefinition.requireNameOnRegistration,
+                        emailOtp: localAuthDefinition.emailOtp,
+                        disableRegistration,
                     }),
                 });
             },
-        });
+        }));
     },
 });
 //# sourceMappingURL=node.js.map

package/dist/local-auth/core/schema/migrations.d.ts

@@ -0,0 +1,3 @@
+import type { PluginConfigMigration } from '@baseplate-dev/project-builder-lib';
+export declare const LOCAL_AUTH_PLUGIN_CONFIG_MIGRATIONS: PluginConfigMigration[];
+//# sourceMappingURL=migrations.d.ts.map

package/dist/local-auth/core/schema/migrations.js

@@ -0,0 +1,36 @@
+import { modelScalarFieldEntityType } from '@baseplate-dev/project-builder-lib';
+import { LOCAL_AUTH_MODELS } from '#src/local-auth/constants/model-names.js';
+export const LOCAL_AUTH_PLUGIN_CONFIG_MIGRATIONS = [
+    {
+        name: 'add-auth-verification-attempts',
+        version: 1,
+        // Emailed sign-in codes count failed guesses in a column so the counter can
+        // be incremented in the database. The field is added for every project, not
+        // just those with the flow enabled, because migrations run on a version
+        // bump rather than when the setting is toggled — gating it here would break
+        // anyone who turns the flow on later.
+        migrate: () => ({
+            updateProjectDefinition: (draft) => {
+                const draftDef = draft;
+                const authVerification = draftDef.models?.find((model) => model.name === LOCAL_AUTH_MODELS.authVerification);
+                const fields = authVerification?.model?.fields;
+                // Projects created after this change are seeded with the field already.
+                if (!fields || fields.some((field) => field.name === 'attempts')) {
+                    return;
+                }
+                // Ahead of expiresAt/createdAt, matching the seeded field order so a
+                // migrated definition and a fresh one produce the same schema.
+                const timestampIndex = fields.findIndex((field) => field.name === 'expiresAt');
+                const insertAt = timestampIndex === -1 ? fields.length : timestampIndex;
+                fields.splice(insertAt, 0, {
+                    id: modelScalarFieldEntityType.generateNewId(),
+                    name: 'attempts',
+                    type: 'int',
+                    isOptional: false,
+                    options: { default: '0' },
+                });
+            },
+        }),
+    },
+];
+//# sourceMappingURL=migrations.js.map

package/dist/local-auth/core/schema/models.js

@@ -247,6 +247,14 @@ export function createLocalAuthPartialDefinition(authFeatureName, accountsFeatur
                             type: 'json',
                             isOptional: true,
                         },
+                        // Failed guesses against a short code. Only the emailed-code flow
+                        // uses this; split-token rows leave it at 0, since their verifier
+                        // is random enough that a single miss deletes the record outright.
+                        {
+                            name: 'attempts',
+                            type: 'int',
+                            options: { default: '0' },
+                        },
                         {
                             name: 'expiresAt',
                             type: 'dateTime',

package/dist/local-auth/core/schema/plugin-definition.d.ts

@@ -3,6 +3,7 @@ import { z } from 'zod';
 export declare const createLocalAuthPluginDefinitionSchema: (context: import("@baseplate-dev/project-builder-lib").DefinitionSchemaParserContext) => z.ZodObject<{
     additionalUserAdminRoles: z.ZodPrefault<z.ZodArray<z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>>;
     requireNameOnRegistration: z.ZodDefault<z.ZodBoolean>;
+    emailOtp: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type LocalAuthPluginDefinition = def.InferOutput<typeof createLocalAuthPluginDefinitionSchema>;
 export type LocalAuthPluginDefinitionInput = def.InferInput<typeof createLocalAuthPluginDefinitionSchema>;

package/dist/local-auth/core/schema/plugin-definition.js

@@ -6,5 +6,6 @@ export const createLocalAuthPluginDefinitionSchema = definitionSchema((ctx) => z
         onDelete: 'DELETE',
     })), []),
     requireNameOnRegistration: z.boolean().default(false),
+    emailOtp: z.boolean().default(false),
 }));
 //# sourceMappingURL=plugin-definition.js.map

package/dist/local-auth/core/schema/web-app-schema.d.ts

@@ -0,0 +1,15 @@
+import type { def, WebAppConfigWithPluginData } from '@baseplate-dev/project-builder-lib';
+import z from 'zod';
+/**
+ * Per-app local-auth settings contributed to the web app config via
+ * `webAppSchemaExtensionSpec`, stored under `pluginData[localAuthPluginKey]`.
+ */
+export declare const createLocalAuthWebAppSchema: (context: import("@baseplate-dev/project-builder-lib").DefinitionSchemaParserContext) => z.ZodObject<{
+    disableRegistration: z.ZodPrefault<z.ZodBoolean>;
+}, z.z.core.$strip>;
+export type LocalAuthWebAppData = def.InferOutput<typeof createLocalAuthWebAppSchema>;
+/**
+ * Reads the local-auth per-app settings slice from a web app config.
+ */
+export declare function getLocalAuthWebAppData(webApp: WebAppConfigWithPluginData, pluginKey: string): LocalAuthWebAppData | undefined;
+//# sourceMappingURL=web-app-schema.d.ts.map

package/dist/local-auth/core/schema/web-app-schema.js

@@ -0,0 +1,16 @@
+import { definitionSchema, getWebAppPluginData, } from '@baseplate-dev/project-builder-lib';
+import z from 'zod';
+/**
+ * Per-app local-auth settings contributed to the web app config via
+ * `webAppSchemaExtensionSpec`, stored under `pluginData[localAuthPluginKey]`.
+ */
+export const createLocalAuthWebAppSchema = definitionSchema((ctx) => z.object({
+    disableRegistration: ctx.withDefault(z.boolean(), false),
+}));
+/**
+ * Reads the local-auth per-app settings slice from a web app config.
+ */
+export function getLocalAuthWebAppData(webApp, pluginKey) {
+    return getWebAppPluginData(webApp, pluginKey);
+}
+//# sourceMappingURL=web-app-schema.js.map

package/dist/local-auth/core/web.js

@@ -1,5 +1,7 @@
 import { createPluginModule, FeatureUtils, pluginDefaultsSpec, webConfigSpec, } from '@baseplate-dev/project-builder-lib';
+import { createWebAppSettingsWebConfig, webAppSchemaExtensionWebSpec, } from '@baseplate-dev/project-builder-lib/web';
 import { LocalAuthDefinitionEditor } from './components/local-auth-definition-editor.js';
+import { LocalAuthWebAppSettingsForm } from './components/local-auth-web-app-settings-form.js';
 import { createLocalAuthPartialDefinition } from './schema/models.js';
 import '../../styles.css';
 const AUTH_FEATURE_NAME = 'accounts/auth';
@@ -9,9 +11,14 @@ export default createPluginModule({
     dependencies: {
         webConfig: webConfigSpec,
         pluginDefaults: pluginDefaultsSpec,
+        webAppSchemaExtensionWeb: webAppSchemaExtensionWebSpec,
     },
-    initialize: ({ webConfig, pluginDefaults }, { pluginKey }) => {
+    initialize: ({ webConfig, pluginDefaults, webAppSchemaExtensionWeb }, { pluginKey }) => {
         webConfig.components.set(pluginKey, LocalAuthDefinitionEditor);
+        webAppSchemaExtensionWeb.configs.set(pluginKey, createWebAppSettingsWebConfig({
+            pluginKey,
+            Form: LocalAuthWebAppSettingsForm,
+        }));
         pluginDefaults.builders.set(pluginKey, ({ draft }) => {
             // Idempotent with the parent auth builder, which also ensures these.
             FeatureUtils.ensureFeatureByNameRecursively(draft, AUTH_FEATURE_NAME);

package/dist/placeholder-auth/core/generators/placeholder-auth-hooks/generated/index.d.ts

@@ -1,13 +1,14 @@
 export declare const PLACEHOLDER_AUTH_CORE_PLACEHOLDER_AUTH_HOOKS_GENERATED: {
     imports: {
+        generatorName: string;
         task: import("@baseplate-dev/sync").GeneratorTask<{
             authHooksImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
                 SessionData: {
                     isTypeOnly: true;
                 };
                 useLogOut: {};
-                useRequiredUserId: {};
                 useSession: {};
+                useUserIdOrThrow: {};
                 AuthRole: {
                     isTypeOnly: true;
                 };
@@ -36,10 +37,10 @@ export declare const PLACEHOLDER_AUTH_CORE_PLACEHOLDER_AUTH_HOOKS_GENERATED: {
     templates: {
         hooksGroup: {
             useLogOut: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
-            useRequiredUserId: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, {
+            useSession: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+            useUserIdOrThrow: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, {
                 useSession: {};
             }>;
-            useSession: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
         };
     };
 };

package/dist/placeholder-auth/core/generators/placeholder-auth-hooks/generated/template-paths.d.ts

@@ -1,7 +1,7 @@
 export interface PlaceholderAuthCorePlaceholderAuthHooksPaths {
     useLogOut: string;
-    useRequiredUserId: string;
     useSession: string;
+    useUserIdOrThrow: string;
 }
 export declare const PLACEHOLDER_AUTH_CORE_PLACEHOLDER_AUTH_HOOKS_PATHS: {
     provider: import("@baseplate-dev/sync").ProviderType<PlaceholderAuthCorePlaceholderAuthHooksPaths>;

package/dist/placeholder-auth/core/generators/placeholder-auth-hooks/generated/template-paths.js

@@ -12,8 +12,8 @@ const placeholderAuthCorePlaceholderAuthHooksPathsTask = createGeneratorTask({
             providers: {
                 placeholderAuthCorePlaceholderAuthHooksPaths: {
                     useLogOut: `${srcRoot}/hooks/use-log-out.ts`,
-                    useRequiredUserId: `${srcRoot}/hooks/use-user-id-or-throw.ts`,
                     useSession: `${srcRoot}/hooks/use-session.ts`,
+                    useUserIdOrThrow: `${srcRoot}/hooks/use-user-id-or-throw.ts`,
                 },
             },
         };

package/dist/placeholder-auth/core/generators/placeholder-auth-hooks/generated/ts-import-providers.d.ts

@@ -1,12 +1,13 @@
 export declare const PLACEHOLDER_AUTH_CORE_PLACEHOLDER_AUTH_HOOKS_IMPORTS: {
+    generatorName: string;
     task: import("@baseplate-dev/sync").GeneratorTask<{
         authHooksImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
             SessionData: {
                 isTypeOnly: true;
             };
             useLogOut: {};
-            useRequiredUserId: {};
             useSession: {};
+            useUserIdOrThrow: {};
             AuthRole: {
                 isTypeOnly: true;
             };

package/dist/placeholder-auth/core/generators/placeholder-auth-hooks/generated/ts-import-providers.js

@@ -14,14 +14,15 @@ const placeholderAuthCorePlaceholderAuthHooksImportsTask = createGeneratorTask({
                     AuthRole: paths.useSession,
                     SessionData: paths.useSession,
                     useLogOut: paths.useLogOut,
-                    useRequiredUserId: paths.useRequiredUserId,
                     useSession: paths.useSession,
+                    useUserIdOrThrow: paths.useUserIdOrThrow,
                 }),
             },
         };
     },
 });
 export const PLACEHOLDER_AUTH_CORE_PLACEHOLDER_AUTH_HOOKS_IMPORTS = {
+    generatorName: '@baseplate-dev/plugin-auth#placeholder-auth/core/placeholder-auth-hooks',
     task: placeholderAuthCorePlaceholderAuthHooksImportsTask,
 };
 //# sourceMappingURL=ts-import-providers.js.map