@monorise/core 1.0.0

package/mock/monorise/index.ts

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

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

package/mock/monorise/learning-activity.ts

@@ -0,0 +1,62 @@
+import { createEntityConfig } from '@monorise/cli';
+import { z } from 'zod';
+
+const baseSchema = z.object({
+  activityType: z.enum(['REFLECTION', 'QUIZ', 'FILE_UPLOAD']),
+  questionType: z.enum(['TEXT', 'RADIO', 'CHECKBOX']).optional(),
+  question: z.string(),
+  explanation: z.string().optional(),
+  options: z
+    .object({
+      label: z.string(),
+      isCorrect: z.boolean(),
+    })
+    .array()
+    .optional(),
+  remark: z.string().optional(),
+});
+
+const config = createEntityConfig({
+  name: 'learning-activity',
+  displayName: 'Learning Activity',
+  baseSchema,
+  effect: (schema) => {
+    return schema.refine(
+      (value) => {
+        if (value.activityType === 'REFLECTION' && value.question) {
+          return true;
+        }
+
+        if (value.activityType === 'FILE_UPLOAD' && value.question) {
+          return true;
+        }
+
+        if (
+          (value.questionType === 'CHECKBOX' ||
+            value.questionType === 'RADIO') &&
+          value.options?.length &&
+          value.options.length >= 2 &&
+          value.options.filter((v) => v.label).length ===
+            value.options.length &&
+          value.options.some((v) => v.isCorrect)
+        ) {
+          return true;
+        }
+
+        if (value.questionType === 'TEXT' && value.question) {
+          return true;
+        }
+
+        return false;
+      },
+      {
+        message:
+          'For checkbox and radio question types, please provide at least two options and at least one correct answer',
+        path: ['options'],
+      },
+    );
+  },
+  searchableFields: ['question', 'remark'],
+});
+
+export default config;

package/mock/monorise/learning-journey-config.ts

@@ -0,0 +1,34 @@
+import { createEntityConfig } from '@monorise/cli';
+import type { Mutual } from '@monorise/react';
+import { z } from 'zod';
+import { Entity } from '../entity';
+
+const baseSchema = z.object({}).partial();
+
+const mutualSchema = z
+  .object({
+    courseOrders: z.string().array(),
+  })
+  .partial();
+
+const config = createEntityConfig({
+  name: 'learning-journey-config',
+  displayName: 'Learning Journey Config',
+  baseSchema,
+  mutual: {
+    mutualSchema,
+    mutualFields: {
+      courseOrders: {
+        entityType: Entity.COURSE,
+        mutualDataProcessor: (
+          ids: string[],
+          context: Mutual<Entity.LEARNING_JOURNEY_CONFIG, Entity.COURSE>,
+        ) => {
+          return { index: ids.indexOf(context.entityId) };
+        },
+      },
+    },
+  },
+});
+
+export default config;

package/mock/monorise/module.ts

