feat(api): add slug parser in the api requests

apps/api/package.json

@@ -57,6 +57,7 @@
     "@types/newrelic": "^9.14.0",
     "@upstash/ratelimit": "^0.4.4",
     "axios": "^1.6.8",
+    "base-x": "^5.0.0",
     "bcrypt": "^5.0.0",
     "body-parser": "^1.20.0",
     "bull": "^4.2.1",
@@ -91,7 +92,7 @@
     "shortid": "^2.2.16",
     "slugify": "^1.4.6",
     "swagger-ui-express": "^4.4.0",
-    "twilio": "^4.14.1",    
+    "twilio": "^4.14.1",
     "json-schema-to-ts": "^3.0.0",
     "uuid": "^8.3.2"
   },

apps/api/src/app/auth/services/passport/jwt.strategy.ts

@@ -39,19 +39,7 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
     const environmentIdFromHeader =
       (req.headers[HttpRequestHeaderKeysEnum.NOVU_ENVIRONMENT_ID.toLowerCase()] as string) || '';
 
-    let currentEnvironmentId = '';
-
-    const environments = await this.environmentRepository.findOrganizationEnvironments(session.organizationId);
-    const environmentIds = environments.map((env) => env._id);
-    const developmentEnvironmentId = environments.find((env) => env.name === 'Development')?._id || '';
-
-    currentEnvironmentId = developmentEnvironmentId;
-
-    if (environmentIds.includes(environmentIdFromHeader)) {
-      currentEnvironmentId = environmentIdFromHeader;
-    }
-
     // eslint-disable-next-line no-param-reassign
-    session.environmentId = currentEnvironmentId;
+    session.environmentId = environmentIdFromHeader;
   }
 }

apps/api/src/app/shared/helpers/base62.ts

@@ -0,0 +1,22 @@
+import basex from 'base-x';
+
+const BASE62 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+const { encode, decode } = basex(BASE62);
+
+export function encodeBase62(value: string): string {
+  const buffer = Buffer.from(value, 'hex');
+
+  return encode(buffer);
+}
+
+export function decodeBase62(encoded: string): string {
+  const uint8Array = decode(encoded);
+
+  return Buffer.from(uint8Array).toString('hex');
+}
+
+export function isBase62(input: string): boolean {
+  const base62Regex = /^[0-9A-Za-z]+$/;
+
+  return base62Regex.test(input);
+}

apps/api/src/app/shared/helpers/index.ts

@@ -1 +1,2 @@
 export * from './utils';
+export * from './base62';

apps/api/src/app/workflows-v2/pipes/parse-slug-Id.pipe spec.ts

@@ -0,0 +1,65 @@
+import { expect } from 'chai';
+import { ArgumentMetadata } from '@nestjs/common';
+
+import { ParseSlugIdPipe } from './parse-slug-Id.pipe';
+import { encodeBase62 } from '../../shared/helpers';
+
+describe('ParseSlugIdPipe', () => {
+  let pipe: ParseSlugIdPipe;
+
+  beforeEach(() => {
+    pipe = new ParseSlugIdPipe();
+  });
+
+  it('should return the original value for non-slug IDs', () => {
+    const workflowIdentifier = 'non-slug-id';
+    expect(pipe.transform(workflowIdentifier, {} as ArgumentMetadata)).to.equal(workflowIdentifier);
+
+    const internalId = '6615943e7ace93b0540ae377';
+    expect(pipe.transform(internalId, {} as ArgumentMetadata)).to.equal(internalId);
+  });
+
+  it('should handle invalid encoded IDs', () => {
+    const invalidSlugId = 'my-workflow_invalidEncoding';
+    expect(pipe.transform(invalidSlugId, {} as ArgumentMetadata)).to.equal(invalidSlugId);
+  });
+
+  it('should not trim or decode internalId', () => {
+    const internalId = '6615943e7ace93b0540ae377';
+    expect(pipe.transform(internalId, {} as ArgumentMetadata)).to.equal(internalId);
+  });
+
+  it.skip('should trim prefix and decode base62 encoded internalId', () => {
+    const internalId = '6615943e7ace93b0540ae377';
+    const encodedId = encodeBase62(`wf_${internalId}`);
+    expect(pipe.transform(`wf_${encodedId}`, {} as ArgumentMetadata)).to.equal(internalId);
+  });
+
+  it('should not trim or decode simple workflow identifier', () => {
+    const identifier = 'my-workflow';
+    expect(pipe.transform(identifier, {} as ArgumentMetadata)).to.equal(identifier);
+  });
+
+  it.skip('should trim, decode, and remove prefix for a valid slug ID', () => {
+    const internalId = '6615943e7ace93b0540ae377';
+    const encodedId = encodeBase62(`wf_${internalId}`);
+    expect(pipe.transform(`my-workflow_${encodedId}`, {} as ArgumentMetadata)).to.equal(internalId);
+  });
+
+  it('should return original value for invalid encoded ID', () => {
+    const invalidSlug = 'my-workflow_invalid';
+    expect(pipe.transform(invalidSlug, {} as ArgumentMetadata)).to.equal(invalidSlug);
+  });
+
+  it('should handle slug IDs without known prefixes', () => {
+    const internalId = '6615943e7ace93b0540ae377';
+    const encodedId = encodeBase62(internalId);
+    expect(pipe.transform(`my-workflow_${encodedId}`, {} as ArgumentMetadata)).to.equal(internalId);
+  });
+
+  it.skip('should handle slug IDs with multiple underscores', () => {
+    const internalId = '6615943e7ace93b0540ae377';
+    const encodedId = encodeBase62(`wf_${internalId}`);
+    expect(pipe.transform(`my_complex_workflow_${encodedId}`, {} as ArgumentMetadata)).to.equal(internalId);
+  });
+});

