rads-db 3.1.11 → 3.1.13

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import { g as RadsConfig, T as TypeDefinition } from './types-9c3659f0.js';
+import { g as RadsConfig, T as TypeDefinition } from './types-9cb9d6e7.js';
 import '_rads-db';
 
 declare function defineRadsConfig(config: RadsConfig): RadsConfig;

package/dist/index.cjs

@@ -268,14 +268,14 @@ function queryArray(array, args) {
   if (!array)
     return array;
   let result = array;
-  const { where, orderByProperty, orderByDirection, maxItemCount, cursor } = prepareArgs(args);
+  const { where, orderByProperties, orderByDirections, maxItemCount, cursor } = prepareArgs(args);
   const startIndex = Number(cursor) || 0;
   const endIndex = startIndex + maxItemCount;
   const f = getFilter(where);
   if (f)
     result = result.filter(f);
-  if (orderByProperty)
-    result = ___default.orderBy(result, [orderByProperty], [orderByDirection]);
+  if (orderByProperties)
+    result = ___default.orderBy(result, orderByProperties, orderByDirections);
   if (maxItemCount)
     result = result.slice(startIndex, endIndex);
   const newCursor = endIndex >= array.length ? null : endIndex;
@@ -362,15 +362,25 @@ function getFilterInner(operator, whereVal, name, namePrefix) {
 function prepareArgs(args) {
   args = args || {};
   const where = { ...args.where };
-  let orderBy = args.orderBy || "";
-  if (Array.isArray(orderBy))
-    orderBy = orderBy[0] || "";
-  const orderByParts = orderBy.split("_");
-  const orderByProperty = orderByParts.slice(0, -1).join(".");
-  const orderByDirection = orderByParts.slice(-1)[0];
+  const orderByProperties = [];
+  const orderByDirections = [];
+  if (args.orderBy) {
+    let orderBy = args.orderBy || "";
+    if (Array.isArray(orderBy))
+      orderBy = orderBy[0] || "";
+    const orderByParts = orderBy.split("_");
+    orderByProperties.push(orderByParts.slice(0, -1).join("."));
+    orderByDirections.push(orderByParts.slice(-1)[0]);
+  } else if (args.orderByArray) {
+    for (const order of args.orderByArray) {
+      const [property, direction] = order.split("_");
+      orderByProperties.push(property);
+      orderByDirections.push(direction);
+    }
+  }
   let maxItemCount = args.maxItemCount;
   maxItemCount = maxItemCount || 100;
-  return { where, orderByProperty, orderByDirection, maxItemCount, cursor: args.cursor, pick: args.include };
+  return { where, orderByProperties, orderByDirections, maxItemCount, cursor: args.cursor, pick: args.include };
 }
 
 const computedPresets = {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { E as EntityDecoratorArgs, U as UiDecoratorArgs, a as UiFieldDecoratorArgs, V as ValidateEntityDecoratorArgs, b as ValidateFieldDecoratorArgs, F as FieldDecoratorArgs, C as ComputedDecoratorArgs, S as Schema, D as DriverConstructor, c as Driver, d as ComputedContext, R as RadsRequestContext, e as CreateRadsDbArgs, f as CreateRadsDbClientArgs } from './types-9c3659f0.js';
-export { N as Change, x as ComputedContextGlobal, k as CreateRadsArgsDrivers, m as CreateRadsDbArgsNormalized, aj as DeepKeys, ae as DeepPartial, ac as DeepPartialWithNulls, ad as DeepPartialWithNullsItem, ak as EntityMethods, w as EnumDefinition, v as FieldDefinition, I as FileSystemNode, u as FileUploadArgs, q as FileUploadDriver, p as FileUploadResult, B as GenerateClientNormalizedOptions, A as GenerateClientOptions, a8 as Get, _ as GetAggArgs, $ as GetAggArgsAgg, a2 as GetAggArgsAny, a5 as GetAggResponse, Z as GetArgs, a1 as GetArgsAny, a4 as GetArgsInclude, O as GetManyArgs, a0 as GetManyArgsAny, a6 as GetManyResponse, a7 as GetResponse, a9 as GetResponseInclude, aa as GetResponseIncludeSelect, ab as GetResponseNoInclude, s as GetRestRoutesArgs, G as GetRestRoutesOptions, t as GetRestRoutesResponse, ag as InverseRelation, M as MinimalDriver, ai as Put, ah as PutArgs, P as PutEffect, g as RadsConfig, h as RadsConfigDataSource, r as RadsDbInstance, L as RadsFeature, y as RadsHookDoc, K as RadsUiSlotDefinition, J as RadsUiSlotName, H as RadsVitePluginOptions, af as Relation, i as RequiredFields, l as RestDriverOptions, z as RestFileUploadDriverOptions, n as SchemaLoadResult, o as SchemaValidators, T as TypeDefinition, j as ValidateStringDecoratorArgs, Q as VerifyManyArgs, a3 as VerifyManyArgsAny, X as VerifyManyResponse, Y as Where, W as WhereJsonContains } from './types-9c3659f0.js';
+import { E as EntityDecoratorArgs, U as UiDecoratorArgs, a as UiFieldDecoratorArgs, V as ValidateEntityDecoratorArgs, b as ValidateFieldDecoratorArgs, F as FieldDecoratorArgs, C as ComputedDecoratorArgs, S as Schema, D as DriverConstructor, c as Driver, d as ComputedContext, R as RadsRequestContext, e as CreateRadsDbArgs, f as CreateRadsDbClientArgs } from './types-9cb9d6e7.js';
+export { N as Change, x as ComputedContextGlobal, k as CreateRadsArgsDrivers, m as CreateRadsDbArgsNormalized, aj as DeepKeys, ae as DeepPartial, ac as DeepPartialWithNulls, ad as DeepPartialWithNullsItem, ak as EntityMethods, w as EnumDefinition, v as FieldDefinition, I as FileSystemNode, u as FileUploadArgs, q as FileUploadDriver, p as FileUploadResult, B as GenerateClientNormalizedOptions, A as GenerateClientOptions, a8 as Get, _ as GetAggArgs, $ as GetAggArgsAgg, a2 as GetAggArgsAny, a5 as GetAggResponse, Z as GetArgs, a1 as GetArgsAny, a4 as GetArgsInclude, O as GetManyArgs, a0 as GetManyArgsAny, a6 as GetManyResponse, a7 as GetResponse, a9 as GetResponseInclude, aa as GetResponseIncludeSelect, ab as GetResponseNoInclude, s as GetRestRoutesArgs, G as GetRestRoutesOptions, t as GetRestRoutesResponse, ag as InverseRelation, M as MinimalDriver, ai as Put, ah as PutArgs, P as PutEffect, g as RadsConfig, h as RadsConfigDataSource, r as RadsDbInstance, L as RadsFeature, y as RadsHookDoc, K as RadsUiSlotDefinition, J as RadsUiSlotName, H as RadsVitePluginOptions, af as Relation, i as RequiredFields, l as RestDriverOptions, z as RestFileUploadDriverOptions, n as SchemaLoadResult, o as SchemaValidators, T as TypeDefinition, j as ValidateStringDecoratorArgs, Q as VerifyManyArgs, a3 as VerifyManyArgsAny, X as VerifyManyResponse, Y as Where, W as WhereJsonContains } from './types-9cb9d6e7.js';
 import { RadsDb } from '_rads-db';
 export { RadsDb } from '_rads-db';
 

package/dist/index.mjs

@@ -261,14 +261,14 @@ function queryArray(array, args) {
   if (!array)
     return array;
   let result = array;
-  const { where, orderByProperty, orderByDirection, maxItemCount, cursor } = prepareArgs(args);
+  const { where, orderByProperties, orderByDirections, maxItemCount, cursor } = prepareArgs(args);
   const startIndex = Number(cursor) || 0;
   const endIndex = startIndex + maxItemCount;
   const f = getFilter(where);
   if (f)
     result = result.filter(f);
-  if (orderByProperty)
-    result = _.orderBy(result, [orderByProperty], [orderByDirection]);
+  if (orderByProperties)
+    result = _.orderBy(result, orderByProperties, orderByDirections);
   if (maxItemCount)
     result = result.slice(startIndex, endIndex);
   const newCursor = endIndex >= array.length ? null : endIndex;
@@ -355,15 +355,25 @@ function getFilterInner(operator, whereVal, name, namePrefix) {
 function prepareArgs(args) {
   args = args || {};
   const where = { ...args.where };
-  let orderBy = args.orderBy || "";
-  if (Array.isArray(orderBy))
-    orderBy = orderBy[0] || "";
-  const orderByParts = orderBy.split("_");
-  const orderByProperty = orderByParts.slice(0, -1).join(".");
-  const orderByDirection = orderByParts.slice(-1)[0];
+  const orderByProperties = [];
+  const orderByDirections = [];
+  if (args.orderBy) {
+    let orderBy = args.orderBy || "";
+    if (Array.isArray(orderBy))
+      orderBy = orderBy[0] || "";
+    const orderByParts = orderBy.split("_");
+    orderByProperties.push(orderByParts.slice(0, -1).join("."));
+    orderByDirections.push(orderByParts.slice(-1)[0]);
+  } else if (args.orderByArray) {
+    for (const order of args.orderByArray) {
+      const [property, direction] = order.split("_");
+      orderByProperties.push(property);
+      orderByDirections.push(direction);
+    }
+  }
   let maxItemCount = args.maxItemCount;
   maxItemCount = maxItemCount || 100;
-  return { where, orderByProperty, orderByDirection, maxItemCount, cursor: args.cursor, pick: args.include };
+  return { where, orderByProperties, orderByDirections, maxItemCount, cursor: args.cursor, pick: args.include };
 }
 
 const computedPresets = {

package/dist/{types-9c3659f0.d.ts → types-9cb9d6e7.d.ts}

@@ -8,6 +8,7 @@ interface GetManyArgs<EN extends keyof EntityMeta> extends GetArgs<EN> {
     cursor?: string | null;
     maxItemCount?: number;
     orderBy?: string;
+    orderByArray?: OrderBy<EntityMeta[EN]>;
 }
 interface VerifyManyArgs<EN extends keyof EntityMeta> extends GetManyArgs<EN> {
     recompute?: string[];
@@ -122,6 +123,14 @@ interface EntityMethods<E, EN extends keyof EntityMeta> {
     verifyMany<A extends VerifyManyArgs<EN>>(args?: A, ctx?: RadsRequestContext): MaybePromise$1<VerifyManyResponse>;
     verifyAll<A extends VerifyManyArgs<EN>>(args?: A, ctx?: RadsRequestContext): MaybePromise$1<Pick<VerifyManyResponse, 'correctCount' | 'incorrectCount'>>;
 }
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...0[]];
+type Primitive = string | number | boolean | symbol | null | undefined;
+type OrderByDeepKeys<T, Prefix extends string = '', MaxDepth extends number = 5, Depth extends number = MaxDepth> = Depth extends 0 ? '' : T extends Primitive ? Prefix extends '' ? never : Prefix : T extends object ? {
+    [K in keyof T]-?: K extends string | number ? OrderByDeepKeys<T[K], `${Prefix}${K & string}`, MaxDepth, Prev[Depth]> : never;
+}[keyof T] : never;
+type TrimEnd<T extends string, S extends string> = T extends `${infer R}${S}` ? R : T;
+type ValidOrderByKey<T> = TrimEnd<OrderByDeepKeys<T>, '.'>;
+type OrderBy<T> = Array<`${ValidOrderByKey<T>}_${'asc' | 'desc'}`>;
 
 interface RadsConfig {
     dataSources: Record<string, RadsConfigDataSource>;

package/drivers/azureCosmos.cjs

@@ -154,14 +154,7 @@ function getCosmosQuery(schema, entity, args) {
     schema,
     entity
   }, parameters, where)].filter(x => x);
-  let orderByClause = "";
-  if (args.orderBy) {
-    const orderByParts = args.orderBy.split("_");
-    const orderPropFromOrderBy = orderByParts.slice(0, -1).join(".");
-    const orderDirection = orderByParts.at(-1);
-    const orderProp = orderPropFromOrderBy === "value" ? `r["value"]` : `r.${orderPropFromOrderBy}`;
-    orderByClause = `order by ${orderProp} ${orderDirection}`;
-  }
+  const orderByClause = getCosmosOrderBy(args);
   let colums = "*";
   if (args.include?._pick) {
     colums = getCosmosSelectValue(args.include);
@@ -466,6 +459,28 @@ const operatorHandlers = {
     return `${namePrefix}${name} <= @${pn}`;
   }
 };
+function getCosmosOrderBy(args) {
+  let orderByClause = "";
+  if (args.orderByArray) {
+    orderByClause = `order by `;
+    const orderByColumns = [];
+    for (const order of args.orderByArray) {
+      orderByColumns.push(parseOrderBy(order));
+    }
+    orderByClause = orderByClause + orderByColumns.join(",");
+  } else if (args.orderBy) {
+    orderByClause = `order by ${parseOrderBy(args.orderBy)}`;
+  }
+  return orderByClause;
+}
+function parseOrderBy(order) {
+  const orderByParts = order.split("_");
+  const orderPropFromOrderBy = orderByParts.slice(0, -1).join(".");
+  const orderDirection = orderByParts.at(-1);
+  const orderProp = orderPropFromOrderBy === "value" ? `r["value"]` : `r.${orderPropFromOrderBy}`;
+  const ordr = `${orderProp} ${orderDirection}`;
+  return ordr;
+}
 function getCosmosQueryWhere(ctx, parameters, where, namePrefix = "r.", paramNamePrefix = "") {
   const whereClauses = [];
   for (const key in where) {

package/drivers/azureCosmos.mjs

@@ -110,14 +110,7 @@ function getCosmosQuery(schema, entity, args) {
     `r._partition = '${entity}'`,
     getCosmosQueryWhere({ schema, entity }, parameters, where)
   ].filter((x) => x);
-  let orderByClause = "";
-  if (args.orderBy) {
-    const orderByParts = args.orderBy.split("_");
-    const orderPropFromOrderBy = orderByParts.slice(0, -1).join(".");
-    const orderDirection = orderByParts.at(-1);
-    const orderProp = orderPropFromOrderBy === "value" ? `r["value"]` : `r.${orderPropFromOrderBy}`;
-    orderByClause = `order by ${orderProp} ${orderDirection}`;
-  }
+  const orderByClause = getCosmosOrderBy(args);
   let colums = "*";
   if (args.include?._pick) {
     colums = getCosmosSelectValue(args.include);
@@ -292,6 +285,28 @@ const operatorHandlers = {
     return `${namePrefix}${name} <= @${pn}`;
   }
 };
+function getCosmosOrderBy(args) {
+  let orderByClause = "";
+  if (args.orderByArray) {
+    orderByClause = `order by `;
+    const orderByColumns = [];
+    for (const order of args.orderByArray) {
+      orderByColumns.push(parseOrderBy(order));
+    }
+    orderByClause = orderByClause + orderByColumns.join(",");
+  } else if (args.orderBy) {
+    orderByClause = `order by ${parseOrderBy(args.orderBy)}`;
+  }
+  return orderByClause;
+}
+function parseOrderBy(order) {
+  const orderByParts = order.split("_");
+  const orderPropFromOrderBy = orderByParts.slice(0, -1).join(".");
+  const orderDirection = orderByParts.at(-1);
+  const orderProp = orderPropFromOrderBy === "value" ? `r["value"]` : `r.${orderPropFromOrderBy}`;
+  const ordr = `${orderProp} ${orderDirection}`;
+  return ordr;
+}
 function getCosmosQueryWhere(ctx, parameters, where, namePrefix = "r.", paramNamePrefix = "") {
   const whereClauses = [];
   for (const key in where) {

package/drivers/memory.cjs

@@ -141,8 +141,8 @@ function queryArray(array, args) {
   let result = array;
   const {
     where,
-    orderByProperty,
-    orderByDirection,
+    orderByProperties,
+    orderByDirections,
     maxItemCount,
     cursor
   } = prepareArgs(args);
@@ -150,7 +150,7 @@ function queryArray(array, args) {
   const endIndex = startIndex + maxItemCount;
   const f = getFilter(where);
   if (f) result = result.filter(f);
-  if (orderByProperty) result = _lodash.default.orderBy(result, [orderByProperty], [orderByDirection]);
+  if (orderByProperties) result = _lodash.default.orderBy(result, orderByProperties, orderByDirections);
   if (maxItemCount) result = result.slice(startIndex, endIndex);
   const newCursor = endIndex >= array.length ? null : endIndex;
   return {
@@ -231,17 +231,27 @@ function prepareArgs(args) {
   const where = {
     ...args.where
   };
-  let orderBy = args.orderBy || "";
-  if (Array.isArray(orderBy)) orderBy = orderBy[0] || "";
-  const orderByParts = orderBy.split("_");
-  const orderByProperty = orderByParts.slice(0, -1).join(".");
-  const orderByDirection = orderByParts.slice(-1)[0];
+  const orderByProperties = [];
+  const orderByDirections = [];
+  if (args.orderBy) {
+    let orderBy = args.orderBy || "";
+    if (Array.isArray(orderBy)) orderBy = orderBy[0] || "";
+    const orderByParts = orderBy.split("_");
+    orderByProperties.push(orderByParts.slice(0, -1).join("."));
+    orderByDirections.push(orderByParts.slice(-1)[0]);
+  } else if (args.orderByArray) {
+    for (const order of args.orderByArray) {
+      const [property, direction] = order.split("_");
+      orderByProperties.push(property);
+      orderByDirections.push(direction);
+    }
+  }
   let maxItemCount = args.maxItemCount;
   maxItemCount = maxItemCount || 100;
   return {
     where,
-    orderByProperty,
-    orderByDirection,
+    orderByProperties,
+    orderByDirections,
     maxItemCount,
     cursor: args.cursor,
     pick: args.include

package/drivers/memory.mjs

@@ -115,12 +115,12 @@ export function getAggFromArray(array, args) {
 export function queryArray(array, args) {
   if (!array) return array;
   let result = array;
-  const { where, orderByProperty, orderByDirection, maxItemCount, cursor } = prepareArgs(args);
+  const { where, orderByProperties, orderByDirections, maxItemCount, cursor } = prepareArgs(args);
   const startIndex = Number(cursor) || 0;
   const endIndex = startIndex + maxItemCount;
   const f = getFilter(where);
   if (f) result = result.filter(f);
-  if (orderByProperty) result = _.orderBy(result, [orderByProperty], [orderByDirection]);
+  if (orderByProperties) result = _.orderBy(result, orderByProperties, orderByDirections);
   if (maxItemCount) result = result.slice(startIndex, endIndex);
   const newCursor = endIndex >= array.length ? null : endIndex;
   return { nodes: _.cloneDeep(result), cursor: newCursor?.toString() || null };
@@ -196,12 +196,22 @@ function getFilterInner(operator, whereVal, name, namePrefix) {
 function prepareArgs(args) {
   args = args || {};
   const where = { ...args.where };
-  let orderBy = args.orderBy || "";
-  if (Array.isArray(orderBy)) orderBy = orderBy[0] || "";
-  const orderByParts = orderBy.split("_");
-  const orderByProperty = orderByParts.slice(0, -1).join(".");
-  const orderByDirection = orderByParts.slice(-1)[0];
+  const orderByProperties = [];
+  const orderByDirections = [];
+  if (args.orderBy) {
+    let orderBy = args.orderBy || "";
+    if (Array.isArray(orderBy)) orderBy = orderBy[0] || "";
+    const orderByParts = orderBy.split("_");
+    orderByProperties.push(orderByParts.slice(0, -1).join("."));
+    orderByDirections.push(orderByParts.slice(-1)[0]);
+  } else if (args.orderByArray) {
+    for (const order of args.orderByArray) {
+      const [property, direction] = order.split("_");
+      orderByProperties.push(property);
+      orderByDirections.push(direction);
+    }
+  }
   let maxItemCount = args.maxItemCount;
   maxItemCount = maxItemCount || 100;
-  return { where, orderByProperty, orderByDirection, maxItemCount, cursor: args.cursor, pick: args.include };
+  return { where, orderByProperties, orderByDirections, maxItemCount, cursor: args.cursor, pick: args.include };
 }

package/features/eventSourcing.cjs

@@ -7,27 +7,27 @@ Object.defineProperty(exports, "__esModule", {
 var _lodash = _interopRequireDefault(require("lodash"));
 var _radsDb = require("rads-db");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-var _default = () => {
+var _default = options => {
   return {
     name: "eventSourcing",
     init(db, context) {
-      verifyEventSourcingSetup(context.schema, context.effects);
+      verifyEventSourcingSetup(context.schema, context.effects, options || {});
     }
   };
 };
 module.exports = _default;
-function verifyEventSourcingSetup(schema, effects) {
+function verifyEventSourcingSetup(schema, effects, options) {
   for (const entityName in schema) {
     if (!schema[entityName].decorators.entity) continue;
     if (schema[entityName].decorators.precomputed?.preset !== "eventSourcing") continue;
     const eventEntityName = `${entityName}Event`;
     const aggregateRelationField = _lodash.default.lowerFirst(entityName);
     validateEventSourcingSetup(schema, entityName, eventEntityName, aggregateRelationField);
-    const effect = getEffectFor(entityName, aggregateRelationField, eventEntityName, schema);
+    const effect = getEffectFor(entityName, aggregateRelationField, eventEntityName, schema, options);
     effects[eventEntityName].push(effect);
   }
 }
-function getEffectFor(entityName, aggregateRelationField, eventEntityName, schema) {
+function getEffectFor(entityName, aggregateRelationField, eventEntityName, schema, options) {
   return {
     async beforePut(context, docs, ctx) {
       const docsByAggId = {};
@@ -62,7 +62,10 @@ function getEffectFor(entityName, aggregateRelationField, eventEntityName, schem
       const existingAggregatesById = _lodash.default.keyBy(existingAggregates, "id");
       const result = [];
       for (const aggId in docsByAggId) {
-        const events = _lodash.default.orderBy([...docsByAggId[aggId], ...(existingEventsByAggId[aggId] || [])], ["date"], "asc");
+        let events = _lodash.default.orderBy([...docsByAggId[aggId], ...(existingEventsByAggId[aggId] || [])], ["date"], "asc");
+        if (options.applyEventIf) {
+          events = events.filter(ev => options.applyEventIf(ev, context, ctx));
+        }
         if (events[0].type !== "creation") throw new Error(`First event must have type = "creation". (type: ${events[0].type}, id: ${events[0].id})`);
         if (events.slice(1).some(ev => ev.type === "creation")) {
           throw new Error(`Only first event may have type = "creation"`);

package/features/eventSourcing.d.ts

@@ -1,3 +1,6 @@
-import type { RadsFeature } from '@/types';
-declare const _default: () => RadsFeature;
+import type { ComputedContext, RadsFeature, RadsRequestContext } from '@/types';
+export interface EventSourcingFeatureOptions {
+    applyEventIf?: (event: any, context: ComputedContext, ctx: RadsRequestContext) => boolean;
+}
+declare const _default: (options?: EventSourcingFeatureOptions) => RadsFeature;
 export default _default;

package/features/eventSourcing.mjs

@@ -1,25 +1,25 @@
 import _ from "lodash";
 import { cleanUndefinedAndNull, diff, handlePrecomputed, merge } from "rads-db";
-export default () => {
+export default (options) => {
   return {
     name: "eventSourcing",
     init(db, context) {
-      verifyEventSourcingSetup(context.schema, context.effects);
+      verifyEventSourcingSetup(context.schema, context.effects, options || {});
     }
   };
 };
-function verifyEventSourcingSetup(schema, effects) {
+function verifyEventSourcingSetup(schema, effects, options) {
   for (const entityName in schema) {
     if (!schema[entityName].decorators.entity) continue;
     if (schema[entityName].decorators.precomputed?.preset !== "eventSourcing") continue;
     const eventEntityName = `${entityName}Event`;
     const aggregateRelationField = _.lowerFirst(entityName);
     validateEventSourcingSetup(schema, entityName, eventEntityName, aggregateRelationField);
-    const effect = getEffectFor(entityName, aggregateRelationField, eventEntityName, schema);
+    const effect = getEffectFor(entityName, aggregateRelationField, eventEntityName, schema, options);
     effects[eventEntityName].push(effect);
   }
 }
-function getEffectFor(entityName, aggregateRelationField, eventEntityName, schema) {
+function getEffectFor(entityName, aggregateRelationField, eventEntityName, schema, options) {
   return {
     async beforePut(context, docs, ctx) {
       const docsByAggId = {};
@@ -52,7 +52,10 @@ function getEffectFor(entityName, aggregateRelationField, eventEntityName, schem
       const existingAggregatesById = _.keyBy(existingAggregates, "id");
       const result = [];
       for (const aggId in docsByAggId) {
-        const events = _.orderBy([...docsByAggId[aggId], ...existingEventsByAggId[aggId] || []], ["date"], "asc");
+        let events = _.orderBy([...docsByAggId[aggId], ...existingEventsByAggId[aggId] || []], ["date"], "asc");
+        if (options.applyEventIf) {
+          events = events.filter((ev) => options.applyEventIf(ev, context, ctx));
+        }
         if (events[0].type !== "creation")
           throw new Error(`First event must have type = "creation". (type: ${events[0].type}, id: ${events[0].id})`);
         if (events.slice(1).some((ev) => ev.type === "creation")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rads-db",
-  "version": "3.1.11",
+  "version": "3.1.13",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "author": "",
   "license": "ISC",