@monorise/core 1.0.0

package/processors/replication-processor.ts

@@ -0,0 +1,261 @@
+import { ConditionalCheckFailedException } from '@aws-sdk/client-dynamodb';
+import type {
+  AttributeValue,
+  _Record as DynamoDBStreamEvent,
+} from '@aws-sdk/client-dynamodb-streams';
+import type { DynamoDBBatchItemFailure } from 'aws-lambda';
+import {
+  ENTITY_REPLICATION_INDEX,
+  MUTUAL_REPLICATION_INDEX,
+} from '#/configs/service.config';
+import { StandardError } from '#/errors/standard-error';
+import { DependencyContainer } from '#/services/DependencyContainer';
+
+const container = new DependencyContainer();
+const TableName = process.env.DDB_TABLE;
+
+export const handler = async (event: { Records: DynamoDBStreamEvent[] }) => {
+  const batchItemFailures: DynamoDBBatchItemFailure[] = [];
+  const { dynamodbClient } = container;
+
+  for (const record of event.Records) {
+    const errorContext: any = {};
+    errorContext.record = record;
+
+    try {
+      if (record.eventName === 'MODIFY') {
+        const modifiedItem = record.dynamodb?.NewImage;
+        if (!modifiedItem) {
+          continue;
+        }
+
+        const isMetadata = modifiedItem.SK.S?.startsWith('#METADATA#');
+        const isMutual = modifiedItem.PK.S?.startsWith('MUTUAL#') && isMetadata;
+        const isEntity = isMetadata && !isMutual;
+
+        if (!isEntity && !isMutual) {
+          // skip replicated data
+          continue;
+        }
+
+        // default variables
+        let targetRPK = 'R1PK';
+        const targetData = 'data';
+        let targetIndexName = ENTITY_REPLICATION_INDEX;
+        const targetUpdatedAt = 'updatedAt';
+
+        let queryExpression: {
+          FilterExpression?: string;
+          ExpressionAttributeNames: Record<string, string>;
+          ExpressionAttributeValues: Record<string, AttributeValue>;
+        } = {
+          FilterExpression: `#${targetUpdatedAt} < :${targetUpdatedAt}`,
+          ExpressionAttributeNames: {
+            [`#${targetRPK}`]: targetRPK,
+            [`#${targetUpdatedAt}`]: targetUpdatedAt,
+          },
+          ExpressionAttributeValues: {
+            [`:${targetRPK}`]: modifiedItem.PK,
+            [`:${targetUpdatedAt}`]: modifiedItem.updatedAt,
+          },
+        };
+
+        const updateExpession: {
+          ConditionExpression: string;
+          UpdateExpression: string;
+          ExpressionAttributeNames: Record<string, string>;
+          ExpressionAttributeValues: Record<string, AttributeValue>;
+        } = {
+          UpdateExpression: `SET #${targetUpdatedAt} = :${targetUpdatedAt}, #${targetData} = :${targetData}`,
+          ConditionExpression: `#${targetUpdatedAt} < :${targetUpdatedAt}`,
+          ExpressionAttributeNames: {
+            [`#${targetData}`]: targetData,
+            [`#${targetUpdatedAt}`]: targetUpdatedAt,
+          },
+          ExpressionAttributeValues: {
+            [`:${targetData}`]: modifiedItem.data,
+            [`:${targetUpdatedAt}`]: modifiedItem.updatedAt,
+          },
+        };
+
+        if (isMutual) {
+          targetRPK = 'R2PK';
+          targetIndexName = MUTUAL_REPLICATION_INDEX;
+
+          // condition to only replicate to mutualAsEntity
+          queryExpression = {
+            FilterExpression: `${queryExpression.FilterExpression} AND #SK = :metadata`, // to replicate to mutualAsEntity only
+            ExpressionAttributeNames: {
+              '#SK': 'SK',
+              [`#${targetRPK}`]: targetRPK,
+              [`#${targetUpdatedAt}`]: targetUpdatedAt,
+            },
+            ExpressionAttributeValues: {
+              ':metadata': { S: '#METADATA#' },
+              [`:${targetRPK}`]: modifiedItem.PK,
+              [`:${targetUpdatedAt}`]: modifiedItem.mutualUpdatedAt,
+            },
+          };
+
+          updateExpession.ExpressionAttributeValues = {
+            [`:${targetData}`]: modifiedItem.mutualData,
+            [`:${targetUpdatedAt}`]: modifiedItem.mutualUpdatedAt,
+          };
+        }
+
+        errorContext.queryExpression = queryExpression;
+        errorContext.updateExpession = updateExpession;
+
+        // retrieve all to be replicated items
+        let toBeReplicatedItems: Record<string, AttributeValue>[] = [];
+        let lastKey;
+
+        do {
+          const queryResult = await dynamodbClient.query({
+            TableName,
+            IndexName: targetIndexName,
+            KeyConditionExpression: `#${targetRPK} = :${targetRPK}`,
+            ...queryExpression,
+          });
+
+          toBeReplicatedItems = [
+            ...toBeReplicatedItems,
+            ...(queryResult.Items || []),
+          ];
+          lastKey = queryResult.LastEvaluatedKey;
+        } while (lastKey);
+        errorContext.toBeReplicatedItems = toBeReplicatedItems;
+
+        const updatePromises = toBeReplicatedItems.map((item) => {
+          const updateParams = {
+            TableName,
+            Key: {
+              PK: item.PK,
+              SK: item.SK,
+            },
+            ...updateExpession,
+          };
+
+          return dynamodbClient.updateItem(updateParams);
+        });
+
+        const results = await Promise.allSettled(updatePromises);
+        errorContext.results = results;
+
+        if (
+          results.some(
+            (result) =>
+              result.status === 'rejected' &&
+              !(result.reason instanceof ConditionalCheckFailedException),
+          )
+        ) {
+          throw new StandardError(
+            'REPLICATION_ERROR',
+            'Replication error',
+            null,
+            errorContext,
+          );
+        }
+      }
+
+      if (record.eventName === 'REMOVE') {
+        const removedKeys = record.dynamodb?.Keys || {};
+        const isMetadata = removedKeys.SK.S?.startsWith('#METADATA#');
+        const isMutual = removedKeys.PK.S?.startsWith('MUTUAL#') && isMetadata;
+        const isEntity = isMetadata && !isMutual;
+
+        if (!isEntity && !isMutual) {
+          continue;
+        }
+
+        // default query settings
+        let targetRPK = 'R1PK';
+        let targetIndexName: string = ENTITY_REPLICATION_INDEX;
+
+        if (isMutual) {
+          targetRPK = 'R2PK';
+          targetIndexName = MUTUAL_REPLICATION_INDEX;
+        }
+
+        let itemsToDelete: Record<string, AttributeValue>[] = [];
+        let lastKey;
+
+        do {
+          const queryResult = await dynamodbClient.query({
+            TableName,
+            IndexName: targetIndexName,
+            KeyConditionExpression: `#${targetRPK} = :${targetRPK}`,
+            ExpressionAttributeNames: {
+              [`#${targetRPK}`]: targetRPK,
+            },
+            ExpressionAttributeValues: {
+              [`:${targetRPK}`]: removedKeys.PK,
+            },
+          });
+
+          itemsToDelete = [...itemsToDelete, ...(queryResult.Items || [])];
+          lastKey = queryResult.LastEvaluatedKey;
+        } while (lastKey);
+
+        const mutualsToDelete = Array.from(
+          new Set(
+            itemsToDelete
+              .filter((item) => item.R2PK?.S?.startsWith('MUTUAL#'))
+              .map((filteredItem) => filteredItem.R2PK?.S),
+          ),
+        );
+        mutualsToDelete.forEach((mutual) => {
+          if (!mutual) {
+            return;
+          }
+
+          itemsToDelete.push({ PK: { S: mutual }, SK: { S: '#METADATA#' } });
+        });
+
+        const deleteResults = await Promise.allSettled(
+          itemsToDelete.map((item) =>
+            dynamodbClient.deleteItem({
+              TableName,
+              Key: {
+                PK: item.PK,
+                SK: item.SK,
+              },
+            }),
+          ),
+        );
+        errorContext.deleteResults = deleteResults;
+
+        if (
+          deleteResults.some(
+            (result) =>
+              result.status === 'rejected' &&
+              !(result.reason instanceof ConditionalCheckFailedException),
+          )
+        ) {
+          throw new StandardError(
+            'REPLICATION_ERROR',
+            'Replication error',
+            null,
+            errorContext,
+          );
+        }
+      }
+    } catch (error) {
+      console.error('====REPLICATION_ERROR', error);
+      console.log(
+        '====REPLICATION_ERROR errorContext',
+        JSON.stringify(errorContext, null, 2),
+      );
+
+      batchItemFailures.push({
+        itemIdentifier: record.dynamodb?.SequenceNumber || '',
+      });
+
+      // immediately return to prevent processing the rest
+      // because stream will restart from this point again
+      return { batchItemFailures };
+    }
+  }
+
+  return { batchItemFailures };
+};

