@or-sdk/authorizer 0.10.0

package/src/OAuth/types.ts

@@ -0,0 +1,131 @@
+import { Token } from '@or-sdk/base';
+import { OAuth } from './OAuth';
+
+export type OAuthConfig = {
+  /**
+   * token or function which return token
+   */
+  token: Token;
+  discoveryUrl: string;
+  serviceName: string;
+  keyValueCollection?: string;
+  authKey: string;
+};
+
+export type OAuthData = {
+  auth_name: string;
+  displayServiceName: string;
+  appId: string;
+  token_type: string;
+  scope: string;
+  redirect_uri: string;
+  expires_in?: number;
+  refreshUri?: string;
+  access_token: string;
+  created_at: string;
+  authLinkParams?: Record<string, string>;
+  accountId: string;
+};
+
+export type CreateOAuthConfig = {
+  /**
+   * Name of OAuth service definition. If service definition is not found in global library, it will be taken from local library
+   */
+  serviceName: string;
+
+  /**
+   * Pass this if your using custom name for key-value collection that differs from serviceName
+   */
+  keyValueCollection?: string;
+
+  authName: string;
+
+  /**
+   * ID of OAuth application. Use the value "predefined" to use environment-shared application
+   */
+  appId: string;
+
+  /**
+   * Array of OAuth scopes
+   */
+  scope?: Array<string>;
+
+  /**
+   * Token or function which return token
+   */
+  token: Token;
+
+  discoveryUrl: string;
+};
+
+export type CreateOAuthInCollectionConfig = Omit<CreateOAuthConfig, 'discoveryUrl' | 'serviceName' | 'token' | 'keyValueCollection'>;
+
+export type CreateOAuthResult = {
+  authorizeUrl: string;
+  instance: OAuth;
+};
+
+export type OAuthApp = {
+  name: string;
+  appId: string;
+  clientId: string;
+  clientSecret: string;
+  environment?: string;
+  authLinkParams?: Record<string, string>;
+};
+
+export type CreateOAuthAppConfig = {
+  name: string;
+  clientId: string;
+  clientSecret: string;
+
+  /**
+   * Name of environment. You can omit this parameter if you want to use the default environment.
+   */
+  environment?: string;
+
+  /**
+   * Object with values for additional params.
+   */
+  authLinkParams?: Record<string, string>;
+};
+
+export type OAuthCollectionConfig = {
+  /**
+   * token or function which return token
+   */
+  token: Token;
+  discoveryUrl: string;
+  serviceName: string;
+  /**
+   * Pass this if your using custom name for key-value collection that differs from serviceName
+   */
+  keyValueCollection?: string;
+};
+
+export type ServiceDefinitionConfig = {
+  serviceName: string;
+  requestDataType: string;
+  grantType?: string;
+  authorizeUri: string;
+  exchangeTokenUri: string;
+  useRefresh: boolean;
+  expiresInPropertyName: string;
+  expiresInDefaultValue?: number;
+  refreshUri?: string;
+  scopeType: ScopeType;
+  authRequestAdditionalParams: string;
+  codeExchangeRequestAdditionalParams: string;
+  environments?: Record<string, any>;
+  authLinkAdditionalParams?: Record<string, string>[];
+  displayServiceName?: string;
+};
+
+export enum ScopeType {
+  SPACE_DELIMITED = 'SPACE_DELIMITED',
+  COMMA_DELIMITED = 'COMMA_DELIMITED',
+  COMMA_DELIMITED_WITHOUT_WHITESPACE = 'COMMA_DELIMITED_WITHOUT_WHITESPACE',
+  JSON_ARRAY = 'JSON_ARRAY'
+}
+
+

package/src/OAuth/utils/ServiceDefinition.ts

