@ampsec/platform-client 59.3.1 → 59.4.0

package/src/dto/flows.dto.ts

@@ -80,27 +80,87 @@ export type FlowStateFilter = z.infer<typeof _FlowStateFilter>;
  * |      FlowSpec      |
  * \====================/
  */
+export const _FlowSpecCreateDto = z.object({
+  name: z.string(),
+  description: z.string(),
+});
+export type FlowSpecCreateDto = z.infer<typeof _FlowSpecCreateDto>;
+
+export enum FlowSpecStatusKind {
+  ACTIVE = 'ACTIVE',
+  PAUSED = 'PAUSED',
+  ERROR = 'ERROR',
+}
+
+const _FlowTrigger = z.object({
+  key: z.string(),
+  displayValue: z.string().optional(),
+});
+export type FlowTrigger = z.infer<typeof _FlowTrigger>;
+
+const _FlowTriggerFilter = z.object({
+  trigger: z.array(_FlowTrigger),
+  custom: z.record(z.unknown()).optional(),
+});
+export type FlowTriggerFilter = z.infer<typeof _FlowTriggerFilter>;
+const _FlowFilter = z.object({
+  cohorts: z.array(z.unknown()),
+  custom: z.record(z.unknown()).optional(),
+});
+const _FlowTone = z.object({
+  kind: z.string(),
+});
+export const _FlowInterval = z.object({
+  minutes: z.number(),
+  value: z.number().optional(),
+  units: z.string().optional(),
+});
+export type FlowInterval = z.infer<typeof _FlowInterval>;
+
+export const _FlowActions = z.object({
+  includeInstructions: z.boolean().optional(),
+  // TODO instructions contact address???
+  expirationActionId: z.string().optional(),
+});
+export type FlowActions = z.infer<typeof _FlowActions>;
+export const _FlowRewardsConfig = z.object({
+  isUpperBound: z.boolean(),
+  points: z.number(),
+  minutes: z.number(),
+  value: z.number().optional(),
+  units: z.string().optional(),
+});
+export type FlowRewardsConfig = z.infer<typeof _FlowRewardsConfig>;
+
 export const _FlowSpecDto = _BaseDto.merge(
   z.object({
     id: z.string(),
-    tid: z.string().optional(),
+    tid: z.string(),
+    status: z.nativeEnum(FlowSpecStatusKind),
     name: z.string(),
-    fslStrategy: z.enum(['STANDARD']),
-    triggerFilter: z.object({
-      trigger: z.string(),
-      custom: z.record(z.unknown()).optional(),
-    }),
+    description: z.string(),
+    fslStrategy: z.enum(['STANDARD']).optional().default('STANDARD'),
+    triggerFilter: _FlowTriggerFilter,
     /** cohort filter */
-    filter: z.object({
-      cohorts: z.unknown().optional(),
-      custom: z.record(z.unknown()).optional(),
-    }),
+    filter: _FlowFilter,
+    engagementChannelCids: z.array(z.string()),
+    tone: _FlowTone.optional(),
+    targetResolution: _FlowInterval.optional(),
+    reminderInterval: _FlowInterval.optional(),
+    actions: _FlowActions.optional(),
+    rewards: z.array(_FlowRewardsConfig).optional(),
+    activity: z
+      .object({
+        lastTriggered: z.string().optional(),
+        activeCount: z.number().default(0),
+        totalCount: z.number().default(0),
+      })
+      .optional(),
   })
 );
-
 export type FlowSpecDto = z.infer<typeof _FlowSpecDto>;
 
-export const _FlowSpecUpsertDto = _FlowSpecDto.merge(_BaseUpsertDto);
+export const _FlowSpecUpsertDto = _FlowSpecDto.omit({activity: true}).merge(_BaseUpsertDto);
 export type FlowSpecUpsertDto = z.infer<typeof _FlowSpecUpsertDto>;
 
 export const _FlowSpecFilter = _FlowSpecDto.omit({triggerFilter: true, filter: true}).partial().merge(_PaginationFilter).merge(_SortFilter);

package/src/dto/platform/platform.flows.dto.ts

@@ -1,5 +1,5 @@
 import {z} from 'zod';
-import {_FlowSpecDto, _FlowSpecUpsertDto, _FlowStateDto, _FlowStateUpsertDto} from '../flows.dto';
+import {FlowSpecStatusKind, _FlowSpecDto, _FlowSpecUpsertDto, _FlowStateDto, _FlowStateUpsertDto} from '../flows.dto';
 import {_TenantBased, _UpsertTenantBased} from './tenant.based.dto';
 
 /*
@@ -26,13 +26,19 @@ export type PlatformFlowStateDto = z.infer<typeof _PlatformFlowStateDto>;
 
 export const NOOP_FLOW_SPEC: PlatformFlowSpecDto = {
   id: '000000000000',
+  tid: '000000000000',
+  status: FlowSpecStatusKind.ACTIVE,
+  engagementChannelCids: [],
   createdAt: '2023-04-17T13:00:00.000Z',
   updatedAt: '2023-04-17T13:00:00.000Z',
   deletedAt: null,
   name: 'NOOP - DROP TRIGGER EVENT',
+  description: 'Used internally to drop trigger events',
   fslStrategy: 'STANDARD',
   triggerFilter: {
-    trigger: 'noop',
+    trigger: [{key: 'noop', displayValue: 'NOOP'}],
+  },
+  filter: {
+    cohorts: [],
   },
-  filter: {},
 };

package/src/services/flowSpecs.service.ts

@@ -0,0 +1,36 @@
+import _ from 'lodash';
+import {FlowSpecCreateDto, FlowSpecDto, FlowSpecUpsertDto, Page} from '../dto';
+import {RestClient} from './rest';
+import {KIND} from './constants';
+import {AmpEntityServiceImpl, EntityCallOptions} from './entity.service';
+
+export class FlowSpecsService extends AmpEntityServiceImpl<FlowSpecUpsertDto, FlowSpecDto> {
+  constructor(rest: RestClient) {
+    super(rest, KIND.FINDINGS);
+  }
+
+  /** @deprecated Use `createFromName` instead */
+  create = (_model: FlowSpecUpsertDto | FlowSpecUpsertDto[], _options?: EntityCallOptions): Promise<Page<FlowSpecDto>> => {
+    throw new Error('Method not implemented.');
+  };
+
+  createFromName = async (model: FlowSpecCreateDto): Promise<FlowSpecDto> => {
+    const res: Page<FlowSpecDto> = await this.call(
+      {
+        url: `/${this.targetApi}/v1/${this.kind}`,
+        method: 'POST',
+        data: model,
+      },
+      (error: unknown) => {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return {
+          data: [],
+          kind: this.kind.toUpperCase(),
+          error: message,
+          hints: {},
+        };
+      }
+    );
+    return res.data[0];
+  };
+}