package/processors/tag-processor.ts

@@ -0,0 +1,174 @@
+import type { CreatedEntity, Entity as EntityType } from '@monorise/base';
+import type { SQSBatchItemFailure, SQSEvent } from 'aws-lambda';
+import type { Entity } from '#/data/Entity';
+import { parseSQSBusEvent } from '#/helpers/event';
+import { EntityConfig } from '#/lambda-layer/monorise';
+import { DependencyContainer } from '#/services/DependencyContainer';
+import type { Tag } from '#/types/entity.type';
+
+export type EventDetailBody = {
+  entityType: EntityType;
+  entityId: string;
+  data: Record<string, any>;
+};
+
+const container = new DependencyContainer();
+
+function compareTags(
+  existingTags: Tag[],
+  newTags: Tag[],
+): {
+  old: Tag[];
+  new: Tag[];
+  remain: Tag[];
+} {
+  const oldMap = new Map(
+    existingTags.map((item) => [`${item.group}#${item.sortValue}`, item]),
+  );
+  const newMap = new Map(
+    newTags.map((item) => [`${item.group}#${item.sortValue}`, item]),
+  );
+
+  const remain: Tag[] = [];
+  const oldDiff: Tag[] = [];
+  const newDiff: Tag[] = [];
+
+  for (const [key, oldItem] of oldMap.entries()) {
+    if (newMap.has(key)) {
+      remain.push(oldItem);
+      newMap.delete(key); // Remove from newMap as it's already in remain
+    } else {
+      oldDiff.push(oldItem);
+    }
+  }
+
+  // Remaining entries in newMap are new
+  for (const newItem of newMap.values()) {
+    newDiff.push(newItem);
+  }
+
+  return {
+    old: oldDiff,
+    new: newDiff,
+    remain,
+  };
+}
+
+async function batchUpdateTags({
+  tagName,
+  entity,
+  diff,
+}: {
+  tagName: string;
+  entity: Entity<EntityType>;
+  diff: { old: Tag[]; new: Tag[] };
+}): Promise<void> {
+  if (!entity.entityId) {
+    throw new Error('entityId is required');
+  }
+
+  const { old: tagsToRemove, new: tagsToAdd } = diff;
+  const { entityType, entityId } = entity;
+
+  const removePromises = tagsToRemove.reduce(
+    (acc, tag) => [
+      ...acc,
+      container.tagRepository.deleteTag({
+        tagName,
+        group: tag.group,
+        sortValue: tag.sortValue,
+        entityType,
+        entityId,
+      }),
+    ],
+    [] as Promise<any>[],
+  );
+
+  const addPromises = tagsToAdd.reduce(
+    (acc, tag) => [
+      ...acc,
+      container.tagRepository.createTag({
+        tagName,
+        group: tag.group,
+        sortValue: tag.sortValue,
+        entity,
+      }),
+    ],
+    [] as Promise<any>[],
+  );
+
+  await Promise.all([...removePromises, ...addPromises]);
+}
+
+export const handler = async (ev: SQSEvent) => {
+  const batchItemFailures: SQSBatchItemFailure[] = [];
+
+  for (const record of ev.Records) {
+    const body = parseSQSBusEvent<EventDetailBody>(record.body);
+    const { detail } = body;
+    const { entityType, entityId } = detail;
+
+    const errorContext: Record<string, unknown> = {};
+    errorContext.body = body;
+
+    try {
+      const tagConfigs = EntityConfig[entityType]?.tags;
+
+      if (!tagConfigs || !tagConfigs.length) {
+        // skip if entity has no tag configs
+        continue;
+      }
+
+      await container.tagRepository.createLock({
+        entityType,
+        entityId,
+      });
+
+      for (const tagConfig of tagConfigs) {
+        const { name, processor } = tagConfig;
+
+        const existingTags = await container.tagRepository.getExistingTags({
+          entityType,
+          entityId,
+          tagName: name,
+        });
+        errorContext.existingTags = existingTags;
+
+        const entity = await container.entityRepository.getEntity(
+          entityType,
+          entityId,
+        );
+        errorContext.entity = entity;
+
+        const newTags = await processor(
+          entity as unknown as CreatedEntity<EntityType>,
+        );
+        errorContext.newTags = newTags;
+
+        const diff = compareTags(existingTags, newTags);
+        errorContext.diff = diff;
+
+        await batchUpdateTags({
+          tagName: name,
+          entity,
+          diff,
+        });
+      }
+
+      await container.tagRepository.deleteLock({
+        entityType,
+        entityId,
+      });
+    } catch (err) {
+      console.log(
+        '===TAG-PROCESSOR ERROR===',
+        err,
+        JSON.stringify({ errorContext }, null, 2),
+      );
+
+      batchItemFailures.push({ itemIdentifier: record.messageId });
+    }
+  }
+
+  return { batchItemFailures };
+};

