@monorise/base 1.0.4 → 3.0.1

package/dist/index.d.ts

@@ -1,3 +1,254 @@
-import { CreatedEntity, DraftEntity, Entity, EntitySchemaMap, MonoriseEntityConfig } from './types/monorise.type';
-export { Entity, EntitySchemaMap, DraftEntity, CreatedEntity, MonoriseEntityConfig, };
-//# sourceMappingURL=index.d.ts.map
+import { z } from 'zod';
+
+declare enum Entity {
+}
+interface EntitySchemaMap {
+    [key: string]: Record<string, any>;
+}
+type DraftEntity<T extends Entity = Entity> = T extends keyof EntitySchemaMap ? EntitySchemaMap[T] : never;
+type CreatedEntity<T extends Entity = Entity> = {
+    entityId: string;
+    entityType: string;
+    data: T extends keyof EntitySchemaMap ? EntitySchemaMap[T] : never;
+    createdAt: string;
+    updatedAt: string;
+};
+/**
+ * @description Configuration for a monorise entity, a shared configuration that is used across frontend and backend.
+ * This can be served as a single source of truth for the entity configuration.
+ * It is used to define the schema, and mutual relationships between this entity and other entities.
+ *
+ * @example
+ * ```ts
+ * const baseSchema = z.object({
+ *   title: z.string(),
+ * }).partial();
+ *
+ * const createSchema = baseSchema.extend({
+ *   title: z.string(),
+ * })
+ *
+ * const config = createEntityConfig({
+ *   name: 'learner',
+ *   displayName: 'Learner',
+ *   baseSchema,
+ *   createSchema,
+ * });
+ * ```
+ */
+interface MonoriseEntityConfig<T extends Entity = Entity, B extends z.ZodRawShape = z.ZodRawShape, C extends z.ZodRawShape = z.ZodRawShape, M extends z.ZodRawShape = z.ZodRawShape, CO extends z.ZodObject<C> | undefined = undefined, MO extends z.ZodObject<M> | undefined = undefined> {
+    /**
+     * @description Name of the entity. Must be in **lower-kebab-case** and **unique** across all entities
+     *
+     * @example `learner`, `learning-activity`
+     */
+    name: string | T;
+    /**
+     * @description Display name of the entity. It is not required to be unique
+     */
+    displayName: string;
+    /**
+     * @description (DEPRECATED) Use `uniqueFields` instead, Monorise should not handle auth mechanism
+     * @description (Optional) Specify the authentication method to be used for the entity
+     */
+    authMethod?: {
+        /**
+         * @description Authentication method using email
+         *
+         * Note: The email used for authentication is unique per entity.
+         * For example, if `johndoe@mail.com` is used for `learner` entity,
+         * it can be reused again on `admin` entity. However, the same email
+         * address cannot be repeated for the same entity.
+         */
+        email: {
+            /**
+             * @description Number of milliseconds before the token expires
+             */
+            tokenExpiresIn: number;
+        };
+    };
+    /**
+     * @description Base schema for the entity
+     */
+    baseSchema: z.ZodObject<B>;
+    /**
+     * @description Minimal schema required to create an entity
+     */
+    createSchema?: CO;
+    searchableFields?: (keyof B)[];
+    uniqueFields?: (keyof B)[];
+    /**
+     * @description Define mutual relationship of this entity with other entities
+     */
+    mutual?: {
+        /**
+         * @description Subscribes to update events from specified entities in the array.
+         * These events will be used to run prejoin processor.
+         */
+        subscribes?: {
+            entityType: Entity;
+        }[];
+        /**
+         * @description Virtual schema for mutual relationship. The schema is only used for validation purpose, but these fields are not stored in the database
+         */
+        mutualSchema: MO;
+        /**
+         * @description Keys of `mutualFields` are fields defined in `mutualSchema`.
+         * Each field is a mutual relationship between this entity and another entity.
+         */
+        mutualFields: {
+            [key: string]: {
+                entityType: Entity;
+                toMutualIds?: (context: any) => string[];
+                /**
+                 * @description (Optional) Custom function to process `mutualData`. If not provided, `mutualData` will be empty.
+                 *
+                 * @returns the final state of `mutualData` to be stored in the mutual record. Must be an object.
+                 */
+                mutualDataProcessor?: (mutualIds: string[], currentMutual: any, customContext?: Record<string, any>) => Record<string, any>;
+            };
+        };
+        /**
+         * @description (Optional) Better known as tree processor
+         * This is used to prejoin entities that are not directly related as mutual.
+         * For example, if `learner` entity is related to `course` entity, and `course` entity is related to `module` entity,
+         * prejoins can be used to join `learner` and `module` entities.
+         * With this, the `learner` entity can access the `module` entity without having to go through the `course` entity,
+         * hence reducing the number of queries.
+         *
+         * DynamoDB best practices: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-general-normalization.html
+         *
+         */
+        prejoins?: {
+            mutualField: string;
+            targetEntityType: Entity;
+            entityPaths: {
+                skipCache?: boolean;
+                entityType: Entity;
+                processor?: (items: any[], context: Record<string, any>) => any;
+            }[];
+        }[];
+    };
+    /**
+     * Use this function to perform side effects on the final schema for example refine/superRefine the schema
+     *
+     * @param schema The final schema of the entity (the combination of `baseSchema`/`createSchema` and `mutualSchema` if specified)
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * effect: (schema) => {
+     *   schema.refine(
+     *     // refinement logic here
+     *   )
+     * }
+     */
+    effect?: (schema: z.ZodObject<z.ZodRawShape>) => z.ZodEffects<z.ZodObject<z.ZodRawShape>>;
+    /**
+     * @description (Optional) Use tags to create additional access patterns for the entity.
+     * Time complexity for retrieving tagged entities is O(1).
+     *
+     * The following configuration will create a tag named `region` for the `organization` entity grouped by `region`.
+     * You would then be able to retrieve all organizations in a specific region by:
+     * GET `/core/tag/organization/region?group={region_name}`
+     *
+     * @example
+     *
+     * ```ts
+     * {
+     *   name: 'organization',
+     *   tags: [
+     *    {
+     *      name: 'region',
+     *      processor: (entity) => {
+     *        return [
+     *          {
+     *            group: entity.data.region
+     *          }
+     *        ]
+     *      },
+     *    }
+     *   ]
+     * }
+     * ```
+     *
+     * @description
+     *
+     * The following configuration will create a tag named `dob` for the `user` entity sorted by `dob`.
+     * You would then be able to retrieve all users sorted by `dob` by:
+     * GET `/core/tag/user/dob?start=2000-01-01&end=2020-12-31`
+     *
+     * @example
+     * ```ts
+     * {
+     *   name: 'user',
+     *   tags: [
+     *    {
+     *      name: 'dob',
+     *      processor: (entity) => {
+     *        return [
+     *          {
+     *            sortValue: entity.data.dob
+     *          }
+     *        ]
+     *      },
+     *    }
+     *   ]
+     * }
+     * ```
+     */
+    tags?: {
+        name: string;
+        processor: (entity: CreatedEntity<T>) => {
+            group?: string;
+            sortValue?: string;
+        }[];
+    }[];
+}
+
+declare const createEntityConfig: <T extends Entity, B extends z.ZodRawShape, C extends z.ZodRawShape, M extends z.ZodRawShape, CO extends z.ZodObject<C> | undefined = undefined, MO extends z.ZodObject<M> | undefined = undefined>(config: MonoriseEntityConfig<T, B, C, M, CO, MO>) => {
+    finalSchema: (CO extends z.AnyZodObject ? MO extends z.AnyZodObject ? z.ZodObject<MO["shape"] & CO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & CO["shape"]>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & CO["shape"]>, any>[k]; } : never, z.baseObjectInputType<MO["shape"] & CO["shape"]> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<MO["shape"] & CO["shape"]>[k_1]; } : never> : CO : MO extends z.AnyZodObject ? z.ZodObject<MO["shape"] & B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & B>, any> extends infer T_3 ? { [k_2 in keyof T_3]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & B>, any>[k_2]; } : never, z.baseObjectInputType<MO["shape"] & B> extends infer T_4 ? { [k_3 in keyof T_4]: z.baseObjectInputType<MO["shape"] & B>[k_3]; } : never> : z.ZodObject<B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_5 ? { [k_4 in keyof T_5]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any>[k_4]; } : never, z.baseObjectInputType<B> extends infer T_6 ? { [k_5 in keyof T_6]: z.baseObjectInputType<B>[k_5]; } : never>) | z.ZodEffects<CO extends z.AnyZodObject ? MO extends z.AnyZodObject ? z.ZodObject<MO["shape"] & CO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & CO["shape"]>, any> extends infer T_7 ? { [k in keyof T_7]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & CO["shape"]>, any>[k]; } : never, z.baseObjectInputType<MO["shape"] & CO["shape"]> extends infer T_8 ? { [k_1 in keyof T_8]: z.baseObjectInputType<MO["shape"] & CO["shape"]>[k_1]; } : never> : CO : MO extends z.AnyZodObject ? z.ZodObject<MO["shape"] & B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & B>, any> extends infer T_9 ? { [k_2 in keyof T_9]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & B>, any>[k_2]; } : never, z.baseObjectInputType<MO["shape"] & B> extends infer T_10 ? { [k_3 in keyof T_10]: z.baseObjectInputType<MO["shape"] & B>[k_3]; } : never> : z.ZodObject<B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_11 ? { [k_4 in keyof T_11]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any>[k_4]; } : never, z.baseObjectInputType<B> extends infer T_12 ? { [k_5 in keyof T_12]: z.baseObjectInputType<B>[k_5]; } : never>, z.output<CO extends z.AnyZodObject ? MO extends z.AnyZodObject ? z.ZodObject<MO["shape"] & CO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & CO["shape"]>, any> extends infer T_13 ? { [k in keyof T_13]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & CO["shape"]>, any>[k]; } : never, z.baseObjectInputType<MO["shape"] & CO["shape"]> extends infer T_14 ? { [k_1 in keyof T_14]: z.baseObjectInputType<MO["shape"] & CO["shape"]>[k_1]; } : never> : CO : MO extends z.AnyZodObject ? z.ZodObject<MO["shape"] & B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & B>, any> extends infer T_15 ? { [k_2 in keyof T_15]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & B>, any>[k_2]; } : never, z.baseObjectInputType<MO["shape"] & B> extends infer T_16 ? { [k_3 in keyof T_16]: z.baseObjectInputType<MO["shape"] & B>[k_3]; } : never> : z.ZodObject<B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_17 ? { [k_4 in keyof T_17]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any>[k_4]; } : never, z.baseObjectInputType<B> extends infer T_18 ? { [k_5 in keyof T_18]: z.baseObjectInputType<B>[k_5]; } : never>>, z.input<CO extends z.AnyZodObject ? MO extends z.AnyZodObject ? z.ZodObject<MO["shape"] & CO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & CO["shape"]>, any> extends infer T_19 ? { [k in keyof T_19]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & CO["shape"]>, any>[k]; } : never, z.baseObjectInputType<MO["shape"] & CO["shape"]> extends infer T_20 ? { [k_1 in keyof T_20]: z.baseObjectInputType<MO["shape"] & CO["shape"]>[k_1]; } : never> : CO : MO extends z.AnyZodObject ? z.ZodObject<MO["shape"] & B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & B>, any> extends infer T_21 ? { [k_2 in keyof T_21]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<MO["shape"] & B>, any>[k_2]; } : never, z.baseObjectInputType<MO["shape"] & B> extends infer T_22 ? { [k_3 in keyof T_22]: z.baseObjectInputType<MO["shape"] & B>[k_3]; } : never> : z.ZodObject<B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_23 ? { [k_4 in keyof T_23]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any>[k_4]; } : never, z.baseObjectInputType<B> extends infer T_24 ? { [k_5 in keyof T_24]: z.baseObjectInputType<B>[k_5]; } : never>>>;
+    name: string | T;
+    displayName: string;
+    authMethod?: {
+        email: {
+            tokenExpiresIn: number;
+        };
+    };
+    baseSchema: z.ZodObject<B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_25 ? { [k_4 in keyof T_25]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any>[k_4]; } : never, z.baseObjectInputType<B> extends infer T_26 ? { [k_5 in keyof T_26]: z.baseObjectInputType<B>[k_5]; } : never>;
+    createSchema?: CO | undefined;
+    searchableFields?: (keyof B)[] | undefined;
+    uniqueFields?: (keyof B)[] | undefined;
+    mutual?: {
+        subscribes?: {
+            entityType: Entity;
+        }[];
+        mutualSchema: MO;
+        mutualFields: {
+            [key: string]: {
+                entityType: Entity;
+                toMutualIds?: (context: any) => string[];
+                mutualDataProcessor?: (mutualIds: string[], currentMutual: any, customContext?: Record<string, any>) => Record<string, any>;
+            };
+        };
+        prejoins?: {
+            mutualField: string;
+            targetEntityType: Entity;
+            entityPaths: {
+                skipCache?: boolean;
+                entityType: Entity;
+                processor?: (items: any[], context: Record<string, any>) => any;
+            }[];
+        }[];
+    } | undefined;
+    effect?: (schema: z.ZodObject<z.ZodRawShape>) => z.ZodEffects<z.ZodObject<z.ZodRawShape>>;
+    tags?: {
+        name: string;
+        processor: (entity: undefined<T>) => {
+            group?: string;
+            sortValue?: string;
+        }[];
+    }[] | undefined;
+}
+
+export { type CreatedEntity, type DraftEntity, Entity, type EntitySchemaMap, type MonoriseEntityConfig, createEntityConfig };