@@ -0,0 +1,171 @@
+import { ServiceDefinitionConfig, ScopeType } from '../types';
+
+export class ServiceDefinition {
+  public currentEnvironment: string;
+  public authLinkAdditionalParamsValues: Record<string, string>;
+
+  private readonly _serviceName: string;
+  private readonly _requestDataType: string;
+  private readonly _grantType?: string;
+  private readonly _authorizeUri: string;
+  private readonly _exchangeTokenUri: string;
+  private readonly _useRefresh: boolean;
+  private readonly _expiresInPropertyName: string;
+  private readonly _expiresInDefaultValue?: number;
+  private readonly _refreshUri?: string;
+  private readonly _scopeType: ScopeType;
+  private readonly _authRequestAdditionalParams: string;
+  private readonly _codeExchangeRequestAdditionalParams: string;
+  private readonly _environments?: any;
+  private readonly _authLinkAdditionalParams?: Record<string, string>[];
+  private readonly _displayServiceName?: string;
+
+  constructor(params: ServiceDefinitionConfig, authLinkAdditionalParamsValues?: Record<string, string>, currentEnvironment?: string) {
+    this.currentEnvironment = currentEnvironment || 'default';
+    this.authLinkAdditionalParamsValues = authLinkAdditionalParamsValues || {};
+
+    this._serviceName = params.serviceName;
+    this._requestDataType = params.requestDataType;
+    this._grantType = params.grantType;
+    this._authorizeUri = params.authorizeUri;
+    this._exchangeTokenUri = params.exchangeTokenUri;
+    this._useRefresh = params.useRefresh;
+    this._expiresInPropertyName = params.expiresInPropertyName;
+    this._expiresInDefaultValue = params.expiresInDefaultValue;
+    this._refreshUri = params.refreshUri;
+    this._scopeType = params.scopeType;
+    this._authRequestAdditionalParams = params.authRequestAdditionalParams;
+    this._codeExchangeRequestAdditionalParams =
+      params.codeExchangeRequestAdditionalParams;
+    this._environments = params.environments;
+    this._authLinkAdditionalParams = params.authLinkAdditionalParams;
+  }
+
+  /**
+   * Checks if property exists in environment or not.
+   * @param environment
+   * @param prop
+   */
+  private isPropertyInEnvironment(environment: string, prop: string) {
+    if (this._environments === undefined) {
+      return false;
+    }
+
+    const isEnvironmentExist = Object.keys(this._environments).includes(
+      environment
+    );
+    if (!isEnvironmentExist) {
+      return false;
+    }
+
+    const currentEnv = this._environments[environment];
+
+    if (!currentEnv) {
+      return false;
+    }
+
+    const isPropExist = Object.keys(currentEnv).includes(prop);
+    return isPropExist;
+  }
+
+  private replaceAuthLinkParamsByValues(url: string) {
+    let template = url;
+    const params = this.authLinkAdditionalParamsValues;
+    Object.entries(params).forEach(([key, value]) => {
+      template = template.replace(new RegExp(`{${key}}`), value);
+    });
+
+    return template;
+  }
+
+  public get requestDataType(): string {
+    return this._requestDataType;
+  }
+
+  public get grantType(): string {
+    if (this.isPropertyInEnvironment(this.currentEnvironment, 'grantType')) {
+      return this._environments[this.currentEnvironment].grantType;
+    }
+
+    return this._grantType || 'authorization_code';
+  }
+
+  public get authorizeUri(): string {
+    let url;
+    if (this.isPropertyInEnvironment(this.currentEnvironment, 'authorizeUri')) {
+      url = this._environments[this.currentEnvironment].authorizeUri;
+    } else {
+      url = this._authorizeUri;
+    }
+
+    return this.replaceAuthLinkParamsByValues(url);
+  }
+
+  public get exchangeTokenUri(): string {
+    let url;
+    if (this.isPropertyInEnvironment(this.currentEnvironment, 'exchangeTokenUri')) {
+      url = this._environments[this.currentEnvironment].exchangeTokenUri;
+    } else {
+      url = this._exchangeTokenUri;
+    }
+
+    return this.replaceAuthLinkParamsByValues(url);
+  }
+
+  public get refreshUri(): string {
+    let url;
+    if (this.isPropertyInEnvironment(this.currentEnvironment, 'refreshUri')) {
+      url = this._environments[this.currentEnvironment].refreshUri;
+    } else {
+      url = this._refreshUri;
+    }
+
+    return this.replaceAuthLinkParamsByValues(url);
+  }
+
+  public get useRefresh(): boolean {
+    return this._useRefresh;
+  }
+
+  public get expiresInPropertyName(): string {
+    return this._expiresInPropertyName;
+  }
+
+  public get expiresInDefaultValue(): number {
+    if (this.isPropertyInEnvironment(this.currentEnvironment, 'expiresInDefaultValue')) {
+      return this._environments[this.currentEnvironment].expiresInDefaultValue;
+    }
+
+    return this._expiresInDefaultValue || 0;
+  }
+
+  public get scopeType(): ScopeType {
+    return this._scopeType;
+  }
+
+  public get authRequestAdditionalParams(): string {
+    if (this.isPropertyInEnvironment(this.currentEnvironment, 'authRequestAdditionalParams')) {
+      return this._environments[this.currentEnvironment].authRequestAdditionalParams;
+    }
+
+    return this._authRequestAdditionalParams;
+  }
+
+  public get codeExchangeRequestAdditionalParams(): string {
+    if (this.isPropertyInEnvironment(this.currentEnvironment, 'codeExchangeRequestAdditionalParams')) {
+      return this._environments[this.currentEnvironment].codeExchangeRequestAdditionalParams;
+    }
+
+    return this._codeExchangeRequestAdditionalParams;
+  }
+
+  public get authLinkAdditionalParams(): Record<string, string>[] | undefined {
+    return this._authLinkAdditionalParams;
+  }
+
+  public get displayServiceName(): string {
+    return this._displayServiceName || this._serviceName.split(
+      '__authorization_service_'
+    )[1];
+  }
+}

