rads-db 3.1.9 → 3.1.12

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/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

@@ -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);
   }
@@ -261,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;
@@ -355,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 };
+  return { where, orderByProperties, orderByDirections, maxItemCount, cursor: args.cursor, pick: args.include };
 }
 
 const computedPresets = {
@@ -690,7 +707,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 +812,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 +820,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 +965,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 +975,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 +989,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 +1067,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 +1269,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.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

@@ -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);
   }
@@ -254,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;
@@ -348,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 };
+  return { where, orderByProperties, orderByDirections, maxItemCount, cursor: args.cursor, pick: args.include };
 }
 
 const computedPresets = {
@@ -683,7 +700,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 +805,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 +813,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 +958,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 +968,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 +982,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 +1060,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 +1262,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/{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

@@ -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
@@ -153,15 +154,12 @@ 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);
   }
-  const query = `select * from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
+  const query = `select ${colums} from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
   return {
     query,
     parameters
@@ -461,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) {
@@ -589,4 +609,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;