@or-sdk/flows 0.27.0-beta.427.0 → 0.27.1-beta.531.0

package/src/Flows.ts

@@ -1,10 +1,10 @@
-import { Base, List } from '@or-sdk/base';
-import { Flow, StepTemplateRaw } from '@or-sdk/deployer';
-import _ from 'lodash';
-import {v4 as uuidV4} from 'uuid';
-import { SERVICE_KEY } from './constants';
-import { FlowsConfig, ListFlowsParams, StepTemplateToDelete, ActivateFlowParams, DeactivageFlowParams } from './types';
-import { deleteUnusedStepTemplates, listUnusedStepTemplates } from './utils';
+import { List, makeList } from '@or-sdk/base';
+import { DataHub, GraphqlResponseCheckExecution, GraphqlResponse, GraphqlResponseDelete, OperationNames } from '@or-sdk/data-hub';
+import { Deployer, Flow, PollingResultActivateSuccess, PollingResultDeactivateSuccess, StepTemplateRaw } from '@or-sdk/deployer';
+import { FlowsConfig, FlowListResponse, ListFlowsParams, StepTemplateToDelete } from './types';
+import { QUERY_DELETE, ENTITY_NAME } from './constants';
+import { Tags, Taggable, filterTagIds, addTagsIds, removeTagIds } from '@or-sdk/tags';
+import { listUnusedStepTemplates, deleteUnusedStepTemplates } from './utils';
 
 /**
  * OneReach Flows service client
@@ -13,10 +13,10 @@ import { deleteUnusedStepTemplates, listUnusedStepTemplates } from './utils';
  * $ npm i @or-sdk/flows
  * ```
  */
