@or-sdk/flows 0.26.1-beta.424.0 → 0.27.0-beta.427.0

package/src/Flows.ts

@@ -1,10 +1,10 @@
-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';
+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';
 
 /**
  * OneReach Flows service client
@@ -13,10 +13,10 @@ import { listUnusedStepTemplates, deleteUnusedStepTemplates } from './utils';
  * $ npm i @or-sdk/flows
  * ```
  */
-export class Flows implements Taggable<Flow> {
-  private readonly dataHub: DataHub;
-  private readonly deployer: Deployer;
-  private readonly tags: Tags;
+export class Flows extends Base {
+  // private readonly dataHub: DataHub;
+  // private readonly deployer: Deployer;
+  // private readonly tags: Tags;
 
   /**
    * ```typescript
@@ -25,35 +25,45 @@ export class Flows implements Taggable<Flow> {
    * await flows.init();
    * ```
    */
+  sdkApiUrl?: string;
+  deployerUrl?: string;
   constructor(params: FlowsConfig) {
-    const { discoveryUrl, token, accountId, dataHubUrl, deployerUrl } = params;
-
-    this.dataHub = new DataHub({
-      token,
-      discoveryUrl,
-      accountId,
-      dataHubUrl,
-    });
-    this.deployer = new Deployer({
+    const { discoveryUrl, token, accountId, dataHub2Url, deployerUrl, sdkApiUrl } = params;
+    super({
       token,
       discoveryUrl,
+      serviceKey: SERVICE_KEY,
       accountId,
-      deployerUrl,
-    });
-    this.tags = new Tags({
-      token,
-      discoveryUrl,
-      accountId,
-      dataHubUrl,
+      serviceUrl: dataHub2Url,
     });
+    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(),
+    // ]);
   }
 
   /**
@@ -64,73 +74,169 @@ export class Flows implements Taggable<Flow> {
    * 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,
-    };
 
-    const route = `/v2/${this.dataHub.currentAccountId ? this.dataHub.currentAccountId : 'current'}/flows`;
+  /**
+   * 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',
+    });
+  }
 
-    let result: FlowListResponse;
-    let flowList: Flow[] = [];
-    const query: { botId?: string; last?: string; } = { botId: botId ? botId : undefined };
-    const projection = JSON.stringify(requestParams.projection);
+  /**
+   * Recover deleted flow
+   * ```typescript
+   * const result = await flows.recoverFlow(flowSource);
+   * ```
+   */
+  async recoverFlow(flow: {id: string;}) {
+    return this.callApiV2({
+      route: `/flows/${flow.id}`,
+      method: 'patch',
+    });
+  }
 
-    do {
-      result = await this.dataHub.makeRequest({
-        method: 'GET',
-        route,
-        params: {
-          includeDeleted: requestParams.includeDeleted,
-          includeExisting: requestParams.includeExisting,
-          projection,
-          query: JSON.stringify(query),
-        },
-      });
+  /**
+   * 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,
+      },
+    });
+  }
+
+  /**
+   * 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}`,
+    });
+  }
 
-      flowList = [...flowList, ...result.items];
-      query.last = result.last;
+  /**
+   * 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',
+    });
 
-    } while (result.last);
+  }
 
-    return makeList<Flow>(flowList);
+  /**
+   * 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 },
+    });
   }
 
   /**
-   * Get flow
+   * Get version
    * ```typescript
-   * const flow = await flows.getFlow('flow-id');
+   * const result = await flows.getVersion({flowId, version});
    * ```
    */
-  public async getFlow(id: string): Promise<Flow> {
-    const route = `/v2/${this.dataHub.currentAccountId ? this.dataHub.currentAccountId : 'current'}/flow/${id}`;
+  async getVersion(params: {flowId: string; version: string;}) {
+    const data = await this.listVersions(params);
+    return data[0];
+  }
 
-    const params = {
-      includeDeleted: false,
-      includeExisting: true,
-      sandbox: false,
-    };
+  /**
+   * List flow versions by bot id
+   * ```typescript
+   * const result = await flows.listFlowVersionsByBotId({botId});
+   * ```
+   */
+  async listFlowVersionsByBotId(params: { botId: string; }) {
+    return this.listVersions(params);
+  }
 
-    return await this.dataHub.makeRequest<Flow>({
-      method: 'GET',
-      route,
-      params,
+  /**
+   * 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 };
+
+    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,
     });
   }
 
@@ -139,60 +245,209 @@ export class Flows implements Taggable<Flow> {
    *
    * If source contains existing id - existing flow will be updated
    * ```typescript
-   * const savedFlow = await flows.saveFlow(flowSource);
+   * const savedFlow = await flows.saveFlow(flowSource, { previousVersion });
    * ```
    */
-  public async saveFlow(source: Flow): Promise<Flow> {
-    const route = `/v2/${this.dataHub.currentAccountId ? this.dataHub.currentAccountId : 'current'}/flow/${source.id ? source.id : 'new'}`;
-
-    const data = {
-      flow: source,
-      previousVersion: source.id ? source.version : undefined,
+  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,
     };
+  }
 
-    return await this.dataHub.makeRequest<Flow>({
-      method: 'POST',
-      route,
-      data,
+  /**
+   * Get flows by bot id
+   *
+   * ```typescript
+   * const flows = await flows.getFlowsByBotId(botId, projection);
+   * ```
+   */
+  getFlowsByBotId(botId: string, projection: string[]) {
+    return this.getFlows({
+      query: { botId },
+      projection,
     });
   }
 
   /**
-   * Delete flow
+   * Get remote data outs by bot id
+   *
    * ```typescript
-   * const result = await flows.deleteFlow(flowSource, flowAlias);
+   * const data = await flows.getRemoteDataOutsByBotId(id);
    * ```
    */
-  public async deleteFlow(source: Flow, flowAlias = 'dev'): Promise<GraphqlResponseCheckExecution> {
-    if (this.dataHub.isCrossAccount) {
-      throw Error('Cross-account deleting is not implemented.');
-    }
+  async getRemoteDataOutsByBotId(id: string) {
+    const flows: any = await this.getFlows({
+      query: {
+        botId: id,
+        isDeleted: false,
+      },
+      projection: ['id', 'data.label'],
+    });
 
-    const variables = {
-      entity: ENTITY_NAME,
+    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 _.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
+   *
+   * ```typescript
+   * const data = await flows.constructor.getEmptyStep(id);
+   * ```
+   */
+  static getEmptyStep(stepId?: string) {
+    return {
+      id: stepId || uuidV4(),
+      icon: 'add',
+      iconType: 'default',
+      iconUrl: '',
+      shape: 'empty',
+      type: 'empty',
+      pinLabel: true,
+      stepInputData: {},
+    };
+  }
+
+  /**
+   * Get empty flow
+   *
+   * ```typescript
+   * const data = await flows.constructor.getEmptyFlow(botId);
+   * ```
+   */
+  static getEmptyFlow(botId: string): any {
+    const defaultLambdaMemorySize = 1024;
+    const defaultLambdaTimeout = 30;
+    return {
+      botId,
       data: {
-        id: source.id,
-        flowAlias,
-        subscribe: true,
-        role: source.data.deploy.role,
+        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()],
+          },
+        },
       },
     };
+  }
 
-    const operationName = this.dataHub.getOperationName(OperationNames.DELETE_TEMPORARILY);
+  /**
+   * 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']);
 
-    const data = {
-      operationName,
-      query: QUERY_DELETE,
-      variables,
-    };
+    // 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;
 
-    const result = await this.dataHub.makeRequest<GraphqlResponse<void>>({
-      method: 'POST',
-      route: '/graphql',
-      data,
+    // merge step with flow template
+    return _.merge(flow, template);
+  }
+
+
+  public async listFlows(botId?: string, params: ListFlowsParams = {}): Promise<List<Flow>> {
+    return this.getFlows({
+      ...params,
+      query: { botId },
     });
+  }
+
+  /**
+   * 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`;
+  }
+
 
-    return this.dataHub.subscribe((result.data[operationName] as GraphqlResponseDelete).requestId);
+  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');
   }
 
   /**
@@ -201,8 +456,23 @@ export class Flows implements Taggable<Flow> {
    * const triggerList = await flows.activateFlow(flowSource, false);
    * ```
    */
-  public async activateFlow(source: Flow, interactiveDebug = false): Promise<PollingResultActivateSuccess> {
-    return this.deployer.activateFlow(source, interactiveDebug);
+
+  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);
   }
 
   /**
@@ -211,31 +481,46 @@ export class Flows implements Taggable<Flow> {
    * const deactivatedFlowList = await flows.deactivateFlow(flowSource, 'flowAlias', false);
    * ```
    */
-  public async deactivateFlow(source: Flow, flowAlias: string, deleteLambda = false): Promise<PollingResultDeactivateSuccess> {
-    return this.deployer.deactivateFlow(source, flowAlias, deleteLambda);
+  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);
   }
 
+
   /**
    * 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
@@ -243,21 +528,21 @@ export class Flows implements Taggable<Flow> {
    * 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,9 +1,2 @@
-export const QUERY_DELETE = `mutation deleteTemporarily($entity: EntityType!, $data: DeleteInput!) {
-  deleteTemporarily(entity: $entity, data: $data) {
-    ... on AsyncRequest {
-      requestId
-    }
-  }
-}`;
+export const SERVICE_KEY = 'datahub2';
 
-export const ENTITY_NAME = 'FLOW';