@temboplus/afloat 0.1.12 → 0.1.30

package/README.md

@@ -8,7 +8,7 @@ This JavaScript/TypeScript package provides a central hub for shared utilities,
 
 * **Abstracted Server Communication**
     * Simplifies front-end development by abstracting all interactions with the server behind model-specific repositories
-    * Front-end projects only need to interact with these repositories, decoupling them from the underlying API implementation
+    * Consuming projects only need to interact with these repositories, decoupling them from the underlying API implementation
 
 * **Shared Utilities**
     * Provides a collection of reusable helper functions for common tasks across Afloat projects, such as error handling
@@ -18,4 +18,122 @@ This JavaScript/TypeScript package provides a central hub for shared utilities,
 
 * **Enhanced Maintainability**
     * Centralizes common logic, making it easier to maintain and update across all consuming projects
-    * Reduces code duplication and improves consistency
+    * Reduces code duplication and improves consistency
+
+* **Cross-Environment Compatibility**
+    * Works seamlessly in both client-side and server-side environments
+    * Supports both synchronous and asynchronous initialization patterns
+
+## Usage
+
+### Authentication Setup
+
+#### Client-Side Usage
+
+In client-side applications, authentication is initialized synchronously:
+
+```typescript
+import { AfloatAuth } from "@temboplus/afloat";
+
+// Initialize client auth (typically in your app entry point)
+const auth = AfloatAuth.instance;
+
+// Check if user is authenticated
+console.log("User authenticated:", !!auth.currentUser);
+
+// Access current user
+const user = auth.currentUser;
+if (user) {
+  console.log(`Logged in as: ${user.email}`);
+}
+```
+
+#### Server-Side Usage
+
+In server-side environments, authentication requires asynchronous initialization:
+
+```typescript
+import { AfloatAuth } from "@temboplus/afloat";
+
+// In a server route handler or similar context
+async function handleRequest(req, res) {
+  try {
+    // Extract token from request
+    const token = req.headers.authorization?.replace('Bearer ', '');
+    
+    if (!token) {
+      return res.status(401).json({ error: 'Unauthorized' });
+    }
+    
+    // Initialize server-side auth
+    const auth = await AfloatAuth.initializeServer(token);
+    
+    // Now you can use auth for permission checks
+    const isAdmin = auth.checkPermission(Permissions.Payout.View);
+    
+    // Continue with your handler logic...
+  } catch (error) {
+    console.error('Authentication error:', error);
+    return res.status(500).json({ error: 'Authentication failed' });
+  }
+}
+```
+
+### Using Repositories
+
+Repositories provide a consistent interface for data operations across environments.
+
+#### Client-Side Repository Usage
+
+```typescript
+import { WalletRepo } from "@temboplus/afloat";
+
+// Create repository - auth is automatically handled
+const walletRepo = new WalletRepo();
+
+// Use repository methods
+async function displayBalance() {
+  try {
+    const balance = await walletRepo.getBalance();
+    console.log(`Current balance: ${balance}`);
+  } catch (error) {
+    console.error('Error fetching balance:', error);
+  }
+}
+```
+
+#### Server-Side Repository Usage
+
+```typescript
+import { AfloatAuth, WalletRepo } from "@temboplus/afloat";
+
+async function processServerRequest(token) {
+  // Initialize auth for this request
+  const auth = await AfloatAuth.initializeServer(token);
+  
+  // Create repository with explicit auth instance
+  const walletRepo = new WalletRepo({ auth });
+  
+  // Use repository methods
+  const balance = await walletRepo.getBalance();
+  const wallets = await walletRepo.getWallets();
+  
+  return { balance, wallets };
+}
+```
+
+## Best Practices
+
+1. **Client-Side Applications**
+   - Initialize `AfloatAuth.instance` early in your application lifecycle
+   - Create repositories without explicit auth parameters
+   - Handle permission errors appropriately in your UI
+
+2. **Server-Side Applications**
+   - Always use `await AfloatAuth.initializeServer(token)` for each request
+   - Pass the auth instance explicitly to repositories
+   - Implement proper error handling for authentication failures
+
+3. **Testing**
+   - Use the `AuthContext` to inject mock auth instances during testing
+   - Reset `AuthContext.current` after each test to prevent test pollution

