@monorise/base 4.1.0-dev.2 → 4.1.0

package/dist/index.d.ts

@@ -1,53 +1,10 @@
 import { z } from 'zod';
 
-type WhereOperator = {
-    $eq: string | number | boolean;
-} | {
-    $ne: string | number | boolean;
-} | {
-    $gt: number;
-} | {
-    $lt: number;
-} | {
-    $gte: number;
-} | {
-    $lte: number;
-} | {
-    $exists: boolean;
-} | {
-    $beginsWith: string;
-};
-type WhereClause = WhereOperator | string | number | boolean;
-type WhereConditions = Record<string, WhereClause>;
-type AdjustmentConditionFn<B extends z.ZodRawShape = z.ZodRawShape> = (data: Partial<z.infer<z.ZodObject<B>>>, adjustments: Record<string, number>) => WhereConditions;
-type AdjustmentCondition<B extends z.ZodRawShape = z.ZodRawShape> = WhereConditions | AdjustmentConditionFn<B>;
-type UpdateConditionFn<B extends z.ZodRawShape = z.ZodRawShape> = (data: Partial<z.infer<z.ZodObject<B>>>) => WhereConditions;
-type UpdateCondition<B extends z.ZodRawShape = z.ZodRawShape> = WhereConditions | UpdateConditionFn<B>;
-
 declare enum Entity {
 }
 interface EntitySchemaMap {
     [key: string]: Record<string, any>;
 }
-/**
- * @description Configuration for a mutual relationship between two entities.
- * Defines the schema for mutualData validation. Define once, reference from both entity configs.
- *
- * @example
- * ```ts
- * const enrollmentMutual = createMutualConfig({
- *   entities: [Entity.STUDENT, Entity.COURSE],
- *   mutualDataSchema: z.object({
- *     role: z.enum(['student', 'auditor']),
- *     enrolledAt: z.string().datetime(),
- *   }),
- * });
- * ```
- */
-interface MutualConfig<MD extends z.ZodRawShape = z.ZodRawShape> {
-    entities: [Entity, Entity];
-    mutualDataSchema: z.ZodObject<MD>;
-}
 type DraftEntity<T extends Entity = Entity> = T extends keyof EntitySchemaMap ? EntitySchemaMap[T] : never;
 type NumericFields<T> = {
     [K in keyof T as T[K] extends number ? K : never]?: number;
@@ -152,11 +109,6 @@ interface MonoriseEntityConfig<T extends Entity = Entity, B extends z.ZodRawShap
                  * @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) Reference to a mutual config created by `createMutualConfig`.
