@monorise/core 1.0.2 → 1.0.4-0

package/helpers/event.ts

@@ -1,85 +0,0 @@
-import {
-  EventBridgeClient,
-  PutEventsCommand,
-} from '@aws-sdk/client-eventbridge';
-import { CORE_EVENT_BUS } from '../configs/service.config';
-import { EVENT, type EventDetail } from '../types/event';
-
-const eventBridge = new EventBridgeClient();
-
-type PublishEventProps<T> = {
-  payload: T;
-  event: EventDetail;
-};
-
-type ParsedSQSBusEvent<T = Record<string, any>> = {
-  event: EventDetail;
-  detail: T;
-};
-
-export function parseSQSBusEvent<T>(
-  evRecordBody: string,
-): ParsedSQSBusEvent<T> {
-  const body = JSON.parse(evRecordBody);
-  return {
-    ...body,
-    detail: body.detail,
-    event: {
-      Source: body.source,
-      DetailType: body['detail-type'],
-    },
-  };
-}
-
-export async function publishEvent<T extends Record<string, any>>({
-  payload,
-  event,
-}: PublishEventProps<T>): Promise<void> {
-  const params = {
-    Entries: [
-      {
-        ...event,
-        Detail: JSON.stringify(payload),
-        EventBusName: CORE_EVENT_BUS,
-      },
-    ],
-  };
-
-  await eventBridge.send(new PutEventsCommand(params));
-}
-
-type PublishErrorEventPayload = {
-  id: string;
-  serviceName: string;
-  method: string;
-  path: string;
-  body?: Record<string, any>;
-  error: Error;
-};
-
-export async function publishErrorEvent({
-  id,
-  serviceName,
-  method,
-  path,
-  body,
-  error,
-}: PublishErrorEventPayload) {
-  await publishEvent({
-    event: EVENT.GENERAL.ENDPOINT_ERROR,
-    payload: {
-      id,
-      serviceName,
-      method,
-      path,
-      ...(body ? { requestBody: body } : {}),
-      error: {
-        name: error.name,
-        message: error.message,
-        // @ts-ignore
-        cause: error.cause,
-        stack: error.stack,
-      },
-    },
-  });
-}

package/helpers/fromLastKeyQuery.ts

@@ -1,11 +0,0 @@
-import type { NativeAttributeValue } from '@aws-sdk/util-dynamodb';
-
-export function fromLastKeyQuery(
-  lastKeyQuery?: string,
-): Record<string, NativeAttributeValue> | undefined {
-  if (!lastKeyQuery) {
-    return;
-  }
-
-  return JSON.parse(Buffer.from(lastKeyQuery, 'base64').toString('utf-8'));
-}

package/helpers/sleep.ts

@@ -1 +0,0 @@
-export const sleep = (ms: number) => new Promise((res) => setTimeout(res, ms));

package/helpers/toLastKeyResponse.ts

@@ -1,11 +0,0 @@
-import type { NativeAttributeValue } from '@aws-sdk/util-dynamodb';
-
-export function toLastKeyResponse(
-  lastKey?: Record<string, NativeAttributeValue>,
-): string | undefined {
-  if (!lastKey) {
-    return;
-  }
-
-  return Buffer.from(JSON.stringify(lastKey)).toString('base64');
-}

package/index.ts

@@ -1,23 +0,0 @@
-import { setupCommonRoutes } from './controllers/setupRoutes';
-import { Entity } from './data/Entity';
-import { Mutual } from './data/Mutual';
-import { PROJECTION_EXPRESSION } from './data/ProjectionExpression';
-import { handler as createEntityProcessor } from './processors/create-entity-processor';
-import { handler as mutualProcessor } from './processors/mutual-processor';
-import { handler as prejoinProcessor } from './processors/prejoin-processor';
-import { handler as replicationProcessor } from './processors/replication-processor';
-import { handler as tagProcessor } from './processors/tag-processor';
-import { DependencyContainer } from './services/DependencyContainer';
-
-export {
-  setupCommonRoutes,
-  Entity,
-  Mutual,
-  PROJECTION_EXPRESSION,
-  createEntityProcessor,
-  mutualProcessor,
-  prejoinProcessor,
-  replicationProcessor,
-  tagProcessor,
-  DependencyContainer,
-};

package/middlewares/entity-type-check.ts

