@monorise/core 1.0.0

package/configs/service.config.ts

@@ -0,0 +1,14 @@
+import {
+  ENTITY_REPLICATION_INDEX,
+  MUTUAL_REPLICATION_INDEX,
+} from '../constants/table';
+
+const CORE_TABLE = process.env.CORE_TABLE || '';
+const CORE_EVENT_BUS = process.env.CORE_EVENT_BUS || '';
+
+export {
+  CORE_TABLE,
+  CORE_EVENT_BUS,
+  ENTITY_REPLICATION_INDEX,
+  MUTUAL_REPLICATION_INDEX,
+};

package/constants/table.ts

@@ -0,0 +1,3 @@
+export const REPLICATION_INDEX = 'REPLICATION_INDEX';
+export const ENTITY_REPLICATION_INDEX = 'ENTITY_REPLICATION_INDEX';
+export const MUTUAL_REPLICATION_INDEX = 'MUTUAL_REPLICATION_INDEX';

package/controllers/entity/create-entity.controller.ts

@@ -0,0 +1,51 @@
+import type { Entity } from '@monorise/base';
+import type { Request, Response } from 'express';
+import httpStatus from 'http-status';
+import { ZodError } from 'zod';
+import { StandardError } from '#/errors/standard-error';
+import type { EntityService } from '#/services/entity.service';
+
+export class CreateEntityController {
+  constructor(private entityService: EntityService) {}
+
+  controller: (req: Request, res: Response) => void = async (req, res) => {
+    const accountId = req.headers['account-id'];
+    const { entityType } = req.params as unknown as {
+      entityType: Entity;
+    };
+
+    try {
+      const entity = await this.entityService.createEntity({
+        entityType,
+        entityPayload: req.body,
+        accountId,
+        options: {
+          createAndUpdateDatetime: req.body.createdAt,
+        },
+      });
+
+      return res.status(httpStatus.OK).json(entity);
+    } catch (err) {
+      if (err instanceof ZodError) {
+        return res.status(httpStatus.BAD_REQUEST).json({
+          code: 'API_VALIDATION_ERROR',
+          message: 'API validation failed',
+          details: err.flatten(),
+        });
+      }
+
+      if (err instanceof StandardError && err.code === 'EMAIL_EXISTS') {
+        return res.status(httpStatus.BAD_REQUEST).json({
+          ...err.toJSON(),
+        });
+      }
+
+      console.log('===create-entity error:', {
+        err,
+        errorContext: JSON.stringify({ body: req.body, headers: req.headers }),
+      });
+
+      throw err;
+    }
+  };
+}

package/controllers/entity/delete-entity.controller.ts

@@ -0,0 +1,35 @@
+import type { Entity } from '@monorise/base';
+import type { Request, Response } from 'express';
+import httpStatus from 'http-status';
+import { StandardError } from '#/errors/standard-error';
+import type { EntityService } from '#/services/entity.service';
+
+export class DeleteEntityController {
+  constructor(private readonly entityService: EntityService) {}
+
+  controller: (req: Request, res: Response) => void = async (req, res) => {
+    const accountId = req.headers['account-id'];
+    const { entityType, entityId } = req.params as unknown as {
+      entityType: Entity;
+      entityId: string;
+    };
+
+    try {
+      await this.entityService.deleteEntity({
+        entityType,
+        entityId,
+        accountId,
+      });
+
+      return res.json({ message: 'entity deleted' });
+    } catch (err) {
+      if (err instanceof StandardError && err.code === 'ENTITY_NOT_FOUND') {
+        return res.status(httpStatus.NOT_FOUND).json({
+          ...err.toJSON(),
+        });
+      }
+
+      throw err;
+    }
+  };
+}

package/controllers/entity/entity.http

