rads-db 0.1.26 → 0.1.28

package/dist/index.cjs

@@ -2,15 +2,12 @@
 
 const zod = require('zod');
 const _ = require('lodash');
-const pluralize = require('pluralize');
-const cosmos = require('@azure/cosmos');
 const uuid = require('uuid');
 const _radsDb = require('_rads-db');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const ___default = /*#__PURE__*/_interopDefaultCompat(_);
-const pluralize__default = /*#__PURE__*/_interopDefaultCompat(pluralize);
 
 function generateValidators(schema) {
   const zodSchemas = {};
@@ -117,7 +114,7 @@ const operatorFns = {
     return result;
   }
 };
-const memory = (schema, entity) => {
+const memory = (options) => (schema, entity) => {
   let cache = {};
   function getItemById(id) {
     return cache[id] ?? null;
@@ -126,6 +123,7 @@ const memory = (schema, entity) => {
     return ids.map((id) => cache[id]);
   }
   const instance = {
+    driverName: "memory",
     clear() {
       cache = {};
     },
@@ -194,7 +192,7 @@ function getFilter(where, namePrefix = "") {
     return null;
   const andClauses = [];
   for (const key in where) {
-    const [nameFromWhere, operator] = getWhereNameOperatorPair$1(key);
+    const [nameFromWhere, operator] = getWhereNameOperatorPair(key);
     const name = [namePrefix, nameFromWhere].filter((x) => x).join(".");
     const whereVal = where[key];
     if (whereVal == null)
@@ -207,7 +205,7 @@ function getFilter(where, namePrefix = "") {
     return null;
   return (x) => andClauses.every((ac) => ac(x));
 }
-function getWhereNameOperatorPair$1(whereKey) {
+function getWhereNameOperatorPair(whereKey) {
   if (whereKey.startsWith("_type")) {
     const operator = whereKey.split("_")[2];
     return ["_type", operator];
@@ -270,338 +268,6 @@ function prepareArgs(args) {
   return { where, orderByProperty, orderByDirection, maxItemCount, cursor: args.cursor };
 }
 
-const restApi = (schema, entity, options) => {
-  options = { baseUrl: "/api", fetch: globalThis.fetch, ...options };
-  const fetch = options.fetch || global.fetch;
-  if (!options.fetch)
-    throw new Error('Please provide "fetch" argument to rest driver definition');
-  const pluralEntityName = ___default.lowerFirst(pluralize__default(entity));
-  const instance = {
-    async getMany(args) {
-      args = args || {};
-      const response = await fetch(`${options.baseUrl}/${pluralEntityName}`, {
-        method: "POST",
-        body: JSON.stringify(args)
-      });
-      return await response?.json();
-    },
-    async putMany(item) {
-      await fetch(`${options.baseUrl}/${pluralEntityName}`, {
-        method: "PUT",
-        body: JSON.stringify({ data: item })
-      });
-    }
-  };
-  return instance;
-};
-
-const cosmosClientCache = {};
-const databaseClientCache = {};
-const containerClientCache = {};
-const simpleSubclauseRegex = /^[a-z0-9_@]+.[a-z0-9_@]+ = [a-z0-9_@.]+$/i;
-const azureCosmos = (schema, entity, options) => {
-  const client = getCosmosContainerClient(options);
-  async function getItemByIds(ids, ctx) {
-    const { query, parameters } = getCosmosQuery(schema, entity, { where: { id_in: ids } });
-    const response = client.items.query({
-      query,
-      parameters: Object.keys(parameters).map((k) => ({ name: `@${k}`, value: parameters[k] }))
-    });
-    const r = await response.fetchAll();
-    ctx?.log?.({ charge: r.requestCharge, request: query });
-    return r.resources;
-  }
-  const instance = {
-    async clear(ctx) {
-      const responseIter = client.items.readAll();
-      const items = await responseIter.fetchAll();
-      ctx?.log?.({ charge: items.requestCharge, request: "readAll" });
-      for (const r of items.resources) {
-        await client.item(r.id, r._partition).delete();
-        ctx?.log?.({ charge: items.requestCharge, request: `delete#${r._partition}|${r.id}` });
-      }
-    },
-    async putMany(items, ctx) {
-      for (const item of items) {
-        const id = item?.id;
-        if (!id)
-          throw new Error(`You must provide an id`);
-        const itemToPut = { _partition: entity, id, ...item };
-        const response = await client.items.upsert(itemToPut);
-        ctx?.log?.({ charge: response.requestCharge, request: `put#${itemToPut._partition}|${itemToPut.id}` });
-      }
-    },
-    async getMany(args, ctx) {
-      args = args || {};
-      const where = args.where || {};
-      const whereKeys = ___default.keys(where);
-      if (whereKeys.length === 1) {
-        if (whereKeys[0] === "id" && where.id != null) {
-          const items = await getItemByIds([where.id], ctx);
-          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);
-          return { nodes: items.filter((x) => x), cursor: null };
-        }
-      }
-      const { query, parameters } = getCosmosQuery(schema, entity, args);
-      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();
-      ctx?.log?.({ charge: page.requestCharge, request: query });
-      return {
-        nodes: page.resources,
-        cursor: page.continuationToken || null
-      };
-    }
-  };
-  return instance;
-};
-function getCosmosQuery(schema, entity, args) {
-  args = args || {};
-  const where = args.where || {};
-  const parameters = {};
-  const whereClauses = [
-    `r._partition = '${entity}'`,
-    getCosmosQueryWhere({ schema, entity }, parameters, where)
-  ].filter((x) => x);
-  let orderByClause = "";
-  if (args.orderBy) {
-    const [orderPropFromOrderBy, orderDirection] = args.orderBy.split("_") || [];
-    const orderProp = orderPropFromOrderBy === "value" ? `r["value"]` : `r.${orderPropFromOrderBy}`;
-    orderByClause = `order by ${orderProp} ${orderDirection}`;
-  }
-  const query = `select * from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
-  return { query, parameters };
-}
-const operatorHandlers = {
-  some: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, whereVal } = whereArgs;
-    const newCtx = { ...ctx, entity: ctx.schema[ctx.entity].fields[ctx.field].type };
-    const subClause = getCosmosQueryWhere(newCtx, parameters, whereVal, `${namePrefix}${name}.`);
-    if (subClause) {
-      if (simpleSubclauseRegex.test(subClause)) {
-        const parts = subClause.split(" ");
-        const field = parts[0];
-        const variable = parts[2];
-        return `array_contains(${namePrefix}${name}, { ${field.split(".")[1]}: ${variable} }, true)`;
-      }
-      return `exists (select ${name} from ${name} in ${namePrefix}${name} where ${subClause})`;
-    }
-    return `array_length(${namePrefix}${name}) > 0`;
-  },
-  none: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, whereVal } = whereArgs;
-    const newCtx = { ...ctx, entity: ctx.schema[ctx.entity].fields[ctx.field].type };
-    const subClause = getCosmosQueryWhere(newCtx, parameters, whereVal, `${namePrefix}${name}.`);
-    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 (!___default.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;
-    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;
-    return `not(${subClause})`;
-  },
-  or: (ctx, parameters, whereArgs) => {
-    const { namePrefix, paramNamePrefix, whereVal } = whereArgs;
-    if (!___default.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;
-    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)`;
-    return `(is_defined(${n}) and ${n} != null)`;
-  },
-  eq: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} = @${pn}`;
-  },
-  in: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `array_contains(@${pn}, ${namePrefix}${name})`;
-  },
-  startsWith: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `startswith(${namePrefix}${name}, @${pn})`;
-  },
-  istartsWith: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `startswith(${namePrefix}${name}, @${pn}, true)`;
-  },
-  endsWith: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `endswith(${namePrefix}${name}, @${pn})`;
-  },
-  iendsWith: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `endswith(${namePrefix}${name}, @${pn}, true)`;
-  },
-  contains: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const fieldType = ctx.schema[ctx.entity].fields[ctx.field];
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    if (fieldType.isArray) {
-      return `array_contains(${namePrefix}${name}, @${pn})`;
-    }
-    return `contains(${namePrefix}${name}, @${pn})`;
-  },
-  icontains: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `contains(${namePrefix}${name}, @${pn}, true)`;
-  },
-  ieq: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `stringequals(${namePrefix}${name}, @${pn}, true)`;
-  },
-  gt: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} > @${pn}`;
-  },
-  gte: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} >= @${pn}`;
-  },
-  lt: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} < @${pn}`;
-  },
-  lte: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} <= @${pn}`;
-  }
-};
-function getCosmosQueryWhere(ctx, parameters, where, namePrefix = "r.", paramNamePrefix = "") {
-  const whereClauses = [];
-  for (const key in where) {
-    const [nameFromWhere, operator] = getWhereNameOperatorPair(key);
-    let name = nameFromWhere;
-    if (name === "value") {
-      name = `["${name}"]`;
-      namePrefix = namePrefix.slice(0, -1);
-    }
-    const paramName = key;
-    const whereVal = where[key];
-    if (whereVal == null)
-      continue;
-    const f = getCosmosQueryWhereInner({ ...ctx, field: nameFromWhere }, parameters, {
-      operator,
-      whereVal,
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix
-    });
-    if (f)
-      whereClauses.push(f);
-  }
-  return whereClauses.join(" AND ");
-}
-function getCosmosQueryWhereInner(ctx, parameters, whereArgs) {
-  const { operator, whereVal, name, namePrefix, paramName, paramNamePrefix } = whereArgs;
-  if (!operator && ___default.isObject(whereVal)) {
-    return getCosmosQueryWhere(ctx, parameters, whereVal, `${namePrefix}${name}.`, `${paramNamePrefix}${paramName}_`);
-  }
-  const fn = operatorHandlers[operator || "eq"];
-  if (!fn)
-    console.warn(`Unsupported operator: "${operator}"`);
-  return fn(ctx, parameters, whereArgs);
-}
-function getCosmosContainerClient(options) {
-  options = { databaseName: "main", containerName: "main", ...options };
-  const { databaseName, containerName, endpoint } = options;
-  const key = `${endpoint}|${databaseName}|${containerName}`;
-  if (!containerClientCache[key]) {
-    containerClientCache[key] = getCosmosDatabaseClient(options).container(containerName);
-  }
-  return containerClientCache[key];
-}
-function getCosmosDatabaseClient(options) {
-  options = { databaseName: "main", containerName: "main", ...options };
-  const { databaseName, endpoint } = options;
-  const key = `${endpoint}|${databaseName}`;
-  if (!databaseClientCache[key]) {
-    databaseClientCache[key] = getCosmosAccountClient(options).database(databaseName);
-  }
-  return databaseClientCache[key];
-}
-function getCosmosAccountClient(options) {
-  options = { databaseName: "main", containerName: "main", ...options };
-  const { endpoint, accountKey } = options;
-  const key = endpoint;
-  if (!cosmosClientCache[key]) {
-    cosmosClientCache[key] = new cosmos.CosmosClient({ endpoint, key: accountKey, ...options.options });
-  }
-  return cosmosClientCache[key];
-}
-function getWhereNameOperatorPair(whereKey) {
-  if (whereKey.startsWith("_type")) {
-    const operator = whereKey.split("_")[2];
-    return ["_type", operator];
-  }
-  return whereKey.split("_");
-}
-
 const computedPresets = {
   createdAt: ({ doc }) => {
     return doc.createdAt || (/* @__PURE__ */ new Date()).toISOString();
@@ -818,11 +484,10 @@ async function handleEffectsAfterPut(ctx, docs, beforePutResults) {
   return Promise.all(ctx.effects[ctx.typeName].map((ef, i) => ef.afterPut(ctx, docs, beforePutResults[i])));
 }
 
-const driverConstructors = { memory, restApi, azureCosmos };
-const drivers = {};
 function generateMethods(schema, validators, options) {
+  const drivers = {};
   const db = { _schema: schema };
-  const opts = { computed: {}, driver: { type: "memory" }, ...options };
+  const opts = { computed: {}, driver: memory(), ...options };
   const effects = {};
   for (const key in schema) {
     effects[key] = [];
@@ -835,8 +500,8 @@ function generateMethods(schema, validators, options) {
     const { handle } = schema[key];
     if (!handle)
       throw new Error(`Missing handle for entity ${key}`);
-    const driverInstance = getDriverInstance(schema, key, opts.driver);
     const computedContext = { schema, typeName: key, validators, options: opts, drivers, effects };
+    const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
     db[handle] = {
       getAgg: async (args, ctx) => {
         if (!args?.agg)
@@ -847,16 +512,17 @@ function generateMethods(schema, validators, options) {
       get: async (args, ctx) => {
         args = args || {};
         const result = await driverInstance.get(args, ctx);
-        if (args.include)
-          await handleInclude(schema, key, args.include, [result]);
-        await handleComputed(schema, key, opts, [result]);
+        if (result && args.include)
+          await handleInclude(computedContext, args.include, [result]);
+        if (result)
+          await handleComputed(schema, key, opts, [result]);
         return result;
       },
       getMany: async (args, ctx) => {
         args = args || {};
         const result = await driverInstance.getMany(args, ctx);
         if (args.include)
-          await handleInclude(schema, key, args.include, result.nodes);
+          await handleInclude(computedContext, args.include, result.nodes);
         await handleComputed(schema, key, opts, result.nodes);
         return result;
       },
@@ -864,7 +530,7 @@ function generateMethods(schema, validators, options) {
         args = args || {};
         const result = await driverInstance.getAll(args, ctx);
         if (args.include)
-          await handleInclude(schema, key, args.include, result);
+          await handleInclude(computedContext, args.include, result);
         await handleComputed(schema, key, opts, result);
         return result;
       },
@@ -910,16 +576,17 @@ function generateMethods(schema, validators, options) {
   }
   return db;
 }
-async function handleInclude(schema, entityName, include, result) {
+async function handleInclude(computedContext, include, result) {
   if (!result || !result.length || !include)
     return;
-  const fields = schema[entityName].fields || {};
+  const { schema, typeName, drivers } = computedContext;
+  const fields = schema[typeName].fields || {};
   const relationsToInclude = ___default.keys(include).filter((key) => include[key] && schema[fields[key].type].decorators.entity);
   const downloadRelationsPromises = relationsToInclude.map(async (fieldName) => {
-    const typeName = fields[fieldName].type;
-    const type = schema[typeName];
+    const typeName2 = fields[fieldName].type;
+    const type = schema[typeName2];
     if (!type)
-      throw new Error(`Cannot find entity ${typeName}`);
+      throw new Error(`Cannot find entity ${typeName2}`);
     const idsToGet = /* @__PURE__ */ new Set();
     for (const item of result) {
       if (!item)
@@ -935,7 +602,7 @@ async function handleInclude(schema, entityName, include, result) {
         idsToGet.add(id);
       }
     }
-    const driverInstance = getExistingDriverInstance(typeName);
+    const driverInstance = getExistingDriverInstance(typeName2, drivers);
     const relatedEntities = await driverInstance.getAll({ where: { id_in: [...idsToGet] } });
     const relatedEntitiesById = ___default.keyBy(relatedEntities, "id");
     for (const item of result) {
@@ -951,28 +618,27 @@ async function handleInclude(schema, entityName, include, result) {
           continue;
         const relatedEntity = relatedEntitiesById[id];
         if (!relatedEntity)
-          console.warn(`Cannot find ${typeName} with id "${id}" (for ${entityName}.${fieldName} with id "${item.id}")`);
+          console.warn(`Cannot find ${typeName2} with id "${id}" (for ${typeName2}.${fieldName} with id "${item.id}")`);
         Object.assign(fv, relatedEntity);
       }
     }
   });
   await Promise.all(downloadRelationsPromises);
 }
-function getExistingDriverInstance(entityName) {
+function getExistingDriverInstance(entityName, drivers) {
   if (!drivers[entityName]) {
     throw new Error(`Driver for entity ${entityName} was not found!`);
   }
   return drivers[entityName];
 }
-function getDriverInstance(schema, key, driver) {
+function getDriverInstance(schema, key, driver, drivers) {
   if (!drivers[key]) {
     drivers[key] = getDriverInstanceInner(schema, key, driver);
   }
   return drivers[key];
 }
-function getDriverInstanceInner(schema, key, driver) {
-  const driverConstructor = driverConstructors[driver.type];
-  const driverInstance = driverConstructor(schema, key, driver);
+function getDriverInstanceInner(schema, key, driverConstructor) {
+  const driverInstance = driverConstructor(schema, key);
   async function getAll(args, ctx) {
     const result = [];
     let cursor = args.cursor;
@@ -1010,7 +676,7 @@ function getDriverInstanceInner(schema, key, driver) {
       await driverInstance.putMany([data], ctx);
     },
     async clear() {
-      console.error(`"clear" not supported for driver "${driver.type}"`);
+      console.error(`"clear" not supported for driver "${driverInstance.driverName}"`);
     },
     ...driverInstance
   };

package/dist/index.d.ts

@@ -73,11 +73,11 @@ interface ComputedDecoratorArgs {
 interface FieldDecoratorArgs {
     relation?: Function;
 }
+type DriverConstructor = (schema: Schema, entity: string) => MinimalDriver;
 interface CreateRadsArgs {
     schema?: Schema;
-    driver?: DriverOptions;
-    drivers?: Record<string, DriverOptions>;
-    defaultDriver?: string;
+    driver?: DriverConstructor;
+    drivers?: Record<string, DriverConstructor>;
     computed?: Record<string, Record<string, Function>>;
     context?: Record<string, any>;
 }
@@ -96,6 +96,7 @@ interface TypeDefinition {
     handlePlural?: string;
 }
 interface MinimalDriver {
+    driverName: string;
     putMany: (item: Record<string, any>[], ctx?: RadsRequestContext) => MaybePromise<void>;
     getMany: (args?: GetManyArgsAny, ctx?: RadsRequestContext) => MaybePromise<{
         nodes: Record<string, any>[];
@@ -136,7 +137,6 @@ interface PutEffect {
     }[], beforePutResult: any) => MaybePromise<any>;
 }
 interface RestDriverOptions {
-    type: 'restApi';
     /** @default '/api' */
     baseUrl?: string;
     fetch?: (url: string, options?: {
@@ -146,10 +146,8 @@ interface RestDriverOptions {
     }) => any;
 }
 interface MemoryDriverOptions {
-    type: 'memory';
 }
 interface AzureCosmosDriverOptions {
-    type: 'azureCosmos';
     endpoint: string;
     accountKey?: string;
     databaseName?: string;
@@ -169,10 +167,10 @@ interface RadsRequestContext {
 
 declare function entity(meta?: EntityDecoratorArgs): (classConstructor: Function, _ctx?: ClassDecoratorContext<any>) => void;
 declare function field(meta?: FieldDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext) => void;
-declare function precomputed(meta?: ComputedDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext) => void;
+declare function precomputed(meta?: ComputedDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext | ClassDecoratorContext) => void;
 declare function computed(meta?: ComputedDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext) => void;
 
 declare function createRads(args?: CreateRadsArgs): RadsDb;
 declare function getRestRoutes(db: RadsDb, prefix?: string): Record<string, Record<string, Function>>;
 
-export { AzureCosmosDriverOptions, Change, ComputedContext, ComputedDecoratorArgs, CreateRadsArgs, DeepPartial, Driver, DriverOptions, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, MemoryDriverOptions, MinimalDriver, PutArgs, PutEffect, RadsRequestContext, RestDriverOptions, Schema, SchemaValidators, TypeDefinition, computed, createRads, entity, field, getRestRoutes, precomputed };
+export { AzureCosmosDriverOptions, Change, ComputedContext, ComputedDecoratorArgs, CreateRadsArgs, DeepPartial, Driver, DriverConstructor, DriverOptions, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, MemoryDriverOptions, MinimalDriver, PutArgs, PutEffect, RadsRequestContext, RestDriverOptions, Schema, SchemaValidators, TypeDefinition, computed, createRads, entity, field, getRestRoutes, precomputed };

package/dist/index.mjs

@@ -1,7 +1,5 @@
 import { z } from 'zod';
 import _ from 'lodash';
-import pluralize from 'pluralize';
-import { CosmosClient } from '@azure/cosmos';
 import { v4 } from 'uuid';
 import { schema } from '_rads-db';
 
@@ -110,7 +108,7 @@ const operatorFns = {
     return result;
   }
 };
-const memory = (schema, entity) => {
+const memory = (options) => (schema, entity) => {
   let cache = {};
   function getItemById(id) {
     return cache[id] ?? null;
@@ -119,6 +117,7 @@ const memory = (schema, entity) => {
     return ids.map((id) => cache[id]);
   }
   const instance = {
+    driverName: "memory",
     clear() {
       cache = {};
     },
@@ -187,7 +186,7 @@ function getFilter(where, namePrefix = "") {
     return null;
   const andClauses = [];
   for (const key in where) {
-    const [nameFromWhere, operator] = getWhereNameOperatorPair$1(key);
+    const [nameFromWhere, operator] = getWhereNameOperatorPair(key);
     const name = [namePrefix, nameFromWhere].filter((x) => x).join(".");
     const whereVal = where[key];
     if (whereVal == null)
@@ -200,7 +199,7 @@ function getFilter(where, namePrefix = "") {
     return null;
   return (x) => andClauses.every((ac) => ac(x));
 }
-function getWhereNameOperatorPair$1(whereKey) {
+function getWhereNameOperatorPair(whereKey) {
   if (whereKey.startsWith("_type")) {
     const operator = whereKey.split("_")[2];
     return ["_type", operator];
@@ -263,338 +262,6 @@ function prepareArgs(args) {
   return { where, orderByProperty, orderByDirection, maxItemCount, cursor: args.cursor };
 }
 
-const restApi = (schema, entity, options) => {
-  options = { baseUrl: "/api", fetch: globalThis.fetch, ...options };
-  const fetch = options.fetch || global.fetch;
-  if (!options.fetch)
-    throw new Error('Please provide "fetch" argument to rest driver definition');
-  const pluralEntityName = _.lowerFirst(pluralize(entity));
-  const instance = {
-    async getMany(args) {
-      args = args || {};
-      const response = await fetch(`${options.baseUrl}/${pluralEntityName}`, {
-        method: "POST",
-        body: JSON.stringify(args)
-      });
-      return await response?.json();
-    },
-    async putMany(item) {
-      await fetch(`${options.baseUrl}/${pluralEntityName}`, {
-        method: "PUT",
-        body: JSON.stringify({ data: item })
-      });
-    }
-  };
-  return instance;
-};
-
-const cosmosClientCache = {};
-const databaseClientCache = {};
-const containerClientCache = {};
-const simpleSubclauseRegex = /^[a-z0-9_@]+.[a-z0-9_@]+ = [a-z0-9_@.]+$/i;
-const azureCosmos = (schema, entity, options) => {
-  const client = getCosmosContainerClient(options);
-  async function getItemByIds(ids, ctx) {
-    const { query, parameters } = getCosmosQuery(schema, entity, { where: { id_in: ids } });
-    const response = client.items.query({
-      query,
-      parameters: Object.keys(parameters).map((k) => ({ name: `@${k}`, value: parameters[k] }))
-    });
-    const r = await response.fetchAll();
-    ctx?.log?.({ charge: r.requestCharge, request: query });
-    return r.resources;
-  }
-  const instance = {
-    async clear(ctx) {
-      const responseIter = client.items.readAll();
-      const items = await responseIter.fetchAll();
-      ctx?.log?.({ charge: items.requestCharge, request: "readAll" });
-      for (const r of items.resources) {
-        await client.item(r.id, r._partition).delete();
-        ctx?.log?.({ charge: items.requestCharge, request: `delete#${r._partition}|${r.id}` });
-      }
-    },
-    async putMany(items, ctx) {
-      for (const item of items) {
-        const id = item?.id;
-        if (!id)
-          throw new Error(`You must provide an id`);
-        const itemToPut = { _partition: entity, id, ...item };
-        const response = await client.items.upsert(itemToPut);
-        ctx?.log?.({ charge: response.requestCharge, request: `put#${itemToPut._partition}|${itemToPut.id}` });
-      }
-    },
-    async getMany(args, ctx) {
-      args = args || {};
-      const where = args.where || {};
-      const whereKeys = _.keys(where);
-      if (whereKeys.length === 1) {
-        if (whereKeys[0] === "id" && where.id != null) {
-          const items = await getItemByIds([where.id], ctx);
-          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);
-          return { nodes: items.filter((x) => x), cursor: null };
-        }
-      }
-      const { query, parameters } = getCosmosQuery(schema, entity, args);
-      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();
-      ctx?.log?.({ charge: page.requestCharge, request: query });
-      return {
-        nodes: page.resources,
-        cursor: page.continuationToken || null
-      };
-    }
-  };
-  return instance;
-};
-function getCosmosQuery(schema, entity, args) {
-  args = args || {};
-  const where = args.where || {};
-  const parameters = {};
-  const whereClauses = [
-    `r._partition = '${entity}'`,
-    getCosmosQueryWhere({ schema, entity }, parameters, where)
-  ].filter((x) => x);
-  let orderByClause = "";
-  if (args.orderBy) {
-    const [orderPropFromOrderBy, orderDirection] = args.orderBy.split("_") || [];
-    const orderProp = orderPropFromOrderBy === "value" ? `r["value"]` : `r.${orderPropFromOrderBy}`;
-    orderByClause = `order by ${orderProp} ${orderDirection}`;
-  }
-  const query = `select * from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
-  return { query, parameters };
-}
-const operatorHandlers = {
-  some: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, whereVal } = whereArgs;
-    const newCtx = { ...ctx, entity: ctx.schema[ctx.entity].fields[ctx.field].type };
-    const subClause = getCosmosQueryWhere(newCtx, parameters, whereVal, `${namePrefix}${name}.`);
-    if (subClause) {
-      if (simpleSubclauseRegex.test(subClause)) {
-        const parts = subClause.split(" ");
-        const field = parts[0];
-        const variable = parts[2];
-        return `array_contains(${namePrefix}${name}, { ${field.split(".")[1]}: ${variable} }, true)`;
-      }
-      return `exists (select ${name} from ${name} in ${namePrefix}${name} where ${subClause})`;
-    }
-    return `array_length(${namePrefix}${name}) > 0`;
-  },
-  none: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, whereVal } = whereArgs;
-    const newCtx = { ...ctx, entity: ctx.schema[ctx.entity].fields[ctx.field].type };
-    const subClause = getCosmosQueryWhere(newCtx, parameters, whereVal, `${namePrefix}${name}.`);
-    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`);
-    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;
-    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;
-    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`);
-    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;
-    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)`;
-    return `(is_defined(${n}) and ${n} != null)`;
-  },
-  eq: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} = @${pn}`;
-  },
-  in: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `array_contains(@${pn}, ${namePrefix}${name})`;
-  },
-  startsWith: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `startswith(${namePrefix}${name}, @${pn})`;
-  },
-  istartsWith: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `startswith(${namePrefix}${name}, @${pn}, true)`;
-  },
-  endsWith: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `endswith(${namePrefix}${name}, @${pn})`;
-  },
-  iendsWith: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `endswith(${namePrefix}${name}, @${pn}, true)`;
-  },
-  contains: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const fieldType = ctx.schema[ctx.entity].fields[ctx.field];
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    if (fieldType.isArray) {
-      return `array_contains(${namePrefix}${name}, @${pn})`;
-    }
-    return `contains(${namePrefix}${name}, @${pn})`;
-  },
-  icontains: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `contains(${namePrefix}${name}, @${pn}, true)`;
-  },
-  ieq: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `stringequals(${namePrefix}${name}, @${pn}, true)`;
-  },
-  gt: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} > @${pn}`;
-  },
-  gte: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} >= @${pn}`;
-  },
-  lt: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} < @${pn}`;
-  },
-  lte: (ctx, parameters, whereArgs) => {
-    const { name, namePrefix, paramName, paramNamePrefix, whereVal } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} <= @${pn}`;
-  }
-};
-function getCosmosQueryWhere(ctx, parameters, where, namePrefix = "r.", paramNamePrefix = "") {
-  const whereClauses = [];
-  for (const key in where) {
-    const [nameFromWhere, operator] = getWhereNameOperatorPair(key);
-    let name = nameFromWhere;
-    if (name === "value") {
-      name = `["${name}"]`;
-      namePrefix = namePrefix.slice(0, -1);
-    }
-    const paramName = key;
-    const whereVal = where[key];
-    if (whereVal == null)
-      continue;
-    const f = getCosmosQueryWhereInner({ ...ctx, field: nameFromWhere }, parameters, {
-      operator,
-      whereVal,
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix
-    });
-    if (f)
-      whereClauses.push(f);
-  }
-  return whereClauses.join(" AND ");
-}
-function getCosmosQueryWhereInner(ctx, parameters, whereArgs) {
-  const { operator, whereVal, name, namePrefix, paramName, paramNamePrefix } = whereArgs;
-  if (!operator && _.isObject(whereVal)) {
-    return getCosmosQueryWhere(ctx, parameters, whereVal, `${namePrefix}${name}.`, `${paramNamePrefix}${paramName}_`);
-  }
-  const fn = operatorHandlers[operator || "eq"];
-  if (!fn)
-    console.warn(`Unsupported operator: "${operator}"`);
-  return fn(ctx, parameters, whereArgs);
-}
-function getCosmosContainerClient(options) {
-  options = { databaseName: "main", containerName: "main", ...options };
-  const { databaseName, containerName, endpoint } = options;
-  const key = `${endpoint}|${databaseName}|${containerName}`;
-  if (!containerClientCache[key]) {
-    containerClientCache[key] = getCosmosDatabaseClient(options).container(containerName);
-  }
-  return containerClientCache[key];
-}
-function getCosmosDatabaseClient(options) {
-  options = { databaseName: "main", containerName: "main", ...options };
-  const { databaseName, endpoint } = options;
-  const key = `${endpoint}|${databaseName}`;
-  if (!databaseClientCache[key]) {
-    databaseClientCache[key] = getCosmosAccountClient(options).database(databaseName);
-  }
-  return databaseClientCache[key];
-}
-function getCosmosAccountClient(options) {
-  options = { databaseName: "main", containerName: "main", ...options };
-  const { endpoint, accountKey } = options;
-  const key = endpoint;
-  if (!cosmosClientCache[key]) {
-    cosmosClientCache[key] = new CosmosClient({ endpoint, key: accountKey, ...options.options });
-  }
-  return cosmosClientCache[key];
-}
-function getWhereNameOperatorPair(whereKey) {
-  if (whereKey.startsWith("_type")) {
-    const operator = whereKey.split("_")[2];
-    return ["_type", operator];
-  }
-  return whereKey.split("_");
-}
-
 const computedPresets = {
   createdAt: ({ doc }) => {
     return doc.createdAt || (/* @__PURE__ */ new Date()).toISOString();
@@ -811,11 +478,10 @@ async function handleEffectsAfterPut(ctx, docs, beforePutResults) {
   return Promise.all(ctx.effects[ctx.typeName].map((ef, i) => ef.afterPut(ctx, docs, beforePutResults[i])));
 }
 
-const driverConstructors = { memory, restApi, azureCosmos };
-const drivers = {};
 function generateMethods(schema, validators, options) {
+  const drivers = {};
   const db = { _schema: schema };
-  const opts = { computed: {}, driver: { type: "memory" }, ...options };
+  const opts = { computed: {}, driver: memory(), ...options };
   const effects = {};
   for (const key in schema) {
     effects[key] = [];
@@ -828,8 +494,8 @@ function generateMethods(schema, validators, options) {
     const { handle } = schema[key];
     if (!handle)
       throw new Error(`Missing handle for entity ${key}`);
-    const driverInstance = getDriverInstance(schema, key, opts.driver);
     const computedContext = { schema, typeName: key, validators, options: opts, drivers, effects };
+    const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
     db[handle] = {
       getAgg: async (args, ctx) => {
         if (!args?.agg)
@@ -840,16 +506,17 @@ function generateMethods(schema, validators, options) {
       get: async (args, ctx) => {
         args = args || {};
         const result = await driverInstance.get(args, ctx);
-        if (args.include)
-          await handleInclude(schema, key, args.include, [result]);
-        await handleComputed(schema, key, opts, [result]);
+        if (result && args.include)
+          await handleInclude(computedContext, args.include, [result]);
+        if (result)
+          await handleComputed(schema, key, opts, [result]);
         return result;
       },
       getMany: async (args, ctx) => {
         args = args || {};
         const result = await driverInstance.getMany(args, ctx);
         if (args.include)
-          await handleInclude(schema, key, args.include, result.nodes);
+          await handleInclude(computedContext, args.include, result.nodes);
         await handleComputed(schema, key, opts, result.nodes);
         return result;
       },
@@ -857,7 +524,7 @@ function generateMethods(schema, validators, options) {
         args = args || {};
         const result = await driverInstance.getAll(args, ctx);
         if (args.include)
-          await handleInclude(schema, key, args.include, result);
+          await handleInclude(computedContext, args.include, result);
         await handleComputed(schema, key, opts, result);
         return result;
       },
@@ -903,16 +570,17 @@ function generateMethods(schema, validators, options) {
   }
   return db;
 }
-async function handleInclude(schema, entityName, include, result) {
+async function handleInclude(computedContext, include, result) {
   if (!result || !result.length || !include)
     return;
-  const fields = schema[entityName].fields || {};
+  const { schema, typeName, drivers } = computedContext;
+  const fields = schema[typeName].fields || {};
   const relationsToInclude = _.keys(include).filter((key) => include[key] && schema[fields[key].type].decorators.entity);
   const downloadRelationsPromises = relationsToInclude.map(async (fieldName) => {
-    const typeName = fields[fieldName].type;
-    const type = schema[typeName];
+    const typeName2 = fields[fieldName].type;
+    const type = schema[typeName2];
     if (!type)
-      throw new Error(`Cannot find entity ${typeName}`);
+      throw new Error(`Cannot find entity ${typeName2}`);
     const idsToGet = /* @__PURE__ */ new Set();
     for (const item of result) {
       if (!item)
@@ -928,7 +596,7 @@ async function handleInclude(schema, entityName, include, result) {
         idsToGet.add(id);
       }
     }
-    const driverInstance = getExistingDriverInstance(typeName);
+    const driverInstance = getExistingDriverInstance(typeName2, drivers);
     const relatedEntities = await driverInstance.getAll({ where: { id_in: [...idsToGet] } });
     const relatedEntitiesById = _.keyBy(relatedEntities, "id");
     for (const item of result) {
@@ -944,28 +612,27 @@ async function handleInclude(schema, entityName, include, result) {
           continue;
         const relatedEntity = relatedEntitiesById[id];
         if (!relatedEntity)
-          console.warn(`Cannot find ${typeName} with id "${id}" (for ${entityName}.${fieldName} with id "${item.id}")`);
+          console.warn(`Cannot find ${typeName2} with id "${id}" (for ${typeName2}.${fieldName} with id "${item.id}")`);
         Object.assign(fv, relatedEntity);
       }
     }
   });
   await Promise.all(downloadRelationsPromises);
 }
-function getExistingDriverInstance(entityName) {
+function getExistingDriverInstance(entityName, drivers) {
   if (!drivers[entityName]) {
     throw new Error(`Driver for entity ${entityName} was not found!`);
   }
   return drivers[entityName];
 }
-function getDriverInstance(schema, key, driver) {
+function getDriverInstance(schema, key, driver, drivers) {
   if (!drivers[key]) {
     drivers[key] = getDriverInstanceInner(schema, key, driver);
   }
   return drivers[key];
 }
-function getDriverInstanceInner(schema, key, driver) {
-  const driverConstructor = driverConstructors[driver.type];
-  const driverInstance = driverConstructor(schema, key, driver);
+function getDriverInstanceInner(schema, key, driverConstructor) {
+  const driverInstance = driverConstructor(schema, key);
   async function getAll(args, ctx) {
     const result = [];
     let cursor = args.cursor;
@@ -1003,7 +670,7 @@ function getDriverInstanceInner(schema, key, driver) {
       await driverInstance.putMany([data], ctx);
     },
     async clear() {
-      console.error(`"clear" not supported for driver "${driver.type}"`);
+      console.error(`"clear" not supported for driver "${driverInstance.driverName}"`);
     },
     ...driverInstance
   };

package/drivers/azureCosmos.cjs

@@ -11,7 +11,7 @@ const cosmosClientCache = {};
 const databaseClientCache = {};
 const containerClientCache = {};
 const simpleSubclauseRegex = /^[a-z0-9_@]+.[a-z0-9_@]+ = [a-z0-9_@.]+$/i;
-var _default = (schema, entity, options) => {
+var _default = options => (schema, entity) => {
   const client = getCosmosContainerClient(options);
   async function getItemByIds(ids, ctx) {
     const {
@@ -37,6 +37,7 @@ var _default = (schema, entity, options) => {
     return r.resources;
   }
   const instance = {
+    driverName: "azureCosmos",
     async clear(ctx) {
       const responseIter = client.items.readAll();
       const items = await responseIter.fetchAll();

package/drivers/azureCosmos.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (schema: Schema, entity: string, options: AzureCosmosDriverOptions) => MinimalDriver;
+declare const _default: (options: AzureCosmosDriverOptions) => (schema: Schema, entity: string) => MinimalDriver;
 export default _default;

package/drivers/azureCosmos.mjs

@@ -4,7 +4,7 @@ const cosmosClientCache = {};
 const databaseClientCache = {};
 const containerClientCache = {};
 const simpleSubclauseRegex = /^[a-z0-9_@]+.[a-z0-9_@]+ = [a-z0-9_@.]+$/i;
-export default (schema, entity, options) => {
+export default (options) => (schema, entity) => {
   const client = getCosmosContainerClient(options);
   async function getItemByIds(ids, ctx) {
     const { query, parameters } = getCosmosQuery(schema, entity, { where: { id_in: ids } });
@@ -17,6 +17,7 @@ export default (schema, entity, options) => {
     return r.resources;
   }
   const instance = {
+    driverName: "azureCosmos",
     async clear(ctx) {
       const responseIter = client.items.readAll();
       const items = await responseIter.fetchAll();

package/drivers/memory.cjs

@@ -38,7 +38,7 @@ const operatorFns = {
     return result;
   }
 };
-var _default = (schema, entity) => {
+var _default = options => (schema, entity) => {
   let cache = {};
   function getItemById(id) {
     return cache[id] ?? null;
@@ -47,6 +47,7 @@ var _default = (schema, entity) => {
     return ids.map(id => cache[id]);
   }
   const instance = {
+    driverName: "memory",
     clear() {
       cache = {};
     },

package/drivers/memory.d.ts

@@ -1,5 +1,5 @@
 import type { GetAggArgsAny, GetManyArgsAny } from '@/typesClientEngine';
-declare const _default: (schema: Schema, entity: string) => MinimalDriver;
+declare const _default: (options?: any) => (schema: Schema, entity: string) => MinimalDriver;
 export default _default;
 export declare function getAggFromArray(array: any[], args: GetAggArgsAny): Record<string, any>;
 export declare function queryArray(array: any[], args: GetManyArgsAny): {

package/drivers/memory.mjs

@@ -30,7 +30,7 @@ const operatorFns = {
     return result;
   }
 };
-export default (schema, entity) => {
+export default (options) => (schema, entity) => {
   let cache = {};
   function getItemById(id) {
     return cache[id] ?? null;
@@ -39,6 +39,7 @@ export default (schema, entity) => {
     return ids.map((id) => cache[id]);
   }
   const instance = {
+    driverName: "memory",
     clear() {
       cache = {};
     },

package/drivers/restApi.cjs

@@ -7,7 +7,7 @@ module.exports = void 0;
 var _lodash = _interopRequireDefault(require("lodash"));
 var _pluralize = _interopRequireDefault(require("pluralize"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-var _default = (schema, entity, options) => {
+var _default = options => (schema, entity) => {
   options = {
     baseUrl: "/api",
     fetch: globalThis.fetch,
@@ -17,6 +17,7 @@ var _default = (schema, entity, options) => {
   if (!options.fetch) throw new Error('Please provide "fetch" argument to rest driver definition');
   const pluralEntityName = _lodash.default.lowerFirst((0, _pluralize.default)(entity));
   const instance = {
+    driverName: "restApi",
     async getMany(args) {
       args = args || {};
       const response = await fetch(`${options.baseUrl}/${pluralEntityName}`, {

package/drivers/restApi.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (schema: Schema, entity: string, options: RestDriverOptions) => MinimalDriver;
+declare const _default: (options: RestDriverOptions) => (schema: Schema, entity: string) => MinimalDriver;
 export default _default;

package/drivers/restApi.mjs

@@ -1,12 +1,13 @@
 import _ from "lodash";
 import pluralize from "pluralize";
-export default (schema, entity, options) => {
+export default (options) => (schema, entity) => {
   options = { baseUrl: "/api", fetch: globalThis.fetch, ...options };
   const fetch = options.fetch || global.fetch;
   if (!options.fetch)
     throw new Error('Please provide "fetch" argument to rest driver definition');
   const pluralEntityName = _.lowerFirst(pluralize(entity));
   const instance = {
+    driverName: "restApi",
     async getMany(args) {
       args = args || {};
       const response = await fetch(`${options.baseUrl}/${pluralEntityName}`, {

package/package.json

@@ -28,7 +28,7 @@
       "require": "./integrations/*.cjs"
     }
   },
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "keywords": [],
   "author": "",