package/dist/index.js

@@ -1,6 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Entity = void 0;
-const monorise_type_1 = require("./types/monorise.type");
-Object.defineProperty(exports, "Entity", { enumerable: true, get: function () { return monorise_type_1.Entity; } });
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// types/monorise.type.ts
+var Entity = /* @__PURE__ */ ((Entity2) => {
+  return Entity2;
+})(Entity || {});
+
+// utils/index.ts
+import { z } from "zod";
+function makeSchema(config) {
+  const { baseSchema, createSchema, mutual, effect } = config;
+  const { mutualSchema } = mutual || {};
+  const finalSchema = z.object(__spreadValues(__spreadValues(__spreadValues({}, baseSchema.shape), createSchema == null ? void 0 : createSchema.shape), mutualSchema == null ? void 0 : mutualSchema.shape));
+  if (effect) {
+    return effect(finalSchema);
+  }
+  return finalSchema;
+}
+var createEntityConfig = (config) => __spreadProps(__spreadValues({}, config), {
+  finalSchema: makeSchema(config)
+});
+export {
+  Entity,
+  createEntityConfig
+};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;AAAA,yDAM+B;AAG7B,uFANA,sBAAM,OAMA"}
+{"version":3,"sources":["../types/monorise.type.ts","../utils/index.ts"],"sourcesContent":["import type { z } from 'zod';\n\nexport enum Entity {}\n\nexport interface EntitySchemaMap {\n  [key: string]: Record<string, any>;\n}\n\nexport type DraftEntity<T extends Entity = Entity> =\n  T extends keyof EntitySchemaMap ? EntitySchemaMap[T] : never;\n\nexport type CreatedEntity<T extends Entity = Entity> = {\n  entityId: string;\n  entityType: string;\n  data: T extends keyof EntitySchemaMap ? EntitySchemaMap[T] : never;\n  createdAt: string;\n  updatedAt: string;\n};\n\n/**\n * @description Configuration for a monorise entity, a shared configuration that is used across frontend and backend.\n * This can be served as a single source of truth for the entity configuration.\n * It is used to define the schema, and mutual relationships between this entity and other entities.\n *\n * @example\n * ```ts\n * const baseSchema = z.object({\n *   title: z.string(),\n * }).partial();\n *\n * const createSchema = baseSchema.extend({\n *   title: z.string(),\n * })\n *\n * const config = createEntityConfig({\n *   name: 'learner',\n *   displayName: 'Learner',\n *   baseSchema,\n *   createSchema,\n * });\n * ```\n */\nexport interface MonoriseEntityConfig<\n  T extends Entity = Entity,\n  B extends z.ZodRawShape = z.ZodRawShape,\n  C extends z.ZodRawShape = z.ZodRawShape,\n  M extends z.ZodRawShape = z.ZodRawShape,\n  CO extends z.ZodObject<C> | undefined = undefined,\n  MO extends z.ZodObject<M> | undefined = undefined,\n> {\n  /**\n   * @description Name of the entity. Must be in **lower-kebab-case** and **unique** across all entities\n   *\n   * @example `learner`, `learning-activity`\n   */\n  name: string | T;\n\n  /**\n   * @description Display name of the entity. It is not required to be unique\n   */\n  displayName: string;\n\n  /**\n   * @description (DEPRECATED) Use `uniqueFields` instead, Monorise should not handle auth mechanism\n   * @description (Optional) Specify the authentication method to be used for the entity\n   */\n  authMethod?: {\n    /**\n     * @description Authentication method using email\n     *\n     * Note: The email used for authentication is unique per entity.\n     * For example, if `johndoe@mail.com` is used for `learner` entity,\n     * it can be reused again on `admin` entity. However, the same email\n     * address cannot be repeated for the same entity.\n     */\n    email: {\n      /**\n       * @description Number of milliseconds before the token expires\n       */\n      tokenExpiresIn: number;\n    };\n  };\n\n  /**\n   * @description Base schema for the entity\n   */\n  baseSchema: z.ZodObject<B>;\n\n  /**\n   * @description Minimal schema required to create an entity\n   */\n  createSchema?: CO;\n  searchableFields?: (keyof B)[];\n  uniqueFields?: (keyof B)[];\n\n  /**\n   * @description Define mutual relationship of this entity with other entities\n   */\n  mutual?: {\n    /**\n     * @description Subscribes to update events from specified entities in the array.\n     * These events will be used to run prejoin processor.\n     */\n    subscribes?: { entityType: Entity }[];\n    /**\n     * @description Virtual schema for mutual relationship. The schema is only used for validation purpose, but these fields are not stored in the database\n     */\n    mutualSchema: MO;\n\n    /**\n     * @description Keys of `mutualFields` are fields defined in `mutualSchema`.\n     * Each field is a mutual relationship between this entity and another entity.\n     */\n    mutualFields: {\n      [key: string]: {\n        entityType: Entity;\n        toMutualIds?: (context: any) => string[];\n        /**\n         * @description (Optional) Custom function to process `mutualData`. If not provided, `mutualData` will be empty.\n         *\n         * @returns the final state of `mutualData` to be stored in the mutual record. Must be an object.\n         */\n        mutualDataProcessor?: (\n          mutualIds: string[],\n          currentMutual: any,\n          customContext?: Record<string, any>,\n        ) => Record<string, any>;\n      };\n    };\n\n    /**\n     * @description (Optional) Better known as tree processor\n     * This is used to prejoin entities that are not directly related as mutual.\n     * For example, if `learner` entity is related to `course` entity, and `course` entity is related to `module` entity,\n     * prejoins can be used to join `learner` and `module` entities.\n     * With this, the `learner` entity can access the `module` entity without having to go through the `course` entity,\n     * hence reducing the number of queries.\n     *\n     * DynamoDB best practices: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-general-normalization.html\n     *\n     */\n    prejoins?: {\n      mutualField: string;\n      targetEntityType: Entity;\n      entityPaths: {\n        skipCache?: boolean;\n        entityType: Entity;\n        processor?: (items: any[], context: Record<string, any>) => any;\n      }[];\n    }[];\n  };\n  /**\n   * Use this function to perform side effects on the final schema for example refine/superRefine the schema\n   *\n   * @param schema The final schema of the entity (the combination of `baseSchema`/`createSchema` and `mutualSchema` if specified)\n   * @returns void\n   *\n   * @example\n   * ```ts\n   * effect: (schema) => {\n   *   schema.refine(\n   *     // refinement logic here\n   *   )\n   * }\n   */\n  effect?: (\n    schema: z.ZodObject<z.ZodRawShape>,\n  ) => z.ZodEffects<z.ZodObject<z.ZodRawShape>>;\n\n  /**\n   * @description (Optional) Use tags to create additional access patterns for the entity.\n   * Time complexity for retrieving tagged entities is O(1).\n   *\n   * The following configuration will create a tag named `region` for the `organization` entity grouped by `region`.\n   * You would then be able to retrieve all organizations in a specific region by:\n   * GET `/core/tag/organization/region?group={region_name}`\n   *\n   * @example\n   *\n   * ```ts\n   * {\n   *   name: 'organization',\n   *   tags: [\n   *    {\n   *      name: 'region',\n   *      processor: (entity) => {\n   *        return [\n   *          {\n   *            group: entity.data.region\n   *          }\n   *        ]\n   *      },\n   *    }\n   *   ]\n   * }\n   * ```\n   *\n   * @description\n   *\n   * The following configuration will create a tag named `dob` for the `user` entity sorted by `dob`.\n   * You would then be able to retrieve all users sorted by `dob` by:\n   * GET `/core/tag/user/dob?start=2000-01-01&end=2020-12-31`\n   *\n   * @example\n   * ```ts\n   * {\n   *   name: 'user',\n   *   tags: [\n   *    {\n   *      name: 'dob',\n   *      processor: (entity) => {\n   *        return [\n   *          {\n   *            sortValue: entity.data.dob\n   *          }\n   *        ]\n   *      },\n   *    }\n   *   ]\n   * }\n   * ```\n   */\n  tags?: {\n    name: string;\n    processor: (entity: CreatedEntity<T>) => {\n      group?: string;\n      sortValue?: string;\n    }[];\n  }[];\n}\n","import type { Entity, MonoriseEntityConfig } from '../types/monorise.type';\nimport { z } from 'zod';\n\nfunction makeSchema<\n  T extends Entity,\n  B extends z.ZodRawShape,\n  C extends z.ZodRawShape,\n  M extends z.ZodRawShape,\n  CO extends z.ZodObject<C> | undefined = undefined,\n  MO extends z.ZodObject<M> | undefined = undefined,\n>(config: MonoriseEntityConfig<T, B, C, M, CO, MO>) {\n  const { baseSchema, createSchema, mutual, effect } = config;\n  const { mutualSchema } = mutual || {};\n\n  type FinalSchemaType = CO extends z.AnyZodObject\n    ? MO extends z.AnyZodObject\n      ? z.ZodObject<MO['shape'] & CO['shape']>\n      : CO\n    : MO extends z.AnyZodObject\n      ? z.ZodObject<MO['shape'] & B>\n      : z.ZodObject<B>;\n\n  const finalSchema = z.object({\n    ...baseSchema.shape,\n    ...createSchema?.shape,\n    ...mutualSchema?.shape,\n  }) as FinalSchemaType;\n\n  if (effect) {\n    return effect(finalSchema) as z.ZodEffects<FinalSchemaType>;\n  }\n\n  return finalSchema;\n}\n\nconst createEntityConfig = <\n  T extends Entity,\n  B extends z.ZodRawShape,\n  C extends z.ZodRawShape,\n  M extends z.ZodRawShape,\n  CO extends z.ZodObject<C> | undefined = undefined,\n  MO extends z.ZodObject<M> | undefined = undefined,\n>(\n  config: MonoriseEntityConfig<T, B, C, M, CO, MO>,\n) => ({\n  ...config,\n  finalSchema: makeSchema(config),\n});\n\nexport { createEntityConfig };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAEO,IAAK,SAAL,kBAAKA,YAAL;AAAK,SAAAA;AAAA,GAAA;;;ACDZ,SAAS,SAAS;AAElB,SAAS,WAOP,QAAkD;AAClD,QAAM,EAAE,YAAY,cAAc,QAAQ,OAAO,IAAI;AACrD,QAAM,EAAE,aAAa,IAAI,UAAU,CAAC;AAUpC,QAAM,cAAc,EAAE,OAAO,iDACxB,WAAW,QACX,6CAAc,QACd,6CAAc,MAClB;AAED,MAAI,QAAQ;AACV,WAAO,OAAO,WAAW;AAAA,EAC3B;AAEA,SAAO;AACT;AAEA,IAAM,qBAAqB,CAQzB,WACI,iCACD,SADC;AAAA,EAEJ,aAAa,WAAW,MAAM;AAChC;","names":["Entity"]}

package/package.json

@@ -1,19 +1,24 @@
 {
   "name": "@monorise/base",
-  "version": "1.0.4",
+  "version": "3.0.1",
   "description": "",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "directories": {
     "lib": "lib"
   },
   "scripts": {
-    "build": "tsc"
+    "build": "tsup",
+    "dev": "tsup --watch"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "dependencies": {
-    "zod": "^3.24.2"
-  }
+  "peerDependencies": {
+    "zod": "^3.25.67"
+  },
+  "files": [
+    "dist"
+  ]
 }

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,WAAW,EACX,MAAM,EACN,eAAe,EACf,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,MAAM,EACN,eAAe,EACf,WAAW,EACX,aAAa,EACb,oBAAoB,GACrB,CAAC"}

package/dist/index.esm.js

@@ -1,7 +0,0 @@
-// types/monorise.type.ts
-var Entity = /* @__PURE__ */ ((Entity2) => {
-  return Entity2;
-})(Entity || {});
-export {
-  Entity
-};

package/dist/types/monorise.type.d.ts

@@ -1,205 +0,0 @@
-import type { z } from 'zod';
-export declare enum Entity {
-}
-export interface EntitySchemaMap {
-    [key: string]: Record<string, any>;
-}
-export type DraftEntity<T extends Entity = Entity> = T extends keyof EntitySchemaMap ? EntitySchemaMap[T] : never;
-export type CreatedEntity<T extends Entity = Entity> = {
-    entityId: string;
-    entityType: string;
-    data: T extends keyof EntitySchemaMap ? EntitySchemaMap[T] : never;
-    createdAt: string;
-    updatedAt: string;
-};
-/**
- * @description Configuration for a monorise entity, a shared configuration that is used across frontend and backend.
- * This can be served as a single source of truth for the entity configuration.
- * It is used to define the schema, and mutual relationships between this entity and other entities.
- *
- * @example
- * ```ts
- * const baseSchema = z.object({
- *   title: z.string(),
- * }).partial();
- *
- * const createSchema = baseSchema.extend({
- *   title: z.string(),
- * })
- *
- * const config = createEntityConfig({
- *   name: 'learner',
- *   displayName: 'Learner',
- *   baseSchema,
- *   createSchema,
- * });
- * ```
- */
-export interface MonoriseEntityConfig<T extends Entity = Entity, B extends z.ZodRawShape = z.ZodRawShape, C extends z.ZodRawShape = z.ZodRawShape, M extends z.ZodRawShape = z.ZodRawShape, CO extends z.ZodObject<C> | undefined = undefined, MO extends z.ZodObject<M> | undefined = undefined> {
-    /**
-     * @description Name of the entity. Must be in **lower-kebab-case** and **unique** across all entities
-     *
-     * @example `learner`, `learning-activity`
-     */
-    name: string | T;
-    /**
-     * @description Display name of the entity. It is not required to be unique
-     */
-    displayName: string;
-    /**
-     * @description (Optional) Specify the authentication method to be used for the entity
-     */
-    authMethod?: {
-        /**
-         * @description Authentication method using email
-         *
-         * Note: The email used for authentication is unique per entity.
-         * For example, if `johndoe@mail.com` is used for `learner` entity,
-         * it can be reused again on `admin` entity. However, the same email
-         * address cannot be repeated for the same entity.
-         */
-        email: {
-            /**
-             * @description Number of milliseconds before the token expires
-             */
-            tokenExpiresIn: number;
-        };
-    };
-    /**
-     * @description Base schema for the entity
-     */
-    baseSchema: z.ZodObject<B>;
-    /**
-     * @description Minimal schema required to create an entity
-     */
-    createSchema?: CO;
-    searchableFields?: (keyof B)[];
-    /**
-     * @description Define mutual relationship of this entity with other entities
-     */
-    mutual?: {
-        /**
-         * @description Subscribes to update events from specified entities in the array.
-         * These events will be used to run prejoin processor.
-         */
-        subscribes?: {
-            entityType: Entity;
-        }[];
-        /**
-         * @description Virtual schema for mutual relationship. The schema is only used for validation purpose, but these fields are not stored in the database
-         */
-        mutualSchema: MO;
-        /**
-         * @description Keys of `mutualFields` are fields defined in `mutualSchema`.
-         * Each field is a mutual relationship between this entity and another entity.
-         */
-        mutualFields: {
-            [key: string]: {
-                entityType: Entity;
-                toMutualIds?: (context: any) => string[];
-                /**
-                 * @description (Optional) Custom function to process `mutualData`. If not provided, `mutualData` will be empty.
-                 *
-                 * @returns the final state of `mutualData` to be stored in the mutual record. Must be an object.
-                 */
-                mutualDataProcessor?: (mutualIds: string[], currentMutual: any, customContext?: Record<string, any>) => Record<string, any>;
-            };
-        };
-        /**
-         * @description (Optional) Better known as tree processor
-         * This is used to prejoin entities that are not directly related as mutual.
-         * For example, if `learner` entity is related to `course` entity, and `course` entity is related to `module` entity,
-         * prejoins can be used to join `learner` and `module` entities.
-         * With this, the `learner` entity can access the `module` entity without having to go through the `course` entity,
-         * hence reducing the number of queries.
-         *
-         * DynamoDB best practices: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-general-normalization.html
-         *
-         */
-        prejoins?: {
-            mutualField: string;
-            targetEntityType: Entity;
-            entityPaths: {
-                skipCache?: boolean;
-                entityType: Entity;
-                processor?: (items: any[], context: Record<string, any>) => any;
-            }[];
-        }[];
-    };
-    /**
-     * Use this function to perform side effects on the final schema for example refine/superRefine the schema
-     *
-     * @param schema The final schema of the entity (the combination of `baseSchema`/`createSchema` and `mutualSchema` if specified)
-     * @returns void
-     *
-     * @example
-     * ```ts
-     * effect: (schema) => {
-     *   schema.refine(
-     *     // refinement logic here
-     *   )
-     * }
-     */
-    effect?: (schema: CO extends z.AnyZodObject ? MO extends z.AnyZodObject ? z.ZodObject<MO['shape'] & CO['shape']> : CO : MO extends z.AnyZodObject ? z.ZodObject<MO['shape'] & B> : z.ZodObject<B>) => z.ZodEffects<CO extends z.AnyZodObject ? MO extends z.AnyZodObject ? z.ZodObject<MO['shape'] & CO['shape']> : CO : MO extends z.AnyZodObject ? z.ZodObject<MO['shape'] & B> : z.ZodObject<B>>;
-    /**
-     * @description (Optional) Use tags to create additional access patterns for the entity.
-     * Time complexity for retrieving tagged entities is O(1).
-     *
-     * The following configuration will create a tag named `region` for the `organization` entity grouped by `region`.
-     * You would then be able to retrieve all organizations in a specific region by:
-     * GET `/core/tag/organization/region?group={region_name}`
-     *
-     * @example
-     *
-     * ```ts
-     * {
-     *   name: 'organization',
-     *   tags: [
-     *    {
-     *      name: 'region',
-     *      processor: (entity) => {
-     *        return [
-     *          {
-     *            group: entity.data.region
-     *          }
-     *        ]
-     *      },
-     *    }
-     *   ]
-     * }
-     * ```
-     *
-     * @description
-     *
-     * The following configuration will create a tag named `dob` for the `user` entity sorted by `dob`.
-     * You would then be able to retrieve all users sorted by `dob` by:
-     * GET `/core/tag/user/dob?start=2000-01-01&end=2020-12-31`
-     *
-     * @example
-     * ```ts
-     * {
-     *   name: 'user',
-     *   tags: [
-     *    {
-     *      name: 'dob',
-     *      processor: (entity) => {
-     *        return [
-     *          {
-     *            sortValue: entity.data.dob
-     *          }
-     *        ]
-     *      },
-     *    }
-     *   ]
-     * }
-     * ```
-     */
-    tags?: {
-        name: string;
-        processor: (entity: CreatedEntity<T>) => {
-            group?: string;
-            sortValue?: string;
-        }[];
-    }[];
-}
-//# sourceMappingURL=monorise.type.d.ts.map

package/dist/types/monorise.type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"monorise.type.d.ts","sourceRoot":"","sources":["../../types/monorise.type.ts"],"names":[],"mappings":"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"}

package/dist/types/monorise.type.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Entity = void 0;
-var Entity;
-(function (Entity) {
-})(Entity || (exports.Entity = Entity = {}));
-//# sourceMappingURL=monorise.type.js.map

package/dist/types/monorise.type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"monorise.type.js","sourceRoot":"","sources":["../../types/monorise.type.ts"],"names":[],"mappings":";;;AAEA,IAAY,MAAS;AAArB,WAAY,MAAM;AAAE,CAAC,EAAT,MAAM,sBAAN,MAAM,QAAG"}