-                 * Provides mutualData schema validation for create/update operations on this mutual relationship.
-                 */
-                mutual?: MutualConfig;
             };
         };
         /**
@@ -261,13 +213,53 @@ interface MonoriseEntityConfig<T extends Entity = Entity, B extends z.ZodRawShap
             sortValue?: string;
         }[];
     }[];
+    /**
+     * @description (Optional) Configure a DynamoDB TTL for this entity. When set, `expiresAt`
+     * is computed via `processor` on create, and recomputed on every update/upsert. Once past,
+     * DynamoDB automatically deletes the item (and its derived index rows, since they all carry
+     * the same `expiresAt`).
+     *
+     * `processor` returning `undefined` means "no TTL" for that record. On updates, an `undefined`
+     * result leaves any existing `expiresAt` untouched rather than clearing it.
+     *
+     * @example
+     * ```ts
+     * // fixed 30-day TTL from creation/each update
+     * ttl: {
+     *   processor: () => Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
+     * }
+     * ```
+     *
+     * @example
+     * ```ts
+     * // data-driven TTL, eg. expire when a subscription ends
+     * ttl: {
+     *   processor: (entity) => {
+     *     return entity.data.subscriptionEndsAt
+     *       ? new Date(entity.data.subscriptionEndsAt)
+     *       : undefined;
+     *   },
+     * }
+     * ```
+     */
+    ttl?: {
+        /**
+         * @description Returns the expiry as epoch seconds (absolute) or a `Date`.
+         * Return `undefined` for no expiry.
+         */
+        processor: (entity: {
+            entityId: string;
+            entityType: string;
+            data: Record<string, any>;
+            createdAt: string;
+            updatedAt: string;
+        }) => number | Date | undefined;
+    };
     /**
      * @description (Optional) Constraints for `adjustEntity` operations.
      * When adjusting numeric fields, these constraints are enforced at the database level.
      * If an adjustment would violate a constraint, the operation is rejected.
      *
-     * @deprecated Use `conditions` instead. Will be removed in a future version.
-     *
      * @example
      * ```ts
      * {
@@ -303,59 +295,10 @@ interface MonoriseEntityConfig<T extends Entity = Entity, B extends z.ZodRawShap
             };
         };
     };
-    /**
-     * @description Named conditions for adjustEntity operations.
-     * Each condition is either a static `WhereConditions` object or a function
-     * `(data, adjustments) => WhereConditions` that receives the entity's current data
-     * and the adjustment deltas.
-     *
-     * When defined, `$condition` is **required** in the adjustEntity request body.
-     * The client sends a condition name (string), the server resolves it to a
-     * DynamoDB ConditionExpression.
-     *
-     * @example
-     * ```ts
-     * {
-     *   adjustmentConditions: {
-     *     withdraw: (data, adjustments) => ({
-     *       balance: { $gte: (data.minBalance ?? 0) + Math.abs(adjustments?.balance ?? 0) },
-     *     }),
-     *     deposit: (data, adjustments) => ({
-     *       balance: { $lte: 1000000 - (adjustments.balance ?? 0) },
-     *     }),
-     *   }
-     * }
-     * ```
-     */
-    adjustmentConditions?: {
-        [conditionName: string]: WhereConditions | ((data: Partial<z.infer<z.ZodObject<B>>>, adjustments: Record<string, number>) => WhereConditions);
-    };
-    /**
-     * @description Named conditions for updateEntity operations.
-     * Each condition is either a static `WhereConditions` object or a function
-     * `(data) => WhereConditions` that receives the entity's current data.
-     *
-     * `$condition` is always **optional** for updateEntity.
-     * The client sends a condition name (string), the server resolves it to a
-     * DynamoDB ConditionExpression. Replaces raw `$where` (deprecated).
-     *
-     * @example
-     * ```ts
-     * {
-     *   updateConditions: {
-     *     publish: { status: { $eq: 'draft' } },
-     *     archive: (data) => ({ status: { $ne: 'archived' } }),
-     *   }
-     * }
-     * ```
-     */
-    updateConditions?: {
-        [conditionName: string]: WhereConditions | ((data: Partial<z.infer<z.ZodObject<B>>>) => WhereConditions);
-    };
 }
 
 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<B & CO["shape"] & MO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & CO["shape"] & MO["shape"]>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<B & CO["shape"] & MO["shape"]> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never> : z.ZodObject<B & CO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & CO["shape"]>, any> extends infer T_3 ? { [k_2 in keyof T_3]: T_3[k_2]; } : never, z.baseObjectInputType<B & CO["shape"]> extends infer T_4 ? { [k_3 in keyof T_4]: T_4[k_3]; } : never> : MO extends z.AnyZodObject ? z.ZodObject<B & MO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & MO["shape"]>, any> extends infer T_5 ? { [k_4 in keyof T_5]: T_5[k_4]; } : never, z.baseObjectInputType<B & MO["shape"]> extends infer T_6 ? { [k_5 in keyof T_6]: T_6[k_5]; } : never> : z.ZodObject<B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_7 ? { [k_6 in keyof T_7]: T_7[k_6]; } : never, z.baseObjectInputType<B> extends infer T_8 ? { [k_7 in keyof T_8]: T_8[k_7]; } : never>) | z.ZodEffects<CO extends z.AnyZodObject ? MO extends z.AnyZodObject ? z.ZodObject<B & CO["shape"] & MO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & CO["shape"] & MO["shape"]>, any> extends infer T_9 ? { [k in keyof T_9]: T_9[k]; } : never, z.baseObjectInputType<B & CO["shape"] & MO["shape"]> extends infer T_10 ? { [k_1 in keyof T_10]: T_10[k_1]; } : never> : z.ZodObject<B & CO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & CO["shape"]>, any> extends infer T_11 ? { [k_2 in keyof T_11]: T_11[k_2]; } : never, z.baseObjectInputType<B & CO["shape"]> extends infer T_12 ? { [k_3 in keyof T_12]: T_12[k_3]; } : never> : MO extends z.AnyZodObject ? z.ZodObject<B & MO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & MO["shape"]>, any> extends infer T_13 ? { [k_4 in keyof T_13]: T_13[k_4]; } : never, z.baseObjectInputType<B & MO["shape"]> extends infer T_14 ? { [k_5 in keyof T_14]: T_14[k_5]; } : never> : z.ZodObject<B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_15 ? { [k_6 in keyof T_15]: T_15[k_6]; } : never, z.baseObjectInputType<B> extends infer T_16 ? { [k_7 in keyof T_16]: T_16[k_7]; } : never>, z.output<CO extends z.AnyZodObject ? MO extends z.AnyZodObject ? z.ZodObject<B & CO["shape"] & MO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & CO["shape"] & MO["shape"]>, any> extends infer T_17 ? { [k in keyof T_17]: T_17[k]; } : never, z.baseObjectInputType<B & CO["shape"] & MO["shape"]> extends infer T_18 ? { [k_1 in keyof T_18]: T_18[k_1]; } : never> : z.ZodObject<B & CO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & CO["shape"]>, any> extends infer T_19 ? { [k_2 in keyof T_19]: T_19[k_2]; } : never, z.baseObjectInputType<B & CO["shape"]> extends infer T_20 ? { [k_3 in keyof T_20]: T_20[k_3]; } : never> : MO extends z.AnyZodObject ? z.ZodObject<B & MO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & MO["shape"]>, any> extends infer T_21 ? { [k_4 in keyof T_21]: T_21[k_4]; } : never, z.baseObjectInputType<B & MO["shape"]> extends infer T_22 ? { [k_5 in keyof T_22]: T_22[k_5]; } : never> : z.ZodObject<B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_23 ? { [k_6 in keyof T_23]: T_23[k_6]; } : never, z.baseObjectInputType<B> extends infer T_24 ? { [k_7 in keyof T_24]: T_24[k_7]; } : never>>, z.input<CO extends z.AnyZodObject ? MO extends z.AnyZodObject ? z.ZodObject<B & CO["shape"] & MO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & CO["shape"] & MO["shape"]>, any> extends infer T_25 ? { [k in keyof T_25]: T_25[k]; } : never, z.baseObjectInputType<B & CO["shape"] & MO["shape"]> extends infer T_26 ? { [k_1 in keyof T_26]: T_26[k_1]; } : never> : z.ZodObject<B & CO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & CO["shape"]>, any> extends infer T_27 ? { [k_2 in keyof T_27]: T_27[k_2]; } : never, z.baseObjectInputType<B & CO["shape"]> extends infer T_28 ? { [k_3 in keyof T_28]: T_28[k_3]; } : never> : MO extends z.AnyZodObject ? z.ZodObject<B & MO["shape"], z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B & MO["shape"]>, any> extends infer T_29 ? { [k_4 in keyof T_29]: T_29[k_4]; } : never, z.baseObjectInputType<B & MO["shape"]> extends infer T_30 ? { [k_5 in keyof T_30]: T_30[k_5]; } : never> : z.ZodObject<B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_31 ? { [k_6 in keyof T_31]: T_31[k_6]; } : never, z.baseObjectInputType<B> extends infer T_32 ? { [k_7 in keyof T_32]: T_32[k_7]; } : never>>>;
+    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]: T_1[k]; } : never, z.baseObjectInputType<MO["shape"] & CO["shape"]> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[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]: T_3[k_2]; } : never, z.baseObjectInputType<MO["shape"] & B> extends infer T_4 ? { [k_3 in keyof T_4]: T_4[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]: T_5[k_4]; } : never, z.baseObjectInputType<B> extends infer T_6 ? { [k_5 in keyof T_6]: T_6[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]: T_7[k]; } : never, z.baseObjectInputType<MO["shape"] & CO["shape"]> extends infer T_8 ? { [k_1 in keyof T_8]: T_8[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]: T_9[k_2]; } : never, z.baseObjectInputType<MO["shape"] & B> extends infer T_10 ? { [k_3 in keyof T_10]: T_10[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]: T_11[k_4]; } : never, z.baseObjectInputType<B> extends infer T_12 ? { [k_5 in keyof T_12]: T_12[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]: T_13[k]; } : never, z.baseObjectInputType<MO["shape"] & CO["shape"]> extends infer T_14 ? { [k_1 in keyof T_14]: T_14[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]: T_15[k_2]; } : never, z.baseObjectInputType<MO["shape"] & B> extends infer T_16 ? { [k_3 in keyof T_16]: T_16[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]: T_17[k_4]; } : never, z.baseObjectInputType<B> extends infer T_18 ? { [k_5 in keyof T_18]: T_18[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]: T_19[k]; } : never, z.baseObjectInputType<MO["shape"] & CO["shape"]> extends infer T_20 ? { [k_1 in keyof T_20]: T_20[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]: T_21[k_2]; } : never, z.baseObjectInputType<MO["shape"] & B> extends infer T_22 ? { [k_3 in keyof T_22]: T_22[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]: T_23[k_4]; } : never, z.baseObjectInputType<B> extends infer T_24 ? { [k_5 in keyof T_24]: T_24[k_5]; } : never>>>;
     name: string | T;
     displayName: string;
     authMethod?: {
@@ -363,7 +306,7 @@ declare const createEntityConfig: <T extends Entity, B extends z.ZodRawShape, C
             tokenExpiresIn: number;
         };
     };
