rads-db 3.1.9 → 3.1.11

package/README.md

@@ -53,3 +53,22 @@ Consensus among the developer community is to use “simple” ORM, and use raw
 We wanted to have features that are not supported in current ORMs:
 
 - [This](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) article gives good overview
+
+# Development tips
+
+## Usage with `npm link`
+
+When you want to test changes in this package, it may be useful to test with `pnpm link`.
+
+But due to specifics of how this package uses peer dependencies, it won't work well.
+
+Use file protocol instead:
+
+```
+// package.json
+{
+  "dependencies": {
+    "rads-db": "file:../rads-db"
+  }
+}
+```

package/dist/index.cjs

@@ -204,10 +204,17 @@ const memory = (options) => (schema, entity) => {
     const where = args.where || {};
     const whereKeys = ___default.keys(where);
     if (whereKeys.length === 1) {
-      if (whereKeys[0] === "id")
-        return { nodes: ___default.cloneDeep([getItemById(where.id)].filter((x) => x)), cursor: null };
-      if (whereKeys[0] === "id_in")
-        return { nodes: ___default.cloneDeep(getItemByIds(where.id_in).filter((x) => x)), cursor: null };
+      if (whereKeys[0] === "id") {
+        const node = ___default.cloneDeep([getItemById(where.id)].filter((x) => x));
+        return { nodes: node, cursor: null };
+      }
+      if (whereKeys[0] === "id_in") {
+        const nodes = ___default.cloneDeep(getItemByIds(where.id_in).filter((x) => x));
+        return {
+          nodes,
+          cursor: null
+        };
+      }
     }
     return queryArray(Object.values(itemsById), args);
   }