package/dist/types/mutual.type.d.ts

@@ -1,21 +0,0 @@
-import type { Entity, EntitySchemaMap } from './monorise.type';
-type MutualDataWithIndex = {
-    index: number;
-};
-interface MutualDataMapping {
-}
-type MutualData<B extends Entity, T extends Entity> = B extends keyof MutualDataMapping ? T extends keyof MutualDataMapping[B] ? MutualDataMapping[B][T] : Record<string, any> : Record<string, any>;
-type Mutual<B extends Entity = Entity, T extends Entity = Entity> = {
-    entityId: string;
-    entityType: T;
-    byEntityId: string;
-    byEntityType: B;
-    mutualId: string;
-    data: T extends keyof EntitySchemaMap ? EntitySchemaMap[T] : never;
-    mutualData: MutualData<B, T> | Record<string, any>;
-    createdAt: string;
-    updatedAt: string;
-    mutualUpdatedAt: string;
-};
-export type { MutualDataWithIndex, MutualDataMapping, MutualData, Mutual };
-//# sourceMappingURL=mutual.type.d.ts.map

package/dist/types/mutual.type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutual.type.d.ts","sourceRoot":"","sources":["../../types/mutual.type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAE/D,KAAK,mBAAmB,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAGF,UAAU,iBAAiB;CAAG;AAE9B,KAAK,UAAU,CACb,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,IACd,CAAC,SAAS,MAAM,iBAAiB,GACjC,CAAC,SAAS,MAAM,iBAAiB,CAAC,CAAC,CAAC,GAClC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GACvB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACrB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAExB,KAAK,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,CAAC,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,CAAC,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,CAAC,SAAS,MAAM,eAAe,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IACnE,UAAU,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACnD,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,YAAY,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC"}