apps/api/src/app/workflows-v2/pipes/parse-slug-Id.pipe.ts

@@ -0,0 +1,55 @@
+import { ArgumentMetadata, Injectable, PipeTransform } from '@nestjs/common';
+import { BaseRepository } from '@novu/dal';
+import { decodeBase62 } from '../../shared/helpers';
+
+type InternalId = string;
+const INTERNAL_ID_LENGTH = 24;
+const ENCODED_ID_LENGTH = 16;
+
+function isWorkflowId(value: string) {
+  return value.length < ENCODED_ID_LENGTH;
+}
+
+function isInternalId(value: string) {
+  return BaseRepository.isInternalId(value) && value.length === INTERNAL_ID_LENGTH;
+}
+
+function lookoutForId(value: string): string | null {
+  if (isInternalId(value)) {
+    return value;
+  }
+
+  if (isWorkflowId(value)) {
+    return value;
+  }
+
+  return null;
+}
+
+export function parseSlugId(value: string): InternalId {
+  const validId = lookoutForId(value);
+  if (validId) {
+    return validId;
+  }
+
+  const encodedValue = value.slice(-16);
+  let decodedValue: string;
+  try {
+    decodedValue = decodeBase62(encodedValue);
+  } catch (error) {
+    return value;
+  }
+  const validDecodedId = lookoutForId(decodedValue);
+  if (validDecodedId) {
+    return validDecodedId;
+  }
+
+  return value;
+}
+
+@Injectable()
+export class ParseSlugIdPipe implements PipeTransform<string, InternalId> {
+  transform(value: string, metadata: ArgumentMetadata): InternalId {
+    return parseSlugId(value);
+  }
+}

apps/api/src/app/workflows-v2/usecases/delete-workflow/delete-workflow.command.ts

@@ -4,5 +4,5 @@ import { IsDefined, IsString } from 'class-validator';
 export class DeleteWorkflowCommand extends EnvironmentWithUserObjectCommand {
   @IsString()
   @IsDefined()
-  workflowId: string;
+  workflowIdOrIdentifier: string;
 }

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

@@ -8,35 +8,37 @@ import {
 } from '@novu/dal';
 
 import { DeleteWorkflowCommand } from './delete-workflow.command';
