feat(api-service): polish action steps

apps/api/package.json

@@ -8,6 +8,7 @@
   "scripts": {
     "prebuild": "rimraf dist",
     "build": "pnpm build:metadata && nest build",
+    "build:watch": "pnpm build:metadata && nest build --watch",
     "format": "prettier --write \"src/**/*.ts\"",
     "docker:build": "pnpm --silent --workspace-root pnpm-context -- apps/api/Dockerfile | BULL_MQ_PRO_NPM_TOKEN=${BULL_MQ_PRO_NPM_TOKEN} docker buildx build --load -t novu-api --secret id=BULL_MQ_PRO_NPM_TOKEN --build-arg PACKAGE_PATH=apps/api - $DOCKER_BUILD_ARGUMENTS",
     "docker:build:depot": "pnpm --silent --workspace-root pnpm-context -- apps/api/Dockerfile | depot build --build-arg PACKAGE_PATH=apps/api - -t novu-api --load",

apps/api/src/app/workflows-v2/usecases/upsert-workflow/upsert-workflow.usecase.ts

@@ -11,15 +11,13 @@ import {
 } from '@novu/dal';
 import {
   ContentIssue,
-  CreateWorkflowDto,
   JSONSchemaDto,
   DEFAULT_WORKFLOW_PREFERENCES,
   slugify,
   StepContentIssueEnum,
   StepCreateDto,
   StepIssuesDto,
   StepUpdateDto,
-  UpdateWorkflowDto,
   UserSessionData,
   StepTypeEnum,
   WorkflowCreationSourceEnum,
@@ -317,11 +315,11 @@ export class UpsertWorkflowUseCase {
     const sanitizedControlValues =
       controlValueLocal && workflowOrigin === WorkflowOriginEnum.NOVU_CLOUD
         ? dashboardSanitizeControlValues(controlValueLocal, step.type) || {}
-        : convertEmptyStringsToNull(controlValueLocal) || {};
+        : frameworkSanitizeEmptyStringsToNull(controlValueLocal) || {};
 
     const controlIssues = processControlValuesBySchema(controlSchemas?.schema, sanitizedControlValues || {});
     const liquidTemplateIssues = processControlValuesByLiquid(variableSchema, controlValueLocal || {});
-    const customIssues = await this.processControlValuesByRules(user, step.type, controlValueLocal || {});
+    const customIssues = await this.processControlValuesByRules(user, step.type, sanitizedControlValues || {});
     const customControlIssues = _.isEmpty(customIssues) ? {} : { controls: customIssues };
 
     return _.merge(controlIssues, liquidTemplateIssues, customControlIssues);
@@ -432,13 +430,11 @@ export class UpsertWorkflowUseCase {
     stepType: StepTypeEnum,
     controlValues: Record<string, unknown> | null
   ): Promise<StepIssuesDto> {
-    const cleanedControlValues = controlValues ? cleanObject(controlValues) : {};
-
     const restrictionsErrors = await this.tierRestrictionsValidateUsecase.execute(
       TierRestrictionsValidateCommand.create({
-        amount: cleanedControlValues.amount as string | undefined,
-        unit: cleanedControlValues.unit as string | undefined,
-        cron: cleanedControlValues.cron as string | undefined,
+        amount: controlValues?.amount as number | undefined,
+        unit: controlValues?.unit as string | undefined,
+        cron: controlValues?.cron as string | undefined,
         organizationId: user.organizationId,
         stepType,
       })
@@ -584,7 +580,9 @@ function cleanObject(
   );
 }
 
-function convertEmptyStringsToNull(obj: Record<string, unknown> | undefined): Record<string, unknown> | undefined {
+function frameworkSanitizeEmptyStringsToNull(
+  obj: Record<string, unknown> | undefined
+): Record<string, unknown> | undefined {
   if (typeof obj !== 'object' || obj === null || obj === undefined) return obj;
 
   return Object.fromEntries(
@@ -593,7 +591,7 @@ function convertEmptyStringsToNull(obj: Record<string, unknown> | undefined): Re
         return [key, null];
       }
       if (typeof value === 'object') {
-        return [key, convertEmptyStringsToNull(value as Record<string, unknown>)];
+        return [key, frameworkSanitizeEmptyStringsToNull(value as Record<string, unknown>)];
       }
 
       return [key, value];

apps/api/src/app/workflows-v2/usecases/validate-content/prepare-and-validate-content/prepare-and-validate-content.usecase.ts

@@ -394,7 +394,7 @@ export class PrepareAndValidateContentUsecase {
   ): Promise<Record<string, ContentIssue[]>> {
     const restrictionsErrors = await this.tierRestrictionsValidateUsecase.execute(
       TierRestrictionsValidateCommand.create({
-        amount: defaultControlValues.amount as string | undefined,
+        amount: defaultControlValues.amount as number | undefined,
         unit: defaultControlValues.unit as string | undefined,
         organizationId: user.organizationId,
         stepType,

apps/dashboard/src/components/workflow-editor/step-utils.ts

@@ -1,14 +1,23 @@
 import { flatten } from 'flat';
 import type {
   ContentIssue,
+  StepCreateDto,
   StepIssuesDto,
-  StepTypeEnum,
   StepUpdateDto,
   UpdateWorkflowDto,
   WorkflowResponseDto,
 } from '@novu/shared';
-import { Step } from '@/utils/types';
-import { STEP_TYPE_LABELS } from '@/utils/constants';
+import { StepTypeEnum } from '@novu/shared';
+import {
+  DEFAULT_CONTROL_DELAY_AMOUNT,
+  DEFAULT_CONTROL_DELAY_TYPE,
+  DEFAULT_CONTROL_DELAY_UNIT,
+  DEFAULT_CONTROL_DIGEST_AMOUNT,
+  DEFAULT_CONTROL_DIGEST_CRON,
+  DEFAULT_CONTROL_DIGEST_DIGEST_KEY,
+  DEFAULT_CONTROL_DIGEST_UNIT,
+  STEP_TYPE_LABELS,
+} from '@/utils/constants';
 
 export const getFirstBodyErrorMessage = (issues?: StepIssuesDto) => {
   const stepIssuesArray = Object.entries({ ...issues?.body });
@@ -58,10 +67,25 @@ export const updateStepInWorkflow = (
   };
 };
 
-export const createStep = (type: StepTypeEnum): Step => ({
-  name: STEP_TYPE_LABELS[type] + ' Step',
-  stepId: '',
-  slug: '_st_',
-  type,
-  _id: crypto.randomUUID(),
-});
+export const createStep = (type: StepTypeEnum): StepCreateDto => {
+  const controlValue: Record<string, unknown> = {};
+
+  if (type === StepTypeEnum.DIGEST) {
+    controlValue.amount = DEFAULT_CONTROL_DIGEST_AMOUNT;
+    controlValue.unit = DEFAULT_CONTROL_DIGEST_UNIT;
+    controlValue.digestKey = DEFAULT_CONTROL_DIGEST_DIGEST_KEY;
+    controlValue.cron = DEFAULT_CONTROL_DIGEST_CRON;
+  }
+
+  if (type === StepTypeEnum.DELAY) {
+    controlValue.amount = DEFAULT_CONTROL_DELAY_AMOUNT;
+    controlValue.unit = DEFAULT_CONTROL_DELAY_UNIT;
+    controlValue.type = DEFAULT_CONTROL_DELAY_TYPE;
+  }
+
+  return {
+    name: STEP_TYPE_LABELS[type] + ' Step',
+    type,
+    controlValues: controlValue,
+  };
+};

apps/dashboard/src/utils/constants.ts

@@ -1,4 +1,4 @@
-import { StepTypeEnum } from '@novu/shared';
+import { StepTypeEnum, TimeUnitEnum } from '@novu/shared';
 
 export const AUTOCOMPLETE_PASSWORD_MANAGERS_OFF = {
   autoComplete: 'off',
@@ -27,3 +27,12 @@ export const STEP_TYPE_LABELS: Record<StepTypeEnum, string> = {
   [StepTypeEnum.TRIGGER]: 'Trigger',
   [StepTypeEnum.CUSTOM]: 'Custom',
 };
+
+export const DEFAULT_CONTROL_DELAY_AMOUNT = 42;
+export const DEFAULT_CONTROL_DELAY_UNIT = TimeUnitEnum.SECONDS;
+export const DEFAULT_CONTROL_DELAY_TYPE = 'regular';
+
+export const DEFAULT_CONTROL_DIGEST_AMOUNT = 42;
+export const DEFAULT_CONTROL_DIGEST_UNIT = TimeUnitEnum.SECONDS;
+export const DEFAULT_CONTROL_DIGEST_CRON = '';
+export const DEFAULT_CONTROL_DIGEST_DIGEST_KEY = '';

libs/application-generic/src/schemas/control/delay-control.schema.ts

@@ -13,8 +13,8 @@ import { defaultOptions, skipStepUiSchema, skipZodSchema } from './shared';
 export const delayControlZodSchema = z
   .object({
     skip: skipZodSchema,
-    type: z.enum(['regular']).default('regular'),
-    amount: z.union([z.number().min(1), z.string()]),
+    type: z.enum(['regular']),
+    amount: z.number().min(1),
     unit: z.nativeEnum(TimeUnitEnum),
   })
   .strict();

libs/application-generic/src/schemas/control/digest-control.schema.ts

@@ -20,15 +20,15 @@ const lookBackWindowZodSchema = z
 const digestRegularControlZodSchema = z
   .object({
     skip: skipZodSchema,
-    amount: z.union([z.number().min(1), z.string().min(1)]),
+    amount: z.number().min(1),
     unit: z.nativeEnum(TimeUnitEnum),
     digestKey: z.string().optional(),
     lookBackWindow: lookBackWindowZodSchema.optional(),
   })
   .strict();
 const digestTimedControlZodSchema = z
   .object({
-    skip: z.object({}).catchall(z.unknown()).optional(),
+    skip: skipZodSchema,
     cron: z.string().min(1),
     digestKey: z.string().optional(),
   })

libs/application-generic/src/usecases/tier-restrictions-validate/tier-restrictions-validate.command.ts

@@ -5,9 +5,9 @@ import { OrganizationLevelCommand } from '../../commands';
 
 export class TierRestrictionsValidateCommand extends OrganizationLevelCommand {
   @IsOptional()
-  @Transform(({ value }) => (value ? String(value) : value))
-  @IsString()
-  amount?: string;
+  @Transform(({ value }) => (value ? Number(value) : value))
+  @IsNumber()
+  amount?: number;
 
   @IsString()
   @IsOptional()

libs/application-generic/src/utils/sanitize-control-values.ts

@@ -9,10 +9,8 @@ import {
   SmsControlType,
   InAppRedirectType,
   PushControlType,
-  isDigestTimedControl,
   DigestTimedControlType,
   DigestControlSchemaType,
-  isDigestRegularControl,
   DigestRegularControlType,
   LookBackWindowType,
   DelayControlType,
@@ -49,7 +47,7 @@ function sanitizeAction(action: InAppActionType) {
 function sanitizeInApp(controlValues: InAppControlType) {
   const normalized: InAppControlType = {
     subject: controlValues.subject || undefined,
-    // Cast to string to trigger Ajv validation errors
+    // Cast to string to trigger Ajv validation errors - possible undefined
     body: isEmpty(controlValues.body)
       ? (undefined as unknown as string)
       : controlValues.body,
@@ -126,7 +124,7 @@ function sanitizeChat(controlValues: ChatControlType) {
 }
 
 function sanitizeDigest(controlValues: DigestControlSchemaType) {
-  if (isDigestTimedControl(controlValues)) {
+  if (isTimedDigestControl(controlValues)) {
     const mappedValues: DigestTimedControlType = {
       cron: controlValues.cron || '',
       digestKey: controlValues.digestKey || '',
@@ -136,19 +134,20 @@ function sanitizeDigest(controlValues: DigestControlSchemaType) {
     return filterNullishValues(mappedValues);
   }
 
-  if (isDigestRegularControl(controlValues)) {
+  if (isRegularDigestControl(controlValues)) {
+    const lookBackAmount = (controlValues.lookBackWindow as LookBackWindowType)
+      ?.amount;
     const mappedValues: DigestRegularControlType = {
-      amount: controlValues.amount || 0,
-      unit: controlValues.unit || TimeUnitEnum.SECONDS,
-      digestKey: controlValues.digestKey || '',
+      // Cast to trigger Ajv validation errors - possible undefined
+      ...(parseAmount(controlValues.amount) as { amount?: number }),
+      unit: controlValues.unit,
+      digestKey: controlValues.digestKey,
       skip: controlValues.skip || undefined,
       lookBackWindow: controlValues.lookBackWindow
         ? {
-            amount:
-              (controlValues.lookBackWindow as LookBackWindowType).amount || 0,
-            unit:
-              (controlValues.lookBackWindow as LookBackWindowType).unit ||
-              TimeUnitEnum.SECONDS,
+            // Cast to trigger Ajv validation errors - possible undefined
+            ...(parseAmount(lookBackAmount) as { amount?: number }),
+            unit: (controlValues.lookBackWindow as LookBackWindowType).unit,
           }
         : undefined,
     };
@@ -177,15 +176,31 @@ function sanitizeDigest(controlValues: DigestControlSchemaType) {
 
 function sanitizeDelay(controlValues: DelayControlType) {
   const mappedValues: DelayControlType = {
-    type: controlValues.type || 'regular',
-    amount: controlValues.amount || 0,
-    unit: controlValues.unit || TimeUnitEnum.SECONDS,
+    // Cast to trigger Ajv validation errors - possible undefined
+    ...(parseAmount(controlValues.amount) as { amount?: number }),
+    type: controlValues.type,
+    unit: controlValues.unit,
     skip: controlValues.skip || undefined,
   };
 
   return filterNullishValues(mappedValues);
 }
 
+function parseAmount(amount?: unknown) {
+  try {
+    if (!isNumber(amount)) {
+      return {};
+    }
+
+    const numberAmount =
+      typeof amount === 'string' ? parseInt(amount, 10) : amount;
+
+    return { amount: numberAmount };
+  } catch (error) {
+    return amount;
+  }
+}
+
 function filterNullishValues<T extends Record<string, unknown>>(obj: T): T {
   if (typeof obj === 'object' && obj !== null) {
     return Object.fromEntries(
@@ -222,37 +237,63 @@ export function dashboardSanitizeControlValues(
   controlValues: Record<string, unknown>,
   stepType: StepTypeEnum | unknown,
 ): (Record<string, unknown> & { skip?: Record<string, unknown> }) | null {
-  if (!controlValues) {
-    return null;
-  }
-  let normalizedValues: Record<string, unknown>;
-  switch (stepType) {
-    case StepTypeEnum.IN_APP:
-      normalizedValues = sanitizeInApp(controlValues as InAppControlType);
-      break;
-    case StepTypeEnum.EMAIL:
-      normalizedValues = sanitizeEmail(controlValues as EmailControlType);
-      break;
-    case StepTypeEnum.SMS:
-      normalizedValues = sanitizeSms(controlValues as SmsControlType);
-      break;
-    case StepTypeEnum.PUSH:
-      normalizedValues = sanitizePush(controlValues as PushControlType);
-      break;
-    case StepTypeEnum.CHAT:
-      normalizedValues = sanitizeChat(controlValues as ChatControlType);
-      break;
-    case StepTypeEnum.DIGEST:
-      normalizedValues = sanitizeDigest(
-        controlValues as DigestControlSchemaType,
-      );
-      break;
-    case StepTypeEnum.DELAY:
-      normalizedValues = sanitizeDelay(controlValues as DelayControlType);
-      break;
-    default:
-      normalizedValues = filterNullishValues(controlValues);
+  try {
+    if (!controlValues) {
+      return null;
+    }
+
+    console.log('controlValues 333222 ', controlValues);
+    let normalizedValues: Record<string, unknown>;
+    switch (stepType) {
+      case StepTypeEnum.IN_APP:
+        normalizedValues = sanitizeInApp(controlValues as InAppControlType);
+        break;
+      case StepTypeEnum.EMAIL:
+        normalizedValues = sanitizeEmail(controlValues as EmailControlType);
+        break;
+      case StepTypeEnum.SMS:
+        normalizedValues = sanitizeSms(controlValues as SmsControlType);
+        break;
+      case StepTypeEnum.PUSH:
+        normalizedValues = sanitizePush(controlValues as PushControlType);
+        break;
+      case StepTypeEnum.CHAT:
+        normalizedValues = sanitizeChat(controlValues as ChatControlType);
+        break;
+      case StepTypeEnum.DIGEST:
+        normalizedValues = sanitizeDigest(
+          controlValues as DigestControlSchemaType,
+        );
+        break;
+      case StepTypeEnum.DELAY:
+        normalizedValues = sanitizeDelay(controlValues as DelayControlType);
+        break;
+      default:
+        normalizedValues = filterNullishValues(controlValues);
+    }
+
+    console.log('normalizedValues 333222 ', normalizedValues);
+
+    return normalizedValues;
+  } catch (error) {
+    console.error('Error sanitizing control values', error);
+
+    return controlValues;
   }
+}
+
+function isNumber(value: unknown): value is number {
+  return !Number.isNaN(Number.parseInt(value as string, 10));
+}
+
+function isTimedDigestControl(
+  controlValues: unknown,
+): controlValues is DigestTimedControlType {
+  return !isEmpty((controlValues as DigestTimedControlType)?.cron);
+}
 
-  return normalizedValues;
+function isRegularDigestControl(
+  controlValues: unknown,
+): controlValues is DigestRegularControlType {
+  return !isTimedDigestControl(controlValues);
 }