@@ -1,20 +0,0 @@
-import type { Entity } from '@monorise/base';
-import type { NextFunction, Request, Response } from 'express';
-import httpStatus from 'http-status';
-import { AllowedEntityTypes } from '#/lambda-layer/monorise';
-
-export const entityTypeCheck: (
-  req: Request,
-  res: Response,
-  next: NextFunction,
-) => void = (req, res, next) => {
-  const { entityType } = req.params as unknown as { entityType: Entity };
-
-  if (!AllowedEntityTypes.includes(entityType)) {
-    return res.status(httpStatus.NOT_FOUND).json({
-      code: 'NOT_FOUND',
-    });
-  }
-
-  next();
-};

package/middlewares/mutual-type-check.ts

@@ -1,26 +0,0 @@
-import type { Entity } from '@monorise/base';
-import type { NextFunction, Request, Response } from 'express';
-import httpStatus from 'http-status';
-import { AllowedEntityTypes } from '#/lambda-layer/monorise';
-
-export const mutualTypeCheck: (
-  req: Request,
-  res: Response,
-  next: NextFunction,
-) => void = (req, res, next) => {
-  const { entityType, byEntityType } = req.params as unknown as {
-    entityType: Entity;
-    byEntityType: Entity;
-  };
-
-  if (
-    !AllowedEntityTypes.includes(entityType) ||
-    !AllowedEntityTypes.includes(byEntityType)
-  ) {
-    return res.status(httpStatus.NOT_FOUND).json({
-      code: 'NOT_FOUND',
-    });
-  }
-
-  next();
-};

package/mock/entity.ts

@@ -1,12 +0,0 @@
-export enum Entity {
-  ADMIN = 'admin',
-  CHAPTER = 'chapter',
-  COURSE = 'course',
-  LEARNER = 'learner',
-  LEARNING_ACTIVITY = 'learning-activity',
-  LEARNING_JOURNEY_CONFIG = 'learning-journey-config',
-  MODULE = 'module',
-  ORGANIZATION = 'organization',
-  REFERENCE = 'reference',
-  VIDEO = 'video',
-}

package/mock/monorise/admin.ts

@@ -1,35 +0,0 @@
-import { createEntityConfig } from '@monorise/cli';
-import { z } from 'zod';
-
-const baseSchema = z
-  .object({
-    email: z.string().toLowerCase(),
-    displayName: z.string(),
-  })
-  .partial();
-
-const createSchema = baseSchema.extend({
-  email: z
-    .string()
-    .toLowerCase()
-    .regex(
-      /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/,
-      "Doesn't seems like an email",
-    ),
-  displayName: z.string().min(1, 'Please provide a name for this user account'),
-});
-
-const config = createEntityConfig({
-  name: 'admin',
-  displayName: 'Admin',
-  authMethod: {
-    email: {
-      tokenExpiresIn: 1000 * 60 * 60 * 24 * 14, // 14 days
-    },
-  },
-  baseSchema,
-  createSchema,
-  searchableFields: ['email', 'displayName'],
-});
-
-export default config;

package/mock/monorise/chapter.ts

@@ -1,94 +0,0 @@
-import { createEntityConfig } from '@monorise/cli';
-import type { Mutual } from '@monorise/react';
-import { z } from 'zod';
-import { Entity } from '../entity';
-
-export enum CHAPTER_TYPE {
-  CHAPTER = 'CHAPTER',
-  CUSTOM = 'CUSTOM',
-  TOUCHPOINT = 'TOUCHPOINT',
-  CHECKPOINT = 'CHECKPOINT',
-}
-
-const baseSchema = z
-  .object({
-    description: z.string(),
-    discussionLink: z.string(),
-    remark: z.string(),
-    type: z.nativeEnum(CHAPTER_TYPE),
-    title: z.string(),
-    learningActivityDescription: z.string(),
-    body: z
-      .object({
-        type: z.string(),
-        id: z.string(),
-        content: z.any(),
-      })
-      .array()
-      .optional(),
-    progress: z.coerce.number().int(),
-  })
-  .partial();
-
-const createSchema = baseSchema.extend({
-  remark: z.string(),
-  type: z.nativeEnum(CHAPTER_TYPE),
-});
-
-const mutualSchema = z
-  .object({
-    learningActivityOrders: z.string().array(),
-    referenceOrders: z.string().array(),
-    videos: z.string().array().max(1),
-  })
-  .partial();
-
-const config = createEntityConfig({
-  name: 'chapter',
-  displayName: 'Chapter',
-  baseSchema,
-  createSchema,
-  searchableFields: ['remark', 'title'],
-  mutual: {
-    mutualSchema,
-    mutualFields: {
-      learningActivityOrders: {
-        entityType: Entity.LEARNING_ACTIVITY,
-        mutualDataProcessor: (
-          ids: string[],
-          context: Mutual<Entity.CHAPTER, Entity.LEARNING_ACTIVITY>,
-        ) => {
-          return { index: ids.indexOf(context.entityId) };
-        },
-      },
-      referenceOrders: {
-        entityType: Entity.REFERENCE,
-        mutualDataProcessor: (
-          ids: string[],
-          context: Mutual<Entity.CHAPTER, Entity.REFERENCE>,
-        ) => {
-          return { index: ids.indexOf(context.entityId) };
-        },
-      },
-      videos: {
-        entityType: Entity.VIDEO,
-      },
-    },
-  },
-  effect: (schema) => {
-    return schema.superRefine((value, ctx) => {
-      if (
-        value.type === CHAPTER_TYPE.CHAPTER &&
-        'videos' in value &&
-        !value.videos?.length
-      )
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: 'Video is required',
-          path: ['videos'],
-        });
-    });
-  },
-});
-
-export default config;

