rads-db 3.2.18 → 3.2.21

package/dist/config.cjs

@@ -459,7 +459,8 @@ function verifyDefaultValueType(field, ctx2) {
       throw new TypeError(`Default value type is different from field type: '${type}'`);
     }
   } else {
-    if (supportedPrimitiveTypes.includes(type) && getPrimitiveTypeFromDefaultValue(defaultValue2) !== type) {
+    const normalizedType = type.startsWith("Record<") ? "object" : type;
+    if (supportedPrimitiveTypes.includes(type) && getPrimitiveTypeFromDefaultValue(defaultValue2) !== normalizedType) {
       throw new Error(`Default value type is different from field type: '${type}'`);
     }
     if (!ctx2.result[type] && ctx2.typeNodesMap[type])

package/dist/config.mjs

@@ -451,7 +451,8 @@ function verifyDefaultValueType(field, ctx2) {
       throw new TypeError(`Default value type is different from field type: '${type}'`);
     }
   } else {
-    if (supportedPrimitiveTypes.includes(type) && getPrimitiveTypeFromDefaultValue(defaultValue2) !== type) {
+    const normalizedType = type.startsWith("Record<") ? "object" : type;
+    if (supportedPrimitiveTypes.includes(type) && getPrimitiveTypeFromDefaultValue(defaultValue2) !== normalizedType) {
       throw new Error(`Default value type is different from field type: '${type}'`);
     }
     if (!ctx2.result[type] && ctx2.typeNodesMap[type])

package/features/eventSourcing.cjs

@@ -27,24 +27,74 @@ function verifyEventSourcingSetup(schema, effects, options) {
     effects[eventEntityName].push(effect);
   }
 }
+function groupEventsByAggId(docs, aggregateRelationField, eventEntityName) {
+  const docsByAggId = {};
+  const docsById = {};
+  for (const d of docs) {
+    if (!d.doc.id || docsById[d.doc.id]) continue;
+    docsById[d.doc.id] = d.doc;
+    const aggId = d.doc[aggregateRelationField].id;
+    if (!aggId) throw new Error(`Missing ${eventEntityName}.${aggregateRelationField}.id`);
+    if (d.oldDoc && aggId !== d.oldDoc[aggregateRelationField].id) {
+      throw new Error(`Field ${eventEntityName}.${aggregateRelationField}.id cannot be changed`);
+    }
+    if (!docsByAggId[aggId]) docsByAggId[aggId] = [];
+    docsByAggId[aggId].push(d.doc);
+  }
+  return {
+    docsByAggId,
+    docsById
+  };
+}
+function applyEventToAggregate(ev, aggDoc, aggId, p) {
+  const mergedDoc = (0, _radsDb.merge)(aggDoc || {
+    id: aggId
+  }, ev.change);
+  const newAggDoc = p.context.validators[p.entityName](mergedDoc);
+  if (!p.options.freezeEvent?.(ev, p.context, p.ctx)) {
+    ev.beforeChange = aggDoc;
+    const originalChange = ev.change;
+    ev.change = (0, _radsDb.diff)(newAggDoc, aggDoc);
+    handleKeepHistory(p.schema[p.entityName].keepHistoryFields, originalChange, ev);
+  }
+  if (p.ctx.skipPrecomputed) {
+    for (const field of p.schema[p.entityName].precomputedFields || []) {
+      if (p.ctx.skipPrecomputed.includes(field) && mergedDoc[field] !== void 0) {
+        newAggDoc[field] = mergedDoc[field];
+      }
+    }
+  }
+  return newAggDoc;
+}
+function buildAggregateFromEvents(events, aggId, docsById, existingAggregatesById, p) {
+  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"`);
+  }
+  let aggDoc;
+  for (const ev of events) {
+    const newAggDoc = applyEventToAggregate(ev, aggDoc, aggId, p);
+    if (p.options.applyEventIf && !p.options.applyEventIf(ev, p.context, p.ctx)) continue;
+    aggDoc = newAggDoc;
+    if (!p.context.options.keepNulls) (0, _radsDb.cleanEntity)(aggDoc);
+  }
+  if (!aggDoc) return null;
+  return {
+    aggDoc,
+    events,
+    updatedEvents: events.filter(ev => docsById[ev.id]),
+    oldAggDoc: existingAggregatesById[aggDoc.id]
+  };
+}
 function getEffectFor(entityName, aggregateRelationField, eventEntityName, schema, options) {
   return {
     featureName: "eventSourcing",
     async beforePut(context, docs, ctx) {
-      const docsByAggId = {};
-      const docsById = {};
-      for (const d of docs) {
-        if (!d.doc.id || docsById[d.doc.id]) continue;
-        docsById[d.doc.id] = d.doc;
-        const aggId = d.doc[aggregateRelationField].id;
-        if (!aggId) throw new Error(`Missing ${eventEntityName}.${aggregateRelationField}.id`);
-        if (d.oldDoc && aggId !== d.oldDoc[aggregateRelationField].id) {
-          throw new Error(`Field ${eventEntityName}.${aggregateRelationField}.id cannot be changed`);
-        }
-        if (!docsByAggId[aggId]) docsByAggId[aggId] = [];
-        docsByAggId[aggId].push(d.doc);
-      }
-      const existingEvents = await context.drivers[eventEntityName].getAll({
+      const {
+        docsByAggId,
+        docsById
+      } = groupEventsByAggId(docs, aggregateRelationField, eventEntityName);
+      const [existingEvents, existingAggregates] = await Promise.all([context.drivers[eventEntityName].getAll({
         where: {
           [aggregateRelationField]: {
             id_in: _lodash.default.keys(docsByAggId)
@@ -53,45 +103,24 @@ function getEffectFor(entityName, aggregateRelationField, eventEntityName, schem
             id_in: docs.map(d => d.doc.id)
           }
         }
-      }, ctx);
-      const existingEventsByAggId = _lodash.default.groupBy(existingEvents, ev => ev[aggregateRelationField].id);
-      const existingAggregates = await context.drivers[entityName].getAll({
+      }, ctx), context.drivers[entityName].getAll({
         where: {
           id_in: _lodash.default.keys(docsByAggId)
         }
-      }, ctx);
+      }, ctx)]);
+      const existingEventsByAggId = _lodash.default.groupBy(existingEvents, ev => ev[aggregateRelationField].id);
       const existingAggregatesById = _lodash.default.keyBy(existingAggregates, "id");
-      const result = [];
-      for (const aggId in docsByAggId) {
+      const processor = {
+        context,
+        entityName,
+        schema,
+        options,
+        ctx
+      };
+      const result = _lodash.default.compact(_lodash.default.keys(docsByAggId).map(aggId => {
         const events = _lodash.default.orderBy([...docsByAggId[aggId], ...(existingEventsByAggId[aggId] || [])], ["date"], "asc");
-        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"`);
-        }
-        let aggDoc;
-        for (const ev of events) {
-          const newAggDoc = context.validators[entityName]((0, _radsDb.merge)(aggDoc || {
-            id: aggId
-          }, ev.change));
-          ev.beforeChange = aggDoc;
-          const originalChange = ev.change;
-          ev.change = (0, _radsDb.diff)(newAggDoc, aggDoc);
-          handleKeepHistory(schema[entityName].keepHistoryFields, originalChange, ev);
-          if (options.applyEventIf && !options.applyEventIf(ev, context, ctx)) {
-            continue;
-          }
-          aggDoc = newAggDoc;
-          if (!context.options.keepNulls) (0, _radsDb.cleanEntity)(aggDoc);
-        }
-        if (aggDoc) {
-          result.push({
-            aggDoc,
-            events,
-            updatedEvents: events.filter(ev => docsById[ev.id]),
-            oldAggDoc: existingAggregatesById[aggDoc.id]
-          });
-        }
-      }
+        return buildAggregateFromEvents(events, aggId, docsById, existingAggregatesById, processor);
+      }));
       await (0, _radsDb.handlePrecomputed)(
       // @ts-expect-error TODO wrong types
       {
@@ -105,7 +134,7 @@ function getEffectFor(entityName, aggregateRelationField, eventEntityName, schem
       })), ctx);
       return result;
     },
-    async afterPut(context, docs, beforePutResult, ctx) {
+    async afterPut(context, _docs, beforePutResult, ctx) {
       const aggs = beforePutResult.map(d => d.aggDoc);
       const hookItems = beforePutResult.map(v => ({
         doc: v.aggDoc,

package/features/eventSourcing.d.ts

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

package/features/eventSourcing.mjs

@@ -19,68 +19,87 @@ function verifyEventSourcingSetup(schema, effects, options) {
     effects[eventEntityName].push(effect);
   }
 }
+function groupEventsByAggId(docs, aggregateRelationField, eventEntityName) {
+  const docsByAggId = {};
+  const docsById = {};
+  for (const d of docs) {
+    if (!d.doc.id || docsById[d.doc.id]) continue;
+    docsById[d.doc.id] = d.doc;
+    const aggId = d.doc[aggregateRelationField].id;
+    if (!aggId) throw new Error(`Missing ${eventEntityName}.${aggregateRelationField}.id`);
+    if (d.oldDoc && aggId !== d.oldDoc[aggregateRelationField].id) {
+      throw new Error(`Field ${eventEntityName}.${aggregateRelationField}.id cannot be changed`);
+    }
+    if (!docsByAggId[aggId]) docsByAggId[aggId] = [];
+    docsByAggId[aggId].push(d.doc);
+  }
+  return { docsByAggId, docsById };
+}
+function applyEventToAggregate(ev, aggDoc, aggId, p) {
+  const mergedDoc = merge(aggDoc || { id: aggId }, ev.change);
+  const newAggDoc = p.context.validators[p.entityName](mergedDoc);
+  if (!p.options.freezeEvent?.(ev, p.context, p.ctx)) {
+    ev.beforeChange = aggDoc;
+    const originalChange = ev.change;
+    ev.change = diff(newAggDoc, aggDoc);
+    handleKeepHistory(p.schema[p.entityName].keepHistoryFields, originalChange, ev);
+  }
+  if (p.ctx.skipPrecomputed) {
+    for (const field of p.schema[p.entityName].precomputedFields || []) {
+      if (p.ctx.skipPrecomputed.includes(field) && mergedDoc[field] !== void 0) {
+        newAggDoc[field] = mergedDoc[field];
+      }
+    }
+  }
+  return newAggDoc;
+}
+function buildAggregateFromEvents(events, aggId, docsById, existingAggregatesById, p) {
+  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"`);
+  }
+  let aggDoc;
+  for (const ev of events) {
+    const newAggDoc = applyEventToAggregate(ev, aggDoc, aggId, p);
+    if (p.options.applyEventIf && !p.options.applyEventIf(ev, p.context, p.ctx)) continue;
+    aggDoc = newAggDoc;
+    if (!p.context.options.keepNulls) cleanEntity(aggDoc);
+  }
+  if (!aggDoc) return null;
+  return {
+    aggDoc,
+    events,
+    updatedEvents: events.filter((ev) => docsById[ev.id]),
+    oldAggDoc: existingAggregatesById[aggDoc.id]
+  };
+}
 function getEffectFor(entityName, aggregateRelationField, eventEntityName, schema, options) {
   return {
     featureName: "eventSourcing",
     async beforePut(context, docs, ctx) {
-      const docsByAggId = {};
-      const docsById = {};
-      for (const d of docs) {
-        if (!d.doc.id || docsById[d.doc.id]) continue;
-        docsById[d.doc.id] = d.doc;
-        const aggId = d.doc[aggregateRelationField].id;
-        if (!aggId) throw new Error(`Missing ${eventEntityName}.${aggregateRelationField}.id`);
-        if (d.oldDoc && aggId !== d.oldDoc[aggregateRelationField].id) {
-          throw new Error(`Field ${eventEntityName}.${aggregateRelationField}.id cannot be changed`);
-        }
-        if (!docsByAggId[aggId]) docsByAggId[aggId] = [];
-        docsByAggId[aggId].push(d.doc);
-      }
-      const existingEvents = await context.drivers[eventEntityName].getAll(
-        {
-          where: {
-            [aggregateRelationField]: { id_in: _.keys(docsByAggId) },
-            _not: { id_in: docs.map((d) => d.doc.id) }
-          }
-        },
-        ctx
-      );
+      const { docsByAggId, docsById } = groupEventsByAggId(docs, aggregateRelationField, eventEntityName);
+      const [existingEvents, existingAggregates] = await Promise.all([
+        context.drivers[eventEntityName].getAll(
+          {
+            where: {
+              [aggregateRelationField]: { id_in: _.keys(docsByAggId) },
+              _not: { id_in: docs.map((d) => d.doc.id) }
+            }
+          },
+          ctx
+        ),
+        context.drivers[entityName].getAll({ where: { id_in: _.keys(docsByAggId) } }, ctx)
+      ]);
       const existingEventsByAggId = _.groupBy(existingEvents, (ev) => ev[aggregateRelationField].id);
-      const existingAggregates = await context.drivers[entityName].getAll(
-        { where: { id_in: _.keys(docsByAggId) } },
-        ctx
-      );
       const existingAggregatesById = _.keyBy(existingAggregates, "id");
-      const result = [];
-      for (const aggId in docsByAggId) {
-        const events = _.orderBy([...docsByAggId[aggId], ...existingEventsByAggId[aggId] || []], ["date"], "asc");
-        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"`);
-        }
-        let aggDoc;
-        for (const ev of events) {
-          const newAggDoc = context.validators[entityName](merge(aggDoc || { id: aggId }, ev.change));
-          ev.beforeChange = aggDoc;
-          const originalChange = ev.change;
-          ev.change = diff(newAggDoc, aggDoc);
-          handleKeepHistory(schema[entityName].keepHistoryFields, originalChange, ev);
-          if (options.applyEventIf && !options.applyEventIf(ev, context, ctx)) {
-            continue;
-          }
-          aggDoc = newAggDoc;
-          if (!context.options.keepNulls) cleanEntity(aggDoc);
-        }
-        if (aggDoc) {
-          result.push({
-            aggDoc,
-            events,
-            updatedEvents: events.filter((ev) => docsById[ev.id]),
-            oldAggDoc: existingAggregatesById[aggDoc.id]
-          });
-        }
-      }
+      const processor = { context, entityName, schema, options, ctx };
+      const result = _.compact(
+        _.keys(docsByAggId).map((aggId) => {
+          const events = _.orderBy([...docsByAggId[aggId], ...existingEventsByAggId[aggId] || []], ["date"], "asc");
+          return buildAggregateFromEvents(events, aggId, docsById, existingAggregatesById, processor);
+        })
+      );
       await handlePrecomputed(
         // @ts-expect-error TODO wrong types
         { ...context, typeName: entityName },
@@ -89,7 +108,7 @@ function getEffectFor(entityName, aggregateRelationField, eventEntityName, schem
       );
       return result;
     },
-    async afterPut(context, docs, beforePutResult, ctx) {
+    async afterPut(context, _docs, beforePutResult, ctx) {
       const aggs = beforePutResult.map((d) => d.aggDoc);
       const hookItems = beforePutResult.map((v) => ({
         doc: v.aggDoc,

package/package.json

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