@singularlogic/coreplatts 0.0.9 → 0.0.10

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AxiosInstance } from 'axios';
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
 
 interface Updated {
     by?: string;
@@ -135,6 +135,7 @@ interface Bucket {
     creation_date?: Date;
 }
 
+type TokenProvider = () => string | Promise<string>;
 interface IClient$1 {
     login(email: string, password: string): Promise<OidcToken>;
     myUser(token?: string): Promise<User$1>;
@@ -142,33 +143,69 @@ interface IClient$1 {
     myOrganizations(token?: string): Promise<Group$1[]>;
     organizationByID(id: string, token?: string): Promise<Group$1>;
     organizationByName(name: string, token?: string): Promise<Group$1>;
+    addToOrganization(organization: string, users: UserRoles, token?: string): Promise<void>;
+    register(email: string, password: string, password_confirm: string, firstName: string, lastName: string): Promise<void>;
     createOrganization(name: string, token?: string): Promise<Bucket>;
-    addToOrganization(organization: string, users: UserRoles, token?: string): void;
+    removeOrganizationByID(organization: string, token?: string): Promise<Bucket>;
     getFolderByName(name: string, token?: string): Promise<Folder>;
     getFolderByID(id: string, token?: string): Promise<Folder>;
-    removeOrganizationByID(organization: string, token?: string): Promise<Bucket>;
-    register(email: string, password: string, password_confirm: string, firstName: string, lastName: string): void;
 }
+/**
+ * Client supports:
+ * - Keycloak mode: setTokenProvider(() => auth.getValidToken())
+ * - Legacy mode: login(email, pass) -> stores tokens in sessionStorage
+ *
+ * For SPAs with Keycloak: DO NOT store tokens. Use setTokenProvider.
+ */
 declare class Client implements IClient$1 {
     private _userConsumer;
     private _groupConsumer;
     private _bucketConsumer;
     private _folderConsumer;
-    constructor(_managementURL: string, _accountURL: string);
+    private _axiosAccount;
+    private _axiosManagement;
+    private _tokenProvider?;
+    constructor(managementURL: string, accountURL: string);
+    /**
+     * Set a token provider (Keycloak-friendly).
+     * Example from Angular:
+     *   client.setTokenProvider(() => auth.getValidToken())
+     */
+    setTokenProvider(provider: TokenProvider): void;
+    /**
+     * Optional legacy mode.
+     * If you call login(), it stores tokens in sessionStorage
+     * and the default token provider will read them.
+     *
+     * For Keycloak SPA: do NOT use this.
+     */
+    login(email: string, password: string): Promise<OidcToken>;
     setSession(session: OidcToken): void;
     getSessionVariable(key: string): string | null;
-    login(email: string, password: string): Promise<OidcToken>;
+    private _attachAuthInterceptor;
+    /**
+     * If your consumers already accept `token?: string` and set headers inside,
+     * you can leave them as-is and just pass token through.
+     *
+     * But the best pattern is: do not pass token in SPA and let interceptor handle it.
+     */
     myUser(token?: string): Promise<User$1>;
     allOrganizations(token?: string): Promise<Group$1[]>;
     myOrganizations(token?: string): Promise<Group$1[]>;
     organizationByID(id: string, token?: string): Promise<Group$1>;
     organizationByName(name: string, token?: string): Promise<Group$1>;
+    addToOrganization(organization: string, users: UserRoles, token?: string): Promise<void>;
+    register(email: string, password: string, password_confirm: string, firstName: string, lastName: string): Promise<void>;
     createOrganization(name: string, token?: string): Promise<Bucket>;
     removeOrganizationByID(organization: string, token?: string): Promise<Bucket>;
-    addToOrganization(organization: string, users: UserRoles, token?: string): void;
-    register(email: string, password: string, password_confirm: string, firstName: string, lastName: string): Promise<any>;
     getFolderByName(name: string, token?: string): Promise<Folder>;
     getFolderByID(id: string, token?: string): Promise<Folder>;
+    get accountAxios(): AxiosInstance;
+    get managementAxios(): AxiosInstance;
+    /**
+     * Make an axios request using an explicit token without passing it through every method:
+     */
+    requestWithToken<T>(instance: AxiosInstance, token: string, config: AxiosRequestConfig): Promise<T>;
 }
 
 type User = User$1;

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
@@ -19,6 +21,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -783,65 +786,87 @@ var FolderConsumer = class extends BaseConsumer {
 
 // src/client.ts
 var Client = class {
-  constructor(_managementURL, _accountURL) {
-    const configManagement = {
-      baseURL: _managementURL
-    };
-    const configAccount = {
-      baseURL: _accountURL
-    };
-    const axiosManagement = import_axios.default.create(configManagement);
-    const axiosAccount = import_axios.default.create(configAccount);
+  constructor(managementURL, accountURL) {
+    const axiosManagement = import_axios.default.create({ baseURL: managementURL });
+    const axiosAccount = import_axios.default.create({ baseURL: accountURL });
+    this._axiosManagement = axiosManagement;
+    this._axiosAccount = axiosAccount;
+    this._attachAuthInterceptor(this._axiosAccount);
+    this._attachAuthInterceptor(this._axiosManagement);
     this._userConsumer = new UserConsumer(axiosAccount);
     this._groupConsumer = new GroupConsumer(axiosAccount);
     this._bucketConsumer = new BucketConsumer(axiosManagement);
     this._folderConsumer = new FolderConsumer(axiosManagement);
-    this.addToOrganization = withValidToken(this.addToOrganization.bind(this), _accountURL);
-    this.myUser = withValidToken(this.myUser.bind(this), _accountURL);
-    this.removeOrganizationByID = withValidToken(this.removeOrganizationByID.bind(this), _accountURL);
-    this.organizationByName = withValidToken(this.organizationByName.bind(this), _accountURL);
-    this.allOrganizations = withValidToken(this.allOrganizations.bind(this), _accountURL);
-    this.myOrganizations = withValidToken(this.myOrganizations.bind(this), _accountURL);
-    this.organizationByID = withValidToken(this.organizationByID.bind(this), _accountURL);
-    this.createOrganization = withValidToken(this.createOrganization.bind(this), _accountURL);
-    this.getFolderByName = withValidToken(this.getFolderByName.bind(this), _accountURL);
-    this.getFolderByID = withValidToken(this.getFolderByID.bind(this), _accountURL);
   }
+  /**
+   * Set a token provider (Keycloak-friendly).
+   * Example from Angular:
+   *   client.setTokenProvider(() => auth.getValidToken())
+   */
+  setTokenProvider(provider) {
+    this._tokenProvider = provider;
+  }
+  /**
+   * Optional legacy mode.
+   * If you call login(), it stores tokens in sessionStorage
+   * and the default token provider will read them.
+   *
+   * For Keycloak SPA: do NOT use this.
+   */
+  login(email, password) {
+    return __async(this, null, function* () {
+      const resp = yield this._userConsumer.login(email, password);
+      this.setSession(resp);
+      if (!this._tokenProvider) {
+        this._tokenProvider = () => {
+          var _a;
+          return (_a = this.getSessionVariable("access_token")) != null ? _a : "";
+        };
+      }
+      return resp;
+    });
+  }
+  // -----------------------------
+  // Token / session helpers
+  // -----------------------------
   setSession(session) {
-    const storage = typeof window !== "undefined" ? sessionStorage : global.sessionStorage;
+    if (typeof window === "undefined" || !window.sessionStorage) return;
     const now = Math.floor(Date.now() / 1e3);
-    if (storage) {
-      storage.setItem("access_token", session.access_token);
-      storage.setItem("refresh_token", session.refresh_token);
-      storage.setItem("refresh_expires_in", String(now + session.expires_in));
-      storage.setItem("refresh_exp", String(now + session.refresh_expires_in));
-    } else {
-      console.warn("Session storage is not available.");
-    }
+    sessionStorage.setItem("access_token", session.access_token);
+    sessionStorage.setItem("refresh_token", session.refresh_token);
+    sessionStorage.setItem("exp", String(now + session.expires_in));
+    sessionStorage.setItem("refresh_exp", String(now + session.refresh_expires_in));
   }
   getSessionVariable(key) {
-    const storage = typeof window !== "undefined" ? sessionStorage : global.sessionStorage;
-    return storage ? storage.getItem(key) : null;
-  }
-  // private _setSession(session: OidcToken): void {
-  //   const now = Math.floor(Date.now() / 1000);
-  //   if (typeof localStorage !== "undefined") {
-  //     localStorage.setItem('token', session.access_token);
-  //     localStorage.setItem('refresh_token', session.refresh_token);
-  //     localStorage.setItem('exp', String(now + session.expires_in));
-  //     localStorage.setItem('refresh_exp', String(now + session.refresh_expires_in));
-  //   } else {
-  //     console.warn("⚠️ Local Storage not available. You will need to pass tokens manually.");
-  //   }
-  // }
-  login(email, password) {
-    return this._userConsumer.login(email, password).then(
-      (resp) => {
-        this.setSession(resp);
-        return resp;
+    if (typeof window === "undefined" || !window.sessionStorage) return null;
+    return sessionStorage.getItem(key);
+  }
+  _attachAuthInterceptor(instance) {
+    instance.interceptors.request.use((config) => __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f;
+      const anyConfig = config;
+      if (anyConfig._token && typeof anyConfig._token === "string") {
+        (_c = (_b = (_a = config.headers) == null ? void 0 : _a.set) == null ? void 0 : _b.call(_a, "Authorization", `Bearer ${anyConfig._token}`)) != null ? _c : config.headers["Authorization"] = `Bearer ${anyConfig._token}`;
+        return config;
       }
-    );
-  }
+      if (this._tokenProvider) {
+        const token = yield this._tokenProvider();
+        if (token) {
+          (_f = (_e = (_d = config.headers) == null ? void 0 : _d.set) == null ? void 0 : _e.call(_d, "Authorization", `Bearer ${token}`)) != null ? _f : config.headers["Authorization"] = `Bearer ${token}`;
+        }
+      }
+      return config;
+    }));
+  }
+  /**
+   * If your consumers already accept `token?: string` and set headers inside,
+   * you can leave them as-is and just pass token through.
+   *
+   * But the best pattern is: do not pass token in SPA and let interceptor handle it.
+   */
+  // -----------------------------
+  // Account APIs
+  // -----------------------------
   myUser(token) {
     return this._userConsumer.getUser(token);
   }
@@ -857,35 +882,33 @@ var Client = class {
   organizationByName(name, token) {
     return this._groupConsumer.getGroupByName(name, token);
   }
-  createOrganization(name, token) {
-    return this._groupConsumer.postGroup(name, token).then(
-      (group) => {
-        return this._bucketConsumer.postBucket(group.id, name, token);
-      }
-    );
-  }
-  removeOrganizationByID(organization, token) {
-    return this._groupConsumer.deleteGroup(organization, token).then(
-      () => {
-        return this._bucketConsumer.deleteBucket(organization, token).then(
-          (bucket) => {
-            if (!bucket) {
-              throw new Error(`Bucket with ID ${organization} could not be deleted.`);
-            }
-            return bucket;
-          }
-        );
-      }
-    );
-  }
   addToOrganization(organization, users, token) {
-    return this._groupConsumer.addUsers(organization, users, token);
+    return __async(this, null, function* () {
+      yield this._groupConsumer.addUsers(organization, users, token);
+    });
   }
   register(email, password, password_confirm, firstName, lastName) {
-    if (password != password_confirm) {
-      throw new Error("Passwords do not match");
-    }
-    return this._userConsumer.register(email, password, firstName, lastName);
+    return __async(this, null, function* () {
+      if (password !== password_confirm) throw new Error("Passwords do not match");
+      yield this._userConsumer.register(email, password, firstName, lastName);
+    });
+  }
+  // -----------------------------
+  // Management APIs
+  // -----------------------------
+  createOrganization(name, token) {
+    return __async(this, null, function* () {
+      const group = yield this._groupConsumer.postGroup(name, token);
+      return this._bucketConsumer.postBucket(group.id, name, token);
+    });
+  }
+  removeOrganizationByID(organization, token) {
+    return __async(this, null, function* () {
+      yield this._groupConsumer.deleteGroup(organization, token);
+      const bucket = yield this._bucketConsumer.deleteBucket(organization, token);
+      if (!bucket) throw new Error(`Bucket with ID ${organization} could not be deleted.`);
+      return bucket;
+    });
   }
   getFolderByName(name, token) {
     return this._folderConsumer.getFolderByName(name, token);
@@ -893,6 +916,26 @@ var Client = class {
   getFolderByID(id, token) {
     return this._folderConsumer.getFolderByID(id, token);
   }
+  // ---------------------------------------------------
+  // OPTIONAL helpers for “explicit token per call”
+  // without changing all your consumers:
+  // ---------------------------------------------------
+  get accountAxios() {
+    return this._axiosAccount;
+  }
+  get managementAxios() {
+    return this._axiosManagement;
+  }
+  /**
+   * Make an axios request using an explicit token without passing it through every method:
+   */
+  requestWithToken(instance, token, config) {
+    return __async(this, null, function* () {
+      const cfg = __spreadProps(__spreadValues({}, config), { _token: token });
+      const res = yield instance.request(cfg);
+      return res.data;
+    });
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@singularlogic/coreplatts",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [