@monorise/base 4.1.0-dev.3 → 4.1.0

package/dist/index.d.ts

@@ -1,54 +1,10 @@
 import { z } from 'zod';
-import { Entity as Entity$1, EntitySchemaMap as EntitySchemaMap$1 } from '@monorise/base';
-
-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;
@@ -153,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;
             };
         };
         /**
@@ -262,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
      * {
@@ -304,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?: {
@@ -364,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;
@@ -378,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?: {
@@ -405,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;
@@ -413,64 +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>;
-
-type TransactionCreateEntity<T extends Entity$1 = Entity$1> = {
-    operation: 'createEntity';
-    entityType: T;
-    entityId?: string;
-    payload: EntitySchemaMap$1[T];
-};
-type TransactionUpdateEntity<T extends Entity$1 = Entity$1> = {
-    operation: 'updateEntity';
-    entityType: T;
-    entityId: string;
-    payload: Partial<EntitySchemaMap$1[T]>;
-    accountId?: string;
-    condition?: string;
-};
-type TransactionAdjustEntity<T extends Entity$1 = Entity$1> = {
-    operation: 'adjustEntity';
-    entityType: T;
-    entityId: string;
-    adjustments: Record<string, number>;
-    accountId?: string;
-    condition?: string;
-};
-type TransactionDeleteEntity<T extends Entity$1 = Entity$1> = {
-    operation: 'deleteEntity';
-    entityType: T;
-    entityId: string;
-};
-type TransactionOperation = TransactionCreateEntity | TransactionUpdateEntity | TransactionAdjustEntity | TransactionDeleteEntity;
-type TransactionResultEntry = {
-    operation: string;
-    entityType: Entity$1;
-    entityId: string;
-    data?: Record<string, unknown>;
-};
-type TransactionResult = {
-    results: TransactionResultEntry[];
-};
-
-declare const transactional: {
-    createEntity: <T extends Entity$1>(entityType: T, payload: EntitySchemaMap$1[T] & {
-        entityId?: string;
-    }) => TransactionCreateEntity<T>;
-    updateEntity: <T extends Entity$1>(entityType: T, entityId: string, payload: Partial<EntitySchemaMap$1[T]> & {
-        $condition?: string;
-    }) => TransactionUpdateEntity<T>;
-    adjustEntity: <T extends Entity$1>(entityType: T, entityId: string, adjustments: Record<string, number> & {
-        $condition?: string;
-    }) => TransactionAdjustEntity<T>;
-    deleteEntity: <T extends Entity$1>(entityType: T, entityId: string) => TransactionDeleteEntity<T>;
 };
 
-export { type AdjustmentCondition, type AdjustmentConditionFn, type CreatedEntity, type DraftEntity, Entity, type EntitySchemaMap, type MonoriseEntityConfig, type MutualConfig, type NumericFields, type TransactionAdjustEntity, type TransactionCreateEntity, type TransactionDeleteEntity, type TransactionOperation, type TransactionResult, type TransactionResultEntry, type TransactionUpdateEntity, type UpdateCondition, type UpdateConditionFn, type WhereClause, type WhereConditions, type WhereOperator, createEntityConfig, createMutualConfig, transactional };
+export { type CreatedEntity, type DraftEntity, Entity, type EntitySchemaMap, type MonoriseEntityConfig, type NumericFields, createEntityConfig };

package/dist/index.js

@@ -17,18 +17,6 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
 
 // types/monorise.type.ts
 var Entity = /* @__PURE__ */ ((Entity2) => {
@@ -49,46 +37,8 @@ function makeSchema(config) {
 var createEntityConfig = (config) => __spreadProps(__spreadValues({}, config), {
   finalSchema: makeSchema(config)
 });
-var createMutualConfig = (config) => config;
-
-// transactional.ts
-var transactional = {
-  createEntity: (entityType, payload) => {
-    const _a = payload, { entityId } = _a, rest = __objRest(_a, ["entityId"]);
-    return __spreadValues({
-      operation: "createEntity",
-      entityType,
-      payload: rest
-    }, entityId && { entityId });
-  },
-  updateEntity: (entityType, entityId, payload) => {
-    const _a = payload, { $condition } = _a, rest = __objRest(_a, ["$condition"]);
-    return __spreadValues({
-      operation: "updateEntity",
-      entityType,
-      entityId,
-      payload: rest
-    }, $condition && { condition: $condition });
-  },
-  adjustEntity: (entityType, entityId, adjustments) => {
-    const _a = adjustments, { $condition } = _a, rest = __objRest(_a, ["$condition"]);
-    return __spreadValues({
-      operation: "adjustEntity",
-      entityType,
-      entityId,
-      adjustments: rest
-    }, $condition && { condition: $condition });
-  },
-  deleteEntity: (entityType, entityId) => ({
-    operation: "deleteEntity",
-    entityType,
-    entityId
-  })
-};
 export {
   Entity,
-  createEntityConfig,
-  createMutualConfig,
-  transactional
+  createEntityConfig
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../types/monorise.type.ts","../utils/index.ts","../transactional.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","import type { Entity as EntityType, EntitySchemaMap } from '@monorise/base';\nimport type {\n  TransactionAdjustEntity,\n  TransactionCreateEntity,\n  TransactionDeleteEntity,\n  TransactionOperation,\n  TransactionUpdateEntity,\n} from './types/transaction.type';\n\nexport const transactional = {\n  createEntity: <T extends EntityType>(\n    entityType: T,\n    payload: EntitySchemaMap[T] & { entityId?: string },\n  ): TransactionCreateEntity<T> => {\n    const { entityId, ...rest } = payload as EntitySchemaMap[T] & {\n      entityId?: string;\n    };\n    return {\n      operation: 'createEntity',\n      entityType,\n      payload: rest as EntitySchemaMap[T],\n      ...(entityId && { entityId }),\n    };\n  },\n\n  updateEntity: <T extends EntityType>(\n    entityType: T,\n    entityId: string,\n    payload: Partial<EntitySchemaMap[T]> & { $condition?: string },\n  ): TransactionUpdateEntity<T> => {\n    const { $condition, ...rest } = payload as Partial<EntitySchemaMap[T]> & {\n      $condition?: string;\n    };\n    return {\n      operation: 'updateEntity',\n      entityType,\n      entityId,\n      payload: rest as Partial<EntitySchemaMap[T]>,\n      ...($condition && { condition: $condition }),\n    };\n  },\n\n  adjustEntity: <T extends EntityType>(\n    entityType: T,\n    entityId: string,\n    adjustments: Record<string, number> & { $condition?: string },\n  ): TransactionAdjustEntity<T> => {\n    const { $condition, ...rest } = adjustments;\n    return {\n      operation: 'adjustEntity',\n      entityType,\n      entityId,\n      adjustments: rest,\n      ...($condition && { condition: $condition }),\n    };\n  },\n\n  deleteEntity: <T extends EntityType>(\n    entityType: T,\n    entityId: string,\n  ): TransactionDeleteEntity<T> => ({\n    operation: 'deleteEntity',\n    entityType,\n    entityId,\n  }),\n};\n\nexport type { TransactionOperation };\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;;;AC1CE,IAAM,gBAAgB;AAAA,EAC3B,cAAc,CACZ,YACA,YAC+B;AAC/B,UAA8B,cAAtB,WAdZ,IAckC,IAAT,iBAAS,IAAT,CAAb;AAGR,WAAO;AAAA,MACL,WAAW;AAAA,MACX;AAAA,MACA,SAAS;AAAA,OACL,YAAY,EAAE,SAAS;AAAA,EAE/B;AAAA,EAEA,cAAc,CACZ,YACA,UACA,YAC+B;AAC/B,UAAgC,cAAxB,aA9BZ,IA8BoC,IAAT,iBAAS,IAAT,CAAf;AAGR,WAAO;AAAA,MACL,WAAW;AAAA,MACX;AAAA,MACA;AAAA,MACA,SAAS;AAAA,OACL,cAAc,EAAE,WAAW,WAAW;AAAA,EAE9C;AAAA,EAEA,cAAc,CACZ,YACA,UACA,gBAC+B;AAC/B,UAAgC,kBAAxB,aA/CZ,IA+CoC,IAAT,iBAAS,IAAT,CAAf;AACR,WAAO;AAAA,MACL,WAAW;AAAA,MACX;AAAA,MACA;AAAA,MACA,aAAa;AAAA,OACT,cAAc,EAAE,WAAW,WAAW;AAAA,EAE9C;AAAA,EAEA,cAAc,CACZ,YACA,cACgC;AAAA,IAChC,WAAW;AAAA,IACX;AAAA,IACA;AAAA,EACF;AACF;","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.3",
+  "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",