@monorise/core 1.0.0

package/processors/mutual-processor.ts

@@ -0,0 +1,262 @@
+import { TransactionCanceledException } from '@aws-sdk/client-dynamodb';
+import type { Entity } from '@monorise/base';
+import type { SQSBatchItemFailure, SQSEvent } from 'aws-lambda';
+import { Mutual } from '#/data/Mutual';
+import { StandardError } from '#/errors/standard-error';
+import { parseSQSBusEvent } from '#/helpers/event';
+import { EntityConfig } from '#/lambda-layer/monorise';
+import { DependencyContainer } from '#/services/DependencyContainer';
+import { EVENT } from '#/types/event';
+
+export type EventDetailBody = {
+  mutualIds: string[];
+  byEntityType: Entity;
+  byEntityId: string;
+  entityType: Entity;
+  field: string;
+  publishedAt: string;
+  customContext?: Record<string, unknown>;
+};
+
+const container = new DependencyContainer();
+
+const processEntities = async (
+  entityIds: string[],
+  action: (id: string) => Promise<void>,
+) => Promise.allSettled(entityIds.map(action));
+
+export const handler = async (ev: SQSEvent) => {
+  const batchItemFailures: SQSBatchItemFailure[] = [];
+  const { entityRepository, mutualRepository, publishEvent } = container;
+
+  await Promise.allSettled(
+    ev.Records.map(async (record) => {
+      const errorContext: Record<string, unknown> = {};
+      const body = parseSQSBusEvent<EventDetailBody>(record.body);
+      const { detail } = body;
+      const {
+        mutualIds,
+        byEntityType,
+        byEntityId,
+        entityType,
+        field,
+        publishedAt,
+        customContext,
+      } = detail;
+      errorContext.body = body;
+
+      try {
+        // Validate if mutual configuration exists
+        const config =
+          EntityConfig[byEntityType]?.mutual?.mutualFields?.[field];
+
+        if (!config) {
+          throw new StandardError('INVALID_MUTUAL', 'Invalid mutual');
+        }
+
+        const mutualDataProcessor = config.mutualDataProcessor ?? (() => ({}));
+
+        // Create a lock to prevent concurrent modifications
+        await mutualRepository.createMutualLock({
+          byEntityType,
+          byEntityId,
+          entityType,
+          version: publishedAt,
+        });
+
+        // Fetch related entities in parallel
+        const [byEntity, mutuals] = await Promise.all([
+          entityRepository.getEntity(byEntityType, byEntityId),
+          mutualRepository.listEntitiesByEntity(
+            byEntityType,
+            byEntityId,
+            entityType,
+          ),
+        ]);
+
+        // Determine which entities were added, removed, or need updates
+        const existingEntityIds = new Set(mutuals.items.map((m) => m.entityId));
+        const newMutualIds = new Set(mutualIds ?? []);
+
+        const addedEntityIds = [...newMutualIds].filter(
+          (id) => !existingEntityIds.has(id),
+        );
+        const deletedEntityIds = [...existingEntityIds].filter(
+          (id) => !newMutualIds.has(id),
+        );
+        const toUpdateEntityIds = [...existingEntityIds].filter((id) =>
+          newMutualIds.has(id),
+        );
+
+        errorContext.existingEntityIds = [...existingEntityIds];
+        errorContext.addedEntityIds = addedEntityIds;
+        errorContext.deletedEntityIds = deletedEntityIds;
+        errorContext.toUpdateEntityIds = toUpdateEntityIds;
+
+        const addEntities = await processEntities(
+          addedEntityIds,
+          async (id) => {
+            const entity = await entityRepository.getEntity(entityType, id);
+            await mutualRepository.createMutual(
+              byEntityType,
+              byEntityId,
+              byEntity.data,
+              entityType,
+              id,
+              entity.data,
+              mutualDataProcessor(
+                mutualIds,
+                new Mutual(
+                  byEntityType,
+                  byEntityId,
+                  byEntity.data,
+                  entityType,
+                  id,
+                  entity.data,
+                  {},
+                ),
+                customContext,
+              ),
+              {
+                ConditionExpression:
+                  'attribute_not_exists(#mutualUpdatedAt) OR #mutualUpdatedAt < :publishedAt',
+                ExpressionAttributeNames: {
+                  '#mutualUpdatedAt': 'mutualUpdatedAt',
+                },
+                ExpressionAttributeValues: {
+                  ':publishedAt': { S: publishedAt },
+                },
+                createAndUpdateDatetime: new Date(publishedAt),
+              },
+            );
+          },
+        );
+
+        const deleteEntities = await processEntities(
+          deletedEntityIds,
+          async (id) => {
+            await mutualRepository.deleteMutual(
+              byEntityType,
+              byEntityId,
+              entityType,
+              id,
+              {
+                ConditionExpression:
+                  'attribute_exists(PK) AND #mutualUpdatedAt < :publishedAt',
+                ExpressionAttributeNames: {
+                  '#mutualUpdatedAt': 'mutualUpdatedAt',
+                },
+                ExpressionAttributeValues: {
+                  ':publishedAt': { S: publishedAt },
+                },
+              },
+            );
+          },
+        );
+
+        const updateEntities = await processEntities(
+          toUpdateEntityIds,
+          async (id) => {
+            await mutualRepository.updateMutual(
+              byEntityType,
+              byEntityId,
+              entityType,
+              id,
+              {
+                mutualData: mutualDataProcessor(
+                  mutualIds,
+                  new Mutual(
+                    byEntityType,
+                    byEntityId,
+                    byEntity.data,
+                    entityType,
+                    id,
+                    {},
+                    {},
+                  ),
+                  customContext,
+                ),
+                mutualUpdatedAt: publishedAt,
+              },
+              {
+                ConditionExpression:
+                  'attribute_exists(PK) AND #mutualUpdatedAt < :publishedAt',
+                ExpressionAttributeNames: {
+                  '#mutualUpdatedAt': 'mutualUpdatedAt',
+                },
+                ExpressionAttributeValues: {
+                  ':publishedAt': { S: publishedAt },
+                },
+              },
+            );
+          },
+        );
+
+        errorContext.results = { addEntities, deleteEntities, updateEntities };
+
+        // release lock
+        await mutualRepository.deleteMutualLock({
+          byEntityType,
+          byEntityId,
+          entityType,
+        });
+
+        // Check for unprocessable errors in processing results
+        if (
+          [...addEntities, ...deleteEntities, ...updateEntities].some(
+            (res) =>
+              res.status === 'rejected' &&
+              !(
+                res.reason instanceof TransactionCanceledException ||
+                (res.reason instanceof StandardError &&
+                  res.reason.code === 'MUTUAL_NOT_FOUND')
+              ),
+          )
+        ) {
+          throw new StandardError(
+            'MUTUAL_PROCESSOR_ERROR',
+            'Mutual processor error',
+            null,
+            errorContext,
+          );
+        }
+
+        await publishEvent({
+          event: EVENT.CORE.ENTITY_MUTUAL_PROCESSED,
+          payload: {
+            byEntityType,
+            byEntityId,
+            entityType,
+            field,
+            mutualIds,
+            publishedAt,
+          },
+        });
+      } catch (err) {
+        console.error(
+          '=====MUTUAL_PROCESSOR_ERROR=====',
+          err,
+          JSON.stringify({ errorContext }, null, 2),
+        );
+
+        // Release the lock to avoid deadlocks
+        await mutualRepository.deleteMutualLock({
+          byEntityType,
+          byEntityId,
+          entityType,
+        });
+
+        if (
+          err instanceof StandardError &&
+          ['INVALID_MUTUAL', 'MUTUAL_LOCK_CONFLICT'].includes(err.code)
+        ) {
+          return;
+        }
+
+        batchItemFailures.push({ itemIdentifier: record.messageId });
+      }
+    }),
+  );
+
+  return { batchItemFailures };
+};

