@monorise/core 1.0.2 → 1.0.4-0

package/services/DependencyContainer.ts

@@ -1,208 +0,0 @@
-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

@@ -1,41 +0,0 @@
-import type { Entity as EntityType } from '@monorise/base';
-import { EntityConfig } from '#/lambda-layer/monorise';
-import type { Entity } from '../data/Entity';
-import type { EventUtils } from '../data/EventUtils';
-import type { publishEvent as publishEventType } from '../helpers/event';
-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(),
-    },
-  });
-};

package/services/entity.service.ts

@@ -1,201 +0,0 @@
-import type { Entity, EntitySchemaMap } from '@monorise/base';
-import { z } from 'zod';
-import {
-  EmailAuthEnabledEntities,
-  EntityConfig,
-} from '#/lambda-layer/monorise';
-import type { EntityRepository } from '../data/Entity';
-import type { EventUtils } from '../data/EventUtils';
-import { StandardError } from '../errors/standard-error';
-import type { publishEvent as publishEventType } from '../helpers/event';
-import type { EventDetailBody as MutualProcessorEventDetailBody } from '../processors/mutual-processor';
-import { EVENT } from '../types/event';
-import { afterCreateEntityHook } from './entity-service-lifecycle';
-
-export class EntityService {
-  constructor(
-    private entityRepository: EntityRepository,
-    private publishEvent: typeof publishEventType,
-    private eventUtils: EventUtils,
-  ) {}
-
-  createEntity = async <T extends Entity>({
-    entityType,
-    entityId,
-    entityPayload,
-    accountId,
-    options,
-  }: {
-    entityType: T;
-    entityPayload: EntitySchemaMap[T];
-    entityId?: string;
-    accountId?: string | string[];
-    options?: {
-      createAndUpdateDatetime?: string;
-      mutualId?: string;
-    };
-  }) => {
-    const finalSchema = EntityConfig[entityType].finalSchema;
-    const entitySchema =
-      EntityConfig[entityType]?.createSchema ||
-      EntityConfig[entityType]?.baseSchema ||
-      z.object({});
-    // const mutualSchema = EntityConfig[entityType]?.mutual?.mutualSchema;
-
-    if (!finalSchema || !entitySchema) {
-      throw new StandardError('INVALID_ENTITY_TYPE', 'Invalid entity type');
-    }
-
-    finalSchema.parse(entityPayload);
-
-    const parsedEntityPayload = entitySchema.parse(
-      entityPayload,
-    ) as EntitySchemaMap[T] & { email: string };
-
-    // TODO: Create entity to accept mutual payload, so that mutual
-    // relationship can be formed when creating entity
-    // const parsedMutualPayload = mutualSchema?.parse(entityPayload);
-
-    if (EmailAuthEnabledEntities.includes(entityType)) {
-      await this.entityRepository.getEmailAvailability(
-        entityType,
-        parsedEntityPayload.email,
-      );
-    }
-
-    const entity = await this.entityRepository.createEntity(
-      entityType,
-      parsedEntityPayload,
-      entityId,
-      {
-        ...(options?.mutualId
-          ? {
-              mutualId: `MUTUAL#${options.mutualId}`,
-            }
-          : {}),
-        createAndUpdateDatetime: options?.createAndUpdateDatetime
-          ? new Date(options.createAndUpdateDatetime)
-          : new Date(),
-      },
-    );
-
-    await afterCreateEntityHook({
-      entity,
-      entityPayload,
-      accountId,
-      publishEvent: this.publishEvent,
-      eventUtils: this.eventUtils,
-    });
-
-    return entity;
-  };
-
-  updateEntity = async <T extends Entity>({
-    entityType,
-    entityId,
-    entityPayload,
-    accountId,
-  }: {
-    entityType: T;
-    entityId: string;
-    entityPayload: Partial<EntitySchemaMap[T]>;
-    accountId?: string | string[];
-  }) => {
-    const errorContext: Record<string, unknown> = {};
-
-    try {
-      const entitySchema = EntityConfig[entityType].baseSchema;
-      const mutualSchema = EntityConfig[entityType].mutual?.mutualSchema;
-
-      if (!entitySchema) {
-        throw new StandardError('Invalid entity type', 'INVALID_ENTITY_TYPE');
-      }
-
-      const parsedEntityPayload = entitySchema.parse(entityPayload) as Partial<
-        EntitySchemaMap[T]
-      >;
-      const parsedMutualPayload = mutualSchema?.parse(entityPayload);
-      errorContext.parsedMutualPayload = parsedMutualPayload;
-
-      const entity = await this.entityRepository.updateEntity(
-        entityType,
-        entityId,
-        { data: parsedEntityPayload },
-      );
-      errorContext.entity = entity;
-
-      if (parsedMutualPayload) {
-        const byEntityType = entityType;
-        const byEntityId = entityId;
-        const publishEventPromises = [];
-
-        for (const [fieldKey, config] of Object.entries(
-          EntityConfig[entityType].mutual?.mutualFields || {},
-        )) {
-          const toMutualIds = config.toMutualIds;
-          const mutualPayload = (parsedMutualPayload as Record<string, any>)[
-            fieldKey
-          ];
-          if (!mutualPayload) continue;
-
-          publishEventPromises.push(
-            this.publishEvent<MutualProcessorEventDetailBody>({
-              event: EVENT.CORE.ENTITY_MUTUAL_TO_UPDATE,
-              payload: {
-                byEntityType,
-                byEntityId,
-                entityType: config.entityType,
-                field: fieldKey,
-                mutualIds: toMutualIds
-                  ? toMutualIds(mutualPayload)
-                  : mutualPayload,
-                customContext: toMutualIds ? mutualPayload : {},
-                publishedAt: entity.updatedAt || new Date().toISOString(),
-              },
-            }),
-          );
-        }
-        await Promise.allSettled(publishEventPromises);
-      }
-
-      await this.publishEvent({
-        event: EVENT.CORE.ENTITY_UPDATED,
-        payload: {
-          entityType,
-          entityId,
-          data: entity.data,
-          updatedByAccountId: accountId,
-          publishedAt: entity.updatedAt || new Date().toISOString(),
-        },
-      });
-
-      return entity;
-    } catch (error) {
-      if (error && typeof error === 'object') {
-        (error as Record<string, unknown>).context = errorContext;
-      }
-      throw error;
-    }
-  };
-
-  deleteEntity = async <T extends Entity>({
-    entityType,
-    entityId,
-    accountId,
-  }: {
-    entityType: T;
-    entityId: string;
-    accountId?: string | string[];
-  }) => {
-    await this.entityRepository.deleteEntity(entityType, entityId);
-
-    await this.publishEvent({
-      event: EVENT.CORE.ENTITY_DELETED,
-      payload: {
-        entityType,
-        entityId,
-        deletedByAccountId: accountId,
-      },
-    });
-  };
-}