@or-sdk/authorizer 0.10.0

package/src/Basic/BasicAuth.ts

@@ -0,0 +1,147 @@
+import { KeyValueStorage } from '@or-sdk/key-value-storage';
+
+import { v4 as uuidv4 } from 'uuid';
+
+import { BasicAuthConfig, BasicAuthData, CreateBasicAuthConfig } from './types';
+
+import { createAuthKey } from './utils/createAuthKey';
+
+/**
+ * OneReach Authorizer service client
+ *  ## Installation:
+ * ```
+ * $ npm i @or-sdk/authorizer
+ * ```
+ */
+export class BasicAuth {
+  private readonly authKey: string;
+  private readonly serviceName: string;
+  private readonly keyValueStorage: KeyValueStorage;
+
+  /**
+   * Connects to existing authorization
+   *
+   * ```typescript
+   * import { BasicAuth } from '@or-sdk/authorizer'
+   * const basicAuthInstance = new BasicAuth({
+   *   token: 'my-account-token-string',
+   *   discoveryUrl: 'discovery.example.onereach.ai',
+   *   serviceName: '__authorization_service_test_service',
+   *   authKey: '637ac446-1021-475f-9992-3ce7f3ddb637::basic::someAuth::__authorization_service_test_service::02bf4366-f987-49ea-90a6-0d346e13c3c1',
+   * });
+   * ```
+   */
+  constructor(params: BasicAuthConfig) {
+    const { token, discoveryUrl, authKey, serviceName } = params;
+
+    this.authKey = authKey;
+    this.serviceName = serviceName;
+    this.keyValueStorage = new KeyValueStorage({
+      token,
+      discoveryUrl,
+    });
+  }
+
+  /**
+   * Encodes username and passoword 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,
+    };
+  }
+
+  /**
+   * Creates a new auth record in specified collection with the given config.
+   * @returns BasicAuth instance connected to created auth
+   *
+   * ```typescript
+   * const basicAuthInstance = await BasicAuth.create({
+   *   token: 'my-account-token-string',
+   *   discoveryUrl: 'discovery.example.onereach.ai',
+   *   serviceName: '__authorization_service_test_service',
+   *   authName: 'my-auth-name',
+   *   username: 'user',
+   *   password: 'pass'
+   * });
+   * ```
+   */
+  static async create(params: CreateBasicAuthConfig): Promise<BasicAuth> {
+    if (!(params.serviceName && params.authName && params.username && params.password && params.discoveryUrl && params.token)) {
+      throw new Error('Invalid config passed');
+    }
+
+    const { serviceName, authName, username, password, discoveryUrl, token } = params;
+
+    const keyValueStorage = new KeyValueStorage({
+      token,
+      discoveryUrl,
+    });
+
+    const id = uuidv4();
+    const authKey = createAuthKey(id, authName);
+
+    const authData = {
+      auth_name: authName,
+      access_token: BasicAuth.encodeAccessToken(username, password),
+      date_created: new Date().toISOString(),
+    };
+
+    await keyValueStorage.setValueByKey(serviceName, authKey, authData);
+
+    return new BasicAuth({ serviceName,
+      authKey,
+      discoveryUrl,
+      token });
+  }
+
+  /**
+   * Updates username or password
+   */
+  public async update(newCredentials: { username?: string; password?: string; }): Promise<BasicAuthData> {
+    const data = await this.getAuthData();
+    let { username, password } = BasicAuth.decodeAccessToken(data.access_token);
+
+    if (newCredentials.username) {
+      username = newCredentials.username;
+    }
+    if (newCredentials.password) {
+      password = newCredentials.password;
+    }
+
+    const updatedAccessToken = BasicAuth.encodeAccessToken(username, password);
+    const updatedData = {
+      ...data,
+      access_token: updatedAccessToken,
+    };
+
+    const response = await this.keyValueStorage.setValueByKey(this.serviceName, this.authKey, updatedData);
+
+    const updatedRecord = response.value;
+    return updatedRecord as BasicAuthData;
+  }
+
+  /**
+   * Returns authorization data
+   */
+  public async getAuthData(): Promise<BasicAuthData> {
+    const { value } = await this.keyValueStorage.getValueByKey(this.serviceName, this.authKey);
+    return value as BasicAuthData;
+  }
+
+  /**
+   * Deletes authorization from collection
+   */
+  public async delete(): Promise<void> {
+    await this.keyValueStorage.deleteKey(this.serviceName, this.authKey);
+  }
+}