package/mock/monorise/course.ts

@@ -1,149 +0,0 @@
-import { createEntityConfig } from '@monorise/cli';
-import type { Mutual } from '@monorise/react';
-import { z } from 'zod';
-import { Entity } from '../entity';
-
-const baseSchema = z
-  .object({
-    title: z.string(),
-    categories: z.string().array(),
-    duration: z.number(),
-    description: z.string(),
-    learningOutcomes: z.string().array(),
-    infographics: z.string().array(),
-    tags: z.string().array(),
-  })
-  .partial();
-
-const createSchema = baseSchema.extend({
-  title: z.string().min(4, {
-    message: 'Title must be at least 4 characters.',
-  }),
-});
-
-const mutualSchema = z
-  .object({
-    moduleOrders: z.string().array(),
-    videos: z.string().array(),
-    chapters: z.string().array(),
-    learningActivities: z.string().array(),
-  })
-  .partial();
-
-const config = createEntityConfig({
-  name: 'course',
-  displayName: 'Course',
-  baseSchema: baseSchema,
-  createSchema,
-  searchableFields: ['title'],
-  mutual: {
-    subscribes: [{ entityType: Entity.MODULE }],
-    mutualSchema,
-    mutualFields: {
-      moduleOrders: {
-        entityType: Entity.MODULE,
-        mutualDataProcessor: (
-          ids: string[],
-          context: Mutual<Entity.COURSE, Entity.MODULE>,
-        ) => {
-          return { index: ids.indexOf(context.entityId) };
-        },
-      },
-      videos: {
-        entityType: Entity.VIDEO,
-        mutualDataProcessor: (
-          ids: string[],
-          context: Mutual<Entity.COURSE, Entity.VIDEO>,
-          prejoinContext?: Record<string, any>,
-        ) => {
-          return {
-            index: ids.indexOf(context.entityId),
-            moduleId: prejoinContext?.[context.entityId],
-          };
-        },
-      },
-      chapters: {
-        entityType: Entity.CHAPTER,
-        mutualDataProcessor: (
-          ids: string[],
-          context: Mutual<Entity.COURSE, Entity.CHAPTER>,
-          prejoinContext?: Record<string, any>,
-        ) => ({
-          index: ids.indexOf(context.entityId),
-          moduleId: prejoinContext?.[context.entityId],
-        }),
-      },
-      learningActivities: {
-        entityType: Entity.LEARNING_ACTIVITY,
-        mutualDataProcessor: (
-          ids: string[],
-          context: Mutual<Entity.COURSE, Entity.LEARNING_ACTIVITY>,
-          prejoinContext?: Record<string, any>,
-        ) => {
-          return {
-            index: ids.indexOf(context.entityId),
-            moduleId: prejoinContext?.[context.entityId],
-          };
-        },
-      },
-    },
-
-    prejoins: [
-      {
-        mutualField: 'chapters',
-        targetEntityType: Entity.CHAPTER,
-        entityPaths: [
-          {
-            entityType: Entity.COURSE,
-          },
-          {
-            entityType: Entity.MODULE,
-          },
-          {
-            entityType: Entity.CHAPTER,
-          },
-        ],
-      },
-      {
-        mutualField: 'videos',
-        targetEntityType: Entity.VIDEO,
-        entityPaths: [
-          {
-            entityType: Entity.COURSE,
-          },
-          {
-            entityType: Entity.MODULE,
-          },
-          {
-            skipCache: true,
-            entityType: Entity.CHAPTER,
-          },
-          {
-            entityType: Entity.VIDEO,
-          },
-        ],
-      },
-      {
-        mutualField: 'learningActivities',
-        targetEntityType: Entity.LEARNING_ACTIVITY,
-        entityPaths: [
-          {
-            entityType: Entity.COURSE,
-          },
-          {
-            entityType: Entity.MODULE,
-          },
-          {
-            skipCache: true,
-            entityType: Entity.CHAPTER,
-          },
-          {
-            entityType: Entity.LEARNING_ACTIVITY,
-          },
-        ],
-      },
-    ],
-  },
-});
-
-export default config;

