@temboplus/afloat 0.1.77-beta.9 → 0.1.79

package/esm/src/features/auth/identity/repository.js

@@ -0,0 +1,30 @@
+import { APIError } from "../../../errors/api_error.js";
+import { identityContract } from "./contract.js";
+import { TokenRequiredRepository } from "../../../shared/token_required_repository.js";
+/**
+ * Class representing the LoginRepository.
+ * Provides methods to retrieve user identity-related information.
+ */
+export class LoginRepository extends TokenRequiredRepository {
+    /**
+     * Initializes an instance of LoginRepository.
+     */
+    constructor() {
+        super("login", identityContract, "");
+    }
+    /**
+     * Retrieves the user's login credentials.
+     * @returns A promise that resolves to the user's login credentials on success.
+     * @throws {APIError} If an error occurs while retrieving the credentials.
+     */
+    async getIdentity(token) {
+        this.setToken(token);
+        const result = await this.client.getUserCredentials();
+        if (result.status === 200)
+            return result.body;
+        throw new APIError({
+            message: "An error occurred while trying to get login credentials",
+            statusCode: 502,
+        });
+    }
+}

package/esm/src/features/auth/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./manager.js";
+export * from "./repository.js";
+export * from "./profile/repository.js";
+export * from "./identity/repository.js";
+export * from "./access/repository.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/src/features/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/features/auth/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,yBAAyB,CAAA;AACvC,cAAc,0BAA0B,CAAA;AACxC,cAAc,wBAAwB,CAAA"}

package/esm/src/features/auth/index.js

@@ -0,0 +1,5 @@
+export * from "./manager.js";
+export * from "./repository.js";
+export * from "./profile/repository.js";
+export * from "./identity/repository.js";
+export * from "./access/repository.js";

package/esm/src/features/auth/manager.d.ts

@@ -0,0 +1,105 @@
+import type { User } from "../../models/index.js";
+import type { Permission } from "../../models/permission.js";
+/**
+ * Global context to hold the current auth instance reference.
+ * This provides a way to access the auth instance across the application
+ * without directly coupling to the singleton pattern.
+ */
+export declare const AuthContext: {
+    current: AfloatAuth | undefined;
+};
+/**
+ * Main authentication class that works in both client and server environments.
+ * Provides authentication functionality and user management.
+ */
+export declare class AfloatAuth {
+    /** The auth store implementation */
+    private store;
+    /** The token handler implementation */
+    private tokenHandler;
+    /** client AfloatAuth instance */
+    private static _instance;
+    /**
+     * Private constructor to maintain control over instantiation.
+     * @param {AuthStore} store - The auth store implementation to use
+     * @param {TokenHandler} tokenHandler - The token handler implementation to use
+     */
+    private constructor();
+    /**
+     * Gets or creates the client-side singleton instance of AfloatAuth.
+     * This getter will automatically initialize the client instance if it hasn't been created yet.
+     * For server-side usage, use initializeServer() instead.
+     *
+     * @returns {AfloatAuth} The client-side singleton instance
+     * @example
+     * // Client-side usage
+     * const auth = AfloatAuth.instance;
+     *
+     * // Server-side usage (don't use .instance)
+     * const serverAuth = await AfloatAuth.initializeServer(token);
+     */
+    static get instance(): AfloatAuth;
+    /**
+     * Creates a new server-side instance of AfloatAuth.
+     * Unlike the client-side instance getter, this creates a new instance each time.
+     *
+     * @param {string} token - Authentication token
+     * @returns {Promise<AfloatAuth>} A new server-side instance
+     * @throws {Error} If token is invalid or required data cannot be fetched
+     */
+    static initializeServer(token: string): Promise<AfloatAuth>;
+    /**
+     * Gets the authentication repository instance.
+     * @private
+     * @returns {AuthRepository} The repository for auth operations
+     */
+    private get repo();
+    /**
+     * Gets the current authentication token.
+     * @returns {string | undefined} The current token or undefined if not authenticated
+     */
+    getUserToken(): string | undefined;
+    /**
+     * Gets the currently authenticated user.
+     * @returns {User | undefined} The current user or undefined if not authenticated
+     */
+    get currentUser(): User | undefined;
+    /**
+     * React hook for accessing the current user in client-side code.
+     * @throws {Error} If called in a server environment
+     * @returns {User | undefined} The current user or undefined if not authenticated
+     */
+    useCurrentUser(): User | undefined;
+    /**
+     * Checks if the current user has a specific permission.
+     * @param {Permission} perm - The permission to check
+     * @returns {boolean} True if the user has the permission, false otherwise
+     */
+    checkPermission(perm: Permission): boolean;
+    /**
+     * Authenticates a user with email and password.
+     * @param {string} email - The user's email
+     * @param {string} password - The user's password
+     * @returns {Promise<User>} Promise resolving to the authenticated user
+     * @throws Will throw an error if authentication fails
+     */
+    logIn(email: string, password: string): Promise<User>;
+    /**
+     * Updates the user's password.
+     * @param {string} current - The current password
+     * @param {string} updated - The new password
+     * @returns {Promise<boolean>} Promise resolving to true if successful
+     * @throws Will throw an error if the password update fails
+     */
+    resetPassword(current: string, updated: string): Promise<boolean>;
+    /**
+     * Logs out the current user.
+     */
+    logOut(): void;
+    /**
+     * Clears all authentication data.
+     * @private
+     */
+    private clearSavedData;
+}
+//# sourceMappingURL=manager.d.ts.map