package/src/OAuth/utils/createAuthKey.ts

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

package/src/OAuth/utils/formatScope.ts

@@ -0,0 +1,20 @@
+import { ScopeType } from '../types';
+
+export const formatScope = (scopeArray: string[], scopeType: ScopeType): string => {
+  switch (scopeType) {
+    case ScopeType.SPACE_DELIMITED:
+      return scopeArray.join(' ').trim();
+
+    case ScopeType.COMMA_DELIMITED:
+      return scopeArray.join(', ').trim();
+
+    case ScopeType.COMMA_DELIMITED_WITHOUT_WHITESPACE:
+      return scopeArray.join(',').trim();
+
+    case ScopeType.JSON_ARRAY:
+      return JSON.stringify(scopeArray);
+
+    default:
+      return scopeArray.join(' ').trim();
+  }
+};

package/src/OAuth/utils/isExpired.ts

@@ -0,0 +1,7 @@
+export const isExpired = (createdAt: string, expireInSeconds: number): boolean => {
+  const userDate = new Date(createdAt);
+  const userTimezoneOffset = userDate.getTimezoneOffset() * 60000;
+  const correctDate = new Date(userDate.getTime() - userTimezoneOffset);
+  const diff = (Date.now() - correctDate.getTime()) / 1000;
+  return diff > expireInSeconds;
+};

package/src/Token/TokenAuth.ts

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

package/src/Token/TokenCollection.ts