package/mock/monorise/index.ts

@@ -1,143 +0,0 @@
-import type { z } from 'zod';
-import admin from './admin';
-import chapter from './chapter';
-import course from './course';
-import learner from './learner';
-import learningActivity from './learning-activity';
-import learningJourneyConfig from './learning-journey-config';
-import module from './module';
-import organization from './organization';
-import reference from './reference';
-import video from './video';
-
-export enum Entity {
-  ADMIN = 'admin',
-  CHAPTER = 'chapter',
-  COURSE = 'course',
-  LEARNER = 'learner',
-  LEARNING_ACTIVITY = 'learning-activity',
-  LEARNING_JOURNEY_CONFIG = 'learning-journey-config',
-  MODULE = 'module',
-  ORGANIZATION = 'organization',
-  REFERENCE = 'reference',
-  VIDEO = 'video',
-}
-
-export type AdminType = z.infer<(typeof admin)['finalSchema']>;
-export type ChapterType = z.infer<(typeof chapter)['finalSchema']>;
-export type CourseType = z.infer<(typeof course)['finalSchema']>;
-export type LearnerType = z.infer<(typeof learner)['finalSchema']>;
-export type LearningActivityType = z.infer<
-  (typeof learningActivity)['finalSchema']
->;
-export type LearningJourneyConfigType = z.infer<
-  (typeof learningJourneyConfig)['finalSchema']
->;
-export type ModuleType = z.infer<(typeof module)['finalSchema']>;
-export type OrganizationType = z.infer<(typeof organization)['finalSchema']>;
-export type ReferenceType = z.infer<(typeof reference)['finalSchema']>;
-export type VideoType = z.infer<(typeof video)['finalSchema']>;
-
-export interface EntitySchemaMap {
-  admin: AdminType;
-  chapter: ChapterType;
-  course: CourseType;
-  learner: LearnerType;
-  learningActivity: LearningActivityType;
-  learningJourneyConfig: LearningJourneyConfigType;
-  module: ModuleType;
-  organization: OrganizationType;
-  reference: ReferenceType;
-  video: VideoType;
-}
-
-const EntityConfig = {
-  [Entity.ADMIN]: admin,
-  [Entity.CHAPTER]: chapter,
-  [Entity.COURSE]: course,
-  [Entity.LEARNER]: learner,
-  [Entity.LEARNING_ACTIVITY]: learningActivity,
-  [Entity.LEARNING_JOURNEY_CONFIG]: learningJourneyConfig,
-  [Entity.MODULE]: module,
-  [Entity.ORGANIZATION]: organization,
-  [Entity.REFERENCE]: reference,
-  [Entity.VIDEO]: video,
-};
-
-const FormSchema = {
-  [Entity.ADMIN]: admin.finalSchema,
-  [Entity.CHAPTER]: chapter.finalSchema,
-  [Entity.COURSE]: course.finalSchema,
-  [Entity.LEARNER]: learner.finalSchema,
-  [Entity.LEARNING_ACTIVITY]: learningActivity.finalSchema,
-  [Entity.LEARNING_JOURNEY_CONFIG]: learningJourneyConfig.finalSchema,
-  [Entity.MODULE]: module.finalSchema,
-  [Entity.ORGANIZATION]: organization.finalSchema,
-  [Entity.REFERENCE]: reference.finalSchema,
-  [Entity.VIDEO]: video.finalSchema,
-};
-
-const AllowedEntityTypes = [
-  Entity.ADMIN,
-  Entity.CHAPTER,
-  Entity.COURSE,
-  Entity.LEARNER,
-  Entity.LEARNING_ACTIVITY,
-  Entity.LEARNING_JOURNEY_CONFIG,
-  Entity.MODULE,
-  Entity.ORGANIZATION,
-  Entity.REFERENCE,
-  Entity.VIDEO,
-];
-
-const EmailAuthEnabledEntities = [Entity.ADMIN, Entity.LEARNER];
-
-export {
-  EntityConfig,
-  FormSchema,
-  AllowedEntityTypes,
-  EmailAuthEnabledEntities,
-};
-
-declare module '@monorise/base' {
-  export enum Entity {
-    ADMIN = 'admin',
-    CHAPTER = 'chapter',
-    COURSE = 'course',
-    LEARNER = 'learner',
-    LEARNING_ACTIVITY = 'learning-activity',
-    LEARNING_JOURNEY_CONFIG = 'learning-journey-config',
-    MODULE = 'module',
-    ORGANIZATION = 'organization',
-    REFERENCE = 'reference',
-    VIDEO = 'video',
-  }
-
-  export type AdminType = z.infer<(typeof admin)['finalSchema']>;
-  export type ChapterType = z.infer<(typeof chapter)['finalSchema']>;
-  export type CourseType = z.infer<(typeof course)['finalSchema']>;
-  export type LearnerType = z.infer<(typeof learner)['finalSchema']>;
-  export type LearningActivityType = z.infer<
-    (typeof learningActivity)['finalSchema']
-  >;
-  export type LearningJourneyConfigType = z.infer<
-    (typeof learningJourneyConfig)['finalSchema']
-  >;
-  export type ModuleType = z.infer<(typeof module)['finalSchema']>;
-  export type OrganizationType = z.infer<(typeof organization)['finalSchema']>;
-  export type ReferenceType = z.infer<(typeof reference)['finalSchema']>;
-  export type VideoType = z.infer<(typeof video)['finalSchema']>;
-
-  export interface EntitySchemaMap {
-    admin: AdminType;
-    chapter: ChapterType;
-    course: CourseType;
-    learner: LearnerType;
-    learningActivity: LearningActivityType;
-    learningJourneyConfig: LearningJourneyConfigType;
-    module: ModuleType;
-    organization: OrganizationType;
-    reference: ReferenceType;
-    video: VideoType;
-  }
-}