package/esm/src/features/auth/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../src/src/features/auth/manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAU7D;;;;GAIG;AACH,eAAO,MAAM,WAAW;aAEA,UAAU,GAAG,SAAS;CAC7C,CAAC;AAEF;;;GAGG;AACH,qBAAa,UAAU;IACrB,oCAAoC;IACpC,OAAO,CAAC,KAAK,CAAY;IAEzB,uCAAuC;IACvC,OAAO,CAAC,YAAY,CAAe;IAEnC,iCAAiC;IACjC,OAAO,CAAC,MAAM,CAAC,SAAS,CAA2B;IAEnD;;;;OAIG;IACH,OAAO;IAKP;;;;;;;;;;;;OAYG;IACH,WAAkB,QAAQ,IAAI,UAAU,CAYvC;IAED;;;;;;;OAOG;WACiB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IA8BxE;;;;OAIG;IACH,OAAO,KAAK,IAAI,GAEf;IAED;;;OAGG;IACH,YAAY,IAAI,MAAM,GAAG,SAAS;IAIlC;;;OAGG;IACH,IAAI,WAAW,IAAI,IAAI,GAAG,SAAS,CAElC;IAED;;;;OAIG;IACH,cAAc,IAAI,IAAI,GAAG,SAAS;IAIlC;;;;OAIG;IACH,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO;IAI1C;;;;;;OAMG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ3D;;;;;;OAMG;IACG,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMvE;;OAEG;IACH,MAAM,IAAI,IAAI;IAId;;;OAGG;IACH,OAAO,CAAC,cAAc;CAIvB"}

package/esm/src/features/auth/manager.js