@@ -0,0 +1,62 @@
+### Entity
+
+@entityType=active-course
+
+### List all entities
+
+GET {{BASE_URL}}/core/entity/{{entityType}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+### Search for entity with query
+
+GET {{BASE_URL}}/core/entity/{{entityType}}
+    ?query=edit
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+### Create entity
+
+POST {{BASE_URL}}/core/entity/{{entityType}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+{
+    "email": "test@mail.com",
+    "displayName": "chapter 3"
+}
+
+### Get entity by entityId
+
+@entityId=config
+
+GET {{BASE_URL}}/core/entity/{{entityType}}/{{entityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+
+### Upsert entity
+
+PUT {{BASE_URL}}/core/entity/{{entityType}}/{{entityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+{
+    "name": "test test edit again"
+}
+
+### Update entity
+
+PATCH {{BASE_URL}}/core/entity/{{entityType}}/{{entityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+{
+    "name": "test test edit again"
+}
+
+### Delete entity
+
+DELETE {{BASE_URL}}/core/entity/{{entityType}}/{{entityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}

package/controllers/entity/get-entity.controller.ts

@@ -0,0 +1,33 @@
+import type { Entity } from '@monorise/base';
+import type { Request, Response } from 'express';
+import httpStatus from 'http-status';
+import type { EntityRepository } from '#/data/Entity';
+
+export class GetEntityController {
+  constructor(private entityRepository: EntityRepository) {}
+
+  controller: (req: Request, res: Response) => void = async (req, res) => {
+    const { entityType, entityId } = req.params as unknown as {
+      entityType: Entity;
+      entityId: string;
+    };
+
+    try {
+      const entity = await this.entityRepository.getEntity(
+        entityType,
+        entityId,
+      );
+
+      return res.status(httpStatus.OK).json(entity);
+    } catch (err) {
+      if ((err as any).code === 'ENTITY_IS_UNDEFINED') {
+        return res.status(httpStatus.NOT_FOUND).json({
+          code: 'ENTITY_NOT_FOUND',
+          message: 'Entity not found',
+        });
+      }
+
+      throw err;
+    }
+  };
+}

package/controllers/entity/list-entities.controller.ts

@@ -0,0 +1,69 @@
+import type { Entity } from '@monorise/base';
+import type { Request, Response } from 'express';
+import { z } from 'zod';
+import type { EntityRepository } from '#/data/Entity';
+import { fromLastKeyQuery } from '#/helpers/fromLastKeyQuery';
+import { toLastKeyResponse } from '#/helpers/toLastKeyResponse';
+
+const querySchema = z.object({
+  limit: z.string().optional(),
+  lastKey: z.string().optional(),
+  query: z.string().trim().optional(),
+  start: z.string().optional(),
+  end: z.string().optional(),
+});
+
+export class ListEntitiesController {
+  constructor(private entityRepository: EntityRepository) {}
+
+  controller: (req: Request, res: Response) => void = async (req, res) => {
+    const errorContext: { [key: string]: any } = {};
+    try {
+      const accountId = req.headers['account-id'] || '';
+      if (Array.isArray(accountId)) {
+        throw new Error('multiple account-id detected');
+      }
+
+      errorContext.accountId = accountId;
+      errorContext.params = req.params;
+      errorContext.query = req.query;
+
+      const { entityType } = req.params as unknown as {
+        entityType: Entity;
+      };
+
+      const { lastKey, query, limit, start, end } = querySchema.parse(
+        req.query,
+      );
+      if (query) {
+        const results = await this.entityRepository.queryEntities(
+          entityType,
+          query,
+        );
+
+        return res.json({
+          data: results.items.map((item) => item.toJSON()),
+          totalCount: results.totalCount,
+          filteredCount: results.filteredCount,
+        });
+      }
+
+      const results = await this.entityRepository.listEntities({
+        entityType,
+        limit: Number(limit),
+        options: {
+          lastKey: fromLastKeyQuery(lastKey),
+        },
+        ...(start && end ? { between: { start, end } } : {}),
+      });
+      return res.json({
+        data: results.items.map((item) => item.toJSON()),
+        totalCount: results.totalCount,
+        lastKey: toLastKeyResponse(results.lastKey),
+      });
+    } catch (error) {
+      console.log({ error, errorContext });
+      return res.status(500).json({ message: error });
+    }
+  };
+}

package/controllers/entity/update-entity.controller.ts

@@ -0,0 +1,56 @@
+import type { Entity } from '@monorise/base';
+import type { Request, Response } from 'express';
+import httpStatus from 'http-status';
+import { ZodError } from 'zod';
+import { StandardError } from '#/errors/standard-error';
+import type { EntityService } from '#/services/entity.service';
+
+export class UpdateEntityController {
+  constructor(private entityService: EntityService) {}
+
+  controller: (req: Request, res: Response) => void = async (req, res) => {
+    const accountId = req.headers['account-id'];
+    const { entityType, entityId } = req.params as unknown as {
+      entityType: Entity;
+      entityId: string;
+    };
+    const errorContext: any = {
+      accountId,
+      'req.params': req.params,
+      'req.body': req.body,
+    };
+
+    try {
+      const entity = await this.entityService.updateEntity({
+        entityType,
+        entityId,
+        entityPayload: req.body,
+        accountId,
+      });
+      errorContext.entity = entity;
+
+      return res.status(httpStatus.OK).json(entity);
+    } catch (err) {
+      if (err instanceof ZodError) {
+        return res.status(httpStatus.BAD_REQUEST).json({
+          code: 'API_VALIDATION_ERROR',
+          message: 'API validation failed',
+          details: err.flatten(),
+        });
+      }
+
+      if (err instanceof StandardError && err.code === 'ENTITY_NOT_FOUND') {
+        return res.status(httpStatus.NOT_FOUND).json({
+          ...err.toJSON(),
+        });
+      }
+
+      console.log(
+        '====UPDATE_ENTITY_CONTROLLER_ERROR',
+        err,
+        JSON.stringify({ errorContext }, null, 2),
+      );
+      throw err;
+    }
+  };
+}

package/controllers/entity/upsert-entity.controller.ts

@@ -0,0 +1,97 @@
+import type { Entity } from '@monorise/base';
+import type { Request, Response } from 'express';
+import httpStatus from 'http-status';
+import { ZodError } from 'zod';
+import type { EntityRepository } from '#/data/Entity';
+import { StandardError } from '#/errors/standard-error';
+import type { publishEvent as publishEventType } from '#/helpers/event';
+import { EntityConfig } from '#/lambda-layer/monorise';
+import { EVENT } from '#/types/event';
+
+export class UpsertEntityController {
+  constructor(
+    private entityRepository: EntityRepository,
+    private publishEvent: typeof publishEventType,
+  ) {}
+
+  controller: (req: Request, res: Response) => void = async (req, res) => {
+    const accountId = req.headers['account-id'];
+    const { entityType, entityId } = req.params as unknown as {
+      entityType: Entity;
+      entityId: string;
+    };
+
+    try {
+      const entitySchema =
+        EntityConfig[entityType].createSchema ||
+        EntityConfig[entityType].baseSchema;
+      const mutualSchema = EntityConfig[entityType].mutual?.mutualSchema;
+
+      if (!entitySchema || !mutualSchema) {
+        throw new StandardError('Invalid entity type', 'INVALID_ENTITY_TYPE');
+      }
+
+      const parsedEntityPayload = entitySchema.parse(req.body);
+      const parsedMutualPayload = mutualSchema.parse(req.body);
+
+      const entity = await this.entityRepository.upsertEntity(
+        entityType,
+        entityId,
+        parsedEntityPayload,
+      );
+
+      if (parsedMutualPayload) {
+        const byEntityType = entityType;
+        const byEntityId = entity.entityId;
+        const publishEventPromises = [];
+
+        for (const [fieldKey, config] of Object.entries(
+          EntityConfig[entityType].mutual?.mutualFields || {},
+        )) {
+          publishEventPromises.push(
+            this.publishEvent({
+              event: EVENT.CORE.ENTITY_MUTUAL_TO_UPDATE,
+              payload: {
+                byEntityType,
+                byEntityId,
+                entityType: config.entityType,
+                field: fieldKey,
+                mutualIds: (parsedMutualPayload as any)[fieldKey],
+                publishedAt: entity.updatedAt || new Date().toISOString(),
+              },
+            }),
+          );
+        }
+        await Promise.allSettled(publishEventPromises);
+      }
+
+      await this.publishEvent({
+        event: EVENT.CORE.ENTITY_UPSERTED,
+        payload: {
+          entityType,
+          entityId: entity.entityId,
+          payload: req.body,
+          createdByAccountId: accountId,
+        },
+      });
+
+      return res.status(httpStatus.OK).json(entity);
+    } catch (err) {
+      if (err instanceof ZodError) {
+        return res.status(httpStatus.BAD_REQUEST).json({
+          code: 'API_VALIDATION_ERROR',
+          message: 'API validation failed',
+          details: err.flatten(),
+        });
+      }
+
+      if (err instanceof StandardError && err.code === 'EMAIL_EXISTS') {
+        return res.status(httpStatus.BAD_REQUEST).json({
+          ...err.toJSON(),
+        });
+      }
+
+      throw err;
+    }
+  };
+}

package/controllers/mutual/create-mutual.controller.ts

@@ -0,0 +1,89 @@
+import type { Entity as EntityType } from '@monorise/base';
+import type { Request, Response } from 'express';
+import httpStatus from 'http-status';
+import { ZodError } from 'zod';
+import { StandardError } from '#/errors/standard-error';
+import type { publishEvent as publishEventType } from '#/helpers/event';
+import type { MutualService } from '#/services/mutual.service';
+// import { EVENT, type EventDetail } from '#/types/event';
+// import { Entity } from '#/lambda-layer/monorise';
+
+export class CreateMutualController {
+  constructor(
+    private mutualService: MutualService,
+    private publishEvent: typeof publishEventType,
+  ) {}
+
+  controller: (req: Request, res: Response) => void = async (req, res) => {
+    const accountId = req.headers['account-id'];
+    const { byEntityType, byEntityId, entityType, entityId } =
+      req.params as unknown as {
+        byEntityType: EntityType;
+        byEntityId: string;
+        entityType: EntityType;
+        entityId: string;
+      };
+
+    const { asEntity } = req.query;
+
+    try {
+      const { mutual, eventPayload } = await this.mutualService.createMutual({
+        byEntityType,
+        byEntityId,
+        entityType,
+        entityId,
+        mutualPayload: req.body,
+        accountId,
+        options: {
+          asEntity: asEntity as unknown as EntityType,
+        },
+      });
+
+      /*
+       * Add more custom event based on byEntityType and entityType
+       */
+
+      // const eventPromises = [];
+
+      // const eventMaps: Record<string, EventDetail> = {
+      //   [`${Entity.LEARNER}_${Entity.LEARNING_ACTIVITY}`]:
+      //     EVENT.CORE_SERVICE.LEARNER_LEARNING_ACTIVITY_SUBMITTED,
+      // };
+
+      // if (eventMaps[`${byEntityType}_${entityType}`]) {
+      //   eventPromises.push(
+      //     this.publishEvent({
+      //       event: eventMaps[`${byEntityType}_${entityType}`],
+      //       payload: eventPayload,
+      //     }),
+      //   );
+      // }
+
+      // await Promise.all(eventPromises);
+
+      return res.status(httpStatus.OK).json(mutual);
+    } catch (err) {
+      if (err instanceof ZodError) {
+        return res.status(httpStatus.BAD_REQUEST).json({
+          code: 'API_VALIDATION_ERROR',
+          message: 'API validation failed',
+          details: err.flatten(),
+        });
+      }
+
+      if (err instanceof StandardError && err.code === 'MUTUAL_EXISTS') {
+        return res.status(httpStatus.BAD_REQUEST).json({
+          ...err.toJSON(),
+        });
+      }
+
+      if (err instanceof StandardError && err.code === 'ENTITY_IS_UNDEFINED') {
+        return res.status(httpStatus.BAD_REQUEST).json({
+          ...err.toJSON(),
+        });
+      }
+
+      throw err;
+    }
+  };
+}

package/controllers/mutual/delete-mutual.controller.ts

@@ -0,0 +1,40 @@
+import type { Entity } from '@monorise/base';
+import type { Request, Response } from 'express';
+import httpStatus from 'http-status';
+import { StandardError } from '#/errors/standard-error';
+import type { MutualService } from '#/services/mutual.service';
+
+export class DeleteMutualController {
+  constructor(private mutualService: MutualService) {}
+
+  controller: (req: Request, res: Response) => void = async (req, res) => {
+    const accountId = req.headers['account-id'];
+    const { byEntityType, byEntityId, entityType, entityId } =
+      req.params as unknown as {
+        byEntityType: Entity;
+        byEntityId: string;
+        entityType: Entity;
+        entityId: string;
+      };
+
+    try {
+      const mutual = await this.mutualService.deleteMutual({
+        byEntityType,
+        byEntityId,
+        entityType,
+        entityId,
+        accountId,
+      });
+
+      return res.json(mutual);
+    } catch (err) {
+      if (err instanceof StandardError && err.code === 'MUTUAL_NOT_FOUND') {
+        return res.status(httpStatus.BAD_REQUEST).json({
+          ...err.toJSON(),
+        });
+      }
+
+      throw err;
+    }
+  };
+}

package/controllers/mutual/get-mutual.controller.ts

@@ -0,0 +1,38 @@
+import type { Entity } from '@monorise/base';
+import type { Request, Response } from 'express';
+import httpStatus from 'http-status';
+import type { MutualRepository } from '#/data/Mutual';
+
+export class GetMutualController {
+  constructor(private associateRepository: MutualRepository) {}
+
+  controller: (req: Request, res: Response) => void = async (req, res) => {
+    const { byEntityType, byEntityId, entityType, entityId } =
+      req.params as unknown as {
+        byEntityType: Entity;
+        byEntityId: string;
+        entityType: Entity;
+        entityId: string;
+      };
+
+    try {
+      const associate = await this.associateRepository.getMutual(
+        byEntityType,
+        byEntityId,
+        entityType,
+        entityId,
+      );
+
+      return res.status(httpStatus.OK).json(associate);
+    } catch (err) {
+      if ((err as any).code === 'MUTUAL_IS_UNDEFINED') {
+        return res.status(httpStatus.NOT_FOUND).json({
+          code: 'MUTUAL_NOT_FOUND',
+          message: 'Mutual not found',
+        });
+      }
+
+      throw err;
+    }
+  };
+}

package/controllers/mutual/list-entities-by-entity.controller.ts

@@ -0,0 +1,76 @@
+import type { Entity } from '@monorise/base';
+import type { Request, Response } from 'express';
+import httpStatus from 'http-status';
+import { z } from 'zod';
+import type { Mutual, MutualRepository } from '#/data/Mutual';
+
+export class ListEntitiesByEntityController {
+  constructor(private associateRepository: MutualRepository) {}
+
+  controller: (req: Request, res: Response) => void = async (req, res) => {
+    const { byEntityType, byEntityId, entityType } = req.params as unknown as {
+      byEntityType: Entity;
+      byEntityId: string;
+      entityType: Entity;
+    };
+
+    /**
+     * Chain query is a query that allows to query entities by a chain of mutual types.
+     * if /core/mutual/learner/:learnerId/pathways?chainEntityQuery=type1,type2
+     * then the query will look for list of type1 in learner based on learnerId,
+     * then look for list of type2 in type1 by list of entityId of type1,
+     * then finally look for list of pathways in type2 by list of entityId of type2.
+     */
+    const querySchema = z.object({
+      chainEntityQuery: z.string().optional(),
+    });
+    const queryParam = querySchema.parse(req.query);
+    if (queryParam?.chainEntityQuery) {
+      try {
+        const mutualTypes = queryParam.chainEntityQuery.split(
+          ',',
+        ) as unknown as Entity[];
+
+        const chainMutualTypes = [byEntityType, ...mutualTypes, entityType];
+        let byIds = [byEntityId];
+        let items: Mutual<Entity, Entity, Record<string, unknown>>[] = [];
+
+        for (let i = 1; i < chainMutualTypes.length; i++) {
+          const byType = chainMutualTypes[i - 1];
+          const type = chainMutualTypes[i];
+          items = [];
+
+          for (const byId of byIds) {
+            const resp = await this.associateRepository.listEntitiesByEntity(
+              byType,
+              byId,
+              type,
+            );
+            items = items.concat(resp.items);
+          }
+          byIds = items.map((item) => item.entityId);
+        }
+
+        return res.json({
+          entities: items,
+        });
+      } catch (err) {
+        return res.status(httpStatus.BAD_REQUEST).json({
+          code: 'INVALID_CHAIN_QUERY',
+          message:
+            'Chain query is invalid. Please double check the chainEntityQuery param',
+        });
+      }
+    } else {
+      const resp = await this.associateRepository.listEntitiesByEntity(
+        byEntityType,
+        byEntityId,
+        entityType,
+      );
+
+      return res.json({
+        entities: resp.items,
+      });
+    }
+  };
+}