package/mock/monorise/learner.ts

@@ -1,66 +0,0 @@
-import { createEntityConfig } from '@monorise/cli';
-import { z } from 'zod';
-import { Entity } from '../entity';
-import { EXPIRY_TYPE } from './organization';
-
-const baseSchema = z
-  .object({
-    email: z
-      .string()
-      .toLowerCase()
-      .regex(
-        /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/,
-        "Doesn't seems like an email",
-      ),
-    displayName: z
-      .string()
-      .min(1, 'Please provide a name for this user account'),
-    firstName: z.string().min(1, 'Please provide first name'),
-    lastName: z.string().min(1, 'Please provide last name'),
-    jobTitle: z.string(),
-    locatedCountry: z.string(),
-    educationLevel: z.string(),
-    school: z.string(),
-    major: z.string(),
-    expiryType: z.nativeEnum(EXPIRY_TYPE).nullable(),
-    expiryDate: z.string().datetime().nullable(),
-    subOrganizationId: z.string(),
-    acceptedDisclaimer: z.boolean(),
-  })
-  .partial();
-
-const createSchema = baseSchema.extend({
-  email: z.string().toLowerCase(),
-  displayName: z.string().min(1, 'Please provide a name for this user account'),
-  firstName: z.string().min(1, 'Please provide first name'),
-  lastName: z.string().min(1, 'Please provide last name'),
-});
-
-const mutualSchema = z
-  .object({
-    organizations: z.string().array(),
-  })
-  .partial();
-
-const config = createEntityConfig({
-  name: 'learner',
-  displayName: 'Learner',
-  authMethod: {
-    email: {
-      tokenExpiresIn: 1000 * 60 * 60 * 24 * 14, // 14 days
-    },
-  },
-  baseSchema,
-  createSchema,
-  searchableFields: ['email', 'displayName', 'firstName', 'lastName'],
-  mutual: {
-    mutualSchema,
-    mutualFields: {
-      organizations: {
-        entityType: Entity.ORGANIZATION,
-      },
-    },
-  },
-});
-
-export default config;