@@ -0,0 +1,181 @@
+import { AuthRepository } from "./repository.js";
+import { createClientStore, useClientUser, } from "./storage/client_store.js";
+import { ClientTokenHandler } from "./storage/client_token_handler.js";
+import { ServerStore } from "./storage/server_store.js";
+import { ServerTokenHandler } from "./storage/server_token_handler.js";
+/**
+ * Global context to hold the current auth instance reference.
+ * This provides a way to access the auth instance across the application
+ * without directly coupling to the singleton pattern.
+ */
+export const AuthContext = {
+    // Default undefined state - will be set during initialization
+    current: undefined,
+};
+/**
+ * Main authentication class that works in both client and server environments.
+ * Provides authentication functionality and user management.
+ */
+export class AfloatAuth {
+    /**
+     * Private constructor to maintain control over instantiation.
+     * @param {AuthStore} store - The auth store implementation to use
+     * @param {TokenHandler} tokenHandler - The token handler implementation to use
+     */
+    constructor(store, tokenHandler) {
+        /** The auth store implementation */
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** The token handler implementation */
+        Object.defineProperty(this, "tokenHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.store = store;
+        this.tokenHandler = tokenHandler;
+    }
+    /**
+     * Gets or creates the client-side singleton instance of AfloatAuth.
+     * This getter will automatically initialize the client instance if it hasn't been created yet.
+     * For server-side usage, use initializeServer() instead.
+     *
+     * @returns {AfloatAuth} The client-side singleton instance
+     * @example
+     * // Client-side usage
+     * const auth = AfloatAuth.instance;
+     *
+     * // Server-side usage (don't use .instance)
+     * const serverAuth = await AfloatAuth.initializeServer(token);
+     */
+    static get instance() {
+        if (!AfloatAuth._instance) {
+            AfloatAuth._instance = new AfloatAuth(createClientStore(), ClientTokenHandler.instance);
+            // Set as current instance for global access
+            AuthContext.current = AfloatAuth._instance;
+        }
+        return AfloatAuth._instance;
+    }
+    /**
+     * Creates a new server-side instance of AfloatAuth.
+     * Unlike the client-side instance getter, this creates a new instance each time.
+     *
+     * @param {string} token - Authentication token
+     * @returns {Promise<AfloatAuth>} A new server-side instance
+     * @throws {Error} If token is invalid or required data cannot be fetched
+     */
+    static async initializeServer(token) {
+        if (!token) {
+            throw new Error("Token is required for server initialization");
+        }
+        const tokenHandler = new ServerTokenHandler(token);
+        const store = new ServerStore();
+        try {
+            // Fetch and construct user data
+            const user = await tokenHandler.constructUser(token);
+            store.setUser(user);
+            // Create and initialize auth instance
+            const auth = new AfloatAuth(store, tokenHandler);
+            // Set as current instance for global access
+            AuthContext.current = auth;
+            return auth;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.log(error.stack);
+                throw new Error(`Failed to initialize server auth: ${error.message}`);
+            }
+            throw new Error("Failed to initialize server auth");
+        }
+    }
+    /**
+     * Gets the authentication repository instance.
+     * @private
+     * @returns {AuthRepository} The repository for auth operations
+     */
+    get repo() {
+        return new AuthRepository();
+    }
+    /**
+     * Gets the current authentication token.
+     * @returns {string | undefined} The current token or undefined if not authenticated
+     */
+    getUserToken() {
+        return this.tokenHandler.getUserToken();
+    }
+    /**
+     * Gets the currently authenticated user.
+     * @returns {User | undefined} The current user or undefined if not authenticated
+     */
+    get currentUser() {
+        return this.store.getUser();
+    }
+    /**
+     * React hook for accessing the current user in client-side code.
+     * @throws {Error} If called in a server environment
+     * @returns {User | undefined} The current user or undefined if not authenticated
+     */
+    useCurrentUser() {
+        return useClientUser();
+    }
+    /**
+     * Checks if the current user has a specific permission.
+     * @param {Permission} perm - The permission to check
+     * @returns {boolean} True if the user has the permission, false otherwise
+     */
+    checkPermission(perm) {
+        return this.currentUser?.can(perm) ?? false;
+    }
+    /**
+     * Authenticates a user with email and password.
+     * @param {string} email - The user's email
+     * @param {string} password - The user's password
+     * @returns {Promise<User>} Promise resolving to the authenticated user
+     * @throws Will throw an error if authentication fails
+     */
+    async logIn(email, password) {
+        const user = await this.repo.logIn(email, password);
+        this.clearSavedData();
+        this.store.setUser(user);
+        this.tokenHandler.setUserToken(user.token);
+        return user;
+    }
+    /**
+     * Updates the user's password.
+     * @param {string} current - The current password
+     * @param {string} updated - The new password
+     * @returns {Promise<boolean>} Promise resolving to true if successful
+     * @throws Will throw an error if the password update fails
+     */
+    async resetPassword(current, updated) {
+        await this.repo.updatePassword(current, updated);
+        this.clearSavedData();
+        return true;
+    }
+    /**
+     * Logs out the current user.
+     */
+    logOut() {
+        this.clearSavedData();
+    }
+    /**
+     * Clears all authentication data.
+     * @private
+     */
+    clearSavedData() {
+        this.store.refresh();
+        this.tokenHandler.clearToken();
+    }
+}
+/** client AfloatAuth instance */
+Object.defineProperty(AfloatAuth, "_instance", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: null
+});