@@ -363,7 +370,7 @@ function prepareArgs(args) {
   const orderByDirection = orderByParts.slice(-1)[0];
   let maxItemCount = args.maxItemCount;
   maxItemCount = maxItemCount || 100;
-  return { where, orderByProperty, orderByDirection, maxItemCount, cursor: args.cursor };
+  return { where, orderByProperty, orderByDirection, maxItemCount, cursor: args.cursor, pick: args.include };
 }
 
 const computedPresets = {
@@ -690,7 +697,7 @@ async function handleInclude(computedContext, include, result, ctx) {
     return;
   const { schema, typeName } = computedContext;
   const fields = schema[typeName].fields || {};
-  const fieldsToInclude = ___default.keys(include).filter((key) => include[key]);
+  const fieldsToInclude = ___default.keys(include).filter((key) => include[key] && key !== "_pick");
   const nestedFieldsToInclude = fieldsToInclude.filter(
     (key) => !fields[key].isRelation && !fields[key].isInverseRelation && schema[fields[key].type]?.fields
   );
@@ -795,7 +802,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
   const { precomputedFields } = entitySchema;
   async function getMany(args, ctx) {
     args = { ...args, where: { ...args?.where } };
-    ctx = { ...options.context, ...ctx, method: "getMany" };
+    ctx = { ...options.context, ...ctx, method: "getMany", _isRecursiveRoot: !ctx?._isRecursiveRoot };
     let result2 = await beforeGet(args, ctx, computedContext);
     if (!result2)
       result2 = await driverInstance.getMany(args, ctx);
@@ -803,6 +810,8 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       await radsDbRelations.handleInclude(computedContext, args.include, result2.nodes, ctx);
     await handleComputed(computedContext, result2.nodes, ctx);
     await afterGet(result2.nodes, args, ctx, computedContext);
+    if (ctx._isRecursiveRoot && args.include?._pick)
+      result2.nodes = await pickPropsFromObjectAsync(result2.nodes, args.include);
     return result2;
   }
   async function putMany(docs, ctx) {
@@ -946,7 +955,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
     },
     get: async (args, ctx) => {
       args = { ...args, where: { ...args?.where } };
-      ctx = { ...options.context, ...ctx, method: "get" };
+      ctx = { ...options.context, ...ctx, method: "get", _isRecursiveRoot: !ctx?._isRecursiveRoot };
       let result2 = await beforeGet(args, ctx, computedContext);
       if (!result2)
         result2 = await driverInstance.get(args, ctx);
@@ -956,11 +965,13 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       if (result2)
         await handleComputed(computedContext, resultArray, ctx);
       await afterGet(resultArray, args, ctx, computedContext);
+      if (ctx._isRecursiveRoot && args.include?._pick)
+        result2 = await pickPropsFromObjectAsync(result2, args.include);
       return result2;
     },
     getAll: async (args, ctx) => {
       args = { ...args, where: { ...args?.where } };
-      ctx = { ...options.context, ...ctx, method: "getAll" };
+      ctx = { ...options.context, ...ctx, method: "getAll", _isRecursiveRoot: !ctx?._isRecursiveRoot };
       let result2 = await beforeGet(args, ctx, computedContext);
       if (!result2)
         result2 = await driverInstance.getAll(args, ctx);
@@ -968,6 +979,9 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
         await radsDbRelations.handleInclude(computedContext, args.include, result2, ctx);
       await handleComputed(computedContext, result2, ctx);
       await afterGet(result2, args, ctx, computedContext);
+      if (ctx._isRecursiveRoot && args.include?._pick) {
+        result2 = await pickPropsFromObjectAsync(result2, args.include);
+      }
       return result2;
     },
     verifyAll: async (args, ctx) => {
@@ -1043,6 +1057,18 @@ async function afterPut(items, ctx, computedContext) {
     await f.afterPut?.(items, ctx, computedContext);
   }
 }
+async function pickPropsFromObjectAsync(obj, args) {
+  if (Array.isArray(obj)) {
+    return Promise.all(obj.map((o) => pickPropsFromObjectAsync(o, args)));
+  }
+  const result = args._pick ? ___default.pick(obj, args._pick) : {};
+  for (const key of Object.keys(args)) {
+    if (key !== "_pick" && typeof args[key] === "object" && obj[key]) {
+      result[key] = await pickPropsFromObjectAsync(obj[key], args[key]);
+    }
+  }
+  return result;
+}
 
 function generateMethods(schema, validators, options) {
   const drivers = {};
@@ -1233,16 +1259,14 @@ const restApi = (options) => (schema, entity) => {
     if (!response.ok) {
       const msg = responseJson?.message || responseJson?.statusMessage || response.statusText || "Server error.";
       const err = new Error(msg);
-      if (responseJson?.code)
-        err.code = responseJson?.code;
+      if (responseJson?.code) err.code = responseJson?.code;
       err.fetchResponseJson = responseJson;
       throw err;
     }
     return responseJson;
   }
   const { handlePlural } = schema[entity] || {};
-  if (!handlePlural)
-    throw new Error(`Entity ${entity} was not found in schema`);
+  if (!handlePlural) throw new Error(`Entity ${entity} was not found in schema`);
   const instance = {
     driverName: "restApi",
     async getMany(args, ctx) {

package/dist/index.mjs

@@ -197,10 +197,17 @@ const memory = (options) => (schema, entity) => {
     const where = args.where || {};
     const whereKeys = _.keys(where);
     if (whereKeys.length === 1) {
-      if (whereKeys[0] === "id")
-        return { nodes: _.cloneDeep([getItemById(where.id)].filter((x) => x)), cursor: null };
-      if (whereKeys[0] === "id_in")
-        return { nodes: _.cloneDeep(getItemByIds(where.id_in).filter((x) => x)), cursor: null };
+      if (whereKeys[0] === "id") {
+        const node = _.cloneDeep([getItemById(where.id)].filter((x) => x));
+        return { nodes: node, cursor: null };
+      }
+      if (whereKeys[0] === "id_in") {
+        const nodes = _.cloneDeep(getItemByIds(where.id_in).filter((x) => x));
+        return {
+          nodes,
+          cursor: null
+        };
+      }
     }
     return queryArray(Object.values(itemsById), args);
   }
@@ -356,7 +363,7 @@ function prepareArgs(args) {
   const orderByDirection = orderByParts.slice(-1)[0];
   let maxItemCount = args.maxItemCount;
   maxItemCount = maxItemCount || 100;
-  return { where, orderByProperty, orderByDirection, maxItemCount, cursor: args.cursor };
+  return { where, orderByProperty, orderByDirection, maxItemCount, cursor: args.cursor, pick: args.include };
 }
 
 const computedPresets = {
@@ -683,7 +690,7 @@ async function handleInclude(computedContext, include, result, ctx) {
     return;
   const { schema, typeName } = computedContext;
   const fields = schema[typeName].fields || {};
-  const fieldsToInclude = _.keys(include).filter((key) => include[key]);
+  const fieldsToInclude = _.keys(include).filter((key) => include[key] && key !== "_pick");
   const nestedFieldsToInclude = fieldsToInclude.filter(
     (key) => !fields[key].isRelation && !fields[key].isInverseRelation && schema[fields[key].type]?.fields
   );
@@ -788,7 +795,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
   const { precomputedFields } = entitySchema;
   async function getMany(args, ctx) {
     args = { ...args, where: { ...args?.where } };
-    ctx = { ...options.context, ...ctx, method: "getMany" };
+    ctx = { ...options.context, ...ctx, method: "getMany", _isRecursiveRoot: !ctx?._isRecursiveRoot };
     let result2 = await beforeGet(args, ctx, computedContext);
     if (!result2)
       result2 = await driverInstance.getMany(args, ctx);
@@ -796,6 +803,8 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       await radsDbRelations.handleInclude(computedContext, args.include, result2.nodes, ctx);
     await handleComputed(computedContext, result2.nodes, ctx);
     await afterGet(result2.nodes, args, ctx, computedContext);
+    if (ctx._isRecursiveRoot && args.include?._pick)
+      result2.nodes = await pickPropsFromObjectAsync(result2.nodes, args.include);
     return result2;
   }
   async function putMany(docs, ctx) {
@@ -939,7 +948,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
     },
     get: async (args, ctx) => {
       args = { ...args, where: { ...args?.where } };
-      ctx = { ...options.context, ...ctx, method: "get" };
+      ctx = { ...options.context, ...ctx, method: "get", _isRecursiveRoot: !ctx?._isRecursiveRoot };
       let result2 = await beforeGet(args, ctx, computedContext);
       if (!result2)
         result2 = await driverInstance.get(args, ctx);
@@ -949,11 +958,13 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       if (result2)
         await handleComputed(computedContext, resultArray, ctx);
       await afterGet(resultArray, args, ctx, computedContext);
+      if (ctx._isRecursiveRoot && args.include?._pick)
+        result2 = await pickPropsFromObjectAsync(result2, args.include);
       return result2;
     },
     getAll: async (args, ctx) => {
       args = { ...args, where: { ...args?.where } };
-      ctx = { ...options.context, ...ctx, method: "getAll" };
+      ctx = { ...options.context, ...ctx, method: "getAll", _isRecursiveRoot: !ctx?._isRecursiveRoot };
       let result2 = await beforeGet(args, ctx, computedContext);
       if (!result2)
         result2 = await driverInstance.getAll(args, ctx);
@@ -961,6 +972,9 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
         await radsDbRelations.handleInclude(computedContext, args.include, result2, ctx);
       await handleComputed(computedContext, result2, ctx);
       await afterGet(result2, args, ctx, computedContext);
+      if (ctx._isRecursiveRoot && args.include?._pick) {
+        result2 = await pickPropsFromObjectAsync(result2, args.include);
+      }
       return result2;
     },
     verifyAll: async (args, ctx) => {
@@ -1036,6 +1050,18 @@ async function afterPut(items, ctx, computedContext) {
     await f.afterPut?.(items, ctx, computedContext);
   }
 }
+async function pickPropsFromObjectAsync(obj, args) {
+  if (Array.isArray(obj)) {
+    return Promise.all(obj.map((o) => pickPropsFromObjectAsync(o, args)));
+  }
+  const result = args._pick ? _.pick(obj, args._pick) : {};
+  for (const key of Object.keys(args)) {
+    if (key !== "_pick" && typeof args[key] === "object" && obj[key]) {
+      result[key] = await pickPropsFromObjectAsync(obj[key], args[key]);
+    }
+  }
+  return result;
+}
 
 function generateMethods(schema, validators, options) {
   const drivers = {};
@@ -1226,16 +1252,14 @@ const restApi = (options) => (schema, entity) => {
     if (!response.ok) {
       const msg = responseJson?.message || responseJson?.statusMessage || response.statusText || "Server error.";
       const err = new Error(msg);
-      if (responseJson?.code)
-        err.code = responseJson?.code;
+      if (responseJson?.code) err.code = responseJson?.code;
       err.fetchResponseJson = responseJson;
       throw err;
     }
     return responseJson;
   }
   const { handlePlural } = schema[entity] || {};
-  if (!handlePlural)
-    throw new Error(`Entity ${entity} was not found in schema`);
+  if (!handlePlural) throw new Error(`Entity ${entity} was not found in schema`);
   const instance = {
     driverName: "restApi",
     async getMany(args, ctx) {

package/drivers/azureCosmos.cjs

@@ -3,10 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-module.exports = void 0;
+
 var _cosmos = require("@azure/cosmos");
 var _lodash = _interopRequireDefault(require("lodash"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const cosmosClientCache = {};
 const databaseClientCache = {};
 const containerClientCache = {};
@@ -24,14 +24,15 @@ var _default = options => (schema, entity) => {
   if (options.createDatabaseIfNotExists) {
     createDatabaseIfNotExists(normalizedOptions, client.database.client);
   }
-  async function getItemByIds(ids, ctx) {
+  async function getItemByIds(ids, ctx, include) {
     const {
       query,
       parameters
     } = getCosmosQuery(schema, entity, {
       where: {
         id_in: ids
-      }
+      },
+      include
     });
     const response = client.items.query({
       query,
@@ -53,14 +54,14 @@ var _default = options => (schema, entity) => {
     const whereKeys = _lodash.default.keys(where);
     if (whereKeys.length === 1) {
       if (whereKeys[0] === "id" && where.id != null) {
-        const items = await getItemByIds([where.id], ctx);
+        const items = await getItemByIds([where.id], ctx, args.include);
         return {
           nodes: [items[0]].filter(x => x),
           cursor: null
         };
       }
       if (whereKeys[0] === "id_in" && where.id_in != null) {
-        const items = await getItemByIds(where.id_in, ctx);
+        const items = await getItemByIds(where.id_in, ctx, args.include);
         return {
           nodes: items.filter(x => x),
           cursor: null
@@ -161,7 +162,11 @@ function getCosmosQuery(schema, entity, args) {
     const orderProp = orderPropFromOrderBy === "value" ? `r["value"]` : `r.${orderPropFromOrderBy}`;
     orderByClause = `order by ${orderProp} ${orderDirection}`;
   }
-  const query = `select * from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
+  let colums = "*";
+  if (args.include?._pick) {
+    colums = getCosmosSelectValue(args.include);
+  }
+  const query = `select ${colums} from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
   return {
     query,
     parameters
@@ -589,4 +594,27 @@ async function bulkSendWithRetry(client, chunkToSend) {
     });
   }
   return responses;
+}
+function buildSelectValue(includeArgs, path = "r") {
+  const parts = [];
+  if (Array.isArray(includeArgs._pick)) {
+    for (const key of includeArgs._pick) {
+      parts.push(`${key}: ${path}.${key}`);
+    }
+  }
+  for (const key of Object.keys(includeArgs)) {
+    if (key === "_pick") continue;
+    const nested = includeArgs[key];
+    if (typeof nested === "object" && nested !== null) {
+      const nestedSelect = buildSelectValue(nested, `${path}.${key}`);
+      parts.push(`${key}: { ${nestedSelect} }`);
+    }
+  }
+  return parts.join(", ");
+}
+function getCosmosSelectValue(includeArgs) {
+  const projection = buildSelectValue(includeArgs);
+  return `VALUE {
+  ${projection}
+} `;
 }

package/drivers/azureCosmos.d.ts

@@ -1,4 +1,5 @@
 import type { CosmosClientOptions } from '@azure/cosmos';
+import type { Schema } from 'rads-db';
 interface AzureCosmosDriverOptions {
     /** HTTPS endpoint of your cosmosdb instance. For example, https://mydb.documents.azure.com:443/ */
     endpoint: string;

package/drivers/azureCosmos.mjs

@@ -17,8 +17,8 @@ export default (options) => (schema, entity) => {
   if (options.createDatabaseIfNotExists) {
     createDatabaseIfNotExists(normalizedOptions, client.database.client);
   }
-  async function getItemByIds(ids, ctx) {
-    const { query, parameters } = getCosmosQuery(schema, entity, { where: { id_in: ids } });
+  async function getItemByIds(ids, ctx, include) {
+    const { query, parameters } = getCosmosQuery(schema, entity, { where: { id_in: ids }, include });
     const response = client.items.query({
       query,
       parameters: Object.keys(parameters).map((k) => ({ name: `@${k}`, value: parameters[k] }))
@@ -33,11 +33,11 @@ export default (options) => (schema, entity) => {
     const whereKeys = _.keys(where);
     if (whereKeys.length === 1) {
       if (whereKeys[0] === "id" && where.id != null) {
-        const items = await getItemByIds([where.id], ctx);
+        const items = await getItemByIds([where.id], ctx, args.include);
         return { nodes: [items[0]].filter((x) => x), cursor: null };
       }
       if (whereKeys[0] === "id_in" && where.id_in != null) {
-        const items = await getItemByIds(where.id_in, ctx);
+        const items = await getItemByIds(where.id_in, ctx, args.include);
         return { nodes: items.filter((x) => x), cursor: null };
       }
     }
@@ -84,8 +84,7 @@ export default (options) => (schema, entity) => {
       const itemsToPut = [];
       for (const item of items) {
         const id = item?.id;
-        if (!id)
-          throw new Error(`You must provide an id`);
+        if (!id) throw new Error(`You must provide an id`);
         itemsToPut.push({ _partition: entity, id, ...item });
       }
       for (const chunk of _.chunk(itemsToPut, 100)) {
@@ -119,7 +118,11 @@ function getCosmosQuery(schema, entity, args) {
     const orderProp = orderPropFromOrderBy === "value" ? `r["value"]` : `r.${orderPropFromOrderBy}`;
     orderByClause = `order by ${orderProp} ${orderDirection}`;
   }
-  const query = `select * from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
+  let colums = "*";
+  if (args.include?._pick) {
+    colums = getCosmosSelectValue(args.include);
+  }
+  const query = `select ${colums} from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
   return { query, parameters };
 }
 const operatorHandlers = {
@@ -140,48 +143,41 @@ const operatorHandlers = {
   none: (ctx, parameters, whereArgs) => {
     const { name, namePrefix, paramNamePrefix, paramName, whereVal } = whereArgs;
     const subClause = getCosmosQueryWhere(ctx, parameters, whereVal, `${name}.`, `${paramNamePrefix}${paramName}_`);
-    if (subClause)
-      return `not exists (select ${name} from ${name} in ${namePrefix}${name} where ${subClause})`;
+    if (subClause) return `not exists (select ${name} from ${name} in ${namePrefix}${name} where ${subClause})`;
     return `array_length(${namePrefix}${name}) = 0`;
   },
   and: (ctx, parameters, whereArgs) => {
     const { namePrefix, paramNamePrefix, whereVal } = whereArgs;
-    if (!_.isArray(whereVal))
-      throw new Error(`Value for where._and must be an array`);
+    if (!_.isArray(whereVal)) throw new Error(`Value for where._and must be an array`);
     const clauses = [];
     for (let i = 0; i < whereVal.length; i++) {
       const andQuery = getCosmosQueryWhere(ctx, parameters, whereVal[i], namePrefix, `${paramNamePrefix}and${i}_`);
       clauses.push(andQuery);
     }
-    if (!clauses.length)
-      return null;
+    if (!clauses.length) return null;
     return `((${clauses.join(") and (")}))`;
   },
   not: (ctx, parameters, whereArgs) => {
     const { name, namePrefix, paramNamePrefix, whereVal } = whereArgs;
     const subClause = getCosmosQueryWhere(ctx, parameters, whereVal, `${namePrefix}${name}`, `${paramNamePrefix}not_`);
-    if (!subClause)
-      return null;
+    if (!subClause) return null;
     return `not(${subClause})`;
   },
   or: (ctx, parameters, whereArgs) => {
     const { namePrefix, paramNamePrefix, whereVal } = whereArgs;
-    if (!_.isArray(whereVal))
-      throw new Error(`Value for where._or must be an array`);
+    if (!_.isArray(whereVal)) throw new Error(`Value for where._or must be an array`);
     const clauses = [];
     for (let i = 0; i < whereVal.length; i++) {
       const orQuery = getCosmosQueryWhere(ctx, parameters, whereVal[i], namePrefix, `${paramNamePrefix}or${i}_`);
       clauses.push(orQuery);
     }
-    if (!clauses.length)
-      return null;
+    if (!clauses.length) return null;
     return `((${clauses.join(") or (")}))`;
   },
   isNull: (ctx, parameters, whereArgs) => {
     const { name, namePrefix, whereVal } = whereArgs;
     const n = `${namePrefix}${name}`;
-    if (whereVal)
-      return `(not (is_defined(${n})) or ${n} = null)`;
+    if (whereVal) return `(not (is_defined(${n})) or ${n} = null)`;
     return `(is_defined(${n}) and ${n} != null)`;
   },
   eq: (ctx, parameters, whereArgs) => {
@@ -241,17 +237,14 @@ const operatorHandlers = {
   isEmpty: (ctx, parameters, whereArgs) => {
     const { name, namePrefix, whereVal } = whereArgs;
     const n = `${namePrefix}${name}`;
-    if (whereVal)
-      return `(not (is_defined(${n})) or ${n} = null or array_length(${n}) = 0)`;
+    if (whereVal) return `(not (is_defined(${n})) or ${n} = null or array_length(${n}) = 0)`;
     return `(is_defined(${n}) and ${n} != null and array_length(${n}) > 0)`;
   },
   jsonContains: (ctx, parameters, whereArgs) => {
     const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
     const { path, isNull, value } = whereVal;
-    if (!path)
-      return "";
-    if (!sanitizePathRegex.test(path))
-      throw new Error(`Invalid path ${path}`);
+    if (!path) return "";
+    if (!sanitizePathRegex.test(path)) throw new Error(`Invalid path ${path}`);
     const pn = `${paramNamePrefix}${paramName}`;
     parameters[pn] = whereVal;
     const fullPath = `${namePrefix}${name}.${path}`;
@@ -310,8 +303,7 @@ function getCosmosQueryWhere(ctx, parameters, where, namePrefix = "r.", paramNam
     }
     const paramName = key;
     const whereVal = where[key];
-    if (whereVal == null)
-      continue;
+    if (whereVal == null) continue;
     const f = getCosmosQueryWhereInner({ ...ctx, field: nameFromWhere }, parameters, {
       operator,
       whereVal,
@@ -320,8 +312,7 @@ function getCosmosQueryWhere(ctx, parameters, where, namePrefix = "r.", paramNam
       paramName,
       paramNamePrefix
     });
-    if (f)
-      whereClauses.push(f);
+    if (f) whereClauses.push(f);
   }
   return whereClauses.join(" AND ");
 }
@@ -389,8 +380,7 @@ async function bulkSendWithRetry(client, chunkToSend) {
       }
     }
     chunkToSend = newChunkToSend;
-    if (chunkToSend.length === 0)
-      break;
+    if (chunkToSend.length === 0) break;
     const delay = 50 + i * 100;
     console.warn(`Db overloaded. Retrying after ${delay}ms...`);
     await new Promise((resolve) => setTimeout(resolve, delay));
@@ -402,3 +392,26 @@ async function bulkSendWithRetry(client, chunkToSend) {
   }
   return responses;
 }
+function buildSelectValue(includeArgs, path = "r") {
+  const parts = [];
+  if (Array.isArray(includeArgs._pick)) {
+    for (const key of includeArgs._pick) {
+      parts.push(`${key}: ${path}.${key}`);
+    }
+  }
+  for (const key of Object.keys(includeArgs)) {
+    if (key === "_pick") continue;
+    const nested = includeArgs[key];
+    if (typeof nested === "object" && nested !== null) {
+      const nestedSelect = buildSelectValue(nested, `${path}.${key}`);
+      parts.push(`${key}: { ${nestedSelect} }`);
+    }
+  }
+  return parts.join(", ");
+}
+function getCosmosSelectValue(includeArgs) {
+  const projection = buildSelectValue(includeArgs);
+  return `VALUE {
+  ${projection}
+} `;
+}

package/drivers/azureStorageBlob.cjs

@@ -3,10 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-module.exports = void 0;
+
 var _storageBlob = require("@azure/storage-blob");
 var _lodash = _interopRequireDefault(require("lodash"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const blobServiceClientCache = {};
 const containerClientCache = {};
 var _default = options => (schema, entity) => {

package/drivers/azureStorageBlob.d.ts

@@ -1,4 +1,5 @@
 import type { StoragePipelineOptions } from '@azure/storage-blob';
+import type { Schema } from 'rads-db';
 interface AzureStorageBlobDriverOptions {
     connectionString: string;
     defaultContainer?: string;

package/drivers/azureStorageBlob.mjs

@@ -15,8 +15,7 @@ export default (options) => (schema, entity) => {
       ctx?.log?.({ requestId: downloadResponse.requestId, charge: str.length, request: `download ${name}` });
       return JSON.parse(str);
     } catch (e) {
-      if (e?.statusCode === 404)
-        return void 0;
+      if (e?.statusCode === 404) return void 0;
       throw e;
     }
   }
@@ -41,8 +40,7 @@ export default (options) => (schema, entity) => {
         return { nodes: items.filter((x) => x), cursor: null };
       }
     }
-    if (whereKeys.length > 1)
-      throw new Error("Complex queries are not supported by azureStorageBlob");
+    if (whereKeys.length > 1) throw new Error("Complex queries are not supported by azureStorageBlob");
     const iterator = containerClient.listBlobsFlat({}).byPage({ maxPageSize: args.maxItemCount || 30, continuationToken: args.cursor || void 0 });
     for await (const page of iterator) {
       ctx?.log?.({
@@ -81,8 +79,7 @@ export default (options) => (schema, entity) => {
     async putMany(items, ctx) {
       for (const item of items) {
         const id = item?.id;
-        if (!id)
-          throw new Error(`You must provide an id`);
+        if (!id) throw new Error(`You must provide an id`);
         const blobName = getBlobName(entity, item);
         const itemToPut = item;
         const blobClient = containerClient.getBlockBlobClient(blobName);
@@ -95,8 +92,7 @@ export default (options) => (schema, entity) => {
   return instance;
 };
 function getBlobName(entity, item) {
-  if (!item.id)
-    throw new Error("Item must have an id");
+  if (!item.id) throw new Error("Item must have an id");
   return `${entity}/${item.id}.json`;
 }
 async function blobOrStreamToString(response) {

package/drivers/indexedDb.cjs

@@ -3,11 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-module.exports = void 0;
+
 var _dexie = _interopRequireDefault(require("dexie"));
 var _lodash = _interopRequireDefault(require("lodash"));
 var _memory = require("./memory.cjs");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const dbs = {};
 const tableOperatorFns = {
   eq: (where, value) => where.equals(value),

package/drivers/indexedDb.d.ts

@@ -1,4 +1,5 @@
 import type { DexieOptions } from 'dexie';
+import type { MinimalDriver, Schema } from 'rads-db';
 declare const _default: (options?: IndexedDbDriverOptions) => (schema: Schema, entity: string) => MinimalDriver;
 export default _default;
 export interface IndexedDbDriverOptions {