@or-sdk/authorizer 0.24.14-beta.971.0 → 0.24.14-beta.976.0

package/src/Basic/BasicCollection.ts

@@ -1,8 +1,6 @@
-import { List, makeList } from '@or-sdk/base';
+import { Token } from '@or-sdk/base';
 import { KeyValueStorage } from '@or-sdk/key-value-storage';
-import { BasicAuthData } from './types';
-import { createAuthKey } from './utils/createAuthKey';
-import { v4 as uuidv4 } from 'uuid';
+import { BasicAuth } from './BasicAuth';
 
 import {
   BasicCollectionConfig,
@@ -10,95 +8,55 @@ import {
 } from './types';
 
 export class BasicCollection {
-  private serviceName: string;
+  private readonly serviceName: string;
   private readonly keyValueStorage: KeyValueStorage;
+  private readonly localToken: Token;
+  private readonly localDiscoveryUrl: string;
 
   constructor(params: BasicCollectionConfig) {
-    const { token, discoveryUrl, serviceName, accountId } = params;
+    const { token, discoveryUrl, serviceName } = params;
 
-    this.serviceName = serviceName || '';
+    this.localToken = token;
+    this.localDiscoveryUrl = discoveryUrl;
+    this.serviceName = serviceName;
     this.keyValueStorage = new KeyValueStorage({
       token,
       discoveryUrl,
-      accountId,
     });
   }
 
-
-  /**
-   * 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<List<string>> {
+  public async listAuthorizations(): Promise<string[]> {
     const { items: records } = await this.keyValueStorage.listKeys(this.serviceName);
 
-    return makeList<string>(records.map((record) => record.key).filter(key => key.includes('::basic')));
+    return records.map((record) => record.key);
   }
 
-
   /**
    * Returns BasicAuth instance for given key
    */
-  public async getAuthorization(key: string): Promise<BasicAuthData> {
-    if (!this.serviceName) throw new Error('Service name is not defined.');
-    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));
-
+  public async getAuthorization(key: string): Promise<BasicAuth> {
+    const record = await this.keyValueStorage.getValueByKey(this.serviceName, key);
     if (!record.value) {
-      throw new Error('Authorization does not exist.');
-    }
-
-
-    const authRecord = record.value as Omit<BasicAuthData, 'key'>;
-
-    if (!authRecord.auth_name || !authRecord.access_token || !authRecord.date_created) {
-      throw new Error('Authorization does not exist or invalid.');
+      throw new Error('Authorization does not exist');
     }
 
-    return {
-      auth_name: authRecord.auth_name,
-      access_token: authRecord.access_token,
-      date_created: authRecord.date_created,
-      key,
-    } as BasicAuthData;
+    return new BasicAuth({
+      serviceName: this.serviceName,
+      authKey: key,
+      discoveryUrl: this.localDiscoveryUrl,
+      token: this.localToken,
+    });
   }
 
-
   /**
    * Creates a new auth record in current collection with the given config.
    * @returns BasicAuth instance connected to created auth
    *
    * ```typescript
-   * const basicAuthData = await basicCollectionInstance.createAuthorization({
+   * const basicAuthInstance = await basicCollectionInstance.createAuthorization({
    *   authName: 'my-auth-name',
    *   username: 'user',
    *   password: 'pass'
@@ -107,83 +65,14 @@ export class BasicCollection {
    */
   public async createAuthorization(
     params: CreateBasicAuthInCollectionConfig
-  ): Promise<BasicAuthData> {
-
-    const { authName, password, username } = 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 = createAuthKey(id, authName);
-
-    const authData = {
-      auth_name: authName,
-      access_token: BasicCollection.encodeAccessToken(username, password),
-      date_created: new Date().toISOString(),
-    } as Omit<BasicAuthData, 'key'>;
-
-    await this.keyValueStorage.setValueByKey(this.serviceName, encodeURIComponent(authKey), authData);
-
-    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,
-        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.');
-    await this.keyValueStorage.deleteKey(this.serviceName, encodeURIComponent(authKey));
+  ): Promise<BasicAuth> {
+    return await BasicAuth.create({
+      discoveryUrl: this.localDiscoveryUrl,
+      token: this.localToken,
+      serviceName: this.serviceName,
+      authName: params.authName,
+      password: params.password,
+      username: params.username,
+    });
   }
 }