-export class Flows extends Base {
-  // private readonly dataHub: DataHub;
-  // private readonly deployer: Deployer;
-  // private readonly tags: Tags;
+export class Flows implements Taggable<Flow> {
+  private readonly dataHub: DataHub;
+  private readonly deployer: Deployer;
+  private readonly tags: Tags;
 
   /**
    * ```typescript
@@ -25,45 +25,35 @@ export class Flows extends Base {
    * await flows.init();
    * ```
    */
-  sdkApiUrl?: string;
-  deployerUrl?: string;
   constructor(params: FlowsConfig) {
-    const { discoveryUrl, token, accountId, dataHub2Url, deployerUrl, sdkApiUrl } = params;
-    super({
+    const { discoveryUrl, token, accountId, dataHubUrl, deployerUrl } = params;
+
+    this.dataHub = new DataHub({
+      token,
+      discoveryUrl,
+      accountId,
+      dataHubUrl,
+    });
+    this.deployer = new Deployer({
       token,
       discoveryUrl,
-      serviceKey: SERVICE_KEY,
       accountId,
-      serviceUrl: dataHub2Url,
+      deployerUrl,
+    });
+    this.tags = new Tags({
+      token,
+      discoveryUrl,
+      accountId,
+      dataHubUrl,
     });
-    this.deployerUrl = deployerUrl;
-    this.sdkApiUrl = sdkApiUrl;
-    // this.dataHub = new DataHub({
-    //   token,
-    //   discoveryUrl,
-    //   accountId,
-    //   dataHubUrl,
-    // });
-    // this.deployer = new Deployer({
-    //   token,
-    //   discoveryUrl,
-    //   accountId,
-    //   deployerUrl,
-    // });
-    // this.tags = new Tags({
-    //   token,
-    //   discoveryUrl,
-    //   accountId,
-    //   dataHubUrl,
-    // });
   }
 
   async init() {
-    // await Promise.all([
-    //   this.dataHub.init(),
-    //   this.deployer.init(),
-    //   this.tags.init(),
-    // ]);
+    await Promise.all([
+      this.dataHub.init(),
+      this.deployer.init(),
+      this.tags.init(),
+    ]);
   }
 
   /**
@@ -74,169 +64,73 @@ export class Flows extends Base {
    * const flowsList = await flows.listFlows('bot-id');
    * ```
    */
+  public async listFlows(botId?: string, params?: ListFlowsParams): Promise<List<Flow>> {
+    const requestParams = {
+      // defaults
+      includeDeleted: false,
+      includeExisting: true,
+      projection: [
+        'id',
+        'version',
+        'botId',
+        'data.label',
+        'data.color',
+        'data.description',
+        'data.isHidden',
+        'tags',
+        'dateModified',
+      ],
+
+      // overrides
+      ...params,
+    };
 
-  /**
-   * Delete flow
-   * ```typescript
-   * const result = await flows.deleteFlow(flowSource, flowAlias);
-   * ```
-   */
-  async deleteFlow(flow: {id: string;}, flowAlias = 'dev', temporarily = true) {
-    return this.callApiV2({
-      route: `/flows/${flow.id}`,
-      data: {
-        flowAlias,
-        temporarily,
-      },
-      method: 'delete',
-    });
-  }
-
-  /**
-   * Recover deleted flow
-   * ```typescript
-   * const result = await flows.recoverFlow(flowSource);
-   * ```
-   */
-  async recoverFlow(flow: {id: string;}) {
-    return this.callApiV2({
-      route: `/flows/${flow.id}`,
-      method: 'patch',
-    });
-  }
-
-  /**
-   * Get flow by id
-   * ```typescript
-   * const result = await flows.getFlowById(id, projection, sandbox);
-   * ```
-   */
-  async getFlowById(id: string, projection?: string[], sandbox = false): Promise<Flow> {
-    return this.callApiV2({
-      route: `/flows/${id}`,
-      params: {
-        projection,
-        sandbox,
-      },
-    });
-  }
+    const route = `/v2/${this.dataHub.currentAccountId ? this.dataHub.currentAccountId : 'current'}/flows`;
 
-  /**
-   * Get flows
-   * ```typescript
-   * const result = await flows.getFlows({query, projection, includeDeleted, includeExisting, sandbox, limit,offset});
-   * ```
-   */
-  async getFlows({ query = {}, projection, includeDeleted = false, includeExisting = true, sandbox = false, limit, offset }: ListFlowsParams = {}): Promise<List<Flow>> {
-    if (typeof query.id === 'string') query.id = query.id.split('.');
-    if (includeDeleted && !includeExisting) query.isDeleted = true;
-    if (!includeDeleted && includeExisting) query.isDeleted = false;
-    return this.callApiV2({
-      route: '/flows',
-      params: {
-        projection,
-        query,
-        sandbox,
-        limit,
-        offset,
-      },
-    });
-  }
-  /**
-   * Get flow events
-   * ```typescript
-   * const result = await flows.getFlowEvents({flowId, alias});
-   * ```
-   */
-  async getFlowEvents({ flowId, alias = 'prod' }: {flowId: string; alias: string;}) {
-    return this.callApiV2({
-      url: this.sdkApiUrl,
-      route: `${this.sdkApiUrl}/event-manager/get-flow-events/${flowId}/${alias}`,
-    });
-  }
+    let result: FlowListResponse;
+    let flowList: Flow[] = [];
+    const query: { botId?: string; last?: string; } = { botId: botId ? botId : undefined };
+    const projection = JSON.stringify(requestParams.projection);
 
-  /**
-   * Get trigger flows
-   * ```typescript
-   * const result = await flows.getTriggerFlows(triggers);
-   * ```
-   */
-  async getTriggerFlows(triggers = []) {
-    return this.callApiV2({
-      url: this.sdkApiUrl,
-      route: `${this.sdkApiUrl}event-manager/get-trigger-flows`,
-      data: { triggers },
-      method: 'post',
-    });
+    do {
+      result = await this.dataHub.makeRequest({
+        method: 'GET',
+        route,
+        params: {
+          includeDeleted: requestParams.includeDeleted,
+          includeExisting: requestParams.includeExisting,
+          projection,
+          query: JSON.stringify(query),
+        },
+      });
 
-  }
+      flowList = [...flowList, ...result.items];
+      query.last = result.last;
 
-  /**
-   * List versions
-   * ```typescript
-   * const result = await flows.listVersions({flowId, botId});
-   * ```
-   */
-  async listVersions(query: {flowId?: string; botId?: string;version?: string;}): Promise<any[]> {
-    return this.callApiV2({
-      route: '/flows/versions',
-      params: { query },
-    });
-  }
+    } while (result.last);
 
-  /**
-   * Get version
-   * ```typescript
-   * const result = await flows.getVersion({flowId, version});
-   * ```
-   */
-  async getVersion(params: {flowId: string; version: string;}) {
-    const data = await this.listVersions(params);
-    return data[0];
+    return makeList<Flow>(flowList);
   }
 
   /**
-   * List flow versions by bot id
+   * Get flow
    * ```typescript
-   * const result = await flows.listFlowVersionsByBotId({botId});
+   * const flow = await flows.getFlow('flow-id');
    * ```
    */
-  async listFlowVersionsByBotId(params: { botId: string; }) {
-    return this.listVersions(params);
-  }
+  public async getFlow(id: string): Promise<Flow> {
+    const route = `/v2/${this.dataHub.currentAccountId ? this.dataHub.currentAccountId : 'current'}/flow/${id}`;
 
-  /**
-   * Load flow logs
-   * ```typescript
-   * const result = await flows.loadLogs({flowId, next, startTime, endTime, limit, filter, relativeTime});
-   * ```
-   */
-  async loadLogs(params: { flowId: string; next: string; startTime: number; endTime: number; limit: number; filter: string; relativeTime: boolean; }) {
-    const { flowId, next, startTime, endTime, limit, filter, relativeTime } = params;
-    const queryParams: {[key: string]: any;} = { skipOriginal: true };
+    const params = {
+      includeDeleted: false,
+      includeExisting: true,
+      sandbox: false,
+    };
 
-    if (next) {
-      queryParams.next = next;
-    }
-    if (startTime) {
-      queryParams.start = startTime;
-    }
-    if (endTime) {
-      queryParams.end = endTime;
-    }
-    if (limit) {
-      queryParams.limit = limit;
-    }
-    if (filter) {
-      queryParams.filter = filter;
-    }
-    if (relativeTime) {
-      queryParams.relativeTime = relativeTime;
-    }
-    return this.callApiV2({
-      url: this.deployerUrl,
-      route: `/flows/${flowId}/logs`,
-      params: queryParams,
+    return await this.dataHub.makeRequest<Flow>({
+      method: 'GET',
+      route,
+      params,
     });
   }
 
@@ -245,209 +139,60 @@ export class Flows extends Base {
    *
    * If source contains existing id - existing flow will be updated
    * ```typescript
-   * const savedFlow = await flows.saveFlow(flowSource, { previousVersion });
-   * ```
-   */
-  async saveFlow(flow: Flow, { previousVersion }: {previousVersion?: string;} = {}) {
-    flow.id = flow.id || 'new';
-    const { id, version } = await this.callApiV2({
-      route: `/flows/${flow.id}`,
-      data: {
-        flow,
-        previousVersion,
-      },
-      method: 'post',
-    });
-    return {
-      ...flow,
-      id,
-      version,
-    };
-  }
-
-  /**
-   * Get flows by bot id
-   *
-   * ```typescript
-   * const flows = await flows.getFlowsByBotId(botId, projection);
+   * const savedFlow = await flows.saveFlow(flowSource);
    * ```
    */
-  getFlowsByBotId(botId: string, projection: string[]) {
-    return this.getFlows({
-      query: { botId },
-      projection,
-    });
-  }
+  public async saveFlow(source: Flow): Promise<Flow> {
+    const route = `/v2/${this.dataHub.currentAccountId ? this.dataHub.currentAccountId : 'current'}/flow/${source.id ? source.id : 'new'}`;
 
-  /**
-   * Get remote data outs by bot id
-   *
-   * ```typescript
-   * const data = await flows.getRemoteDataOutsByBotId(id);
-   * ```
-   */
-  async getRemoteDataOutsByBotId(id: string) {
-    const flows: any = await this.getFlows({
-      query: {
-        botId: id,
-        isDeleted: false,
-      },
-      projection: ['id', 'data.label'],
-    });
+    const data = {
+      flow: source,
+      previousVersion: source.id ? source.version : undefined,
+    };
 
-    const dataOuts = await this.callApiV2({
-      route: 'flows/data-outs',
-      params: {
-        query: {
-          type: {
-            not: 'session',
-            ne: null,
-          },
-          name: { ne: null },
-          botId: id,
-          flowId: flows.map((flow: {id: string;}) => flow.id),
-        },
-      },
+    return await this.dataHub.makeRequest<Flow>({
+      method: 'POST',
+      route,
+      data,
     });
-
-    return _.reduce(flows, (acc: any, flow: any) => {
-      const flowLabel = _.get(flow, 'data.label', 'No name flow');
-      acc[flow.id] = _.map(dataOuts as any, (dataOut: any) => ({
-        ...dataOut,
-        flowLabel,
-      }));
-      return acc;
-    }, {});
   }
 
   /**
-   * Get empty step
-   *
+   * Delete flow
    * ```typescript
-   * const data = await flows.constructor.getEmptyStep(id);
+   * const result = await flows.deleteFlow(flowSource, flowAlias);
    * ```
    */
-  static getEmptyStep(stepId?: string) {
-    return {
-      id: stepId || uuidV4(),
-      icon: 'add',
-      iconType: 'default',
-      iconUrl: '',
-      shape: 'empty',
-      type: 'empty',
-      pinLabel: true,
-      stepInputData: {},
-    };
-  }
+  public async deleteFlow(source: Flow, flowAlias = 'dev'): Promise<GraphqlResponseCheckExecution> {
+    if (this.dataHub.isCrossAccount) {
+      throw Error('Cross-account deleting is not implemented.');
+    }
 
-  /**
-   * Get empty flow
-   *
-   * ```typescript
-   * const data = await flows.constructor.getEmptyFlow(botId);
-   * ```
-   */
-  static getEmptyFlow(botId: string): any {
-    const defaultLambdaMemorySize = 1024;
-    const defaultLambdaTimeout = 30;
-    return {
-      botId,
+    const variables = {
+      entity: ENTITY_NAME,
       data: {
-        label: '',
-        description: '',
-        deploy: {
-          memory: defaultLambdaMemorySize,
-          timeout: defaultLambdaTimeout,
-          role: 'USER',
-        },
-        meta: {},
-        color: null,
-        categories: null,
-        annotations: null,
-        stepTemplates: [],
-        trees: {
-          main: {
-            position: {
-              x: 0,
-              y: 0,
-            },
-            steps: [this.getEmptyStep()],
-          },
-        },
+        id: source.id,
+        flowAlias,
+        subscribe: true,
+        role: source.data.deploy.role,
       },
     };
-  }
-
-  /**
-   * Get new flow
-   *
-   * ```typescript
-   * const data = await flows.constructor.getNewFlow(botId, flowTemplate);
-   * ```
-   */
-  static async getNewFlow(botId: string, flowTemplate: any) {
-    const flow = this.getEmptyFlow(botId);
-    const template = _.omit(flowTemplate, ['id', 'botId', 'dateCreated', 'dateModified', 'version']);
 
-    // if template has any steps then remove default empty step
-    // or leave it otherwise
-    flow.data.steps = _.get(template, 'data.steps.length') > 0 ? [] : flow.data.steps;
-
-    // merge step with flow template
-    return _.merge(flow, template);
-  }
+    const operationName = this.dataHub.getOperationName(OperationNames.DELETE_TEMPORARILY);
 
+    const data = {
+      operationName,
+      query: QUERY_DELETE,
+      variables,
+    };
 
-  public async listFlows(botId?: string, params: ListFlowsParams = {}): Promise<List<Flow>> {
-    return this.getFlows({
-      ...params,
-      query: { botId },
+    const result = await this.dataHub.makeRequest<GraphqlResponse<void>>({
+      method: 'POST',
+      route: '/graphql',
+      data,
     });
-  }
-
-  /**
-   * Get flow
-   * ```typescript
-   * const flow = await flows.getFlow('flow-id');
-   * ```
-   */
-  public async getFlow(id: string): Promise<Flow> {
-    return this.getFlowById(id);
-  }
-
-  private get deployUrl() {
-    return this.targetAccountId ? `${this.deployerUrl}/accounts/${this.targetAccountId}/flows/deploy` : `${this.deployerUrl}/flows/deploy`;
-  }
-
 
-  private get checkUrl() {
-    return this.targetAccountId ? `${this.deployerUrl}/accounts/${this.targetAccountId}/flows/check` : `${this.deployerUrl}/flows/check`;
-  }
-
-  private async _pollResult(flowId: string, requestId: string, headers?: any, progresCallback?: any) {
-    let counter = 0;
-
-    do {
-      counter++;
-      await new Promise(r => setTimeout(r, 1000));
-
-      const result: any = await this.callApiV2({
-        url: `${this.checkUrl}`,
-        route: `/${flowId}/${requestId}`,
-      });
-      if (_.isFunction(progresCallback)) {
-        progresCallback(result);
-      }
-      if (result.status !== 'pending') {
-        if (result.errorData) {
-          throw result;
-        }
-
-        return result;
-      }
-    } while (counter < 100);
-
-    throw new Error('Activation duration is too long');
+    return this.dataHub.subscribe((result.data[operationName] as GraphqlResponseDelete).requestId);
   }
 
   /**
@@ -456,23 +201,8 @@ export class Flows extends Base {
    * const triggerList = await flows.activateFlow(flowSource, false);
    * ```
    */
-
-  async activateFlow(flow: ActivateFlowParams, progresCallback: any) {
-    const flowAlias = `v-${Date.now()}`;
-
-    const { requestId } = await this.callApiV2({
-      url: this.deployUrl,
-      route: '',
-      method: 'post',
-      data: {
-        flowId: flow.id,
-        flowAlias,
-        interactiveDebug: flow.interactiveDebug,
-        role: _.get(flow, 'data.deploy.role'),
-      },
-    });
-
-    return this._pollResult(flow.id, requestId, null, progresCallback);
+  public async activateFlow(source: Flow, interactiveDebug = false): Promise<PollingResultActivateSuccess> {
+    return this.deployer.activateFlow(source, interactiveDebug);
   }
 
   /**
@@ -481,46 +211,31 @@ export class Flows extends Base {
    * const deactivatedFlowList = await flows.deactivateFlow(flowSource, 'flowAlias', false);
    * ```
    */
-  async deactivateFlow(flow: DeactivageFlowParams, flowAlias: string, deleteLambda = false) {
-    const { requestId } = await this.callApiV2({
-      url: this.deployUrl,
-      route: '',
-      method: 'delete',
-      data: {
-        flow: {
-          id: flow.id,
-        },
-        flowAlias,
-        role: _.get(flow, 'data.deploy.role'),
-        deleteLambda,
-      },
-    });
-
-    return this._pollResult(flow.id, requestId);
+  public async deactivateFlow(source: Flow, flowAlias: string, deleteLambda = false): Promise<PollingResultDeactivateSuccess> {
+    return this.deployer.deactivateFlow(source, flowAlias, deleteLambda);
   }
 
-
   /**
    * Add tags
    * ```typescript
    * const flow = await flows.addTags(flowSource, tagIdsArr);
    * ```
    */
-  // public async addTags(source: Flow, tagNames: string[]): Promise<Flow> {
-  //   const tags = await this.tags.getMultipleTagsByName(tagNames, true);
-  //   const tagIds = tags.map(tag => tag.id!);
+  public async addTags(source: Flow, tagNames: string[]): Promise<Flow> {
+    const tags = await this.tags.getMultipleTagsByName(tagNames, true);
+    const tagIds = tags.map(tag => tag.id!);
 
-  //   const { newIds } = filterTagIds(source.tags, tagIds);
+    const { newIds } = filterTagIds(source.tags, tagIds);
 
-  //   if (!newIds.length) {
-  //     throw Error('No tags to add.');
-  //   }
+    if (!newIds.length) {
+      throw Error('No tags to add.');
+    }
 
-  //   return this.saveFlow({
-  //     ...source,
-  //     tags: addTagsIds(source.tags, newIds),
-  //   });
-  // }
+    return this.saveFlow({
+      ...source,
+      tags: addTagsIds(source.tags, newIds),
+    });
+  }
 
   /**
    * Remove tags
@@ -528,21 +243,21 @@ export class Flows extends Base {
    * const flow = await flows.removeTags(flowSource, tagIdsArr);
    * ```
    */
-  // public async removeTags(source: Flow, tagNames: string[]): Promise<Flow> {
-  //   const tags = await this.tags.getMultipleTagsByName(tagNames);
-  //   const tagIds = tags.map(tag => tag.id!);
+  public async removeTags(source: Flow, tagNames: string[]): Promise<Flow> {
+    const tags = await this.tags.getMultipleTagsByName(tagNames);
+    const tagIds = tags.map(tag => tag.id!);
 
-  //   const { existingIds } = filterTagIds(source.tags, tagIds);
+    const { existingIds } = filterTagIds(source.tags, tagIds);
 
-  //   if (!existingIds.length) {
-  //     throw Error('No tags to remove.');
-  //   }
+    if (!existingIds.length) {
+      throw Error('No tags to remove.');
+    }
 
-  //   return this.saveFlow({
-  //     ...source,
-  //     tags: removeTagIds(source.tags, existingIds),
-  //   });
-  // }
+    return this.saveFlow({
+      ...source,
+      tags: removeTagIds(source.tags, existingIds),
+    });
+  }
 
   /**
    * List unused step templates from flow source

package/src/constants.ts

@@ -1,2 +1,12 @@
-export const SERVICE_KEY = 'datahub2';
+export { DATA_HUB_SERVICE_KEY } from '@or-sdk/data-hub';
+export { DEPLOYER_SERVICE_KEY } from '@or-sdk/deployer';
 
+export const QUERY_DELETE = `mutation deleteTemporarily($entity: EntityType!, $data: DeleteInput!) {
+  deleteTemporarily(entity: $entity, data: $data) {
+    ... on AsyncRequest {
+      requestId
+    }
+  }
+}`;
+
+export const ENTITY_NAME = 'FLOW';