@monorise/core 1.0.2 → 1.0.4-0

package/mock/monorise/learning-activity.ts

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

@@ -1,34 +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({}).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

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

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

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

@@ -1,36 +0,0 @@
-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/processors/create-entity-processor.ts

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

package/processors/mutual-processor.ts

@@ -1,262 +0,0 @@
-import { TransactionCanceledException } from '@aws-sdk/client-dynamodb';
-import type { Entity } from '@monorise/base';
-import type { SQSBatchItemFailure, SQSEvent } from 'aws-lambda';
-import { EntityConfig } from '#/lambda-layer/monorise';
-import { Mutual } from '../data/Mutual';
-import { StandardError } from '../errors/standard-error';
-import { parseSQSBusEvent } from '../helpers/event';
-import { DependencyContainer } from '../services/DependencyContainer';
-import { EVENT } from '../types/event';
-
-export type EventDetailBody = {
-  mutualIds: string[];
-  byEntityType: Entity;
-  byEntityId: string;
-  entityType: Entity;
-  field: string;
-  publishedAt: string;
-  customContext?: Record<string, unknown>;
-};
-
-const container = new DependencyContainer();
-
-const processEntities = async (
-  entityIds: string[],
-  action: (id: string) => Promise<void>,
-) => Promise.allSettled(entityIds.map(action));
-
-export const handler = async (ev: SQSEvent) => {
-  const batchItemFailures: SQSBatchItemFailure[] = [];
-  const { entityRepository, mutualRepository, publishEvent } = container;
-
-  await Promise.allSettled(
-    ev.Records.map(async (record) => {
-      const errorContext: Record<string, unknown> = {};
-      const body = parseSQSBusEvent<EventDetailBody>(record.body);
-      const { detail } = body;
-      const {
-        mutualIds,
-        byEntityType,
-        byEntityId,
-        entityType,
-        field,
-        publishedAt,
-        customContext,
-      } = detail;
-      errorContext.body = body;
-
-      try {
-        // Validate if mutual configuration exists
-        const config =
-          EntityConfig[byEntityType]?.mutual?.mutualFields?.[field];
-
-        if (!config) {
-          throw new StandardError('INVALID_MUTUAL', 'Invalid mutual');
-        }
-
-        const mutualDataProcessor = config.mutualDataProcessor ?? (() => ({}));
-
-        // Create a lock to prevent concurrent modifications
-        await mutualRepository.createMutualLock({
-          byEntityType,
-          byEntityId,
-          entityType,
-          version: publishedAt,
-        });
-
-        // Fetch related entities in parallel
-        const [byEntity, mutuals] = await Promise.all([
-          entityRepository.getEntity(byEntityType, byEntityId),
-          mutualRepository.listEntitiesByEntity(
-            byEntityType,
-            byEntityId,
-            entityType,
-          ),
-        ]);
-
-        // Determine which entities were added, removed, or need updates
-        const existingEntityIds = new Set(mutuals.items.map((m) => m.entityId));
-        const newMutualIds = new Set(mutualIds ?? []);
-
-        const addedEntityIds = [...newMutualIds].filter(
-          (id) => !existingEntityIds.has(id),
-        );
-        const deletedEntityIds = [...existingEntityIds].filter(
-          (id) => !newMutualIds.has(id),
-        );
-        const toUpdateEntityIds = [...existingEntityIds].filter((id) =>
-          newMutualIds.has(id),
-        );
-
-        errorContext.existingEntityIds = [...existingEntityIds];
-        errorContext.addedEntityIds = addedEntityIds;
-        errorContext.deletedEntityIds = deletedEntityIds;
-        errorContext.toUpdateEntityIds = toUpdateEntityIds;
-
-        const addEntities = await processEntities(
-          addedEntityIds,
-          async (id) => {
-            const entity = await entityRepository.getEntity(entityType, id);
-            await mutualRepository.createMutual(
-              byEntityType,
-              byEntityId,
-              byEntity.data,
-              entityType,
-              id,
-              entity.data,
-              mutualDataProcessor(
-                mutualIds,
-                new Mutual(
-                  byEntityType,
-                  byEntityId,
-                  byEntity.data,
-                  entityType,
-                  id,
-                  entity.data,
-                  {},
-                ),
-                customContext,
-              ),
-              {
-                ConditionExpression:
-                  'attribute_not_exists(#mutualUpdatedAt) OR #mutualUpdatedAt < :publishedAt',
-                ExpressionAttributeNames: {
-                  '#mutualUpdatedAt': 'mutualUpdatedAt',
-                },
-                ExpressionAttributeValues: {
-                  ':publishedAt': { S: publishedAt },
-                },
-                createAndUpdateDatetime: new Date(publishedAt),
-              },
-            );
-          },
-        );
-
-        const deleteEntities = await processEntities(
-          deletedEntityIds,
-          async (id) => {
-            await mutualRepository.deleteMutual(
-              byEntityType,
-              byEntityId,
-              entityType,
-              id,
-              {
-                ConditionExpression:
-                  'attribute_exists(PK) AND #mutualUpdatedAt < :publishedAt',
-                ExpressionAttributeNames: {
-                  '#mutualUpdatedAt': 'mutualUpdatedAt',
-                },
-                ExpressionAttributeValues: {
-                  ':publishedAt': { S: publishedAt },
-                },
-              },
-            );
-          },
-        );
-
-        const updateEntities = await processEntities(
-          toUpdateEntityIds,
-          async (id) => {
-            await mutualRepository.updateMutual(
-              byEntityType,
-              byEntityId,
-              entityType,
-              id,
-              {
-                mutualData: mutualDataProcessor(
-                  mutualIds,
-                  new Mutual(
-                    byEntityType,
-                    byEntityId,
-                    byEntity.data,
-                    entityType,
-                    id,
-                    {},
-                    {},
-                  ),
-                  customContext,
-                ),
-                mutualUpdatedAt: publishedAt,
-              },
-              {
-                ConditionExpression:
-                  'attribute_exists(PK) AND #mutualUpdatedAt < :publishedAt',
-                ExpressionAttributeNames: {
-                  '#mutualUpdatedAt': 'mutualUpdatedAt',
-                },
-                ExpressionAttributeValues: {
-                  ':publishedAt': { S: publishedAt },
-                },
-              },
-            );
-          },
-        );
-
-        errorContext.results = { addEntities, deleteEntities, updateEntities };
-
-        // release lock
-        await mutualRepository.deleteMutualLock({
-          byEntityType,
-          byEntityId,
-          entityType,
-        });
-
-        // Check for unprocessable errors in processing results
-        if (
-          [...addEntities, ...deleteEntities, ...updateEntities].some(
-            (res) =>
-              res.status === 'rejected' &&
-              !(
-                res.reason instanceof TransactionCanceledException ||
-                (res.reason instanceof StandardError &&
-                  res.reason.code === 'MUTUAL_NOT_FOUND')
-              ),
-          )
-        ) {
-          throw new StandardError(
-            'MUTUAL_PROCESSOR_ERROR',
-            'Mutual processor error',
-            null,
-            errorContext,
-          );
-        }
-
-        await publishEvent({
-          event: EVENT.CORE.ENTITY_MUTUAL_PROCESSED,
-          payload: {
-            byEntityType,
-            byEntityId,
-            entityType,
-            field,
-            mutualIds,
-            publishedAt,
-          },
-        });
-      } catch (err) {
-        console.error(
-          '=====MUTUAL_PROCESSOR_ERROR=====',
-          err,
-          JSON.stringify({ errorContext }, null, 2),
-        );
-
-        // Release the lock to avoid deadlocks
-        await mutualRepository.deleteMutualLock({
-          byEntityType,
-          byEntityId,
-          entityType,
-        });
-
-        if (
-          err instanceof StandardError &&
-          ['INVALID_MUTUAL', 'MUTUAL_LOCK_CONFLICT'].includes(err.code)
-        ) {
-          return;
-        }
-
-        batchItemFailures.push({ itemIdentifier: record.messageId });
-      }
-    }),
-  );
-
-  return { batchItemFailures };
-};