package/{dist/modules/profile/profile.api-contract.d.ts → esm/src/features/auth/profile/contract.d.ts}

@@ -8,14 +8,13 @@ export declare const profileContract: {
         responses: {
             200: import("zod").ZodObject<{
                 id: import("zod").ZodString;
-                firstName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-                lastName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                firstName: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+                lastName: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
                 displayName: import("zod").ZodString;
-                phone: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+                phone: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
                 accountNo: import("zod").ZodString;
-                email: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-                autoApprove: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
-            }, "strip", import("zod").ZodTypeAny, {
+                email: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+            }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
                 id: string;
                 displayName: string;
                 accountNo: string;
@@ -23,7 +22,6 @@ export declare const profileContract: {
                 lastName?: string | null | undefined;
                 phone?: string | null | undefined;
                 email?: string | null | undefined;
-                autoApprove?: boolean | null | undefined;
             }, {
                 id: string;
                 displayName: string;
@@ -32,8 +30,8 @@ export declare const profileContract: {
                 lastName?: string | null | undefined;
                 phone?: string | null | undefined;
                 email?: string | null | undefined;
-                autoApprove?: boolean | null | undefined;
             }>;
         };
     };
 };
+//# sourceMappingURL=contract.d.ts.map

package/esm/src/features/auth/profile/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/profile/contract.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ1B,CAAC"}

package/esm/src/features/auth/profile/contract.js

@@ -0,0 +1,14 @@
+import { initContract } from "@ts-rest/core";
+import { Profile } from "../../../models/index.js";
+/**
+ * Profile API contract
+ */
+export const profileContract = initContract().router({
+    getCurrentProfile: {
+        method: "GET",
+        path: "/me",
+        responses: {
+            200: Profile.schema,
+        },
+    },
+});

package/esm/src/features/auth/profile/repository.d.ts

@@ -0,0 +1,11 @@
+import { Profile } from "../../../models/index.js";
+import { profileContract } from "./contract.js";
+import { TokenRequiredRepository } from "../../../shared/token_required_repository.js";
+export declare class ProfileRepository extends TokenRequiredRepository<typeof profileContract> {
+    /**
+     * Initializes an instance of ProfileRepository.
+     */
+    constructor();
+    getCurrentProfile(token: string): Promise<Profile>;
+}
+//# sourceMappingURL=repository.d.ts.map

package/esm/src/features/auth/profile/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/profile/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAC;AAEvF,qBAAa,iBAAkB,SAAQ,uBAAuB,CAAC,OAAO,eAAe,CAAC;IACpF;;OAEG;;IAKG,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAazD"}

package/esm/src/features/auth/profile/repository.js

@@ -0,0 +1,25 @@
+import { Profile } from "../../../models/index.js";
+import { APIError } from "../../../errors/api_error.js";
+import { profileContract } from "./contract.js";
+import { TokenRequiredRepository } from "../../../shared/token_required_repository.js";
+export class ProfileRepository extends TokenRequiredRepository {
+    /**
+     * Initializes an instance of ProfileRepository.
+     */
+    constructor() {
+        super("profile", profileContract, "");
+    }
+    async getCurrentProfile(token) {
+        this.setToken(token);
+        const result = await this.client.getCurrentProfile();
+        if (result.status === 200) {
+            const profile = Profile.from(result.body);
+            if (profile)
+                return profile;
+        }
+        throw new APIError({
+            message: "An error occurred while trying to get the current profile",
+            statusCode: 502,
+        });
+    }
+}

package/esm/src/features/auth/repository.d.ts

@@ -0,0 +1,30 @@
+import { User } from "../../models/index.js";
+import { BaseRepository } from "../../shared/base_repository.js";
+import { authContract } from "./contract.js";
+/**
+ * Class representing the AuthRepository.
+ * Provides methods to handle authentication-related operations, such as login and password updates.
+ */
+export declare class AuthRepository extends BaseRepository<typeof authContract> {
+    /**
+     * Initializes an instance of AuthRepository.
+     */
+    constructor();
+    /**
+     * Logs in a user with the provided email and password.
+     * @param email - The email of the user attempting to log in.
+     * @param password - The password of the user.
+     * @returns A promise that resolves to a User object on successful login.
+     * @throws {APIError} If the email or password is invalid, or if another error occurs during the login process.
+     */
+    logIn(email: string, password: string): Promise<User>;
+    /**
+     * Updates the user's password.
+     * @param currentPassword - The user's current password.
+     * @param newPassword - The new password the user wants to set.
+     * @returns A promise that resolves to true if the password update is successful.
+     * @throws {APIError} If the current password is invalid or another error occurs during the update process.
+     */
+    updatePassword(currentPassword: string, newPassword: string): Promise<boolean>;
+}
+//# sourceMappingURL=repository.d.ts.map