-    baseSchema: z.ZodObject<B, z.UnknownKeysParam, z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_33 ? { [k_6 in keyof T_33]: T_33[k_6]; } : never, z.baseObjectInputType<B> extends infer T_34 ? { [k_7 in keyof T_34]: T_34[k_7]; } : never>;
+    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]: T_25[k_4]; } : never, z.baseObjectInputType<B> extends infer T_26 ? { [k_5 in keyof T_26]: T_26[k_5]; } : never>;
     createSchema?: CO | undefined;
     searchableFields?: (keyof B)[] | undefined;
     uniqueFields?: (keyof B)[] | undefined;
@@ -377,7 +320,6 @@ declare const createEntityConfig: <T extends Entity, B extends z.ZodRawShape, C
                 entityType: Entity;
                 toMutualIds?: (context: any) => string[];
                 mutualDataProcessor?: (mutualIds: string[], currentMutual: any, customContext?: Record<string, any>) => Record<string, any>;
-                mutual?: MutualConfig;
             };
         };
         prejoins?: {
@@ -404,6 +346,15 @@ declare const createEntityConfig: <T extends Entity, B extends z.ZodRawShape, C
             sortValue?: string;
         }[];
     }[];
+    ttl?: {
+        processor: (entity: {
+            entityId: string;
+            entityType: string;
+            data: Record<string, any>;
+            createdAt: string;
+            updatedAt: string;
+        }) => number | Date | undefined;
+    };
     adjustmentConstraints?: {
         [fieldName: string]: {
             min?: number;
@@ -412,13 +363,6 @@ declare const createEntityConfig: <T extends Entity, B extends z.ZodRawShape, C
             maxField?: (keyof { [K_2 in keyof B as B[K_2] extends z.ZodNumber | z.ZodOptional<z.ZodNumber> ? K_2 : never]: K_2; } extends never ? string : keyof { [K_3 in keyof B as B[K_3] extends z.ZodNumber | z.ZodOptional<z.ZodNumber> ? K_3 : never]: K_3; }) | undefined;
         };
     } | undefined;