package/dist/types/mutual.type.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=mutual.type.js.map

package/dist/types/mutual.type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutual.type.js","sourceRoot":"","sources":["../../types/mutual.type.ts"],"names":[],"mappings":""}

package/index.ts

@@ -1,15 +0,0 @@
-import {
-  CreatedEntity,
-  DraftEntity,
-  Entity,
-  EntitySchemaMap,
-  MonoriseEntityConfig,
-} from './types/monorise.type';
-
-export {
-  Entity,
-  EntitySchemaMap,
-  DraftEntity,
-  CreatedEntity,
-  MonoriseEntityConfig,
-};

package/tsconfig.json

@@ -1,114 +0,0 @@
-{
-  "extends": "@tsconfig/node20/tsconfig.json",
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-
-    /* Projects */
-    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
-    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
-    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
-    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
-    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
-    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-
-    /* Language and Environment */
-    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-    "jsx": "preserve",                                /* Specify what JSX code is generated. */
-    // "libReplacement": true,                           /* Enable lib replacement. */
-    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
-    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
-    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
-    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
-    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
-    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
-    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
-    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-
-    /* Modules */
-    "module": "commonjs",                                /* Specify what module code is generated. */
-    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    "moduleResolution": "node",                     /* Specify how TypeScript looks up a file from a given module specifier. */
-    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
-    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
-    // "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
-    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
-    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
-    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
-    // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
-    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
-    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
-
-    /* JavaScript Support */
-    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
-    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-
-    /* Emit */
-    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-    "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-    "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
-    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
-    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
-    // "removeComments": true,                           /* Disable emitting comments. */
-    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
-    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
-    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
-    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
-    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
-    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
-    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
-    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
-    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
-    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-
-    /* Interop Constraints */
-    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
-    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
-    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
-    // "erasableSyntaxOnly": true,                       /* Do not allow runtime constructs that are not part of ECMAScript. */
-    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
-    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
-
-    /* Type Checking */
-    "strict": true,                                      /* Enable all strict type-checking options. */
-    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
-    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
-    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
-    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
-    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
-    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
-    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
-    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
-    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
-    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
-    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
-    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
-    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
-    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
-    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
-    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
-    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-
-    /* Completeness */
-    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
-  }
-}