@@ -0,0 +1,97 @@
+import { Token } from '@or-sdk/base';
+import { KeyValueStorage } from '@or-sdk/key-value-storage';
+import { TokenAuth } from './TokenAuth';
+
+import {
+  TokenCollectionConfig,
+  CreateTokenAuthInCollectionConfig,
+} from './types';
+
+/**
+ * OneReach Authorizer service client
+ *  ## Installation:
+ * ```
+ * $ npm i @or-sdk/authorizer
+ * ```
+ */
+export class TokenCollection {
+  private readonly serviceName: string;
+  private readonly keyValueStorage: KeyValueStorage;
+  private readonly localToken: Token;
+  private readonly localDiscoveryUrl: string;
+
+  /**
+   * Connects to authorization collection
+   *
+   * ```typescript
+   * import { TokenCollection } from '@or-sdk/authorizer'
+   * const tokenCollectionInstance = new TokenCollection({
+   *   token: 'my-account-token-string',
+   *   discoveryUrl: 'discovery.example.onereach.ai',
+   *   serviceName: '__authorization_service_test_service',
+   * });
+   * ```
+   */
+  constructor(params: TokenCollectionConfig) {
+    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 TokenAuth instance for given key
+   */
+  public async getAuthorization(key: string): Promise<TokenAuth> {
+    const record = await this.keyValueStorage.getValueByKey(this.serviceName, key);
+    if (!record.value) {
+      throw new Error('Authorization does not exist');
+    }
+
+    return new TokenAuth({
+      serviceName: this.serviceName,
+      authKey: key,
+      discoveryUrl: this.localDiscoveryUrl,
+      token: this.localToken,
+    });
+  }
+
+  /**
+   * Creates a new auth record in current collection with the given config.
+   * @returns TokenCollection instance connected to created auth
+   *
+   * ```typescript
+   * const tokenCollectionInstance = await tokenCollectionInstance.createAuthorization({
+   *   authName: 'my-auth-name',
+   *   credentials: {
+   *      token: 'secrettoken'
+   *   }
+   * });
+   * ```
+   */
+  public async createAuthorization(
+    params: CreateTokenAuthInCollectionConfig
+  ): Promise<TokenAuth> {
+    return await TokenAuth.create({
+      discoveryUrl: this.localDiscoveryUrl,
+      token: this.localToken,
+      serviceName: this.serviceName,
+      authName: params.authName,
+      credentials: params.credentials,
+    });
+  }
+}

package/src/Token/types.ts

@@ -0,0 +1,51 @@
+import { Token } from '@or-sdk/base';
+
+export type TokenAuthConfig = {
+  /**
+   * token or function which return token
+   */
+  token: Token;
+  discoveryUrl: string;
+  serviceName: string;
+  authKey: string;
+};
+
+export type TokenAuthData = {
+  auth_name: string;
+  /**
+   * Datetime of auth creation in YYYY-MM-DDTHH:MM:SSZ format
+   */
+  date_created: string;
+
+  /**
+   * Saved credentials by given keys
+   */
+  [credentialKey: string]: string;
+};
+
+export type CreateTokenAuthConfig = {
+  serviceName: string;
+  authName: string;
+
+  /**
+   * Object with credentials
+   */
+  credentials: Record<string, unknown>;
+
+  /**
+   * token or function which return token
+   */
+  token: Token;
+  discoveryUrl: string;
+};
+
+export type CreateTokenAuthInCollectionConfig = Omit<CreateTokenAuthConfig, 'serviceName' | 'discoveryUrl' | 'token'>;
+
+export type TokenCollectionConfig = {
+  /**
+   * token or function which return token
+   */
+  token: Token;
+  discoveryUrl: string;
+  serviceName: string;
+};

package/src/Token/utils/createAuthKey.ts

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

package/src/constants.ts

@@ -0,0 +1,14 @@
+export const SERVICE_PROVIDER_PATH = '/authorizer/services/list';
+export const OAUTH_REDIRECT_PROVIDER_PATH = '/authorizer/redirect';
+
+export enum AuthStatus {
+  NEW = 'NEW',
+  PENDING = 'PENDING',
+  READY = 'READY',
+  DELETED = 'DELETED',
+  ERROR = 'ERROR'
+}
+
+export const PREDEFINED_APP = 'predefined';
+
+export const TEMPORARY_DATA_EXPIRATION_TIME = 300000; // 5 minutes

package/src/index.ts

@@ -0,0 +1,10 @@
+export { BasicAuth } from './Basic/BasicAuth';
+export { BasicCollection } from './Basic/BasicCollection';
+
+export { TokenAuth } from './Token/TokenAuth';
+export { TokenCollection } from './Token/TokenCollection';
+
+export { OAuth } from './OAuth/OAuth';
+export { OAuthCollection } from './OAuth/OAuthCollection';
+
+export * from './types';

package/src/types.ts

@@ -0,0 +1,3 @@
+export * from './Basic/types';
+export * from './Token/types';
+export * from './OAuth/types';

package/tsconfig.esm.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "ES6",
+    "target": "es6",
+    "outDir": "./dist/esm/",
+    "rootDir": "./src"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/cjs/",
+    "rootDir": "./src"
+  }
+}

package/tsconfig.types.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/types/",
+    "rootDir": "./src",
+    "declaration": true,
+    "emitDeclarationOnly": true
+  }
+}