@dstny/scp-authenticator 0.0.2 → 0.0.3

package/dist/index.js

@@ -11250,8 +11250,153 @@ Object.defineProperty(Emittery, "listenerRemoved", {
   configurable: false
 });
 
-// src/Authenticator.ts
-var import_scp_credentials = require("@dstny/scp-credentials");
+// ../credentials/dist/index.mjs
+function base64decode(str) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+  let output = "";
+  str = String(str).replace(/={1,10}$/, "");
+  if (str.length % 4 === 1) {
+    throw new Error("'atob' failed: The string to be decoded is not correctly encoded.");
+  }
+  for (
+    let bc = 0, bs, buffer, idx = 0;
+    // tslint:disable-next-line:no-conditional-assignment
+    buffer = str.charAt(idx++);
+    // tslint:disable-next-line:no-bitwise
+    ~buffer && // tslint:disable-next-line:no-conditional-assignment
+    (bs = bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? (
+      // tslint:disable-next-line:no-bitwise
+      output += String.fromCharCode(255 & bs >> (-2 * bc & 6))
+    ) : 0
+  ) {
+    buffer = chars.indexOf(buffer);
+  }
+  return output;
+}
+async function sha1(str) {
+  if (typeof crypto === "object") {
+    const hash = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(str));
+    return Array.from(new Uint8Array(hash)).map((v) => v.toString(16).padStart(2, "0")).join("");
+  } else {
+    const Crypto = await import("crypto");
+    return Crypto.createHash("sha1").update(str).digest("hex");
+  }
+}
+var STORE_CREDENTILAS_KEY = "sdk-auth-credential";
+var Credentials = class _Credentials {
+  static async fromStorage(storage) {
+    const str = await storage.getItem(STORE_CREDENTILAS_KEY);
+    if (str == null || str == void 0) {
+      throw new Error("No credentials found in storage.");
+    }
+    return _Credentials.fromJSON(str);
+  }
+  static async toStorage(storage, credentials) {
+    await storage.setItem(STORE_CREDENTILAS_KEY, JSON.stringify(credentials));
+  }
+  static async clearFromStorage(storage) {
+    await storage.deleteItem(STORE_CREDENTILAS_KEY);
+  }
+  static fromJSON(str) {
+    const { access_token, refresh_token, expires_in } = JSON.parse(str);
+    return new _Credentials(access_token, refresh_token, expires_in);
+  }
+  static onStorageUpdate(storage, callback) {
+    return storage.on(STORE_CREDENTILAS_KEY, (credentials) => {
+      if (typeof credentials === "string") {
+        callback(_Credentials.fromJSON(credentials));
+      }
+    });
+  }
+  static equals(a, b) {
+    if (!a && !b) {
+      return true;
+    }
+    if (a && !b || b && !a) {
+      return false;
+    }
+    return a?.access_token === b?.access_token && a?._refresh_token === b?.refresh_token && a?.expires_in === b?.expires_in;
+  }
+  /**
+   * Used to access resources.
+   */
+  _access_token;
+  /**
+   * Used to obtain a new access token.
+   */
+  _refresh_token;
+  /**
+   * Number of seconds until the access token expires.
+   * This value is calculated at the moment the access token is generated.
+   */
+  _expires_in;
+  constructor(access_token, refresh_token, expires_in) {
+    this._access_token = access_token;
+    this._refresh_token = refresh_token;
+    this._expires_in = expires_in;
+  }
+  /**
+   * Lists the claims present in the access token.
+   */
+  get claims() {
+    const fallback = {};
+    if (typeof this._access_token != "string") {
+      return fallback;
+    }
+    const [, b64payload] = this._access_token.split(".");
+    const payload = base64decode(b64payload);
+    if (!payload) {
+      return fallback;
+    }
+    try {
+      return JSON.parse(payload);
+    } catch (err) {
+      return {};
+    }
+  }
+  get access_token() {
+    return this._access_token;
+  }
+  get refresh_token() {
+    return this._refresh_token;
+  }
+  get expires_in() {
+    return this._expires_in;
+  }
+  get token_type() {
+    return "Bearer";
+  }
+  get expires_at() {
+    if (typeof this.claims?.exp === "number") {
+      return new Date(this.claims?.exp * 1e3);
+    }
+    const expiryDate = /* @__PURE__ */ new Date();
+    expiryDate.setSeconds(expiryDate.getSeconds() + this._expires_in);
+    return expiryDate;
+  }
+  isExpired() {
+    return this.expires_at && (/* @__PURE__ */ new Date()).getTime() > new Date(this.expires_at).getTime();
+  }
+  async getUepId() {
+    const { sub, uep_id: rawUepId } = this.claims;
+    if (!sub) {
+      throw new Error("Missing 'sub' claim.");
+    }
+    if (rawUepId) {
+      return rawUepId;
+    }
+    return await sha1(sub);
+  }
+  toJSON() {
+    return {
+      access_token: this._access_token,
+      refresh_token: this._refresh_token,
+      expires_in: this._expires_in,
+      expires_at: this.expires_at,
+      token_type: this.token_type
+    };
+  }
+};
 
 // src/utils/jwt.ts
 function decodeToken(token) {
@@ -11429,14 +11574,14 @@ var Authenticator = class extends Emittery {
     } else {
       const localStorageCredentials = await this.secureStorage.getItem(STORE_CREDENTIALS_KEY);
       if (typeof localStorageCredentials === "string") {
-        credentials = import_scp_credentials.Credentials.fromJSON(localStorageCredentials);
+        credentials = Credentials.fromJSON(localStorageCredentials);
       }
     }
     if (credentials) {
       this.logger?.log("Has credentials:", credentials);
       await this._signInWithCredentials(credentials);
     }
-    this.removeCredentialStorageUpdates = import_scp_credentials.Credentials.onStorageUpdate(
+    this.removeCredentialStorageUpdates = Credentials.onStorageUpdate(
       this.secureStorage,
       (credentials2) => {
         this._signInWithCredentials(credentials2, true);
@@ -11455,7 +11600,7 @@ var Authenticator = class extends Emittery {
     this.unsubscribeUpdateState = this.on(
       INTERNAL_CREDENTIALS,
       async ({ credentials: credentials2, isFromOtherInstance }) => {
-        if (import_scp_credentials.Credentials.equals(this._credentials, credentials2)) {
+        if (Credentials.equals(this._credentials, credentials2)) {
           return;
         }
         this._credentials = credentials2;
@@ -15139,7 +15284,6 @@ var AbstractAuthenticationApi = class {
 };
 
 // src/api/OAuthApi.ts
-var import_scp_credentials2 = require("@dstny/scp-credentials");
 var OAuthApi = class extends AbstractAuthenticationApi {
   clientId;
   scope;
@@ -15166,7 +15310,7 @@ var OAuthApi = class extends AbstractAuthenticationApi {
         redirect_uri: redirectUri
       })
     );
-    return new import_scp_credentials2.Credentials(data.access_token, data.refresh_token, data.expires_in);
+    return new Credentials(data.access_token, data.refresh_token, data.expires_in);
   }
   async loginWithUsernamePassword(username, password) {
     const { data } = await this.axiosInstance.post(
@@ -15178,7 +15322,7 @@ var OAuthApi = class extends AbstractAuthenticationApi {
         password
       })
     );
-    return new import_scp_credentials2.Credentials(data.access_token, data.refresh_token, data.expires_in);
+    return new Credentials(data.access_token, data.refresh_token, data.expires_in);
   }
   async refreshToken(refreshToken, accessToken) {
     try {
@@ -15190,7 +15334,7 @@ var OAuthApi = class extends AbstractAuthenticationApi {
           refresh_token: refreshToken
         })
       );
-      return new import_scp_credentials2.Credentials(
+      return new Credentials(
         response.data.access_token,
         response.data.refresh_token,
         response.data.expires_in
@@ -15217,7 +15361,6 @@ var OAuthApi = class extends AbstractAuthenticationApi {
 };
 
 // src/api/SmgAuthApi.ts
-var import_scp_credentials3 = require("@dstny/scp-credentials");
 var SmgAuthApi = class extends AbstractAuthenticationApi {
   clientId;
   realm;
@@ -15252,7 +15395,7 @@ var SmgAuthApi = class extends AbstractAuthenticationApi {
     const expires_in = exp - iat;
     const expires_at = /* @__PURE__ */ new Date();
     expires_at.setSeconds(expires_at.getSeconds() + expires_in);
-    return new import_scp_credentials3.Credentials(accessToken, refreshToken, expires_in);
+    return new Credentials(accessToken, refreshToken, expires_in);
   }
   async refreshToken(refreshToken, accessToken) {
     try {
@@ -15268,7 +15411,7 @@ var SmgAuthApi = class extends AbstractAuthenticationApi {
       const { refreshToken: newRefreshToken, accessToken: newAccessToken } = data;
       const { iat = 0, exp = 0 } = decodeToken(newAccessToken);
       const expires_in = exp - iat;
-      return new import_scp_credentials3.Credentials(newAccessToken, newRefreshToken, expires_in);
+      return new Credentials(newAccessToken, newRefreshToken, expires_in);
     } catch (error) {
       if (axios_default.isAxiosError(error)) {
         if (error.message === "Network Error") {