package/types/monorise.type.ts

@@ -1,242 +0,0 @@
-import type { z } from 'zod';
-
-export enum Entity {}
-
-export interface EntitySchemaMap {
-  [key: string]: Record<string, any>;
-}
-
-export type DraftEntity<T extends Entity = Entity> =
-  T extends keyof EntitySchemaMap ? EntitySchemaMap[T] : never;
-
-export type CreatedEntity<T extends Entity = Entity> = {
-  entityId: string;
-  entityType: string;
-  data: T extends keyof EntitySchemaMap ? EntitySchemaMap[T] : never;
-  createdAt: string;
-  updatedAt: string;
-};
-
-/**
- * @description Configuration for a monorise entity, a shared configuration that is used across frontend and backend.
- * This can be served as a single source of truth for the entity configuration.
- * It is used to define the schema, and mutual relationships between this entity and other entities.
- *
- * @example
- * ```ts
- * const baseSchema = z.object({
- *   title: z.string(),
- * }).partial();
- *
- * const createSchema = baseSchema.extend({
- *   title: z.string(),
- * })
- *
- * const config = createEntityConfig({
- *   name: 'learner',
- *   displayName: 'Learner',
- *   baseSchema,
- *   createSchema,
- * });
- * ```
- */
-export interface MonoriseEntityConfig<
-  T extends Entity = Entity,
-  B extends z.ZodRawShape = z.ZodRawShape,
-  C extends z.ZodRawShape = z.ZodRawShape,
-  M extends z.ZodRawShape = z.ZodRawShape,
-  CO extends z.ZodObject<C> | undefined = undefined,
-  MO extends z.ZodObject<M> | undefined = undefined,
-> {
-  /**
-   * @description Name of the entity. Must be in **lower-kebab-case** and **unique** across all entities
-   *
-   * @example `learner`, `learning-activity`
-   */
-  name: string | T;
-
-  /**
-   * @description Display name of the entity. It is not required to be unique
-   */
-  displayName: string;
-
-  /**
-   * @description (Optional) Specify the authentication method to be used for the entity
-   */
-  authMethod?: {
-    /**
-     * @description Authentication method using email
-     *
-     * Note: The email used for authentication is unique per entity.
-     * For example, if `johndoe@mail.com` is used for `learner` entity,
-     * it can be reused again on `admin` entity. However, the same email
-     * address cannot be repeated for the same entity.
-     */
-    email: {
-      /**
-       * @description Number of milliseconds before the token expires
-       */
-      tokenExpiresIn: number;
-    };
-  };
-
-  /**
-   * @description Base schema for the entity
-   */
-  baseSchema: z.ZodObject<B>;
-
-  /**
-   * @description Minimal schema required to create an entity
-   */
-  createSchema?: CO;
-  searchableFields?: (keyof B)[];
-
-  /**
-   * @description Define mutual relationship of this entity with other entities
-   */
-  mutual?: {
-    /**
-     * @description Subscribes to update events from specified entities in the array.
-     * These events will be used to run prejoin processor.
-     */
-    subscribes?: { entityType: Entity }[];
-    /**
-     * @description Virtual schema for mutual relationship. The schema is only used for validation purpose, but these fields are not stored in the database
-     */
-    mutualSchema: MO;
-
-    /**
-     * @description Keys of `mutualFields` are fields defined in `mutualSchema`.
-     * Each field is a mutual relationship between this entity and another entity.
-     */
-    mutualFields: {
-      [key: string]: {
-        entityType: Entity;
-        toMutualIds?: (context: any) => string[];
-        /**
-         * @description (Optional) Custom function to process `mutualData`. If not provided, `mutualData` will be empty.
-         *
-         * @returns the final state of `mutualData` to be stored in the mutual record. Must be an object.
-         */
-        mutualDataProcessor?: (
-          mutualIds: string[],
-          currentMutual: any,
-          customContext?: Record<string, any>,
-        ) => Record<string, any>;
-      };
-    };
-
-    /**
-     * @description (Optional) Better known as tree processor
-     * This is used to prejoin entities that are not directly related as mutual.
-     * For example, if `learner` entity is related to `course` entity, and `course` entity is related to `module` entity,
-     * prejoins can be used to join `learner` and `module` entities.
-     * With this, the `learner` entity can access the `module` entity without having to go through the `course` entity,
-     * hence reducing the number of queries.
-     *
-     * DynamoDB best practices: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-general-normalization.html
-     *
-     */
-    prejoins?: {
-      mutualField: string;
-      targetEntityType: Entity;
-      entityPaths: {
-        skipCache?: boolean;
-        entityType: Entity;
-        processor?: (items: any[], context: Record<string, any>) => any;
-      }[];
-    }[];
-  };
-  /**
-   * Use this function to perform side effects on the final schema for example refine/superRefine the schema
-   *
-   * @param schema The final schema of the entity (the combination of `baseSchema`/`createSchema` and `mutualSchema` if specified)
-   * @returns void
-   *
-   * @example
-   * ```ts
-   * effect: (schema) => {
-   *   schema.refine(
-   *     // refinement logic here
-   *   )
-   * }
-   */
-  effect?: (
-    schema: CO extends z.AnyZodObject
-      ? MO extends z.AnyZodObject
-        ? z.ZodObject<MO['shape'] & CO['shape']>
-        : CO
-      : MO extends z.AnyZodObject
-        ? z.ZodObject<MO['shape'] & B>
-        : z.ZodObject<B>,
-  ) => z.ZodEffects<
-    CO extends z.AnyZodObject
-      ? MO extends z.AnyZodObject
-        ? z.ZodObject<MO['shape'] & CO['shape']>
-        : CO
-      : MO extends z.AnyZodObject
-        ? z.ZodObject<MO['shape'] & B>
-        : z.ZodObject<B>
-  >;
-
-  /**
-   * @description (Optional) Use tags to create additional access patterns for the entity.
-   * Time complexity for retrieving tagged entities is O(1).
-   *
-   * The following configuration will create a tag named `region` for the `organization` entity grouped by `region`.
-   * You would then be able to retrieve all organizations in a specific region by:
-   * GET `/core/tag/organization/region?group={region_name}`
-   *
-   * @example
-   *
-   * ```ts
-   * {
-   *   name: 'organization',
-   *   tags: [
-   *    {
-   *      name: 'region',
-   *      processor: (entity) => {
-   *        return [
-   *          {
-   *            group: entity.data.region
-   *          }
-   *        ]
-   *      },
-   *    }
-   *   ]
-   * }
-   * ```
-   *
-   * @description
-   *
-   * The following configuration will create a tag named `dob` for the `user` entity sorted by `dob`.
-   * You would then be able to retrieve all users sorted by `dob` by:
-   * GET `/core/tag/user/dob?start=2000-01-01&end=2020-12-31`
-   *
-   * @example
-   * ```ts
-   * {
-   *   name: 'user',
-   *   tags: [
-   *    {
-   *      name: 'dob',
-   *      processor: (entity) => {
-   *        return [
-   *          {
-   *            sortValue: entity.data.dob
-   *          }
-   *        ]
-   *      },
-   *    }
-   *   ]
-   * }
-   * ```
-   */
-  tags?: {
-    name: string;
-    processor: (entity: CreatedEntity<T>) => {
-      group?: string;
-      sortValue?: string;
-    }[];
-  }[];
-}