rads-db 3.1.14 → 3.1.16

package/dist/index.cjs

@@ -1275,10 +1275,21 @@ const restApi = (options) => (schema, entity) => {
     }
     return responseJson;
   }
-  const { handlePlural } = schema[entity] || {};
-  if (!handlePlural) throw new Error(`Entity ${entity} was not found in schema`);
+  const { handlePlural, handle } = schema[entity] || {};
+  if (!handlePlural || !handle) throw new Error(`Entity ${entity} was not found in schema`);
   const instance = {
     driverName: "restApi",
+    async getAgg(args, ctx) {
+      args = args || {};
+      const url = `${opts.baseUrl}/${handle}/agg`;
+      const fetchOptions = {
+        method: "POST",
+        body: JSON.stringify(args),
+        headers: { "Content-Type": "application/json" }
+      };
+      fetchOptions.headers = { ...fetchOptions.headers, ...opts.getHeaders({ args, context: ctx }) };
+      return await fetchInner(url, fetchOptions);
+    },
     async getMany(args, ctx) {
       args = args || {};
       const url = `${opts.baseUrl}/${handlePlural}`;

package/dist/index.mjs

@@ -1268,10 +1268,21 @@ const restApi = (options) => (schema, entity) => {
     }
     return responseJson;
   }
-  const { handlePlural } = schema[entity] || {};
-  if (!handlePlural) throw new Error(`Entity ${entity} was not found in schema`);
+  const { handlePlural, handle } = schema[entity] || {};
+  if (!handlePlural || !handle) throw new Error(`Entity ${entity} was not found in schema`);
   const instance = {
     driverName: "restApi",
+    async getAgg(args, ctx) {
+      args = args || {};
+      const url = `${opts.baseUrl}/${handle}/agg`;
+      const fetchOptions = {
+        method: "POST",
+        body: JSON.stringify(args),
+        headers: { "Content-Type": "application/json" }
+      };
+      fetchOptions.headers = { ...fetchOptions.headers, ...opts.getHeaders({ args, context: ctx }) };
+      return await fetchInner(url, fetchOptions);
+    },
     async getMany(args, ctx) {
       args = args || {};
       const url = `${opts.baseUrl}/${handlePlural}`;

package/drivers/azureCosmos.cjs

@@ -97,6 +97,40 @@ var _default = options => (schema, entity) => {
     driverName: "azureCosmos",
     client,
     getMany,
+    async getAgg(args, ctx) {
+      args = args || {};
+      const where = args.where || {};
+      const {
+        query,
+        parameters
+      } = getCosmosQuery(schema, entity, args);
+      let cursor;
+      const response = client.items.query({
+        query,
+        parameters: Object.keys(parameters).map(k => ({
+          name: `@${k}`,
+          value: parameters[k]
+        }))
+      }, {
+        continuationToken: args.cursor || void 0,
+        continuationTokenLimitInKB: 4,
+        maxItemCount: args.maxItemCount
+      });
+      const page = await response.fetchNext();
+      let result = {};
+      for (const r of page.resources) {
+        result = {
+          ...result,
+          ...r
+        };
+      }
+      ctx?.log?.({
+        charge: page.requestCharge,
+        request: query
+      });
+      if (page.continuationToken) result.cursor = page.continuationToken;
+      return result;
+    },
     async deleteMany(args, ctx) {
       const {
         nodes,
@@ -155,11 +189,32 @@ function getCosmosQuery(schema, entity, args) {
     entity
   }, parameters, where)].filter(x => x);
   const orderByClause = getCosmosOrderBy(args);
-  let colums = "*";
+  let columns = "*";
   if (args.include?._pick) {
-    colums = getCosmosSelectValue(args.include);
+    columns = getCosmosSelectValue(args.include);
+  }
+  if (args.agg) {
+    const columnsArray = [];
+    for (const key of args.agg) {
+      const [field, aggOp] = key.split("_");
+      if (aggOp === "count") {
+        columnsArray.push("COUNT(1) AS _count");
+      }
+      if (aggOp === "max" && field) {
+        columnsArray.push(`MAX(r["${field}"]) AS ${field}_max`);
+      }
+      if (aggOp === "min" && field) {
+        columnsArray.push(`MIN(r["${field}"]) AS ${field}_min`);
+      }
+      if (aggOp === "sum" && field) {
+        columnsArray.push(`SUM(r["${field}"]) AS ${field}_sum`);
+      }
+    }
+    if (columnsArray.length) {
+      columns = columnsArray.join(", ");
+    }
   }
-  const query = `select ${colums} from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
+  const query = `select ${columns} from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
   return {
     query,
     parameters
@@ -588,7 +643,20 @@ async function createDatabaseIfNotExists(options, client) {
 async function bulkSendWithRetry(client, chunkToSend) {
   const responses = [];
   for (let i = 0; i < 20; i++) {
-    const response = await client.items.bulk(chunkToSend);
+    let response;
+    try {
+      response = await client.items.bulk(chunkToSend);
+    } catch (e) {
+      const is429 = e?.message?.includes("cosmosdb-error-429");
+      if (is429) {
+        const delay2 = 50 + i * 100;
+        console.warn(`Db overloaded. Retrying after ${delay2}ms...`);
+        await new Promise(resolve => setTimeout(resolve, delay2));
+        continue;
+      } else {
+        throw e;
+      }
+    }
     const newChunkToSend = [];
     for (let i2 = 0; i2 < chunkToSend.length; i2++) {
       if (response[i2].statusCode !== 429) {

package/drivers/azureCosmos.mjs

@@ -64,6 +64,31 @@ export default (options) => (schema, entity) => {
     driverName: "azureCosmos",
     client,
     getMany,
+    async getAgg(args, ctx) {
+      args = args || {};
+      const where = args.where || {};
+      const { query, parameters } = getCosmosQuery(schema, entity, args);
+      let cursor;
+      const response = client.items.query(
+        {
+          query,
+          parameters: Object.keys(parameters).map((k) => ({ name: `@${k}`, value: parameters[k] }))
+        },
+        {
+          continuationToken: args.cursor || void 0,
+          continuationTokenLimitInKB: 4,
+          maxItemCount: args.maxItemCount
+        }
+      );
+      const page = await response.fetchNext();
+      let result = {};
+      for (const r of page.resources) {
+        result = { ...result, ...r };
+      }
+      ctx?.log?.({ charge: page.requestCharge, request: query });
+      if (page.continuationToken) result.cursor = page.continuationToken;
+      return result;
+    },
     async deleteMany(args, ctx) {
       const { nodes, cursor } = await getMany(args, ctx);
       for (const chunk of _.chunk(nodes, 100)) {
@@ -111,11 +136,32 @@ function getCosmosQuery(schema, entity, args) {
     getCosmosQueryWhere({ schema, entity }, parameters, where)
   ].filter((x) => x);
   const orderByClause = getCosmosOrderBy(args);
-  let colums = "*";
+  let columns = "*";
   if (args.include?._pick) {
-    colums = getCosmosSelectValue(args.include);
+    columns = getCosmosSelectValue(args.include);
+  }
+  if (args.agg) {
+    const columnsArray = [];
+    for (const key of args.agg) {
+      const [field, aggOp] = key.split("_");
+      if (aggOp === "count") {
+        columnsArray.push("COUNT(1) AS _count");
+      }
+      if (aggOp === "max" && field) {
+        columnsArray.push(`MAX(r["${field}"]) AS ${field}_max`);
+      }
+      if (aggOp === "min" && field) {
+        columnsArray.push(`MIN(r["${field}"]) AS ${field}_min`);
+      }
+      if (aggOp === "sum" && field) {
+        columnsArray.push(`SUM(r["${field}"]) AS ${field}_sum`);
+      }
+    }
+    if (columnsArray.length) {
+      columns = columnsArray.join(", ");
+    }
   }
-  const query = `select ${colums} from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
+  const query = `select ${columns} from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
   return { query, parameters };
 }
 const operatorHandlers = {
@@ -385,7 +431,20 @@ async function createDatabaseIfNotExists(options, client) {
 async function bulkSendWithRetry(client, chunkToSend) {
   const responses = [];
   for (let i = 0; i < 20; i++) {
-    const response = await client.items.bulk(chunkToSend);
+    let response;
+    try {
+      response = await client.items.bulk(chunkToSend);
+    } catch (e) {
+      const is429 = e?.message?.includes("cosmosdb-error-429");
+      if (is429) {
+        const delay2 = 50 + i * 100;
+        console.warn(`Db overloaded. Retrying after ${delay2}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, delay2));
+        continue;
+      } else {
+        throw e;
+      }
+    }
     const newChunkToSend = [];
     for (let i2 = 0; i2 < chunkToSend.length; i2++) {
       if (response[i2].statusCode !== 429) {

package/drivers/restApi.cjs

@@ -28,11 +28,31 @@ var _default = options => (schema, entity) => {
     return responseJson;
   }
   const {
-    handlePlural
+    handlePlural,
+    handle
   } = schema[entity] || {};
-  if (!handlePlural) throw new Error(`Entity ${entity} was not found in schema`);
+  if (!handlePlural || !handle) throw new Error(`Entity ${entity} was not found in schema`);
   const instance = {
     driverName: "restApi",
+    async getAgg(args, ctx) {
+      args = args || {};
+      const url = `${opts.baseUrl}/${handle}/agg`;
+      const fetchOptions = {
+        method: "POST",
+        body: JSON.stringify(args),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      };
+      fetchOptions.headers = {
+        ...fetchOptions.headers,
+        ...opts.getHeaders({
+          args,
+          context: ctx
+        })
+      };
+      return await fetchInner(url, fetchOptions);
+    },
     async getMany(args, ctx) {
       args = args || {};
       const url = `${opts.baseUrl}/${handlePlural}`;

package/drivers/restApi.mjs

@@ -21,10 +21,21 @@ export default (options) => (schema, entity) => {
     }
     return responseJson;
   }
-  const { handlePlural } = schema[entity] || {};
-  if (!handlePlural) throw new Error(`Entity ${entity} was not found in schema`);
+  const { handlePlural, handle } = schema[entity] || {};
+  if (!handlePlural || !handle) throw new Error(`Entity ${entity} was not found in schema`);
   const instance = {
     driverName: "restApi",
+    async getAgg(args, ctx) {
+      args = args || {};
+      const url = `${opts.baseUrl}/${handle}/agg`;
+      const fetchOptions = {
+        method: "POST",
+        body: JSON.stringify(args),
+        headers: { "Content-Type": "application/json" }
+      };
+      fetchOptions.headers = { ...fetchOptions.headers, ...opts.getHeaders({ args, context: ctx }) };
+      return await fetchInner(url, fetchOptions);
+    },
     async getMany(args, ctx) {
       args = args || {};
       const url = `${opts.baseUrl}/${handlePlural}`;

package/features/eventSourcing.cjs

@@ -36,9 +36,9 @@ function getEffectFor(entityName, aggregateRelationField, eventEntityName, schem
         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 ${entityName}.${aggregateRelationField}.id`);
+        if (!aggId) throw new Error(`Missing ${eventEntityName}.${aggregateRelationField}.id`);
         if (d.oldDoc && aggId !== d.oldDoc[aggregateRelationField].id) {
-          throw new Error(`Field ${entityName}.${aggregateRelationField}.id cannot be changed`);
+          throw new Error(`Field ${eventEntityName}.${aggregateRelationField}.id cannot be changed`);
         }
         if (!docsByAggId[aggId]) docsByAggId[aggId] = [];
         docsByAggId[aggId].push(d.doc);
@@ -82,12 +82,14 @@ function getEffectFor(entityName, aggregateRelationField, eventEntityName, schem
           aggDoc = newAggDoc;
           if (!context.options.keepNulls) (0, _radsDb.cleanUndefinedAndNull)(aggDoc);
         }
-        result.push({
-          aggDoc,
-          events,
-          updatedEvents: events.filter(ev => docsById[ev.id]),
-          oldAggDoc: existingAggregatesById[aggDoc.id]
-        });
+        if (aggDoc) {
+          result.push({
+            aggDoc,
+            events,
+            updatedEvents: events.filter(ev => docsById[ev.id]),
+            oldAggDoc: existingAggregatesById[aggDoc.id]
+          });
+        }
       }
       await (0, _radsDb.handlePrecomputed)(
       // @ts-expect-error TODO wrong types

package/features/eventSourcing.mjs

@@ -28,9 +28,9 @@ function getEffectFor(entityName, aggregateRelationField, eventEntityName, schem
         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 ${entityName}.${aggregateRelationField}.id`);
+        if (!aggId) throw new Error(`Missing ${eventEntityName}.${aggregateRelationField}.id`);
         if (d.oldDoc && aggId !== d.oldDoc[aggregateRelationField].id) {
-          throw new Error(`Field ${entityName}.${aggregateRelationField}.id cannot be changed`);
+          throw new Error(`Field ${eventEntityName}.${aggregateRelationField}.id cannot be changed`);
         }
         if (!docsByAggId[aggId]) docsByAggId[aggId] = [];
         docsByAggId[aggId].push(d.doc);
@@ -71,12 +71,14 @@ function getEffectFor(entityName, aggregateRelationField, eventEntityName, schem
           aggDoc = newAggDoc;
           if (!context.options.keepNulls) cleanUndefinedAndNull(aggDoc);
         }
-        result.push({
-          aggDoc,
-          events,
-          updatedEvents: events.filter((ev) => docsById[ev.id]),
-          oldAggDoc: existingAggregatesById[aggDoc.id]
-        });
+        if (aggDoc) {
+          result.push({
+            aggDoc,
+            events,
+            updatedEvents: events.filter((ev) => docsById[ev.id]),
+            oldAggDoc: existingAggregatesById[aggDoc.id]
+          });
+        }
       }
       await handlePrecomputed(
         // @ts-expect-error TODO wrong types

package/integrations/restEndpoints.cjs

@@ -68,6 +68,9 @@ function getRestRoutes(options) {
       POST: (args, ctx) => db[entity.handle].getMany(args.body, ctx),
       PUT: (args, ctx) => db[entity.handle].putMany(args.body?.data, ctx)
     };
+    routes[`${prefix}${entity.handle}/agg`] = {
+      POST: (args, ctx) => db[entity.handle].getAgg(args.body, ctx)
+    };
   }
   return routes;
 }

package/integrations/restEndpoints.mjs

@@ -38,6 +38,9 @@ export function getRestRoutes(options) {
       POST: (args, ctx) => db[entity.handle].getMany(args.body, ctx),
       PUT: (args, ctx) => db[entity.handle].putMany(args.body?.data, ctx)
     };
+    routes[`${prefix}${entity.handle}/agg`] = {
+      POST: (args, ctx) => db[entity.handle].getAgg(args.body, ctx)
+    };
   }
   return routes;
 }

package/package.json

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