package/processors/prejoin-processor.ts

@@ -0,0 +1,264 @@
+import type { Entity } from '@monorise/base';
+import type { SQSBatchItemFailure, SQSEvent } from 'aws-lambda';
+import type { MutualRepository } from '#/data/Mutual';
+import { PROJECTION_EXPRESSION } from '#/data/ProjectionExpression';
+import { parseSQSBusEvent } from '#/helpers/event';
+import type { publishEvent as publishEventType } from '#/helpers/event';
+import { AllowedEntityTypes, EntityConfig } from '#/lambda-layer/monorise';
+import type { EventDetailBody as MutualProcessorEventDetailBody } from '#/processors/mutual-processor';
+import { DependencyContainer } from '#/services/DependencyContainer';
+import type { Prejoins } from '#/types/entity.type';
+import { EVENT } from '#/types/event';
+
+export type EventDetailBody = {
+  byEntityType: Entity;
+  byEntityId: string;
+  entityType: Entity;
+  publishedAt: string;
+};
+
+const container = new DependencyContainer();
+
+async function processPrejoins({
+  mutualRepository,
+  publishEvent,
+  byEntityType,
+  byEntityId,
+  prejoins,
+  publishedAt,
+}: {
+  mutualRepository: MutualRepository;
+  publishEvent: typeof publishEventType;
+  byEntityType: Entity;
+  byEntityId: string;
+  prejoins: Prejoins;
+  publishedAt: string;
+}) {
+  const mutualCache: Partial<
+    Record<
+      Entity,
+      Array<{
+        byEntityType?: Entity;
+        byEntityId?: string;
+        entityType: Entity;
+        entityId: string;
+      }>
+    >
+  > = {
+    /*
+        course: [{
+            byEntityType: 'module',
+            byEntityId: '1',
+            entityType: 'course',
+            entityId: '1',
+        }],
+        module: [],
+        chapter: [],
+        video: []
+    */
+  };
+
+  //initiate
+  mutualCache[byEntityType] = [
+    {
+      entityType: byEntityType,
+      entityId: byEntityId,
+    },
+  ];
+
+  for (const { mutualField, targetEntityType, entityPaths } of prejoins) {
+    let toBePublishedContext: Record<string, any> = {};
+
+    for (const [index, entityPath] of entityPaths.entries()) {
+      const entityType = entityPath.entityType as keyof typeof mutualCache;
+
+      // skip cached
+      if (!entityPath.skipCache && mutualCache[entityType]) {
+        continue;
+      }
+
+      // if skipping cache should not have previous run data
+      mutualCache[entityType] = [];
+
+      const parentEntityType = entityPaths[index - 1]
+        .entityType as keyof typeof mutualCache;
+      const parentEntities = mutualCache[parentEntityType] ?? [];
+
+      // find all nested entities
+      for (const parentEntity of parentEntities) {
+        const { entityType: parentEntityType, entityId: parentEntityId } =
+          parentEntity;
+
+        const { items: mutualItems } =
+          await mutualRepository.listEntitiesByEntity(
+            parentEntityType,
+            parentEntityId,
+            entityPath.entityType,
+            {
+              ProjectionExpression: PROJECTION_EXPRESSION.MUTUAL_DATA_ONLY,
+            },
+          );
+
+        // custom processor defined in prejoin config for each path
+        const processor =
+          entityPath.processor || ((items, context) => ({ items, context }));
+
+        const processed = processor(mutualItems, toBePublishedContext);
+        toBePublishedContext = processed?.context || toBePublishedContext;
+
+        mutualCache[entityType] = [
+          ...(mutualCache[entityType] ?? []),
+          ...(processed ? processed.items : mutualItems),
+        ];
+      }
+
+      if (!mutualCache[entityType] && !Array.isArray(mutualCache[entityType])) {
+        // to avoid empty array
+        mutualCache[entityType] = [];
+      }
+    }
+
+    const mutualIds = (
+      mutualCache[targetEntityType as keyof typeof mutualCache] ?? []
+    ).map((item) => item.entityId);
+
+    await publishEvent<MutualProcessorEventDetailBody>({
+      event: EVENT.CORE.ENTITY_MUTUAL_TO_UPDATE,
+      payload: {
+        byEntityType,
+        byEntityId,
+        entityType: targetEntityType,
+        field: mutualField,
+        mutualIds,
+        customContext: toBePublishedContext,
+        publishedAt,
+      },
+    });
+  }
+}
+
+async function publishToSubscribers({
+  mutualRepository,
+  publishEvent,
+  byEntityType,
+  byEntityId,
+  publishedAt,
+}: {
+  mutualRepository: MutualRepository;
+  publishEvent: typeof publishEventType;
+  byEntityType: Entity;
+  byEntityId: string;
+  publishedAt: string;
+}) {
+  const listeners = AllowedEntityTypes.reduce(
+    (acc, configKey) => {
+      const { subscribes } = EntityConfig[configKey].mutual ?? {};
+
+      const hasSubscription = (subscribes ?? []).some(
+        ({ entityType }) => entityType === byEntityType,
+      );
+
+      return [
+        ...acc,
+        ...(hasSubscription
+          ? [
+              {
+                entityType: configKey,
+              },
+            ]
+          : []),
+      ];
+    },
+    [] as { entityType: Entity }[],
+  );
+
+  // publish event for each interested entity
+  const subscribedMutualItems = await Promise.all(
+    listeners.map(({ entityType: subscribedEntityType }) =>
+      mutualRepository.listEntitiesByEntity(
+        byEntityType,
+        byEntityId,
+        subscribedEntityType,
+        {
+          ProjectionExpression: PROJECTION_EXPRESSION.NO_DATA,
+        },
+      ),
+    ),
+  );
+  const subscribedMutuals = subscribedMutualItems.flatMap((item) => item.items);
+
+  await Promise.all(
+    subscribedMutuals.map((subscribedMutual) =>
+      publishEvent({
+        event: EVENT.CORE.PREJOIN_RELATIONSHIP_SYNC,
+        payload: {
+          byEntityType: subscribedMutual.entityType,
+          byEntityId: subscribedMutual.entityId,
+          entityType: subscribedMutual.byEntityType,
+          publishedAt,
+        },
+      }),
+    ),
+  );
+}
+
+export const handler = async (ev: SQSEvent) => {
+  const batchItemFailures: SQSBatchItemFailure[] = [];
+
+  const { mutualRepository, publishEvent } = container;
+
+  for (const record of ev.Records) {
+    const body = parseSQSBusEvent<EventDetailBody>(record.body);
+    const { detail } = body;
+    const { byEntityType, byEntityId, entityType, publishedAt } = detail;
+    let errorContext: Record<string, unknown> = {
+      body,
+    };
+
+    try {
+      const isEntityTypeSubscribed = (
+        EntityConfig[byEntityType]?.mutual?.subscribes ?? []
+      ).some(
+        ({ entityType: subscribedEntityType }) =>
+          subscribedEntityType === entityType,
+      );
+      const hasPrejoins = EntityConfig[byEntityType]?.mutual?.prejoins;
+      const shouldProcessPrejoins = isEntityTypeSubscribed && hasPrejoins;
+      errorContext = {
+        ...errorContext,
+        isEntityTypeSubscribed,
+        hasPrejoins,
+        shouldProcessPrejoins,
+      };
+
+      if (shouldProcessPrejoins) {
+        await processPrejoins({
+          mutualRepository,
+          publishEvent,
+          byEntityType,
+          byEntityId,
+          prejoins: EntityConfig[byEntityType]?.mutual?.prejoins ?? [],
+          publishedAt,
+        });
+      }
+
+      await publishToSubscribers({
+        mutualRepository,
+        publishEvent,
+        byEntityType,
+        byEntityId,
+        publishedAt,
+      });
+    } catch (err) {
+      console.log(
+        '===PREJOIN-PROCESSOR ERROR===',
+        err,
+        JSON.stringify({ errorContext }, null, 2),
+      );
+
+      batchItemFailures.push({ itemIdentifier: record.messageId });
+    }
+  }
+
+  return { batchItemFailures };
+};