@or-sdk/authorizer 0.25.0-beta.647.0 → 0.25.0

package/src/Basic/BasicCollection.ts

@@ -1,78 +1,341 @@
-import { Token } from '@or-sdk/base';
+import { List, makeList } from '@or-sdk/base';
+import { Providers } from '@or-sdk/providers';
 import { KeyValueStorage } from '@or-sdk/key-value-storage';
-import { BasicAuth } from './BasicAuth';
+import { createAuthKey, createDynamicKey } from './utils/createAuthKey';
+import { v4 as uuidv4 } from 'uuid';
 
 import {
+  BasicAuthData,
   BasicCollectionConfig,
   CreateBasicAuthInCollectionConfig,
+  BasicDynamicCollection,
 } from './types';
 
 export class BasicCollection {
-  private readonly serviceName: string;
+  private serviceName: string;
   private readonly keyValueStorage: KeyValueStorage;
-  private readonly localToken: Token;
-  private readonly localDiscoveryUrl: string;
+  private readonly providers: Providers;
 
   constructor(params: BasicCollectionConfig) {
-    const { token, discoveryUrl, serviceName } = params;
+    const { token, discoveryUrl, serviceName, accountId } = params;
 
-    this.localToken = token;
-    this.localDiscoveryUrl = discoveryUrl;
-    this.serviceName = serviceName;
+    this.serviceName = serviceName || '';
     this.keyValueStorage = new KeyValueStorage({
       token,
       discoveryUrl,
+      accountId,
+    });
+    this.providers = new Providers({
+      token,
+      discoveryUrl,
     });
   }
 
+
+  /**
+   * Allows to explicitly (re-)set authorization service name
+   */
+  public init(serviceName: string) {
+    if (!serviceName) throw new Error('Service name is required.');
+
+    this.serviceName = serviceName;
+  }
+
+
+  /**
+   * Encodes username and password into Basic authorization token
+   */
+  static encodeAccessToken(username: string, password: string): string {
+    return btoa(`${username}:${password}`);
+  }
+
+  /**
+   * Decodes base64 encoded token and parses it to username and password
+   */
+  static decodeAccessToken(token: string): {username: string; password: string;} {
+    const [username, password] = atob(token).split(':');
+    return {
+      username,
+      password,
+    };
+  }
+
+
   /**
    * Returns array of auth keys from this collection
    */
-  public async listAuthorizations(): Promise<string[]> {
+  public async listAuthorizations(dynamicCollectionName?: string): Promise<List<string>> {
     const { items: records } = await this.keyValueStorage.listKeys(this.serviceName);
 
-    return records.map((record) => record.key);
+    const pattern = dynamicCollectionName ? '::basic-collection::' + dynamicCollectionName : '::basic::';
+
+    return makeList<string>(records.map((record) => record.key).filter(key => key.includes(pattern)));
   }
 
+
   /**
    * Returns BasicAuth instance for given key
    */
-  public async getAuthorization(key: string): Promise<BasicAuth> {
-    const record = await this.keyValueStorage.getValueByKey(this.serviceName, key);
+  public async getAuthorization(key: string, dynamicCollectionName?: string): Promise<BasicAuthData> {
+    if (!this.serviceName) throw new Error('Service name is not defined.');
+
+    if (dynamicCollectionName) {
+      const collectionRecord = await this.keyValueStorage.getValueByKey(
+        '__authorizer_dynamic_collections',
+        dynamicCollectionName
+      );
+
+      const collection = collectionRecord.value as BasicDynamicCollection;
+      if (!collection || collection.type !== 'basic') throw new Error('Dynamic collection name is invalid');
+
+      key = collection.authorizations[key];
+      if (!key) throw new Error('Dynamic collection does not have such key');
+
+    }
+    if (!key.includes('::basic')) {
+      throw new Error('The basic authorization key should contain "basic" type specifier.');
+    }
+
+    const record = await this.keyValueStorage.getValueByKey(this.serviceName, encodeURIComponent(key));
+
     if (!record.value) {
-      throw new Error('Authorization does not exist');
+      throw new Error('Authorization does not exist.');
     }
 
-    return new BasicAuth({
-      serviceName: this.serviceName,
-      authKey: key,
-      discoveryUrl: this.localDiscoveryUrl,
-      token: this.localToken,
-    });
+    const authRecord = record.value as Omit<BasicAuthData, 'key'>;
+
+    if (
+      !authRecord.auth_name ||
+      !authRecord.access_token ||
+      !(authRecord.date_created || authRecord._date_created)
+    ) {
+      throw new Error('Authorization does not exist or invalid.');
+    }
+
+    return {
+      ...authRecord,
+      key,
+    } as BasicAuthData;
   }
 
+
   /**
    * Creates a new auth record in current collection with the given config.
-   * @returns BasicAuth instance connected to created auth
+   * @returns BasicAuthData object
    *
    * ```typescript
-   * const basicAuthInstance = await basicCollectionInstance.createAuthorization({
+   * const basicAuthData = await basicCollectionInstance.createAuthorization({
    *   authName: 'my-auth-name',
    *   username: 'user',
-   *   password: 'pass'
+   *   password: 'pass',
+   *   dynamicCollection: 'my-dynamic-collection' // Optional
    * });
    * ```
    */
   public async createAuthorization(
     params: CreateBasicAuthInCollectionConfig
-  ): Promise<BasicAuth> {
-    return await BasicAuth.create({
-      discoveryUrl: this.localDiscoveryUrl,
-      token: this.localToken,
-      serviceName: this.serviceName,
-      authName: params.authName,
-      password: params.password,
-      username: params.username,
-    });
+  ): Promise<BasicAuthData> {
+
+    const { authName, password, username, dynamicCollection, destinationAccount = 'CURRENT', customAccountId } = params;
+
+    if (!authName || !username || !password) {
+      throw new Error('Invalid authorization config passed.');
+    }
+
+    if (!this.serviceName) throw new Error('Service name is not defined.');
+
+
+    const id = uuidv4();
+    const authKey = dynamicCollection ? createDynamicKey(id, dynamicCollection) : createAuthKey(id, authName);
+
+    const authData = {
+      auth_name: authName,
+      access_token: BasicCollection.encodeAccessToken(username, password),
+      _date_created: new Date().toISOString(),
+    } as Omit<BasicAuthData, 'key'>;
+
+    if (dynamicCollection) {
+      const { value } = await this.keyValueStorage.getValueByKey(
+        '__authorizer_dynamic_collections',
+        dynamicCollection
+      );
+
+      const collection = value as BasicDynamicCollection;
+
+      if (!collection) throw new Error('Dynamic collection name is invalid');
+      if (collection.type !== 'basic' || collection.service !== this.serviceName) {
+        throw new Error('Dynamic collection\'s type or service is invalid');
+      }
+
+      collection.authorizations[authName] = authKey;
+      await this.keyValueStorage.setValueByKey(
+        '__authorizer_dynamic_collections',
+        dynamicCollection,
+        collection
+      );
+    }
+
+    // Accounts handling
+    if (destinationAccount === 'CURRENT') {
+      await this.keyValueStorage.setValueByKey(this.serviceName, encodeURIComponent(authKey), authData);
+    } else {
+      const localRecord = {
+        auth_name: authData.auth_name,
+        isRemote: true,
+        id,
+      };
+
+      if (destinationAccount === 'CUSTOM' && !customAccountId) {
+        throw new Error('Custom Account ID is required if destinationAccount === "CUSTOM"');
+      }
+
+      await this.providers.makeRequest({
+        route: 'authorizer/redirect',
+        params: {
+          method: 'PUT',
+          data: {
+            authData,
+            id,
+            storeAccount: destinationAccount,
+            storeCustomAccountId: destinationAccount === 'CUSTOM' ? customAccountId : undefined,
+          },
+        },
+      }).catch(() => { throw new Error('Could not save basic credentials to the specified account');});
+
+      await this.keyValueStorage.setValueByKey(this.serviceName, encodeURIComponent(authKey), localRecord);
+    }
+
+    return {
+      ...authData,
+      key: authKey,
+    } as BasicAuthData;
+  }
+
+
+  /**
+   * Returns array of auth keys from this collection
+   */
+  public async updateAuthorization(
+    basicAuth: BasicAuthData,
+    newCredentials: { username?: string; password?: string; }
+  ): Promise<BasicAuthData> {
+    if (!basicAuth || !basicAuth.key || !basicAuth.access_token) {
+      throw new Error('Authorization is invalid.');
+    }
+
+    if (!this.serviceName) throw new Error('Service name is not defined.');
+
+
+    let { username, password } = BasicCollection.decodeAccessToken(basicAuth.access_token);
+
+    if (newCredentials.username) {
+      username = newCredentials.username;
+    }
+    if (newCredentials.password) {
+      password = newCredentials.password;
+    }
+
+    const access_token = BasicCollection.encodeAccessToken(username, password);
+    const response = await this.keyValueStorage.setValueByKey(
+      this.serviceName,
+      encodeURIComponent(basicAuth.key),
+      {
+        auth_name: basicAuth.auth_name,
+        _date_created: basicAuth.date_created || basicAuth._date_created,
+        access_token,
+      }
+    );
+
+    const updatedData = response.value as Omit<BasicAuthData, 'key'>;
+    return {
+      ...updatedData,
+      key: basicAuth.key,
+    } as BasicAuthData;
+  }
+
+
+  /**
+   * Deletes authorization from collection
+   */
+  public async deleteAuthorization(authKey: string): Promise<void> {
+    if (!this.serviceName) throw new Error('Service name is not defined.');
+
+    if (authKey.includes('::basic-collection::')) {
+      const dynamicCollectionName = authKey.split('::')[2].split(' ')[0];
+      const { value } = await this.keyValueStorage.getValueByKey(
+        '__authorizer_dynamic_collections',
+        dynamicCollectionName
+      );
+
+      const collection = value as BasicDynamicCollection;
+      if (collection) {
+        const authName = Object.keys(collection.authorizations)
+          .find(name => collection.authorizations[name] === authKey);
+
+        if (authName) {
+          delete collection.authorizations[authName];
+          await this.keyValueStorage.setValueByKey(
+            '__authorizer_dynamic_collections',
+            dynamicCollectionName,
+            collection
+          );
+        }
+      }
+    }
+
+    await this.keyValueStorage.deleteKey(this.serviceName, encodeURIComponent(authKey));
+  }
+
+
+  /**
+   * Creates a Dynamic Token collection
+   */
+  public async createDynamicCollection(dynamicCollectionName: string): Promise<void> {
+    if (!dynamicCollectionName) throw new Error('Dynamic collection name is empty or invalid');
+    const { value } = await this.keyValueStorage.getValueByKey(
+      '__authorizer_dynamic_collections',
+      dynamicCollectionName
+    );
+    const collection = value as BasicDynamicCollection;
+
+    if (!value) {
+      await this.keyValueStorage.setValueByKey(
+        '__authorizer_dynamic_collections',
+        dynamicCollectionName,
+        {
+          name: dynamicCollectionName,
+          type: 'basic',
+          service: this.serviceName,
+          serviceConfigName: this.serviceName,
+          authorizations: {},
+        });
+    } else if (collection.type === 'oauth' && collection.service === this.serviceName) {
+      throw new Error('Same collection already exists');
+    } else {
+      throw new Error('Different collection exists with this name');
+    }
+  }
+
+
+  /**
+   * Deletes a Dynamic collection
+   */
+  public async deleteDynamicCollection(dynamicCollectionName: string): Promise<void> {
+    if (!dynamicCollectionName) throw new Error('Dynamic collection name is empty or invalid');
+    const { value } = await this.keyValueStorage.getValueByKey('__authorizer_dynamic_collections', dynamicCollectionName);
+    const collection = value as BasicDynamicCollection;
+
+    await Promise.all(
+      Object.keys(collection.authorizations)
+        .map(authName => {
+          return this.keyValueStorage.deleteKey(
+            collection.service,
+            encodeURIComponent(collection.authorizations[authName])
+          );
+        })
+    ).catch(() => {});
+
+    await this.keyValueStorage.deleteKey('__authorizer_dynamic_collections', dynamicCollectionName);
   }
 }
+

package/src/Basic/index.ts

@@ -0,0 +1,3 @@
+export { BasicCollection } from './BasicCollection';
+
+export * from './types';

package/src/Basic/types.ts

@@ -1,19 +1,7 @@
 import { Token } from '@or-sdk/base';
 
-export type BasicAuthConfig = {
-  /**
-   * token
-   */
-  token: Token;
-  /**
-   * function which return token
-   */
-  discoveryUrl: string;
-  serviceName: string;
-  authKey: string;
-};
-
 export type BasicAuthData = {
+  key: string;
   auth_name: string;
 
   /**
@@ -24,7 +12,8 @@ export type BasicAuthData = {
   /**
    * Datetime of auth creation in YYYY-MM-DDTHH:MM:SSZ format
    */
-  date_created: string;
+  date_created?: string;
+  _date_created?: string;
 };
 
 export type CreateBasicAuthConfig = {
@@ -37,6 +26,9 @@ export type CreateBasicAuthConfig = {
    * token
    */
   token: Token;
+  dynamicCollection?: string;
+  destinationAccount: 'CURRENT' | 'CUSTOM' | 'PROVIDER';
+  customAccountId?: string;
 };
 
 export type CreateBasicAuthInCollectionConfig = Omit<CreateBasicAuthConfig, 'serviceName' | 'discoveryUrl' | 'token'>;
@@ -50,5 +42,18 @@ export type BasicCollectionConfig = {
    * function which return token
    */
   discoveryUrl: string;
-  serviceName: string;
+  accountId?: string;
+  serviceName?: string;
+};
+
+export type BasicDynamicCollection = {
+  name: string;
+  type: string;
+  service: string;
+  serviceConfigName: string;
+  authorizations: {
+    [key: string]: string;
+  };
+  appId?: string;
+  scope?: string;
 };

package/src/Basic/utils/createAuthKey.ts

@@ -1,3 +1,7 @@
 export const createAuthKey = (id: string, authName: string): string => {
   return `${id}::basic::${authName}`;
 };
+
+export function createDynamicKey(id: string, dynamicCollection: string): string {
+  return `${id}::basic-collection::${dynamicCollection} collection auth`;
+}