-import { WorkflowNotFoundException } from '../../exceptions/workflow-not-found-exception';
+import { GetWorkflowByIdsUseCase } from '../get-workflow-by-ids/get-workflow-by-ids.usecase';
+import { GetWorkflowByIdsCommand } from '../get-workflow-by-ids/get-workflow-by-ids.command';
 
 @Injectable()
 export class DeleteWorkflowUseCase {
   constructor(
     private notificationTemplateRepository: NotificationTemplateRepository,
     private messageTemplateRepository: MessageTemplateRepository,
+    private getWorkflowByIdsUseCase: GetWorkflowByIdsUseCase,
     private controlValuesRepository: ControlValuesRepository
   ) {}
 
   async execute(command: DeleteWorkflowCommand): Promise<void> {
-    const workflow = await this.notificationTemplateRepository.findByIdQuery({
-      id: command.workflowId,
-      environmentId: command.user.environmentId,
-    });
-    if (!workflow) {
-      throw new WorkflowNotFoundException(command.workflowId);
-    }
-    await this.deleteRelatedEntities(command, workflow);
+    const workflowEntity: NotificationTemplateEntity | null = await this.getWorkflowByIdsUseCase.execute(
+      GetWorkflowByIdsCommand.create({
+        ...command,
+        workflowIdOrIdentifier: command.workflowIdOrIdentifier,
+      })
+    );
+
+    await this.deleteRelatedEntities(command, workflowEntity);
   }
 
-  private async deleteRelatedEntities(command: DeleteWorkflowCommand, workflow) {
+  private async deleteRelatedEntities(command: DeleteWorkflowCommand, workflow: NotificationTemplateEntity) {
     await this.controlValuesRepository.deleteMany({
       _environmentId: command.user.environmentId,
       _organizationId: command.user.organizationId,
-      _workflowId: command.workflowId,
+      _workflowId: workflow._id,
     });
     await this.removeMessageTemplatesIfNeeded(workflow, command);
-    await this.notificationTemplateRepository.delete(buildDeleteQuery(command));
+    await this.notificationTemplateRepository.delete(buildDeleteQuery(command, workflow._id));
   }
 
   private async removeMessageTemplatesIfNeeded(workflow: NotificationTemplateEntity, command: DeleteWorkflowCommand) {
@@ -50,9 +52,9 @@ export class DeleteWorkflowUseCase {
     }
   }
 }
-function buildDeleteQuery(command: DeleteWorkflowCommand) {
+function buildDeleteQuery(command: DeleteWorkflowCommand, _workflowId: string) {
   return {
-    _id: command.workflowId,
+    _id: _workflowId,
     _organizationId: command.user.organizationId,
     _environmentId: command.user.environmentId,
   };

apps/api/src/app/workflows-v2/usecases/get-workflow-by-ids/get-workflow-by-ids.command.ts

@@ -0,0 +1,8 @@
+import { EnvironmentWithUserObjectCommand } from '@novu/application-generic';
+import { IsDefined, IsString } from 'class-validator';
+
+export class GetWorkflowByIdsCommand extends EnvironmentWithUserObjectCommand {
+  @IsString()
+  @IsDefined()
+  workflowIdOrIdentifier: string;
+}

apps/api/src/app/workflows-v2/usecases/get-workflow-by-ids/get-workflow-by-ids.usecase.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+
+import { NotificationTemplateEntity, NotificationTemplateRepository } from '@novu/dal';
+
+import { GetWorkflowByIdsCommand } from './get-workflow-by-ids.command';
+import { WorkflowNotFoundException } from '../../exceptions/workflow-not-found-exception';
+
+@Injectable()
+export class GetWorkflowByIdsUseCase {
+  constructor(private notificationTemplateRepository: NotificationTemplateRepository) {}
+  async execute(command: GetWorkflowByIdsCommand): Promise<NotificationTemplateEntity> {
+    const isInternalId = NotificationTemplateRepository.isInternalId(command.workflowIdOrIdentifier);
+
+    let workflowEntity: NotificationTemplateEntity | null;
+
+    if (isInternalId) {
+      workflowEntity = await this.notificationTemplateRepository.findById(
+        command.workflowIdOrIdentifier,
+        command.user.environmentId
+      );
+    } else {
+      workflowEntity = await this.notificationTemplateRepository.findByTriggerIdentifier(
+        command.user.environmentId,
+        command.workflowIdOrIdentifier
+      );
+    }
+
+    if (!workflowEntity) {
+      throw new WorkflowNotFoundException(command.workflowIdOrIdentifier);
+    }
+
+    return workflowEntity;
+  }
+}

apps/api/src/app/workflows-v2/usecases/get-workflow/get-workflow.command.ts

@@ -4,5 +4,5 @@ import { IsDefined, IsString } from 'class-validator';
 export class GetWorkflowCommand extends EnvironmentWithUserObjectCommand {
   @IsString()
   @IsDefined()
-  _workflowId: string;
+  workflowIdOrIdentifier: string;
 }

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

@@ -4,50 +4,51 @@ import {
   ControlValuesEntity,
   ControlValuesRepository,
   NotificationStepEntity,
-  NotificationTemplateRepository,
+  NotificationTemplateEntity,
 } from '@novu/dal';
 import { ControlValuesLevelEnum, WorkflowResponseDto } from '@novu/shared';
 import { GetPreferences, GetPreferencesCommand } from '@novu/application-generic';
 
 import { GetWorkflowCommand } from './get-workflow.command';
-import { WorkflowNotFoundException } from '../../exceptions/workflow-not-found-exception';
 import { toResponseWorkflowDto } from '../../mappers/notification-template-mapper';
+import { GetWorkflowByIdsUseCase } from '../get-workflow-by-ids/get-workflow-by-ids.usecase';
+import { GetWorkflowByIdsCommand } from '../get-workflow-by-ids/get-workflow-by-ids.command';
 
 @Injectable()
 export class GetWorkflowUseCase {
   constructor(
-    private notificationTemplateRepository: NotificationTemplateRepository,
+    private getWorkflowByIdsUseCase: GetWorkflowByIdsUseCase,
     private controlValuesRepository: ControlValuesRepository,
     private getPreferencesUseCase: GetPreferences
   ) {}
   async execute(command: GetWorkflowCommand): Promise<WorkflowResponseDto> {
-    const notificationTemplateEntity = await this.notificationTemplateRepository.findByIdQuery({
-      id: command._workflowId,
-      environmentId: command.user.environmentId,
-    });
+    const workflowEntity: NotificationTemplateEntity | null = await this.getWorkflowByIdsUseCase.execute(
+      GetWorkflowByIdsCommand.create({
+        ...command,
+        workflowIdOrIdentifier: command.workflowIdOrIdentifier,
+      })
+    );
 
-    if (!notificationTemplateEntity) {
-      throw new WorkflowNotFoundException(command._workflowId);
-    }
-    const stepIdToControlValuesMap = await this.getControlsValuesMap(notificationTemplateEntity.steps, command);
+    const stepIdToControlValuesMap = await this.getControlsValuesMap(workflowEntity.steps, command, workflowEntity._id);
     const preferences = await this.getPreferencesUseCase.safeExecute(
       GetPreferencesCommand.create({
         environmentId: command.user.environmentId,
         organizationId: command.user.organizationId,
       })
     );
 
-    return toResponseWorkflowDto(notificationTemplateEntity, preferences, stepIdToControlValuesMap);
+    return toResponseWorkflowDto(workflowEntity, preferences, stepIdToControlValuesMap);
   }
 
   private async getControlsValuesMap(
     steps: NotificationStepEntity[],
-    command: GetWorkflowCommand
+    command: GetWorkflowCommand,
+    _workflowId: string
   ): Promise<{ [key: string]: ControlValuesEntity }> {
     const acc: { [key: string]: ControlValuesEntity } = {};
 
     for (const step of steps) {
-      const controlValuesEntity = await this.buildControlValuesForStep(step, command);
+      const controlValuesEntity = await this.buildControlValuesForStep(step, command, _workflowId);
       if (controlValuesEntity) {
         acc[step._templateId] = controlValuesEntity;
       }
@@ -57,12 +58,13 @@ export class GetWorkflowUseCase {
   }
   private async buildControlValuesForStep(
     step: NotificationStepEntity,
-    command: GetWorkflowCommand
+    command: GetWorkflowCommand,
+    _workflowId: string
   ): Promise<ControlValuesEntity | null> {
     return await this.controlValuesRepository.findFirst({
       _environmentId: command.user.environmentId,
       _organizationId: command.user.organizationId,
-      _workflowId: command._workflowId,
+      _workflowId,
       _stepId: step._templateId,
       level: ControlValuesLevelEnum.STEP_CONTROLS,
     });

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

@@ -2,7 +2,7 @@ import { EnvironmentWithUserObjectCommand } from '@novu/application-generic';
 import { CreateWorkflowDto, UpdateWorkflowDto } from '@novu/shared';
 
 export class UpsertWorkflowCommand extends EnvironmentWithUserObjectCommand {
-  workflowDatabaseIdForUpdate?: string;
+  workflowIdOrIdentifier?: string;
 
   workflowDto: CreateWorkflowDto | UpdateWorkflowDto;
 }