package/esm/src/features/auth/access/contract.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+/**
+ * Auth API contract
+ */
+export declare const accessContract: {
+    getAccessList: {
+        method: "GET";
+        path: "/access";
+        responses: {
+            200: z.ZodArray<z.ZodString, "many">;
+        };
+    };
+};
+//# sourceMappingURL=contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/access/contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;CAQzB,CAAC"}

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

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { initContract } from "@ts-rest/core";
+/**
+ * Auth API contract
+ */
+export const accessContract = initContract().router({
+    getAccessList: {
+        method: "GET",
+        path: "/access",
+        responses: {
+            200: z.string().array(),
+        },
+    },
+});

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

@@ -23,28 +23,28 @@ export declare const authContract: {
             201: z.ZodObject<{
                 profile: z.ZodObject<{
                     id: z.ZodString;
-                    firstName: z.ZodString;
-                    lastName: z.ZodString;
+                    firstName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                    lastName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
                     displayName: z.ZodString;
-                    phone: z.ZodString;
+                    phone: z.ZodNullable<z.ZodOptional<z.ZodString>>;
                     accountNo: z.ZodString;
-                    email: z.ZodString;
+                    email: z.ZodNullable<z.ZodOptional<z.ZodString>>;
                 }, z.UnknownKeysParam, z.ZodTypeAny, {
                     id: string;
-                    firstName: string;
-                    lastName: string;
                     displayName: string;
-                    phone: string;
                     accountNo: string;
-                    email: string;
+                    firstName?: string | null | undefined;
+                    lastName?: string | null | undefined;
+                    phone?: string | null | undefined;
+                    email?: string | null | undefined;
                 }, {
                     id: string;
-                    firstName: string;
-                    lastName: string;
                     displayName: string;
-                    phone: string;
                     accountNo: string;
-                    email: string;
+                    firstName?: string | null | undefined;
+                    lastName?: string | null | undefined;
+                    phone?: string | null | undefined;
+                    email?: string | null | undefined;
                 }>;
                 token: z.ZodString;
                 access: z.ZodArray<z.ZodString, "many">;
@@ -53,12 +53,12 @@ export declare const authContract: {
                 resetPassword: boolean;
                 profile: {
                     id: string;
-                    firstName: string;
-                    lastName: string;
                     displayName: string;
-                    phone: string;
                     accountNo: string;
-                    email: string;
+                    firstName?: string | null | undefined;
+                    lastName?: string | null | undefined;
+                    phone?: string | null | undefined;
+                    email?: string | null | undefined;
                 };
                 token: string;
                 access: string[];
@@ -66,12 +66,12 @@ export declare const authContract: {
                 resetPassword: boolean;
                 profile: {
                     id: string;
-                    firstName: string;
-                    lastName: string;
                     displayName: string;
-                    phone: string;
                     accountNo: string;
-                    email: string;
+                    firstName?: string | null | undefined;
+                    lastName?: string | null | undefined;
+                    phone?: string | null | undefined;
+                    email?: string | null | undefined;
                 };
                 token: string;
                 access: string[];

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { initContract } from "@ts-rest/core";
-import { profileSchema } from "../../models/index.js";
+import { Profile } from "../../models/index.js";
 /**
  * Auth API contract
  */
@@ -15,7 +15,7 @@ export const authContract = initContract().router({
         }),
         responses: {
             201: z.object({
-                profile: profileSchema,
+                profile: Profile.schema,
                 token: z.string(),
                 access: z.array(z.string()),
                 resetPassword: z.boolean(),

package/esm/src/features/auth/identity/contract.d.ts

@@ -6,13 +6,6 @@ export declare const identityContract: {
     getUserCredentials: {
         method: "GET";
         path: "/me";
-        headers: z.ZodObject<{
-            token: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            token: string;
-        }, {
-            token: string;
-        }>;
         responses: {
             200: z.ZodObject<{
                 name: z.ZodString;

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

@@ -1 +1 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/identity/contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;CAY3B,CAAC"}
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/identity/contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAW3B,CAAC"}

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

@@ -7,7 +7,6 @@ export const identityContract = initContract().router({
     getUserCredentials: {
         method: "GET",
         path: "/me",
-        headers: z.object({ token: z.string() }),
         responses: {
             200: z.object({
                 name: z.string(),

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

@@ -1,12 +1,12 @@
-import { BaseRepository } from "../../../shared/index.js";
 import { identityContract } from "./contract.js";
 import type { ClientInferResponseBody } from "@ts-rest/core";
+import { TokenRequiredRepository } from "../../../shared/token_required_repository.js";
 type GetUserIdentityResponse = ClientInferResponseBody<typeof identityContract.getUserCredentials>;
 /**
  * Class representing the LoginRepository.
  * Provides methods to retrieve user identity-related information.
  */
-export declare class LoginRepository extends BaseRepository<typeof identityContract> {
+export declare class LoginRepository extends TokenRequiredRepository<typeof identityContract> {
     /**
      * Initializes an instance of LoginRepository.
      */

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

@@ -1 +1 @@
-{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/identity/repository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAE7D,KAAK,uBAAuB,GAAG,uBAAuB,CACpD,OAAO,gBAAgB,CAAC,kBAAkB,CAC3C,CAAC;AAEF;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,cAAc,CAAC,OAAO,gBAAgB,CAAC;IAC1E;;OAEG;;IAKH;;;;OAIG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAUnE"}
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/identity/repository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAC;AAEvF,KAAK,uBAAuB,GAAG,uBAAuB,CACpD,OAAO,gBAAgB,CAAC,kBAAkB,CAC3C,CAAC;AAEF;;;GAGG;AACH,qBAAa,eACX,SAAQ,uBAAuB,CAAC,OAAO,gBAAgB,CAAC;IACxD;;OAEG;;IAKH;;;;OAIG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAUnE"}

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

@@ -1,16 +1,16 @@
 import { APIError } from "../../../errors/api_error.js";
-import { BaseRepository } from "../../../shared/index.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 BaseRepository {
+export class LoginRepository extends TokenRequiredRepository {
     /**
      * Initializes an instance of LoginRepository.
      */
     constructor() {
-        super("login", identityContract);
+        super("login", identityContract, "");
     }
     /**
      * Retrieves the user's login credentials.
@@ -18,8 +18,8 @@ export class LoginRepository extends BaseRepository {
      * @throws {APIError} If an error occurs while retrieving the credentials.
      */
     async getIdentity(token) {
-        const headers = { token };
-        const result = await this.client.getUserCredentials({ headers });
+        this.setToken(token);
+        const result = await this.client.getUserCredentials();
         if (result.status === 200)
             return result.body;
         throw new APIError({

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

@@ -77,7 +77,7 @@ export class AfloatAuth {
         const store = new ServerStore();
         try {
             // Fetch and construct user data
-            const user = await tokenHandler.constructUser();
+            const user = await tokenHandler.constructUser(token);
             store.setUser(user);
             // Create and initialize auth instance
             const auth = new AfloatAuth(store, tokenHandler);

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

@@ -1,4 +1,3 @@
-import { z } from "zod";
 /**
  * Profile API contract
  */
@@ -6,38 +5,31 @@ export declare const profileContract: {
     getCurrentProfile: {
         method: "GET";
         path: "/me";
-        headers: z.ZodObject<{
-            token: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            token: string;
-        }, {
-            token: string;
-        }>;
         responses: {
-            200: z.ZodObject<{
-                id: z.ZodString;
-                firstName: z.ZodString;
-                lastName: z.ZodString;
-                displayName: z.ZodString;
-                phone: z.ZodString;
-                accountNo: z.ZodString;
-                email: z.ZodString;
-            }, z.UnknownKeysParam, z.ZodTypeAny, {
+            200: import("zod").ZodObject<{
+                id: 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").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+                accountNo: import("zod").ZodString;
+                email: import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>;
+            }, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
                 id: string;
-                firstName: string;
-                lastName: string;
                 displayName: string;
-                phone: string;
                 accountNo: string;
-                email: string;
+                firstName?: string | null | undefined;
+                lastName?: string | null | undefined;
+                phone?: string | null | undefined;
+                email?: string | null | undefined;
             }, {
                 id: string;
-                firstName: string;
-                lastName: string;
                 displayName: string;
-                phone: string;
                 accountNo: string;
-                email: string;
+                firstName?: string | null | undefined;
+                lastName?: string | null | undefined;
+                phone?: string | null | undefined;
+                email?: string | null | undefined;
             }>;
         };
     };

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

@@ -1 +1 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/profile/contract.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS1B,CAAC"}
+{"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

@@ -1,6 +1,5 @@
 import { initContract } from "@ts-rest/core";
-import { profileSchema } from "../../../models/index.js";
-import { z } from "zod";
+import { Profile } from "../../../models/index.js";
 /**
  * Profile API contract
  */
@@ -8,9 +7,8 @@ export const profileContract = initContract().router({
     getCurrentProfile: {
         method: "GET",
         path: "/me",
-        headers: z.object({ token: z.string() }),
         responses: {
-            200: profileSchema,
+            200: Profile.schema,
         },
     },
 });

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

@@ -26,6 +26,5 @@ export declare class AuthRepository extends BaseRepository<typeof authContract>
      * @throws {APIError} If the current password is invalid or another error occurs during the update process.
      */
     updatePassword(currentPassword: string, newPassword: string): Promise<boolean>;
-    getAccessList(token: string): Promise<string[]>;
 }
 //# sourceMappingURL=repository.d.ts.map

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

@@ -1 +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;IAwB3D;;;;;;OAMG;IACG,cAAc,CAClB,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,OAAO,CAAC;IAkBb,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAStD"}
+{"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

@@ -33,8 +33,9 @@ export class AuthRepository extends BaseRepository {
         if (result.status === 201) {
             const repo = new LoginRepository();
             const loginCredentials = await repo.getIdentity(result.body.token);
-            const user = new User({ ...result.body, loginCredentials });
-            return user;
+            const user = User.from({ ...result.body, ...loginCredentials });
+            if (user)
+                return user;
         }
         throw new APIError({
             message: "An error occurred while trying to log in",
@@ -65,13 +66,4 @@ export class AuthRepository extends BaseRepository {
             statusCode: 502,
         });
     }
-    async getAccessList(token) {
-        const result = await this.client.access({ headers: { token: token } });
-        if (result.status === 200)
-            return result.body;
-        throw new APIError({
-            message: "An error occurred while trying to get access list",
-            statusCode: 502,
-        });
-    }
 }

package/esm/src/features/auth/storage/server_token_handler.d.ts

@@ -3,15 +3,19 @@ import { User } from "../../../models/index.js";
 /**
  * Server-side implementation of TokenHandler.
  * Manages tokens in memory for the duration of a request.
+ * Uses TokenRequiredRepository instead of repositories that rely on AfloatAuth.
  * @implements {TokenHandler}
  */
 export declare class ServerTokenHandler implements TokenHandler {
-    private token?;
+    private token;
+    private accessRepo;
+    private profileRepo;
+    private identityRepo;
     /**
      * Creates a new instance of ServerTokenHandler.
      * @param {string} [token] - Optional initial token value
      */
-    constructor(token?: string | undefined);
+    constructor(token: string);
     /**
      * Returns the stored token.
      * @returns {string | undefined} The current token or undefined if not set
@@ -22,14 +26,11 @@ export declare class ServerTokenHandler implements TokenHandler {
      * @param {string} token - The token to store
      */
     setUserToken(token: string): void;
-    /**
-     * Clears the stored token from memory.
-     */
     clearToken(): void;
     /**
      * Fetches and constructs the full user data
      * @returns {Promise<User>}
      */
-    constructUser(): Promise<User>;
+    constructUser(token: string): Promise<User>;
 }
 //# sourceMappingURL=server_token_handler.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"server_token_handler.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/storage/server_token_handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAKhD;;;;GAIG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IAKzC,OAAO,CAAC,KAAK,CAAC;IAJ1B;;;OAGG;gBACiB,KAAK,CAAC,EAAE,MAAM,YAAA;IAElC;;;OAGG;IACH,YAAY,IAAI,MAAM,GAAG,SAAS;IAIlC;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAIjC;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;;OAGG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBrC"}
+{"version":3,"file":"server_token_handler.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/storage/server_token_handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAW,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAMzD;;;;;GAKG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACrD,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,UAAU,CAAiD;IACnE,OAAO,CAAC,WAAW,CAAkD;IACrE,OAAO,CAAC,YAAY,CAAmD;IAEvE;;;OAGG;gBACS,KAAK,EAAE,MAAM;IAqBzB;;;OAGG;IACH,YAAY,IAAI,MAAM,GAAG,SAAS;IAIlC;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAOjC,UAAU,IAAI,IAAI;IAOlB;;;OAGG;IACG,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAoDlD"}

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

@@ -1,10 +1,12 @@
-import { User } from "../../../models/index.js";
-import { ProfileRepository } from "../profile/repository.js";
-import { LoginRepository } from "../identity/repository.js";
-import { AuthRepository } from "../repository.js";
+import { Profile, User } from "../../../models/index.js";
+import { profileContract } from "../profile/contract.js";
+import { identityContract } from "../identity/contract.js";
+import { TokenRequiredRepository } from "../../../shared/token_required_repository.js";
+import { accessContract } from "../access/contract.js";
 /**
  * Server-side implementation of TokenHandler.
  * Manages tokens in memory for the duration of a request.
+ * Uses TokenRequiredRepository instead of repositories that rely on AfloatAuth.
  * @implements {TokenHandler}
  */
 export class ServerTokenHandler {
@@ -17,8 +19,30 @@ export class ServerTokenHandler {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: token
+            value: void 0
         });
+        Object.defineProperty(this, "accessRepo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "profileRepo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "identityRepo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.token = token;
+        this.accessRepo = new TokenRequiredRepository("auth", accessContract, this.token);
+        this.profileRepo = new TokenRequiredRepository("profile", profileContract, this.token);
+        this.identityRepo = new TokenRequiredRepository("login", identityContract, this.token);
     }
     /**
      * Returns the stored token.
@@ -33,36 +57,59 @@ export class ServerTokenHandler {
      */
     setUserToken(token) {
         this.token = token;
+        this.accessRepo.setToken(token);
+        this.profileRepo.setToken(token);
+        this.identityRepo.setToken(token);
     }
-    /**
-     * Clears the stored token from memory.
-     */
     clearToken() {
-        this.token = undefined;
+        this.token = "";
+        this.accessRepo.setToken("");
+        this.profileRepo.setToken("");
+        this.identityRepo.setToken("");
     }
     /**
      * Fetches and constructs the full user data
      * @returns {Promise<User>}
      */
-    async constructUser() {
+    async constructUser(token) {
         if (!this.token) {
             throw new Error("Token is required to construct user");
         }
-        const profileRepo = new ProfileRepository();
-        const authRepo = new AuthRepository();
-        const logInRepo = new LoginRepository();
-        const token = this.token;
-        const [access, profile, identity] = await Promise.all([
-            authRepo.getAccessList(token),
-            profileRepo.getCurrentProfile(token),
-            logInRepo.getIdentity(token),
-        ]);
-        return new User({
-            token,
-            profile,
-            access,
-            resetPassword: false,
-            loginCredentials: identity,
-        });
+        this.setUserToken(token);
+        try {
+            // Fetch all data concurrently with Promise.all
+            const [access, profileResult, identityResult] = await Promise.all([
+                this.accessRepo.client.getAccessList(),
+                this.profileRepo.client.getCurrentProfile(),
+                this.identityRepo.client.getUserCredentials(),
+            ]);
+            // Extract and validate response data
+            const accessList = this.accessRepo.handleResponse(access, 200);
+            const profileData = this.profileRepo.handleResponse(profileResult, 200);
+            const identityData = this.identityRepo.handleResponse(identityResult, 200);
+            // Create profile object
+            const profile = Profile.from(profileData);
+            if (!profile) {
+                throw new Error("Failed to create profile from response data");
+            }
+            // Construct and return user object
+            const user = User.from({
+                token: this.token,
+                profile,
+                access: accessList,
+                resetPassword: false,
+                ...identityData,
+            });
+            if (!user) {
+                throw new Error("Failed to construct user");
+            }
+            return user;
+        }
+        catch (error) {
+            const message = error instanceof Error
+                ? error.message
+                : "Unknown error occurred";
+            throw new Error(`Error constructing user: ${message}`);
+        }
     }
 }