-    adjustmentConditions?: {
-        [conditionName: string]: undefined | ((data: Partial<z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_35 ? { [k_6 in keyof T_35]: T_35[k_6]; } : never>, adjustments: Record<string, number>) => undefined);
-    } | undefined;
-    updateConditions?: {
-        [conditionName: string]: undefined | ((data: Partial<z.objectUtil.addQuestionMarks<z.baseObjectOutputType<B>, any> extends infer T_35 ? { [k_6 in keyof T_35]: T_35[k_6]; } : never>) => undefined);
-    } | undefined;
 };
-declare const createMutualConfig: <MD extends z.ZodRawShape>(config: MutualConfig<MD>) => MutualConfig<MD>;
 
-export { type AdjustmentCondition, type AdjustmentConditionFn, type CreatedEntity, type DraftEntity, Entity, type EntitySchemaMap, type MonoriseEntityConfig, type MutualConfig, type NumericFields, type UpdateCondition, type UpdateConditionFn, type WhereClause, type WhereConditions, type WhereOperator, createEntityConfig, createMutualConfig };
+export { type CreatedEntity, type DraftEntity, Entity, type EntitySchemaMap, type MonoriseEntityConfig, type NumericFields, createEntityConfig };

package/dist/index.js

@@ -37,10 +37,8 @@ function makeSchema(config) {
 var createEntityConfig = (config) => __spreadProps(__spreadValues({}, config), {
   finalSchema: makeSchema(config)
 });
-var createMutualConfig = (config) => config;
 export {
   Entity,
-  createEntityConfig,
-  createMutualConfig
+  createEntityConfig
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../types/monorise.type.ts","../utils/index.ts"],"sourcesContent":["import type { z } from 'zod';\nimport type { WhereConditions } from './conditions.type';\n\nexport enum Entity {}\n\nexport interface EntitySchemaMap {\n  [key: string]: Record<string, any>;\n}\n\n/**\n * @description Configuration for a mutual relationship between two entities.\n * Defines the schema for mutualData validation. Define once, reference from both entity configs.\n *\n * @example\n * ```ts\n * const enrollmentMutual = createMutualConfig({\n *   entities: [Entity.STUDENT, Entity.COURSE],\n *   mutualDataSchema: z.object({\n *     role: z.enum(['student', 'auditor']),\n *     enrolledAt: z.string().datetime(),\n *   }),\n * });\n * ```\n */\nexport interface MutualConfig<\n  MD extends z.ZodRawShape = z.ZodRawShape,\n> {\n  entities: [Entity, Entity];\n  mutualDataSchema: z.ZodObject<MD>;\n}\n\nexport type DraftEntity<T extends Entity = Entity> =\n  T extends keyof EntitySchemaMap ? EntitySchemaMap[T] : never;\n\nexport type NumericFields<T> = {\n  [K in keyof T as T[K] extends number ? K : never]?: number;\n};\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         * @description (Optional) Reference to a mutual config created by `createMutualConfig`.\n         * Provides mutualData schema validation for create/update operations on this mutual relationship.\n         */\n        mutual?: MutualConfig;\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: { entityId: string; entityType: string; data: Record<string, any>; createdAt: string; updatedAt: string }) => {\n      group?: string;\n      sortValue?: string;\n    }[];\n  }[];\n\n  /**\n   * @description (Optional) Constraints for `adjustEntity` operations.\n   * When adjusting numeric fields, these constraints are enforced at the database level.\n   * If an adjustment would violate a constraint, the operation is rejected.\n   *\n   * @deprecated Use `conditions` instead. Will be removed in a future version.\n   *\n   * @example\n   * ```ts\n   * {\n   *   adjustmentConstraints: {\n   *     // Static: same for all entities of this type\n   *     balance: { min: 0 },\n   *     credits: { min: 0, max: 10000 },\n   *\n   *     // Dynamic: reads constraint value from entity's own data\n   *     balance: { minField: 'minBalance' },\n   *     credits: { min: 0, maxField: 'creditLimit' },\n   *   }\n   * }\n   * ```\n   */\n  adjustmentConstraints?: {\n    [fieldName: string]: {\n      /** Static minimum value */\n      min?: number;\n      /** Static maximum value */\n      max?: number;\n      /** Field name on the entity whose value is used as the minimum (must be a numeric field) */\n      minField?: keyof {\n        [K in keyof B as B[K] extends z.ZodNumber | z.ZodOptional<z.ZodNumber> ? K : never]: K;\n      } extends never ? string : keyof {\n        [K in keyof B as B[K] extends z.ZodNumber | z.ZodOptional<z.ZodNumber> ? K : never]: K;\n      };\n      /** Field name on the entity whose value is used as the maximum (must be a numeric field) */\n      maxField?: keyof {\n        [K in keyof B as B[K] extends z.ZodNumber | z.ZodOptional<z.ZodNumber> ? K : never]: K;\n      } extends never ? string : keyof {\n        [K in keyof B as B[K] extends z.ZodNumber | z.ZodOptional<z.ZodNumber> ? K : never]: K;\n      };\n    };\n  };\n\n  /**\n   * @description Named conditions for adjustEntity operations.\n   * Each condition is either a static `WhereConditions` object or a function\n   * `(data, adjustments) => WhereConditions` that receives the entity's current data\n   * and the adjustment deltas.\n   *\n   * When defined, `$condition` is **required** in the adjustEntity request body.\n   * The client sends a condition name (string), the server resolves it to a\n   * DynamoDB ConditionExpression.\n   *\n   * @example\n   * ```ts\n   * {\n   *   adjustmentConditions: {\n   *     withdraw: (data, adjustments) => ({\n   *       balance: { $gte: (data.minBalance ?? 0) + Math.abs(adjustments?.balance ?? 0) },\n   *     }),\n   *     deposit: (data, adjustments) => ({\n   *       balance: { $lte: 1000000 - (adjustments.balance ?? 0) },\n   *     }),\n   *   }\n   * }\n   * ```\n   */\n  adjustmentConditions?: {\n    [conditionName: string]:\n      | WhereConditions\n      | ((\n          data: Partial<z.infer<z.ZodObject<B>>>,\n          adjustments: Record<string, number>,\n        ) => WhereConditions);\n  };\n\n  /**\n   * @description Named conditions for updateEntity operations.\n   * Each condition is either a static `WhereConditions` object or a function\n   * `(data) => WhereConditions` that receives the entity's current data.\n   *\n   * `$condition` is always **optional** for updateEntity.\n   * The client sends a condition name (string), the server resolves it to a\n   * DynamoDB ConditionExpression. Replaces raw `$where` (deprecated).\n   *\n   * @example\n   * ```ts\n   * {\n   *   updateConditions: {\n   *     publish: { status: { $eq: 'draft' } },\n   *     archive: (data) => ({ status: { $ne: 'archived' } }),\n   *   }\n   * }\n   * ```\n   */\n  updateConditions?: {\n    [conditionName: string]:\n      | WhereConditions\n      | ((data: Partial<z.infer<z.ZodObject<B>>>) => WhereConditions);\n  };\n}\n","import type { Entity, MonoriseEntityConfig, MutualConfig } 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<B & CO['shape'] & MO['shape']>\n      : z.ZodObject<B & CO['shape']>\n    : MO extends z.AnyZodObject\n      ? z.ZodObject<B & MO['shape']>\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\nconst createMutualConfig = <MD extends z.ZodRawShape>(\n  config: MutualConfig<MD>,\n) => config;\n\nexport { createEntityConfig, createMutualConfig };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAGO,IAAK,SAAL,kBAAKA,YAAL;AAAK,SAAAA;AAAA,GAAA;;;ACFZ,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;AAEA,IAAM,qBAAqB,CACzB,WACG;","names":["Entity"]}
+{"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 NumericFields<T> = {\n  [K in keyof T as T[K] extends number ? K : never]?: number;\n};\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: { entityId: string; entityType: string; data: Record<string, any>; createdAt: string; updatedAt: string }) => {\n      group?: string;\n      sortValue?: string;\n    }[];\n  }[];\n\n  /**\n   * @description (Optional) Configure a DynamoDB TTL for this entity. When set, `expiresAt`\n   * is computed via `processor` on create, and recomputed on every update/upsert. Once past,\n   * DynamoDB automatically deletes the item (and its derived index rows, since they all carry\n   * the same `expiresAt`).\n   *\n   * `processor` returning `undefined` means \"no TTL\" for that record. On updates, an `undefined`\n   * result leaves any existing `expiresAt` untouched rather than clearing it.\n   *\n   * @example\n   * ```ts\n   * // fixed 30-day TTL from creation/each update\n   * ttl: {\n   *   processor: () => Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,\n   * }\n   * ```\n   *\n   * @example\n   * ```ts\n   * // data-driven TTL, eg. expire when a subscription ends\n   * ttl: {\n   *   processor: (entity) => {\n   *     return entity.data.subscriptionEndsAt\n   *       ? new Date(entity.data.subscriptionEndsAt)\n   *       : undefined;\n   *   },\n   * }\n   * ```\n   */\n  ttl?: {\n    /**\n     * @description Returns the expiry as epoch seconds (absolute) or a `Date`.\n     * Return `undefined` for no expiry.\n     */\n    processor: (entity: {\n      entityId: string;\n      entityType: string;\n      data: Record<string, any>;\n      createdAt: string;\n      updatedAt: string;\n    }) => number | Date | undefined;\n  };\n\n  /**\n   * @description (Optional) Constraints for `adjustEntity` operations.\n   * When adjusting numeric fields, these constraints are enforced at the database level.\n   * If an adjustment would violate a constraint, the operation is rejected.\n   *\n   * @example\n   * ```ts\n   * {\n   *   adjustmentConstraints: {\n   *     // Static: same for all entities of this type\n   *     balance: { min: 0 },\n   *     credits: { min: 0, max: 10000 },\n   *\n   *     // Dynamic: reads constraint value from entity's own data\n   *     balance: { minField: 'minBalance' },\n   *     credits: { min: 0, maxField: 'creditLimit' },\n   *   }\n   * }\n   * ```\n   */\n  adjustmentConstraints?: {\n    [fieldName: string]: {\n      /** Static minimum value */\n      min?: number;\n      /** Static maximum value */\n      max?: number;\n      /** Field name on the entity whose value is used as the minimum (must be a numeric field) */\n      minField?: keyof {\n        [K in keyof B as B[K] extends z.ZodNumber | z.ZodOptional<z.ZodNumber> ? K : never]: K;\n      } extends never ? string : keyof {\n        [K in keyof B as B[K] extends z.ZodNumber | z.ZodOptional<z.ZodNumber> ? K : never]: K;\n      };\n      /** Field name on the entity whose value is used as the maximum (must be a numeric field) */\n      maxField?: keyof {\n        [K in keyof B as B[K] extends z.ZodNumber | z.ZodOptional<z.ZodNumber> ? K : never]: K;\n      } extends never ? string : keyof {\n        [K in keyof B as B[K] extends z.ZodNumber | z.ZodOptional<z.ZodNumber> ? K : never]: K;\n      };\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,6 +1,11 @@
 {
   "name": "@monorise/base",
-  "version": "4.1.0-dev.2",
+  "version": "4.1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/monorist/monorise.git",
+    "directory": "packages/base"
+  },
   "description": "",
   "type": "module",
   "main": "dist/index.js",