refactor: rename message composer middleware ids

Author: MartinCupela

src/messageComposer/middleware/messageComposer/MessageComposerMiddlewareExecutor.ts

@@ -1,25 +1,25 @@
 import { MiddlewareExecutor } from '../../../middleware';
 import {
-  createDraftTextComposerMiddleware,
-  createTextComposerMiddleware,
+  createDraftTextComposerCompositionMiddleware,
+  createTextComposerCompositionMiddleware,
 } from './textComposer';
 import {
-  createAttachmentsMiddleware,
-  createDraftAttachmentsMiddleware,
+  createAttachmentsCompositionMiddleware,
+  createDraftAttachmentsCompositionMiddleware,
 } from './attachments';
 import {
-  createDraftLinkPreviewsMiddleware,
-  createLinkPreviewsMiddleware,
+  createDraftLinkPreviewsCompositionMiddleware,
+  createLinkPreviewsCompositionMiddleware,
 } from './linkPreviews';
 import {
-  createDraftMessageComposerStateMiddleware,
-  createMessageComposerStateMiddleware,
+  createDraftMessageComposerStateCompositionMiddleware,
+  createMessageComposerStateCompositionMiddleware,
 } from './messageComposerState';
 import {
   createCompositionValidationMiddleware,
   createDraftCompositionValidationMiddleware,
 } from './compositionValidation';
-import { createCleanDataMiddleware } from './cleanData';
+import { createCompositionDataCleanupMiddleware } from './cleanData';
 import type {
   MessageComposerMiddlewareExecutorOptions,
   MessageComposerMiddlewareValueState,
@@ -34,12 +34,12 @@ export class MessageComposerMiddlewareExecutor extends MiddlewareExecutor<Messag
     // todo: document how to add custom data to a composed message using middleware
     //  or adding custom composer components (apart from AttachmentsManager, TextComposer etc.)
     this.use([
-      createTextComposerMiddleware(composer),
-      createAttachmentsMiddleware(composer),
-      createLinkPreviewsMiddleware(composer),
-      createMessageComposerStateMiddleware(composer),
+      createTextComposerCompositionMiddleware(composer),
+      createAttachmentsCompositionMiddleware(composer),
+      createLinkPreviewsCompositionMiddleware(composer),
+      createMessageComposerStateCompositionMiddleware(composer),
       createCompositionValidationMiddleware(composer),
-      createCleanDataMiddleware(composer),
+      createCompositionDataCleanupMiddleware(composer),
     ]);
   }
 }
@@ -50,10 +50,10 @@ export class MessageDraftComposerMiddlewareExecutor extends MiddlewareExecutor<M
     // todo: document how to add custom data to a composed message using middleware
     //  or adding custom composer components (apart from AttachmentsManager, TextComposer etc.)
     this.use([
-      createDraftTextComposerMiddleware(composer),
-      createDraftAttachmentsMiddleware(composer),
-      createDraftLinkPreviewsMiddleware(composer),
-      createDraftMessageComposerStateMiddleware(composer),
+      createDraftTextComposerCompositionMiddleware(composer),
+      createDraftAttachmentsCompositionMiddleware(composer),
+      createDraftLinkPreviewsCompositionMiddleware(composer),
+      createDraftMessageComposerStateCompositionMiddleware(composer),
       createDraftCompositionValidationMiddleware(composer),
     ]);
   }

src/messageComposer/middleware/messageComposer/attachments.ts

@@ -12,8 +12,8 @@ const localAttachmentToAttachment = (localAttachment: LocalAttachment) => {
   return attachment as Attachment;
 };
 