package/services/DependencyContainer.ts

@@ -0,0 +1,208 @@
+import { DynamoDB } from '@aws-sdk/client-dynamodb';
+import { CORE_TABLE } from '#/configs/service.config';
+import { getDependencies } from '#/helpers/dependencies';
+import type { publishEvent as publishEventType } from '#/helpers/event';
+
+import { DbUtils } from '#/data/DbUtils';
+import { EntityRepository } from '#/data/Entity';
+import { EventUtils } from '#/data/EventUtils';
+import { MutualRepository } from '#/data/Mutual';
+import { TagRepository } from '#/data/Tag';
+
+import { CreateEntityController } from '#/controllers/entity/create-entity.controller';
+import { DeleteEntityController } from '#/controllers/entity/delete-entity.controller';
+import { GetEntityController } from '#/controllers/entity/get-entity.controller';
+import { ListEntitiesController } from '#/controllers/entity/list-entities.controller';
+import { UpdateEntityController } from '#/controllers/entity/update-entity.controller';
+import { UpsertEntityController } from '#/controllers/entity/upsert-entity.controller';
+import { CreateMutualController } from '#/controllers/mutual/create-mutual.controller';
+import { DeleteMutualController } from '#/controllers/mutual/delete-mutual.controller';
+import { GetMutualController } from '#/controllers/mutual/get-mutual.controller';
+import { ListEntitiesByEntityController } from '#/controllers/mutual/list-entities-by-entity.controller';
+import { UpdateMutualController } from '#/controllers/mutual/update-mutual.controller';
+import { EntityService } from './entity.service';
+import { MutualService } from './mutual.service';
+
+import { ListTagsController } from '#/controllers/tag/list-tags.controller';
+
+export class DependencyContainer {
+  private _instanceCache: Map<string, any>;
+  private _publishEvent: typeof publishEventType | null;
+  private _tableName: string;
+
+  constructor() {
+    this._instanceCache = new Map();
+    this._publishEvent = null;
+    this._tableName = CORE_TABLE;
+  }
+
+  createCachedInstance<T extends new (...args: any[]) => any>(
+    ClassRef: T,
+    ...args: ConstructorParameters<T>
+  ): InstanceType<T> {
+    const cacheKey = ClassRef.name;
+
+    if (this._instanceCache.has(cacheKey)) {
+      return this._instanceCache.get(cacheKey) as InstanceType<T>;
+    }
+
+    const instance = new ClassRef(...args);
+    this._instanceCache.set(cacheKey, instance);
+    return instance;
+  }
+
+  get coreTable(): string {
+    if (this._tableName) return this._tableName;
+
+    this._tableName = CORE_TABLE;
+    return this._tableName;
+  }
+
+  get publishEvent(): typeof publishEventType {
+    // for non class based function you can still have your own way of constructing
+    if (this._publishEvent) return this._publishEvent;
+
+    this._publishEvent = getDependencies().publishEvent;
+    return this._publishEvent;
+  }
+
+  get dynamodbClient(): DynamoDB {
+    return this.createCachedInstance(DynamoDB);
+  }
+
+  get dbUtils(): DbUtils {
+    return this.createCachedInstance(DbUtils, this.dynamodbClient);
+  }
+
+  get eventUtils(): EventUtils {
+    return this.createCachedInstance(EventUtils, this.publishEvent);
+  }
+
+  get entityRepository(): EntityRepository {
+    return this.createCachedInstance(
+      EntityRepository,
+      this.coreTable,
+      this.dynamodbClient,
+    );
+  }
+
+  get mutualRepository(): MutualRepository {
+    return this.createCachedInstance(
+      MutualRepository,
+      this.coreTable,
+      this.dynamodbClient,
+      this.dbUtils,
+    );
+  }
+
+  get entityService(): EntityService {
+    return this.createCachedInstance(
+      EntityService,
+      this.entityRepository,
+      this.publishEvent,
+      this.eventUtils,
+    );
+  }
+
+  get mutualService(): MutualService {
+    return this.createCachedInstance(
+      MutualService,
+      this.entityRepository,
+      this.mutualRepository,
+      this.publishEvent,
+      this.eventUtils,
+      this.dbUtils,
+    );
+  }
+
+  get tagRepository(): TagRepository {
+    return this.createCachedInstance(
+      TagRepository,
+      this.coreTable,
+      this.dynamodbClient,
+    );
+  }
+
+  get getEntityController(): GetEntityController {
+    return this.createCachedInstance(
+      GetEntityController,
+      this.entityRepository,
+    );
+  }
+
+  get listEntitiesController(): ListEntitiesController {
+    return this.createCachedInstance(
+      ListEntitiesController,
+      this.entityRepository,
+    );
+  }
+
+  get createEntityController(): CreateEntityController {
+    return this.createCachedInstance(
+      CreateEntityController,
+      this.entityService,
+    );
+  }
+
+  get upsertEntityController(): UpsertEntityController {
+    return this.createCachedInstance(
+      UpsertEntityController,
+      this.entityRepository,
+      this.publishEvent,
+    );
+  }
+
+  get updateEntityController(): UpdateEntityController {
+    return this.createCachedInstance(
+      UpdateEntityController,
+      this.entityService,
+    );
+  }
+
+  get deleteEntityController(): DeleteEntityController {
+    return this.createCachedInstance(
+      DeleteEntityController,
+      this.entityService,
+    );
+  }
+
+  get listEntitiesByEntityController(): ListEntitiesByEntityController {
+    return this.createCachedInstance(
+      ListEntitiesByEntityController,
+      this.mutualRepository,
+    );
+  }
+
+  get getMutualController(): GetMutualController {
+    return this.createCachedInstance(
+      GetMutualController,
+      this.mutualRepository,
+    );
+  }
+
+  get createMutualController(): CreateMutualController {
+    return this.createCachedInstance(
+      CreateMutualController,
+      this.mutualService,
+      this.publishEvent,
+    );
+  }
+
+  get updateMutualController(): UpdateMutualController {
+    return this.createCachedInstance(
+      UpdateMutualController,
+      this.mutualService,
+    );
+  }
+
+  get deleteMutualController(): DeleteMutualController {
+    return this.createCachedInstance(
+      DeleteMutualController,
+      this.mutualService,
+    );
+  }
+
+  get listTagsController(): ListTagsController {
+    return this.createCachedInstance(ListTagsController, this.tagRepository);
+  }
+}

