rads-db 3.1.9 → 3.1.12

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)) {
@@ -111,15 +110,12 @@ 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);
   }
-  const query = `select * from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
+  const query = `select ${colums} from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
   return { query, parameters };
 }
 const operatorHandlers = {
@@ -140,48 +136,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 +230,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}`;
@@ -299,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) {
@@ -310,8 +318,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 +327,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 +395,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 +407,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 {

package/drivers/indexedDb.mjs

@@ -22,8 +22,7 @@ export default (options) => {
   const dbWrapper = getDb(options);
   return (schema, entity) => {
     const handle = schema[entity]?.handle;
-    if (!handle)
-      throw new Error(`Entity ${entity} not found`);
+    if (!handle) throw new Error(`Entity ${entity} not found`);
     dbWrapper.entities[handle] = true;
     async function getMany(args, ctx) {
       await initDbIfNeeded(dbName);
@@ -79,8 +78,7 @@ function applyArgsToDexieTable(table, args) {
   if (!collection && orderByProp) {
     if (indexedProps.includes(orderByProp)) {
       collection = table.orderBy(orderByProp);
-      if (orderByDirection === "desc")
-        collection = collection.reverse();
+      if (orderByDirection === "desc") collection = collection.reverse();
       orderByProp = "";
     }
   }
@@ -92,8 +90,7 @@ function applyArgsToDexieTable(table, args) {
     collection = collection.filter((x) => f(x) || false);
   }
   if (maxItemCount && !orderByProp) {
-    if (args.cursor)
-      collection = collection.offset(_.toNumber(args.cursor));
+    if (args.cursor) collection = collection.offset(_.toNumber(args.cursor));
     collection = collection.limit(maxItemCount);
   }
   return { collection, orderByProp, orderByDirection, maxItemCount };
@@ -125,12 +122,10 @@ function applyTableFiltering(table, where, fieldName) {
   }
 }
 function normalizeArgs(args) {
-  if (!args)
-    args = {};
+  if (!args) args = {};
   const where = _.cloneDeep(args.where) || {};
   let orderBy = args.orderBy || "";
-  if (_.isArray(orderBy))
-    orderBy = orderBy[0] || "";
+  if (_.isArray(orderBy)) orderBy = orderBy[0] || "";
   const orderByParts = orderBy.split("_");
   const orderByProperty = orderByParts.slice(0, -1).join(".");
   const orderByDirection = orderByParts.slice(-1)[0];
@@ -180,8 +175,7 @@ async function initDbInner(dbName) {
 }
 function getDb(options) {
   const dbName = options?.dbName || "db";
-  if (dbs[dbName]?.db)
-    dbs[dbName].db?.close();
+  if (dbs[dbName]?.db) dbs[dbName].db?.close();
   dbs[dbName] = { entities: {}, driverOptions: { dbName, dexieOptions: void 0, invalidateCounter: 0, ...options } };
   return dbs[dbName];
 }

package/drivers/memory.cjs

@@ -3,12 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-module.exports = void 0;
+
 exports.getAggFromArray = getAggFromArray;
 exports.getFilter = getFilter;
 exports.queryArray = queryArray;
 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 operatorFns = {
   eq: (x, w) => x === w,
   ieq: (x, w) => x?.toLowerCase() === w?.toLowerCase(),
@@ -76,14 +76,20 @@ var _default = options => (schema, entity) => {
     const where = args.where || {};
     const whereKeys = _lodash.default.keys(where);
     if (whereKeys.length === 1) {
-      if (whereKeys[0] === "id") return {
-        nodes: _lodash.default.cloneDeep([getItemById(where.id)].filter(x => x)),
-        cursor: null
-      };
-      if (whereKeys[0] === "id_in") return {
-        nodes: _lodash.default.cloneDeep(getItemByIds(where.id_in).filter(x => x)),
-        cursor: null
-      };
+      if (whereKeys[0] === "id") {
+        const node = _lodash.default.cloneDeep([getItemById(where.id)].filter(x => x));
+        return {
+          nodes: node,
+          cursor: null
+        };
+      }
+      if (whereKeys[0] === "id_in") {
+        const nodes = _lodash.default.cloneDeep(getItemByIds(where.id_in).filter(x => x));
+        return {
+          nodes,
+          cursor: null
+        };
+      }
     }
     return queryArray(Object.values(itemsById), args);
   }
@@ -135,8 +141,8 @@ function queryArray(array, args) {
   let result = array;
   const {
     where,
-    orderByProperty,
-    orderByDirection,
+    orderByProperties,
+    orderByDirections,
     maxItemCount,
     cursor
   } = prepareArgs(args);
@@ -144,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 {
@@ -225,18 +231,29 @@ 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
+    cursor: args.cursor,
+    pick: args.include
   };
 }

package/drivers/memory.d.ts

@@ -1,3 +1,4 @@
+import type { Schema } from '@/types';
 import type { GetAggArgsAny, GetManyArgsAny } from '@/typesClientEngine';
 interface MemoryDriverOptions {
 }