@@ -0,0 +1,108 @@
+import { createEntityConfig } from '@monorise/cli';
+import type { Mutual } from '@monorise/react';
+import { z } from 'zod';
+import { Entity } from '../entity';
+
+const allowedTypes = ['MODULE', 'TOUCHPOINT', 'CHECKPOINT'] as const;
+
+const baseSchema = z
+  .object({
+    title: z.string(),
+    description: z.string(),
+    shortDescription: z.string(),
+    remark: z
+      .string()
+      .describe('For internal use, eg. This module is for tracks'),
+    type: z.enum(allowedTypes),
+  })
+  .partial();
+
+const createSchema = baseSchema.extend({
+  title: z.string(),
+  type: z.enum(allowedTypes),
+});
+
+const mutualSchema = z
+  .object({
+    chapterOrders: z.string().array(),
+  })
+  .partial();
+
+const config = createEntityConfig({
+  name: 'module',
+  displayName: 'Module',
+  baseSchema,
+  createSchema,
+  searchableFields: ['title'],
+  mutual: {
+    subscribes: [{ entityType: Entity.CHAPTER }],
+    mutualSchema,
+    mutualFields: {
+      chapterOrders: {
+        entityType: Entity.CHAPTER,
+        mutualDataProcessor: (
+          ids: string[],
+          context: Mutual<Entity.MODULE, Entity.CHAPTER>,
+        ) => {
+          return { index: ids.indexOf(context.entityId) };
+        },
+      },
+      videos: {
+        entityType: Entity.VIDEO,
+        mutualDataProcessor: (
+          ids: string[],
+          context: Mutual<Entity.MODULE, Entity.VIDEO>,
+          prejoinContext?: Record<string, any>,
+        ) => ({
+          index: ids.indexOf(context.entityId),
+          chapterId: prejoinContext?.[context.entityId],
+        }),
+      },
+      learningActivities: {
+        entityType: Entity.LEARNING_ACTIVITY,
+        mutualDataProcessor: (
+          ids: string[],
+          context: Mutual<Entity.MODULE, Entity.LEARNING_ACTIVITY>,
+          prejoinContext?: Record<string, any>,
+        ) => ({
+          index: ids.indexOf(context.entityId),
+          chapterId: prejoinContext?.[context.entityId],
+        }),
+      },
+    },
+    prejoins: [
+      {
+        mutualField: 'videos',
+        targetEntityType: Entity.VIDEO,
+        entityPaths: [
+          {
+            entityType: Entity.MODULE,
+          },
+          {
+            entityType: Entity.CHAPTER,
+          },
+          {
+            entityType: Entity.VIDEO,
+          },
+        ],
+      },
+      {
+        mutualField: 'learningActivities',
+        targetEntityType: Entity.LEARNING_ACTIVITY,
+        entityPaths: [
+          {
+            entityType: Entity.MODULE,
+          },
+          {
+            entityType: Entity.CHAPTER,
+          },
+          {
+            entityType: Entity.LEARNING_ACTIVITY,
+          },
+        ],
+      },
+    ],
+  },
+});
+
+export default config;

package/mock/monorise/organization.ts

@@ -0,0 +1,63 @@
+import { createEntityConfig } from '@monorise/cli';
+import { z } from 'zod';
+
+import type { Mutual } from '@monorise/react';
+import { Entity } from '../entity';
+
+export enum EXPIRY_TYPE {
+  ORG_WIDE = 'ORG_WIDE',
+  PER_INDIVIDUAL = 'PER_INDIVIDUAL',
+}
+
+const baseSchema = z
+  .object({
+    name: z.string(),
+    licenseCount: z.coerce.number(),
+    allowSelfRegistration: z.boolean(),
+    isPrimary: z.boolean(),
+    domains: z.string().array(),
+    selfRegistrationDisclaimer: z.string(),
+    welcomeMessage: z.string(),
+    pathwayWelcomeMessage: z.string(),
+    expiryType: z.nativeEnum(EXPIRY_TYPE),
+    orgExpiryDate: z.string().datetime(),
+    individualAccessDuration: z.coerce.number(),
+  })
+  .partial();
+
+const createSchema = baseSchema.extend({
+  name: z.string().min(1, 'Please provide a name for this organization'),
+});
+
+const mutualSchema = z
+  .object({
+    organizationOrders: z.string().array(),
+  })
+  .partial();
+
+const config = createEntityConfig({
+  name: 'organization',
+  displayName: 'Organization',
+  baseSchema,
+  createSchema,
+  searchableFields: ['name'],
+  mutual: {
+    mutualSchema,
+    mutualFields: {
+      organizationOrders: {
+        entityType: Entity.ORGANIZATION,
+        mutualDataProcessor: (
+          ids: string[],
+          context: Mutual<Entity.ORGANIZATION, Entity.ORGANIZATION>,
+        ) => {
+          return {
+            index: ids.indexOf(context.entityId),
+            primaryOrganizationId: context.byEntityId,
+          };
+        },
+      },
+    },
+  },
+});
+
+export default config;

package/mock/monorise/reference.ts