package/services/entity-service-lifecycle.ts

@@ -0,0 +1,41 @@
+import type { Entity as EntityType } from '@monorise/base';
+import type { Entity } from '#/data/Entity';
+import type { EventUtils } from '#/data/EventUtils';
+import type { publishEvent as publishEventType } from '#/helpers/event';
+import { EntityConfig } from '#/lambda-layer/monorise';
+import { EVENT } from '#/types/event';
+
+export const afterCreateEntityHook = async <T extends EntityType>({
+  entity,
+  entityPayload = {},
+  accountId,
+  publishEvent,
+  eventUtils,
+}: {
+  entity: Entity<T>;
+  entityPayload?: Record<string, unknown>;
+  accountId?: string | string[];
+  publishEvent: typeof publishEventType;
+  eventUtils: EventUtils;
+}) => {
+  const mutualSchema = EntityConfig[entity.entityType].mutual?.mutualSchema;
+  const parsedMutualPayload = mutualSchema?.parse(entityPayload);
+
+  if (parsedMutualPayload) {
+    await eventUtils.publishCreateMutualsEvent({
+      entity,
+      mutualPayload: parsedMutualPayload,
+    });
+  }
+
+  await publishEvent({
+    event: EVENT.CORE.ENTITY_CREATED,
+    payload: {
+      entityType: entity.entityType,
+      entityId: entity.entityId,
+      data: entity.data,
+      createdByAccountId: accountId,
+      publishedAt: entity.updatedAt || new Date().toISOString(),
+    },
+  });
+};