package/esm/src/features/auth/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../src/src/features/auth/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAI7C;;;GAGG;AACH,qBAAa,cAAe,SAAQ,cAAc,CAAC,OAAO,YAAY,CAAC;IACrE;;OAEG;;IAKH;;;;;;OAMG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB3D;;;;;;OAMG;IACG,cAAc,CAClB,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,OAAO,CAAC;CAiBpB"}

package/esm/src/features/auth/repository.js

@@ -0,0 +1,69 @@
+import { User } from "../../models/index.js";
+import { BaseRepository } from "../../shared/base_repository.js";
+import { authContract } from "./contract.js";
+import { APIError } from "../../errors/api_error.js";
+import { LoginRepository } from "./identity/repository.js";
+/**
+ * Class representing the AuthRepository.
+ * Provides methods to handle authentication-related operations, such as login and password updates.
+ */
+export class AuthRepository extends BaseRepository {
+    /**
+     * Initializes an instance of AuthRepository.
+     */
+    constructor() {
+        super("auth", authContract);
+    }
+    /**
+     * Logs in a user with the provided email and password.
+     * @param email - The email of the user attempting to log in.
+     * @param password - The password of the user.
+     * @returns A promise that resolves to a User object on successful login.
+     * @throws {APIError} If the email or password is invalid, or if another error occurs during the login process.
+     */
+    async logIn(email, password) {
+        const body = { type: "password", identity: email, password };
+        const result = await this.client.logIn({ body });
+        if (result.status === 400) {
+            throw new APIError({
+                message: "Invalid email or password",
+                statusCode: 400,
+            });
+        }
+        if (result.status === 201) {
+            const repo = new LoginRepository();
+            const loginCredentials = await repo.getIdentity(result.body.token);
+            const user = User.from({ ...result.body, ...loginCredentials });
+            if (user)
+                return user;
+        }
+        throw new APIError({
+            message: "An error occurred while trying to log in",
+            statusCode: 502,
+        });
+    }
+    /**
+     * Updates the user's password.
+     * @param currentPassword - The user's current password.
+     * @param newPassword - The new password the user wants to set.
+     * @returns A promise that resolves to true if the password update is successful.
+     * @throws {APIError} If the current password is invalid or another error occurs during the update process.
+     */
+    async updatePassword(currentPassword, newPassword) {
+        const result = await this.client.resetPassword({
+            body: { currentPassword, newPassword },
+        });
+        if (result.status === 200)
+            return true;
+        if (result.status === 400) {
+            throw new APIError({
+                message: "Invalid current password",
+                statusCode: 400,
+            });
+        }
+        throw new APIError({
+            message: "An error occurred while trying to update password",
+            statusCode: 502,
+        });
+    }
+}

package/{dist/modules/auth/storage/client-store.d.ts → esm/src/features/auth/storage/client_store.d.ts}

@@ -1,6 +1,6 @@
+import { User } from "../../../models/user/index.js";
 import { type StoreApi, type UseBoundStore } from "zustand";
 import type { AuthStore } from "./types.js";