-

package/src/Basic/types.ts

@@ -14,7 +14,6 @@ export type BasicAuthConfig = {
 };
 
 export type BasicAuthData = {
-  key: string;
   auth_name: string;
 
   /**
@@ -51,6 +50,5 @@ export type BasicCollectionConfig = {
    * function which return token
    */
   discoveryUrl: string;
-  accountId?: string;
-  serviceName?: string;
+  serviceName: string;
 };

package/src/OAuth/OAuth.ts

@@ -1,7 +1,5 @@
 import { KeyValueStorage } from '@or-sdk/key-value-storage';
-import { Providers } from '@or-sdk/providers';
-import { EVENT_MANAGER_SERVICE_KEY } from '@or-sdk/event-manager';
-import { Discovery } from '@or-sdk/discovery';
+import { EventManager } from '@or-sdk/event-manager';
 import { timeout } from '@or-sdk/base';
 
 import { v4 as uuidv4 } from 'uuid';
@@ -35,27 +33,11 @@ export class OAuth {
   private readonly serviceName: string;
   private readonly keyValueCollection: string;
   private readonly keyValueStorage: KeyValueStorage;
-  private readonly providers: Providers;
+  private readonly eventManager: EventManager;
 
   constructor(params: OAuthConfig) {
-    const {
-      accountId,
-      authKey,
-      discoveryUrl,
-      eventManagerUrl,
-      keyValueCollection,
-      providersAccountId,
-      serviceName,
-      token,
-    } = params;
-
-    if (!(authKey && serviceName && authKey)) {
-      throw new Error('Invalit OAuth params passed.');
-    }
-
-    if (!discoveryUrl && !(eventManagerUrl && providersAccountId)) {
-      throw new Error('OAuth require Discovery URL or both Event Manager URL and Providers Account ID');
-    }
+    const { token, discoveryUrl, authKey, serviceName, keyValueCollection } =
+      params;
 
     this.authKey = authKey;
     this.serviceName = serviceName;
@@ -64,21 +46,19 @@ export class OAuth {
     this.keyValueStorage = new KeyValueStorage({
       token,
       discoveryUrl,
-      accountId,
     });
 
-    this.providers = new Providers({
+    this.eventManager = new EventManager({
       token,
       discoveryUrl,
-      eventManagerUrl,
-      providersAccountId,
+      requestAccountId: true,
+      requestProvidersAccountId: true,
     });
   }
 
   /**
    * Creates a new auth record in specified collection with the given config.
-   * @returns Object with OAuth instance connected to created auth and authorizerUrl
-   *            to redirect the user to for completing authorization
+   * @returns Object with OAuth instance connected to created auth and authorizerUrl to redirect the user to for completing authorization
    *
    * ```typescript
    *  const {
@@ -90,12 +70,10 @@ export class OAuth {
    *   serviceName: '__authorization_service_test_service',
    *   authName: 'my-auth-name',
    *   appId: 'my-app-id',
-   *   keyValueCollection: 'custom_collection_name' // Pass this if you using custom name for key-value collection
-   *                                                // that differs from serviceName
+   *   keyValueCollection: 'custom_collection_name' // Pass this if you using custom name for key-value collection that differs from serviceName
    * });
    *
-   * // if you want to use returned instance, you must call a method that returns a promise
-   * // that will be resolved when the user completes authorization process
+   * // if you want to use returned instance, you must call a method that returns a promise that will be resolved when the user completes authorization process
    * // if not, you can omit this step
    * try {
    *   await instance.waitForCompletion()
@@ -107,85 +85,48 @@ export class OAuth {
   static async create(
     params: CreateOAuthConfig
   ): Promise<CreateOAuthResult> {
-
-    if (!(
-      params.serviceName &&
-      params.authName &&
-      params.token &&
-      params.appId
-    ) || !(
-      params.discoveryUrl ||
-        (
-          params.accountId &&
-          params.providersAccountId &&
-          params.eventManagerUrl
-        )
-    )) {
-      throw new Error('Invalid OAuth config passed');
+    if (
+      !(
+        params.serviceName &&
+        params.authName &&
+        params.discoveryUrl &&
+        params.token &&
+        params.appId
+      )
+    ) {
+      throw new Error('Invalid config passed');
     }
 
-    const {
-      appId,
-      authName,
-      discoveryUrl,
-      scope,
-      serviceName,
-      token,
-    } = params;
-
-    let {
-      accountId,
-      eventManagerUrl,
-      providersAccountId,
-    } = params;
-
-
-    // If AccountID, EventManagerURL or Providers Account ID are not available, fetch them from Discovery
-    if (discoveryUrl && !(accountId && eventManagerUrl && providersAccountId)) {
-      const discovery = new Discovery({
-        token,
-        discoveryUrl,
-      });
-
-      if (!accountId) {
-        accountId = await discovery.getCurrentAccountId();
-      }
-
-      if (!eventManagerUrl) {
-        eventManagerUrl = await discovery.getServiceUrl(EVENT_MANAGER_SERVICE_KEY);
-      }
-
-      if (!providersAccountId) {
-        providersAccountId = await discovery.getProvidersAccountId();
-      }
-    }
+    const { serviceName, authName, discoveryUrl, token, appId, scope } = params;
 
     const keyValueCollection = params.keyValueCollection || serviceName;
 
     const keyValueStorage = new KeyValueStorage({
       token,
       discoveryUrl,
-      accountId,
     });
 
-    const providers = new Providers({
+    const eventManager = new EventManager({
       token,
       discoveryUrl,
-      eventManagerUrl,
-      providersAccountId,
+      requestAccountId: true,
+      requestProvidersAccountId: true,
     });
 
-    const services = await providers.makeRequest<{
+    await eventManager.init();
+
+    const serviceDefinitionProviderRoute = `http/${eventManager.providersAccountId}${SERVICE_PROVIDER_PATH}`;
+
+    const services = await eventManager.makeRequest<{
       [key: string]: ServiceDefinitionConfig;
     }>({
       method: 'GET',
-      route: SERVICE_PROVIDER_PATH,
+      route: serviceDefinitionProviderRoute,
       params: {
         type: 'list',
       },
     });
 
-
     const currentServiceData = services[serviceName];
 
     const apps = await keyValueStorage.getValueByKey(
@@ -193,7 +134,6 @@ export class OAuth {
       '__authorizer_apps'
     );
 
-    // eslint-disable-next-line
     const currentApp: OAuthApp = (apps.value as any).find(
       (app: { label: string; value: OAuthApp; }) => app.value.appId === appId
     ).value;
@@ -205,14 +145,14 @@ export class OAuth {
     );
 
     const id = uuidv4();
-    const authKey = createAuthKey(id, authName, keyValueCollection, accountId || null);
+    const authKey = createAuthKey(id, authName, keyValueCollection, eventManager.currentAccountId);
 
     const additionalBodyData = {};
     const additionalHeaders = {};
 
-    const redirectProviderUrl = `${eventManagerUrl}/http/${providersAccountId}${OAUTH_REDIRECT_PROVIDER_PATH}`;
+    const emUrl = eventManager.serviceUrl;
+    const redirectProviderUrl = `${emUrl}/http/${eventManager.providersAccountId}${OAUTH_REDIRECT_PROVIDER_PATH}`;
 
-    // eslint-disable-next-line
     const authConfigs: any = {
       ...additionalBodyData,
       grant_type: 'authorization_code',
@@ -241,7 +181,7 @@ export class OAuth {
       serviceConfigName: serviceName,
       name: authName,
       displayServiceName: serviceDefinition.displayServiceName,
-      accountId: accountId,
+      accountId: eventManager.currentAccountId,
     };
 
     const authDataExpire = Date.now() + TEMPORARY_DATA_EXPIRATION_TIME;
@@ -273,12 +213,9 @@ export class OAuth {
     const authorizeUrl = authUrl.href;
 
     const newOAuth = new OAuth({
-      accountId,
+      serviceName,
       authKey,
       discoveryUrl,
-      eventManagerUrl,
-      providersAccountId,
-      serviceName,
       token,
     });
 
@@ -314,12 +251,15 @@ export class OAuth {
   }
 
   private async getServiceDefinition(currentApp: OAuthApp): Promise<ServiceDefinition> {
+    await this.eventManager.init();
+
+    const serviceDefinitionProviderRoute = `http/${this.eventManager.providersAccountId}${SERVICE_PROVIDER_PATH}`;
 
-    const services = await this.providers.makeRequest<{
+    const services = await this.eventManager.makeRequest<{
       [key: string]: ServiceDefinitionConfig;
     }>({
       method: 'GET',
-      route: SERVICE_PROVIDER_PATH,
+      route: serviceDefinitionProviderRoute,
       params: {
         type: 'list',
       },
@@ -359,7 +299,7 @@ export class OAuth {
       while (spentTime < pollTimeout) {
         const record = await this.keyValueStorage.getValueByKey(
           this.keyValueCollection,
-          encodeURIComponent(this.authKey)
+          this.authKey
         );
 
         if (record.value) {
@@ -397,7 +337,7 @@ export class OAuth {
 
     const { value } = await this.keyValueStorage.getValueByKey(
       this.serviceName,
-      encodeURIComponent(this.authKey)
+      this.authKey
     );
 
     if (!value) {
@@ -411,14 +351,16 @@ export class OAuth {
       return authData;
     }
 
-    if (!isExpired(authData.created_at, authData.expires_in)) {
+    const expired = isExpired(authData.created_at, authData.expires_in);
+
+    if (!expired) {
       return authData;
     }
 
     await this.refresh();
 
     const { value: refreshedAuthData } =
-      await this.keyValueStorage.getValueByKey(this.serviceName, encodeURIComponent(this.authKey));
+      await this.keyValueStorage.getValueByKey(this.serviceName, this.authKey);
 
     return refreshedAuthData as OAuthData;
   }
@@ -429,7 +371,7 @@ export class OAuth {
   public async refresh(): Promise<void> {
     const { value } = await this.keyValueStorage.getValueByKey(
       this.serviceName,
-      encodeURIComponent(this.authKey)
+      this.authKey
     );
 
     if (!value) {
@@ -450,9 +392,9 @@ export class OAuth {
 
     const serviceDefinition = await this.getServiceDefinition(currentApp);
 
-    await this.providers.makeRequest({
+    await this.eventManager.makeRequest({
       method: 'POST',
-      route: OAUTH_REDIRECT_PROVIDER_PATH,
+      route: new URL(authData.redirect_uri).pathname,
       data: {
         refreshTokenUrl: authData.refreshUri,
         sendDataType: serviceDefinition.requestDataType,
@@ -477,7 +419,7 @@ export class OAuth {
 
     const { value } = await this.keyValueStorage.getValueByKey(
       this.serviceName,
-      encodeURIComponent(this.authKey)
+      this.authKey
     );
 
     if (!value) {
@@ -509,7 +451,7 @@ export class OAuth {
   public async delete(): Promise<void> {
     await this.keyValueStorage.deleteKey(
       this.serviceName,
-      encodeURIComponent(this.authKey)
+      this.authKey
     );
 
     this.status = AuthStatus.DELETED;

package/src/OAuth/OAuthCollection.ts

@@ -1,77 +1,51 @@
-import { Token, List, makeList } from '@or-sdk/base';
+import { Token } from '@or-sdk/base';
 import { KeyValueStorage } from '@or-sdk/key-value-storage';
 import { OAuth } from './OAuth';
 
-import {
-  CreateOAuthInCollectionConfig,
-  CreateOAuthResult,
-  OAuthCollectionConfig,
-  OAuthApp,
-  OAuthCollectionInitConfig,
-} from './types';
+import { OAuthCollectionConfig, CreateOAuthInCollectionConfig, CreateOAuthResult, OAuthApp } from './types';
 
 export class OAuthCollection {
-  private serviceName: string;
-  private keyValueCollection: string;
-  private keyValueStorage: KeyValueStorage;
-  private localAccountId: string | undefined;
+  private readonly serviceName: string;
+  private readonly keyValueCollection: string;
+  private readonly keyValueStorage: KeyValueStorage;
   private readonly localToken: Token;
   private readonly localDiscoveryUrl: string;
 
   constructor(params: OAuthCollectionConfig) {
-    const { token, discoveryUrl, accountId, serviceName, keyValueCollection } = params;
+    const { token, discoveryUrl, serviceName, keyValueCollection } = params;
 
     this.localToken = token;
-    this.localAccountId = accountId;
     this.localDiscoveryUrl = discoveryUrl;
-    this.serviceName = serviceName || '';
-    this.keyValueCollection = keyValueCollection || serviceName || '';
-
+    this.serviceName = serviceName;
+    this.keyValueCollection = keyValueCollection || serviceName;
     this.keyValueStorage = new KeyValueStorage({
-      token: this.localToken,
-      discoveryUrl: this.localDiscoveryUrl,
-      accountId: this.localAccountId,
+      token,
+      discoveryUrl,
     });
   }
 
-
-  /**
-   * Allows to explicitly (re)initialize collection parameters
-   */
-  public init(params: OAuthCollectionInitConfig): void {
-    const { serviceName, keyValueCollection } = params;
-
-    this.serviceName = serviceName || this.serviceName;
-    this.keyValueCollection = keyValueCollection || this.keyValueCollection || this.serviceName;
-
-    if (!this.serviceName) {
-      throw new Error('Service Name is required.');
-    }
-  }
-
-
   /**
    * Returns array of auth keys from this collection
    */
-  public async listAuthorizations(): Promise<List<string>> {
+  public async listAuthorizations(): Promise<string[]> {
     const { items: records } = await this.keyValueStorage.listKeys(
-      this.keyValueCollection || ''
+      this.keyValueCollection
     );
 
-    return makeList<string>(records.map((record) => record.key).filter(key => key.includes('::oauth')));
+    return records.map((record) => record.key);
   }
 
   /**
    * Returns array of OAuth applications for this service
    */
-  public async listOAuthApps(): Promise<List<OAuthApp>> {
+  public async listOAuthApps(): Promise<OAuthApp[]> {
     const appsStorageRecord = await this.keyValueStorage.getValueByKey(
       this.keyValueCollection,
       '__authorizer_apps'
     );
 
     if (!appsStorageRecord.value) {
-      return makeList<OAuthApp>([]);
+      return [];
     }
 
     const appsRecords = appsStorageRecord.value as Array<{
@@ -79,21 +53,19 @@ export class OAuthCollection {
       value: Omit<OAuthApp, 'name'>;
     }>;
 
-    return makeList<OAuthApp>(appsRecords.map((record) => ({
+    return appsRecords.map((record) => ({
       name: record.label,
       ...record.value,
-    })));
+    }));
   }
 
-
   /**
    * Returns OAuth instance for given key
    */
   public async getAuthorization(key: string): Promise<OAuth> {
-    if (!key.includes('::oauth')) throw new Error('The OAuth authorization key should contain "oauth" type specifier.');
     const record = await this.keyValueStorage.getValueByKey(
       this.keyValueCollection,
-      encodeURIComponent(key)
+      key
     );
     if (!record.value) {
       throw new Error('This authorization does not exist');
@@ -108,7 +80,6 @@ export class OAuthCollection {
     });
   }
 
-
   /**
    * Creates a new auth record in current collection with the given config.
    * @returns Object with OAuth instance connected to created auth and authorizerUrl to redirect the user to for completing authorization
@@ -137,7 +108,6 @@ export class OAuthCollection {
     return await OAuth.create({
       discoveryUrl: this.localDiscoveryUrl,
       token: this.localToken,
-      accountId: this.localAccountId,
       appId: params.appId,
       keyValueCollection: this.keyValueCollection,
       scope: params.scope,