package/src/Basic/BasicCollection.ts

@@ -0,0 +1,97 @@
+import { Token } from '@or-sdk/base';
+import { KeyValueStorage } from '@or-sdk/key-value-storage';
+import { BasicAuth } from './BasicAuth';
+
+import {
+  BasicCollectionConfig,
+  CreateBasicAuthInCollectionConfig,
+} from './types';
+
+/**
+ * OneReach Authorizer service client
+ *  ## Installation:
+ * ```
+ * $ npm i @or-sdk/authorizer
+ * ```
+ */
+export class BasicCollection {
+  private readonly serviceName: string;
+  private readonly keyValueStorage: KeyValueStorage;
+  private readonly localToken: Token;
+  private readonly localDiscoveryUrl: string;
+
+  /**
+   * Connects to authorization collection
+   *
+   * ```typescript
+   * import { BasicCollection } from '@or-sdk/authorizer'
+   * const basicCollectionInstance = new BasicCollection({
+   *   token: 'my-account-token-string',
+   *   discoveryUrl: 'discovery.example.onereach.ai',
+   *   serviceName: '__authorization_service_test_service',
+   * });
+   * ```
+   */
+  constructor(params: BasicCollectionConfig) {
+    const { token, discoveryUrl, serviceName } = params;
+
+    this.localToken = token;
+    this.localDiscoveryUrl = discoveryUrl;
+    this.serviceName = serviceName;
+    this.keyValueStorage = new KeyValueStorage({
+      token,
+      discoveryUrl,
+    });
+  }
+
+  /**
+   * Returns array of auth keys from this collection
+   */
+  public async listAuthorizations(): Promise<string[]> {
+    const records = await this.keyValueStorage.listKeys(this.serviceName);
+
+    return records.map((record) => record.key);
+  }
+
+  /**
+   * Returns BasicAuth instance for given 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');
+    }
+
+    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 basicAuthInstance = await basicCollectionInstance.createAuthorization({
+   *   authName: 'my-auth-name',
+   *   username: 'user',
+   *   password: 'pass'
+   * });
+   * ```
+   */
+  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,
+    });
+  }
+}

package/src/Basic/types.ts

@@ -0,0 +1,54 @@
+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 = {
+  auth_name: string;
+
+  /**
+   * HTTP Basic authentication Base64 encoded username and password joined by a single colon
+   */
+  access_token: string;
+
+  /**
+   * Datetime of auth creation in YYYY-MM-DDTHH:MM:SSZ format
+   */
+  date_created: string;
+};
+
+export type CreateBasicAuthConfig = {
+  serviceName: string;
+  authName: string;
+  username: string;
+  password: string;
+  discoveryUrl: string;
+  /**
+   * token
+   */
+  token: Token;
+};
+
+export type CreateBasicAuthInCollectionConfig = Omit<CreateBasicAuthConfig, 'serviceName' | 'discoveryUrl' | 'token'>;
+
+export type BasicCollectionConfig = {
+  /**
+   * token
+   */
+  token: Token;
+  /**
+   * function which return token
+   */
+  discoveryUrl: string;
+  serviceName: string;
+};

package/src/Basic/utils/createAuthKey.ts

@@ -0,0 +1,3 @@
+export const createAuthKey = (id: string, authName: string): string => {
+  return `${id}::basic::${authName}`;
+};