-export const createAttachmentsMiddleware = (composer: MessageComposer) => ({
-  id: 'attachments',
+export const createAttachmentsCompositionMiddleware = (composer: MessageComposer) => ({
+  id: 'stream-io/message-composer-middleware/attachments',
   compose: ({
     input,
     nextHandler,
@@ -61,8 +61,10 @@ export const createAttachmentsMiddleware = (composer: MessageComposer) => ({
   },
 });
 
-export const createDraftAttachmentsMiddleware = (composer: MessageComposer) => ({
-  id: 'attachments',
+export const createDraftAttachmentsCompositionMiddleware = (
+  composer: MessageComposer,
+) => ({
+  id: 'stream-io/message-composer-middleware/draft-attachments',
   compose: ({
     input,
     nextHandler,

src/messageComposer/middleware/messageComposer/cleanData.ts

@@ -2,8 +2,8 @@ import { formatMessage, toUpdatedMessagePayload } from '../../../utils';
 import type { MessageComposer } from '../../messageComposer';
 import type { MessageComposerMiddlewareValue } from './types';
 
-export const createCleanDataMiddleware = (composer: MessageComposer) => ({
-  id: 'cleanData',
+export const createCompositionDataCleanupMiddleware = (composer: MessageComposer) => ({
+  id: 'stream-io/message-composer-middleware/data-cleanup',
   compose: ({
     input,
     nextHandler,

src/messageComposer/middleware/messageComposer/compositionValidation.ts

@@ -6,7 +6,7 @@ import { textIsEmpty } from '../../textComposer';
 import type { MessageComposer } from '../../messageComposer';
 
 export const createCompositionValidationMiddleware = (composer: MessageComposer) => ({
-  id: 'validation',
+  id: 'stream-io/message-composer-middleware/data-validation',
   compose: async ({
     input,
     nextHandler,
@@ -32,7 +32,7 @@ export const createCompositionValidationMiddleware = (composer: MessageComposer)
 export const createDraftCompositionValidationMiddleware = (
   composer: MessageComposer,
 ) => ({
-  id: 'validation',
+  id: 'stream-io/message-composer-middleware/draft-data-validation',
   compose: async ({
     input,
     nextHandler,

src/messageComposer/middleware/messageComposer/linkPreviews.ts

@@ -5,8 +5,8 @@ import type {
 import type { MessageComposer } from '../../messageComposer';
 import type { Attachment } from '../../../types';
 
-export const createLinkPreviewsMiddleware = (composer: MessageComposer) => ({
-  id: 'linkPreviews',
+export const createLinkPreviewsCompositionMiddleware = (composer: MessageComposer) => ({
+  id: 'stream-io/message-composer-middleware/link-previews',
   compose: ({
     input,
     nextHandler,
@@ -59,8 +59,10 @@ export const createLinkPreviewsMiddleware = (composer: MessageComposer) => ({
   },
 });
 
-export const createDraftLinkPreviewsMiddleware = (composer: MessageComposer) => ({
-  id: 'linkPreviews',
+export const createDraftLinkPreviewsCompositionMiddleware = (
+  composer: MessageComposer,
+) => ({
+  id: 'stream-io/message-composer-middleware/draft-link-previews',
   compose: ({
     input,
     nextHandler,

src/messageComposer/middleware/messageComposer/messageComposerState.ts

@@ -5,8 +5,10 @@ import type {
 import type { MessageComposer } from '../../messageComposer';
 import type { LocalMessage, LocalMessageBase } from '../../../types';
 
-export const createMessageComposerStateMiddleware = (composer: MessageComposer) => ({
-  id: 'messageComposerState',
+export const createMessageComposerStateCompositionMiddleware = (
+  composer: MessageComposer,
+) => ({
+  id: 'stream-io/message-composer-middleware/own-state',
   compose: ({
     input,
     nextHandler,
@@ -42,8 +44,10 @@ export const createMessageComposerStateMiddleware = (composer: MessageComposer)
   },
 });
 
-export const createDraftMessageComposerStateMiddleware = (composer: MessageComposer) => ({
-  id: 'messageComposerState',
+export const createDraftMessageComposerStateCompositionMiddleware = (
+  composer: MessageComposer,
+) => ({
+  id: 'stream-io/message-composer-middleware/draft-own-state',
   compose: ({
     input,
     nextHandler,

src/messageComposer/middleware/messageComposer/textComposer.ts

@@ -4,8 +4,8 @@ import type {
 } from './types';
 import type { MessageComposer } from '../../messageComposer';
 
-export const createTextComposerMiddleware = (composer: MessageComposer) => ({
-  id: 'textComposerState',
+export const createTextComposerCompositionMiddleware = (composer: MessageComposer) => ({
+  id: 'stream-io/message-composer-middleware/text-composition',
   compose: ({
     input,
     nextHandler,
@@ -50,8 +50,10 @@ export const createTextComposerMiddleware = (composer: MessageComposer) => ({
   },
 });
 
-export const createDraftTextComposerMiddleware = (composer: MessageComposer) => ({
-  id: 'textComposerState',
+export const createDraftTextComposerCompositionMiddleware = (
+  composer: MessageComposer,
+) => ({
+  id: 'stream-io/message-composer-middleware/draft-text-composition',
   compose: ({
     input,
     nextHandler,

src/messageComposer/middleware/pollComposer/PollComposerMiddlewareExecutor.ts

@@ -1,6 +1,6 @@
 import { MiddlewareExecutor } from '../../../middleware';
 import { createPollComposerStateMiddleware } from './state';
-import { createPollComposerValidationMiddleware } from './composition';
+import { createPollCompositionValidationMiddleware } from './composition';
 import type {
   PollComposerCompositionMiddlewareValueState,
   PollComposerStateMiddlewareValueState,
@@ -14,7 +14,7 @@ export type PollComposerMiddlewareExecutorOptions = {
 export class PollComposerCompositionMiddlewareExecutor extends MiddlewareExecutor<PollComposerCompositionMiddlewareValueState> {
   constructor({ composer }: PollComposerMiddlewareExecutorOptions) {
     super();
-    this.use([createPollComposerValidationMiddleware(composer)]);
+    this.use([createPollCompositionValidationMiddleware(composer)]);
   }
 }
 

src/messageComposer/middleware/pollComposer/composition.ts

@@ -2,10 +2,10 @@ import type { Middleware } from '../../../middleware';
 import type { MessageComposer } from '../../messageComposer';
 import type { PollComposerCompositionMiddlewareValueState } from './types';
 
-export const createPollComposerValidationMiddleware = (
+export const createPollCompositionValidationMiddleware = (
   composer: MessageComposer,
 ): Middleware<PollComposerCompositionMiddlewareValueState> => ({
-  id: 'pollComposerComposition',
+  id: 'stream-io/poll-composer-composition',
   compose: ({ input, nextHandler }) => {
     if (composer.pollComposer.canCreatePoll) return nextHandler(input);
     return nextHandler({ ...input, status: 'discard' });

src/messageComposer/middleware/pollComposer/state.ts

@@ -120,7 +120,7 @@ const processors: Partial<Record<keyof PollComposerState['data'], Processor>> =
 
 export const createPollComposerStateMiddleware =
   (): Middleware<PollComposerStateMiddlewareValueState> => ({
-    id: 'pollComposerStateProcessing',
+    id: 'stream-io/poll-composer-state-processing',
     handleFieldChange: ({ input, nextHandler }) => {
       if (!input.state.targetFields) return nextHandler(input);
       const {

test/unit/MessageComposer/middleware/messageComposer/attachments.test.ts

@@ -2,18 +2,18 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { Channel } from '../../../../../src/channel';
 import { StreamChat } from '../../../../../src/client';
 import { MessageComposer } from '../../../../../src/messageComposer/messageComposer';
-import { createAttachmentsMiddleware } from '../../../../../src/messageComposer/middleware/messageComposer/attachments';
+import { createAttachmentsCompositionMiddleware } from '../../../../../src/messageComposer/middleware/messageComposer/attachments';
 import {
   AttachmentLoadingState,
   LocalImageAttachment,
 } from '../../../../../src/messageComposer/types';
-import { createDraftAttachmentsMiddleware } from '../../../../../src/messageComposer/middleware/messageComposer/attachments';
+import { createDraftAttachmentsCompositionMiddleware } from '../../../../../src/messageComposer/middleware/messageComposer/attachments';
 
 describe('AttachmentsMiddleware', () => {
   let channel: Channel;
   let client: StreamChat;
   let messageComposer: MessageComposer;
-  let attachmentsMiddleware: ReturnType<typeof createAttachmentsMiddleware>;
+  let attachmentsMiddleware: ReturnType<typeof createAttachmentsCompositionMiddleware>;
 
   beforeEach(() => {
     client = {
@@ -100,11 +100,7 @@ describe('AttachmentsMiddleware', () => {
       },
     } as any;
 
-    attachmentsMiddleware = createAttachmentsMiddleware(messageComposer);
-  });
-
-  it('should initialize with correct id', () => {
-    expect(attachmentsMiddleware.id).toBe('attachments');
+    attachmentsMiddleware = createAttachmentsCompositionMiddleware(messageComposer);
   });
 
   it('should handle message without attachments', async () => {
@@ -371,7 +367,9 @@ describe('DraftAttachmentsMiddleware', () => {
   let channel: Channel;
   let client: StreamChat;
   let messageComposer: MessageComposer;
-  let draftAttachmentsMiddleware: ReturnType<typeof createDraftAttachmentsMiddleware>;
+  let draftAttachmentsMiddleware: ReturnType<
+    typeof createDraftAttachmentsCompositionMiddleware
+  >;
 
   beforeEach(() => {
     client = {
@@ -403,11 +401,8 @@ describe('DraftAttachmentsMiddleware', () => {
       attachmentManager,
     } as any;
 
-    draftAttachmentsMiddleware = createDraftAttachmentsMiddleware(messageComposer);
-  });
-
-  it('should initialize with correct id', () => {
-    expect(draftAttachmentsMiddleware.id).toBe('attachments');
+    draftAttachmentsMiddleware =
+      createDraftAttachmentsCompositionMiddleware(messageComposer);
   });
 
   it('should handle draft without attachments', async () => {
@@ -507,7 +502,8 @@ describe('DraftAttachmentsMiddleware', () => {
 
   it('should handle case when attachmentManager is not available', async () => {
     messageComposer.attachmentManager = undefined as any;
-    draftAttachmentsMiddleware = createDraftAttachmentsMiddleware(messageComposer);
+    draftAttachmentsMiddleware =
+      createDraftAttachmentsCompositionMiddleware(messageComposer);
 
     const result = await draftAttachmentsMiddleware.compose({
       input: {

test/unit/MessageComposer/middleware/messageComposer/compositionValidation.test.ts

@@ -106,10 +106,6 @@ describe('MessageComposerValidationMiddleware', () => {
     validationMiddleware = createCompositionValidationMiddleware(messageComposer);
   });
 
-  it('should initialize with correct id', () => {
-    expect(validationMiddleware.id).toBe('validation');
-  });
-
   it('should validate empty message', async () => {
     const result = await validationMiddleware.compose({
       input: {
@@ -432,10 +428,6 @@ describe('DraftCompositionValidationMiddleware', () => {
     validationMiddleware = createDraftCompositionValidationMiddleware(messageComposer);
   });
 
-  it('should initialize with correct id', () => {
-    expect(validationMiddleware.id).toBe('validation');
-  });
-
   it('should discard empty draft', async () => {
     const result = await validationMiddleware.compose({
       input: {

test/unit/MessageComposer/middleware/messageComposer/linkPreviews.test.ts

@@ -6,14 +6,14 @@ import {
   LinkPreviewStatus,
 } from '../../../../../src/messageComposer/linkPreviewsManager';
 import { MessageComposer } from '../../../../../src/messageComposer/messageComposer';
-import { createLinkPreviewsMiddleware } from '../../../../../src/messageComposer/middleware/messageComposer/linkPreviews';
-import { createDraftLinkPreviewsMiddleware } from '../../../../../src/messageComposer/middleware/messageComposer/linkPreviews';
+import { createLinkPreviewsCompositionMiddleware } from '../../../../../src/messageComposer/middleware/messageComposer/linkPreviews';
+import { createDraftLinkPreviewsCompositionMiddleware } from '../../../../../src/messageComposer/middleware/messageComposer/linkPreviews';
 
 describe('LinkPreviewsMiddleware', () => {
   let channel: Channel;
   let client: StreamChat;
   let messageComposer: MessageComposer;
-  let linkPreviewsMiddleware: ReturnType<typeof createLinkPreviewsMiddleware>;
+  let linkPreviewsMiddleware: ReturnType<typeof createLinkPreviewsCompositionMiddleware>;
 
   beforeEach(() => {
     // Create a real StreamChat instance with minimal implementation
@@ -45,11 +45,7 @@ describe('LinkPreviewsMiddleware', () => {
     messageComposer = channel.messageComposer;
 
     // Create the middleware
-    linkPreviewsMiddleware = createLinkPreviewsMiddleware(messageComposer);
-  });
-
-  it('should initialize with correct id', () => {
-    expect(linkPreviewsMiddleware.id).toBe('linkPreviews');
+    linkPreviewsMiddleware = createLinkPreviewsCompositionMiddleware(messageComposer);
   });
 
   it('should handle message without link previews', async () => {
@@ -582,7 +578,9 @@ describe('DraftLinkPreviewsMiddleware', () => {
   let channel: Channel;
   let client: StreamChat;
   let messageComposer: MessageComposer;
-  let linkPreviewsMiddleware: ReturnType<typeof createDraftLinkPreviewsMiddleware>;
+  let linkPreviewsMiddleware: ReturnType<
+    typeof createDraftLinkPreviewsCompositionMiddleware
+  >;
 
   beforeEach(() => {
     client = {
@@ -617,11 +615,8 @@ describe('DraftLinkPreviewsMiddleware', () => {
       linkPreviewsManager,
     } as any;
 
-    linkPreviewsMiddleware = createDraftLinkPreviewsMiddleware(messageComposer);
-  });
-
-  it('should initialize with correct id', () => {
-    expect(linkPreviewsMiddleware.id).toBe('linkPreviews');
+    linkPreviewsMiddleware =
+      createDraftLinkPreviewsCompositionMiddleware(messageComposer);
   });
 
   it('should handle draft without link previews', async () => {
@@ -734,7 +729,8 @@ describe('DraftLinkPreviewsMiddleware', () => {
 
   it('should handle case when linkPreviewsManager is not available', async () => {
     messageComposer.linkPreviewsManager = undefined as any;
-    linkPreviewsMiddleware = createDraftLinkPreviewsMiddleware(messageComposer);
+    linkPreviewsMiddleware =
+      createDraftLinkPreviewsCompositionMiddleware(messageComposer);
 
     const result = await linkPreviewsMiddleware.compose({
       input: {