@baseplate-dev/plugin-auth 0.6.18 → 0.6.19

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

@@ -1,103 +1,119 @@
 // @ts-nocheck
 import { getSafeLocalStorage } from '%reactUtilsImports';
+const USER_ID_STORAGE_KEY = 'APP_USER_ID';
+const PUBLIC_SESSION = {
+    userId: undefined,
+    isAuthenticated: false,
+    roles: ['public'],
+    isPending: false,
+};
+function areSessionsEqual(a, b) {
+    return (a.userId === b.userId &&
+        a.isPending === b.isPending &&
+        a.roles.length === b.roles.length &&
+        a.roles.every((role, idx) => role === b.roles[idx]));
+}
 /**
- * User session client for managing session persistence using localStorage
- * Handles session state persistence and cross-tab synchronization
+ * 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 class UserSessionClient {
-    static USER_ID_STORAGE_KEY = 'APP_USER_ID';
-    storage = getSafeLocalStorage();
-    callbacks = new Set();
-    cleanupListener;
-    constructor() {
-        // Initialize storage listener for cross-tab synchronization
-        this.setupStorageListener();
+export function createUserSessionClient() {
+    const storage = getSafeLocalStorage();
+    const callbacks = new Set();
+    function getPersistedUserId() {
+        return storage.getItem(USER_ID_STORAGE_KEY) ?? undefined;
     }
-    /**
-     * Sign in a user with the given user ID
-     * @param userId - The user ID to sign in
-     */
-    signIn(userId) {
-        const existingUserId = this.getUserId();
-        this.setUserId(userId);
-        if (existingUserId !== userId) {
-            this.notifyCallbacks();
+    // 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 = getPersistedUserId()
+        ? undefined
+        : PUBLIC_SESSION;
+    function publish(newSession) {
+        if (session && areSessionsEqual(session, newSession)) {
+            return;
         }
-    }
-    /**
-     * Sign out the current user
-     */
-    signOut() {
-        const existingUserId = this.getUserId();
-        this.setUserId(null);
-        if (existingUserId) {
-            this.notifyCallbacks();
+        session = newSession;
+        for (const callback of callbacks) {
+            callback();
         }
     }
-    /**
-     * Subscribe to user ID changes
-     * @param callback - Function to call when user ID changes
-     * @returns Cleanup function to unsubscribe
-     */
-    onUserIdChange(callback) {
-        this.callbacks.add(callback);
-        return () => {
-            this.callbacks.delete(callback);
-        };
-    }
-    /**
-     * Clean up resources when the client is no longer needed
-     */
-    destroy() {
-        this.cleanupListener?.();
-        this.callbacks.clear();
-    }
-    /**
-     * Get the current user ID from storage
-     * @returns User ID or null if not authenticated
-     */
-    getUserId() {
-        return (this.storage.getItem(UserSessionClient.USER_ID_STORAGE_KEY) ?? undefined);
-    }
-    /**
-     * Set the user ID in storage
-     * @param userId - User ID to store, or null to clear
-     */
-    setUserId(userId) {
-        const currentUserId = this.getUserId();
-        const userIdChanged = userId !== currentUserId;
-        if (!userIdChanged) {
+    function persistUserId(userId) {
+        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
-     */
-    setupStorageListener() {
-        this.cleanupListener = this.storage.addEventListener((key) => {
-            if (key === UserSessionClient.USER_ID_STORAGE_KEY) {
-                this.notifyCallbacks();
-            }
+    function signIn(userId, roles) {
+        publish({
+            userId,
+            isAuthenticated: true,
+            roles,
+            isPending: false,
         });
+        persistUserId(userId);
     }
-    /**
-     * Notify all registered callbacks of session changes
-     */
-    notifyCallbacks() {
-        const userId = this.getUserId();
-        for (const callback of this.callbacks) {
-            callback(userId);
-        }
+    function signOut() {
+        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();
 //# sourceMappingURL=user-session-client.js.map

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, pluginAppCompiler, 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';
@@ -30,11 +30,12 @@ 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.
@@ -50,7 +51,6 @@ export default createPluginModule({
                     }),
                     authModule: authModuleGenerator({
                         userAdminRoles: adminRoles,
-                        devWebPorts,
                         emailOtp: localAuthDefinition.emailOtp,
                     }),
                     emailPassword: appModuleGenerator({
@@ -59,7 +59,7 @@ export default createPluginModule({
                         children: {
                             module: authEmailPasswordGenerator({
                                 adminRoles,
-                                devWebDomainPort,
+                                webAppName: authWebApp.name,
                                 requireNameOnRegistration: localAuthDefinition.requireNameOnRegistration,
                                 emailOtp: localAuthDefinition.emailOtp,
                                 disableRegistration,

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

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

@@ -1,17 +1,17 @@
 export declare const 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>>>;
 };
 export declare const PLACEHOLDER_AUTH_CORE_PLACEHOLDER_AUTH_HOOKS_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>>>;
     };
 };
 //# sourceMappingURL=typed-templates.d.ts.map