@@ -0,0 +1,28 @@
+import { createEntityConfig } from '@monorise/cli';
+import { z } from 'zod';
+
+const baseSchema = z
+  .object({
+    label: z.string(),
+    link: z.string(),
+    prelabel: z.string(),
+    postlabel: z.string(),
+  })
+  .partial();
+
+const createSchema = baseSchema.extend({
+  label: z.string().min(1, {
+    message: 'Label is required',
+  }),
+  link: z.string().url('This is not a valid url'),
+});
+
+const config = createEntityConfig({
+  name: 'reference',
+  displayName: 'Reference',
+  baseSchema,
+  createSchema,
+  searchableFields: ['label', 'link', 'prelabel', 'postlabel'],
+});
+
+export default config;

package/mock/monorise/video.ts

@@ -0,0 +1,36 @@
+import { createEntityConfig } from '@monorise/cli';
+import { z } from 'zod';
+
+const baseSchema = z
+  .object({
+    title: z.string(),
+    categories: z.string().array(),
+    additionalFiles: z
+      .object({
+        type: z.string(),
+        id: z.string(),
+        content: z.any(),
+      })
+      .array()
+      .optional(),
+    keyTakeaway: z.string(),
+    remark: z.string(),
+    duration: z.number(),
+  })
+  .partial();
+
+const createSchema = baseSchema.extend({
+  title: z.string().min(4, {
+    message: 'Title must be at least 4 characters.',
+  }),
+});
+
+const config = createEntityConfig({
+  name: 'video',
+  displayName: 'Video',
+  baseSchema,
+  createSchema,
+  searchableFields: ['title', 'remark'],
+});
+
+export default config;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@monorise/core",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.758.0",
+    "@aws-sdk/client-dynamodb-streams": "^3.758.0",
+    "@aws-sdk/client-eventbridge": "^3.758.0",
+    "@aws-sdk/util-dynamodb": "^3.758.0",
+    "@monorise/base": "^1.0.3",
+    "http-status": "^1.7.0",
+    "nanoid": "^5.1.3",
+    "ulid": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.147",
+    "@types/express": "^5.0.0"
+  },
+  "peerDependencies": {
+    "express": "^4.21.2"
+  }
+}

package/processors/create-entity-processor.ts

@@ -0,0 +1,55 @@
+import type { Entity } from '@monorise/base';
+import type { SQSBatchItemFailure, SQSEvent } from 'aws-lambda';
+import { StandardError } from '#/errors/standard-error';
+import { parseSQSBusEvent } from '#/helpers/event';
+import { DependencyContainer } from '#/services/DependencyContainer';
+
+const container = new DependencyContainer();
+
+type EventDetailBody = {
+  entityType: Entity;
+  entityId?: string;
+  entityPayload: Record<string, any>;
+  accountId?: string;
+  options: {
+    createAndUpdateDatetime?: string;
+    mutualId?: string;
+  };
+};
+
+export const handler = async (ev: SQSEvent) => {
+  const { entityService } = container;
+  const batchItemFailures: SQSBatchItemFailure[] = [];
+
+  for (const record of ev.Records) {
+    const errorContext: Record<string, unknown> = {};
+    const body = parseSQSBusEvent<EventDetailBody>(record.body);
+    const { detail } = body;
+    const { entityType, entityId, entityPayload, accountId, options } = detail;
+    errorContext.body = body;
+
+    try {
+      await entityService.createEntity({
+        entityType,
+        entityId,
+        entityPayload,
+        accountId,
+        options,
+      });
+    } catch (err) {
+      console.error(
+        '=====CREATE_ENTITY_PROCESSOR_ERROR=====',
+        err,
+        JSON.stringify({ errorContext }, null, 2),
+      );
+
+      if (err instanceof StandardError && err.code === 'INVALID_ENTITY_TYPE') {
+        continue; // do not retry
+      }
+
+      batchItemFailures.push({ itemIdentifier: record.messageId });
+    }
+  }
+
+  return { batchItemFailures };
+};