-import { User } from "@/modules/auth/user.model.js";
 /** Type definition for the store's state */
 type State = {
     user: string | undefined;
@@ -27,3 +27,4 @@ export declare const createClientStore: () => AuthStore;
  */
 export declare const useClientUser: () => User | undefined;
 export {};
+//# sourceMappingURL=client_store.d.ts.map

package/esm/src/features/auth/storage/client_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client_store.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/storage/client_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAC;AACrD,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,aAAa,EAAY,MAAM,SAAS,CAAC;AAE9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAK5C,4CAA4C;AAC5C,KAAK,KAAK,GAAG;IAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAE1C,8CAA8C;AAC9C,UAAU,OAAO;IACf,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IAC9B,OAAO,EAAE,MAAM,IAAI,GAAG,SAAS,CAAC;IAChC,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC,QAAQ,CAAC,KAAK,GAAG,OAAO,CAAC,CA2BhE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAAO,SAMpC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,QAAO,IAAI,GAAG,SAEvC,CAAC"}

package/esm/src/features/auth/storage/client_store.js

@@ -0,0 +1,46 @@
+import { User } from "../../../models/user/index.js";
+import { create, useStore } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+/** Key used for storing auth data in session storage */
+const AUTH_STORE_SESSION_STORAGE_KEY = "auth-store";
+/**
+ * Creates and exports the Zustand store directly for reactive hooks
+ * @internal This should only be used by AfloatAuth
+ */
+export const clientStore = create(persist((set, get) => ({
+    user: undefined,
+    getUser: () => {
+        try {
+            const jsonUser = get().user;
+            if (jsonUser)
+                return User.fromJSON(jsonUser);
+        }
+        catch (_) {
+            console.log(_);
+        }
+        return undefined;
+    },
+    setUser: (user) => set({ user: user.toJSON() }),
+    refresh: () => set({ user: undefined }),
+}), {
+    name: AUTH_STORE_SESSION_STORAGE_KEY,
+    storage: createJSONStorage(() => sessionStorage),
+}));
+/**
+ * Creates a client-side authentication store using Zustand.
+ * @returns {AuthStore} An implementation of AuthStore for client-side use
+ */
+export const createClientStore = () => {
+    return {
+        getUser: () => clientStore.getState().getUser(),
+        setUser: (user) => clientStore.getState().setUser(user),
+        refresh: () => clientStore.getState().refresh(),
+    };
+};
+/**
+ * React hook to access the current user with reactive updates.
+ * @returns {User | undefined} The current user or undefined if not authenticated
+ */
+export const useClientUser = () => {
+    return useStore(clientStore).getUser();
+};

package/{dist/modules/auth/storage/client-token-handler.d.ts → esm/src/features/auth/storage/client_token_handler.d.ts}

@@ -29,3 +29,4 @@ export declare class ClientTokenHandler implements TokenHandler {
      */
     clearToken(): void;
 }
+//# sourceMappingURL=client_token_handler.d.ts.map

package/esm/src/features/auth/storage/client_token_handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client_token_handler.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/storage/client_token_handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;GAIG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACrD,yBAAyB;IACzB,OAAO,CAAC,MAAM,CAAC,SAAS,CAAqB;IAE7C,uDAAuD;IACvD,OAAO;IAEP;;;OAGG;IACH,MAAM,KAAK,QAAQ,IAAI,kBAAkB,CAExC;IAED;;;OAGG;IACH,YAAY,IAAI,MAAM,GAAG,SAAS;IAIlC;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIjC;;OAEG;IACH,UAAU,IAAI,IAAI;CAGnB"}

package/esm/src/features/auth/storage/client_token_handler.js

@@ -0,0 +1,36 @@
+/**
+ * Client-side implementation of TokenHandler.
+ * Manages tokens using sessionStorage.
+ * @implements {TokenHandler}
+ */
+export class ClientTokenHandler {
+    /** Private constructor to enforce singleton pattern */
+    constructor() { }
+    /**
+     * Gets the singleton instance of ClientTokenHandler.
+     * @returns {ClientTokenHandler} The singleton instance
+     */
+    static get instance() {
+        return this._instance || (this._instance = new this());
+    }
+    /**
+     * Retrieves the token from sessionStorage.
+     * @returns {string | undefined} The stored token or undefined if not present
+     */
+    getUserToken() {
+        return sessionStorage.getItem("auth_token") || undefined;
+    }
+    /**
+     * Stores the token in sessionStorage.
+     * @param {string} token - The token to store
+     */
+    setUserToken(token) {
+        sessionStorage.setItem("auth_token", token);
+    }
+    /**
+     * Removes the token from sessionStorage.
+     */
+    clearToken() {
+        sessionStorage.removeItem("auth_token");
+    }
+}