@monorise/core 1.0.0

package/controllers/mutual/mutual.http

@@ -0,0 +1,88 @@
+### Mutual
+
+@byEntityType=learner
+@byEntityId=01J5R3ZS09J1GHP3DKSRC6D601
+@entityType=course
+@entityId=01J5R4032JRV4ABQE42GVGW96C
+
+### Create mutual: Associate entity x with entity y
+
+POST {{BASE_URL}}/core/mutual/{{byEntityType}}/{{byEntityId}}/{{entityType}}/{{entityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+{
+    "scope": ["member"]
+}
+
+### Reverse associate, same as associate (should failed if already associated)
+
+POST {{BASE_URL}}/core/mutual/{{entityType}}/{{entityId}}/{{byEntityType}}/{{byEntityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+{
+    "scope": ["member"]
+}
+
+### List associated accounts (flexible)
+
+GET {{BASE_URL}}/core/mutual/{{byEntityType}}/{{byEntityId}}/{{entityType}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+### List associated via chain query
+
+GET {{BASE_URL}}/core/mutual/{{byEntityType}}/{{byEntityId}}/{{entityType}}?chainEntityQuery=organization
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+### Reverse list associated accounts (list from the other perspective)
+
+GET {{BASE_URL}}/core/mutual/{{entityType}}/{{entityId}}/{{byEntityType}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+### Get account by entityId
+
+GET {{BASE_URL}}/core/mutual/{{byEntityType}}/{{byEntityId}}/{{entityType}}/{{entityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+### Reverse get account by entityId (should get the same thing but reversed ID)
+
+GET {{BASE_URL}}/core/mutual/{{entityType}}/{{entityId}}/{{byEntityType}}/{{byEntityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+### Update associate
+
+PATCH {{BASE_URL}}/core/mutual/{{byEntityType}}/{{byEntityId}}/{{entityType}}/{{entityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+{
+    "scope": ["superadmin"]
+}
+
+### Reverse update associate
+
+PATCH {{BASE_URL}}/core/mutual/{{entityType}}/{{entityId}}/{{byEntityType}}/{{byEntityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+{
+    "scope": ["hello"]
+}
+
+### Delete associate
+
+DELETE {{BASE_URL}}/core/mutual/{{byEntityType}}/{{byEntityId}}/{{entityType}}/{{entityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}
+
+### Reverse delete associate
+
+DELETE {{BASE_URL}}/core/mutual/{{entityType}}/{{entityId}}/{{byEntityType}}/{{byEntityId}}
+content-type: application/json
+x-api-key: {{X_API_KEY}}

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

@@ -0,0 +1,50 @@
+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 { MutualService } from '#/services/mutual.service';
+
+export class UpdateMutualController {
+  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.updateMutual({
+        byEntityType,
+        byEntityId,
+        entityType,
+        entityId,
+        mutualPayload: req.body,
+        accountId,
+      });
+
+      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_NOT_FOUND') {
+        return res.status(httpStatus.BAD_REQUEST).json({
+          ...err.toJSON(),
+        });
+      }
+
+      throw err;
+    }
+  };
+}

package/controllers/setupRoutes.ts

@@ -0,0 +1,73 @@
+import type { Router } from 'express';
+import { DependencyContainer } from '#/services/DependencyContainer';
+import { entityTypeCheck } from '../middlewares/entity-type-check';
+import { mutualTypeCheck } from '../middlewares/mutual-type-check';
+
+const setupCommonRoutes = (router: Router) => {
+  /*
+   * Mutual endpoint
+   */
+  const container = new DependencyContainer();
+
+  router.use('/mutual/:byEntityType/:byEntityId/:entityType', mutualTypeCheck);
+  router.get(
+    '/mutual/:byEntityType/:byEntityId/:entityType',
+    container.listEntitiesByEntityController.controller,
+  );
+  router.post(
+    '/mutual/:byEntityType/:byEntityId/:entityType/:entityId',
+    container.createMutualController.controller,
+  );
+  router.get(
+    '/mutual/:byEntityType/:byEntityId/:entityType/:entityId',
+    container.getMutualController.controller,
+  );
+  router.patch(
+    '/mutual/:byEntityType/:byEntityId/:entityType/:entityId',
+    container.updateMutualController.controller,
+  );
+  router.delete(
+    '/mutual/:byEntityType/:byEntityId/:entityType/:entityId',
+    container.deleteMutualController.controller,
+  );
+
+  /*
+   * Entities endpoint
+   */
+
+  router.use('/entity/:entityType', entityTypeCheck);
+  router.get(
+    '/entity/:entityType',
+    container.listEntitiesController.controller,
+  );
+  router.post(
+    '/entity/:entityType',
+    container.createEntityController.controller,
+  );
+  router.get(
+    '/entity/:entityType/:entityId',
+    container.getEntityController.controller,
+  );
+  router.put(
+    '/entity/:entityType/:entityId',
+    container.upsertEntityController.controller,
+  );
+  router.patch(
+    '/entity/:entityType/:entityId',
+    container.updateEntityController.controller,
+  );
+  router.delete(
+    '/entity/:entityType/:entityId',
+    container.deleteEntityController.controller,
+  );
+
+  /*
+   * Tag endpoint
+   */
+  router.get(
+    '/tag/:entityType/:tagName',
+    container.listTagsController.controller,
+  );
+};
+
+export { setupCommonRoutes };

package/controllers/tag/list-tags.controller.ts

@@ -0,0 +1,57 @@
+import type { Entity } from '@monorise/base';
+import type { Request, Response } from 'express';
+import { z } from 'zod';
+import type { TagRepository } from '#/data/Tag';
+import { fromLastKeyQuery } from '#/helpers/fromLastKeyQuery';
+import { toLastKeyResponse } from '#/helpers/toLastKeyResponse';
+
+const querySchema = z.object({
+  group: z.string().optional(),
+  query: z.string().optional(),
+  start: z.string().optional(),
+  end: z.string().optional(),
+  limit: z.string().optional(),
+  lastKey: z.string().optional(),
+});
+
+export class ListTagsController {
+  constructor(private tagRepository: TagRepository) {}
+
+  controller: (req: Request, res: Response) => void = async (req, res) => {
+    const errorContext: Record<string, unknown> = {};
+    try {
+      errorContext.params = req.params;
+      errorContext.query = req.query;
+
+      const { entityType, tagName } = req.params as unknown as {
+        entityType: Entity;
+        tagName: string;
+      };
+
+      const { lastKey, query, limit, start, end, group } = querySchema.parse(
+        req.query,
+      );
+
+      const results = await this.tagRepository.listTags({
+        entityType,
+        tagName,
+        limit: Number(limit),
+        options: {
+          lastKey: fromLastKeyQuery(lastKey),
+        },
+        query,
+        group,
+        start,
+        end,
+      });
+      return res.json({
+        entities: 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/data/DbUtils.ts

@@ -0,0 +1,40 @@
+import {
+  BatchStatementErrorCodeEnum,
+  type DynamoDB,
+  type TransactWriteItemsInput,
+  TransactionCanceledException,
+} from '@aws-sdk/client-dynamodb';
+import { StandardError } from '#/errors/standard-error';
+
+export class DbUtils {
+  constructor(private ddbClient: DynamoDB) {}
+
+  async executeTransactWrite(params: TransactWriteItemsInput) {
+    try {
+      await this.ddbClient.transactWriteItems(params);
+    } catch (err) {
+      if (err instanceof TransactionCanceledException) {
+        const hasConditionalCheckFailed = err.CancellationReasons?.some(
+          (reason) =>
+            reason.Code === BatchStatementErrorCodeEnum.ConditionalCheckFailed,
+        );
+
+        if (hasConditionalCheckFailed) {
+          throw new StandardError(
+            'CONDITIONAL_CHECK_FAILED',
+            'Failed to executeTransactWrite',
+            err,
+            { params },
+          );
+        }
+      }
+
+      throw new StandardError(
+        'TRANSACTION_FAILED',
+        'Failed to executeTransactWrite',
+        err,
+        { params },
+      );
+    }
+  }
+}