rads-db 0.1.92 → 0.1.94

package/dist/index.cjs

@@ -131,23 +131,26 @@ const operatorFns = {
   }
 };
 const memory = (options) => (schema, entity) => {
-  let cache = {};
+  let itemsById = {};
   function getItemById(id) {
-    return cache[id] ?? null;
+    return itemsById[id] ?? null;
   }
   function getItemByIds(ids) {
-    return ids.map((id) => cache[id]);
+    return ids.map((id) => itemsById[id]);
   }
   const instance = {
     driverName: "memory",
+    get itemsById() {
+      return itemsById;
+    },
     clear() {
-      cache = {};
+      itemsById = {};
     },
     putMany(items) {
       for (const item of items) {
         if (!item?.id)
           throw new Error(`You must provide an id`);
-        cache[item.id] = item;
+        itemsById[item.id] = item;
       }
     },
     getMany(args) {
@@ -160,7 +163,7 @@ const memory = (options) => (schema, entity) => {
         if (whereKeys[0] === "id_in")
           return { nodes: ___default.cloneDeep(getItemByIds(where.id_in).filter((x) => x)), cursor: null };
       }
-      return queryArray(Object.values(cache), args);
+      return queryArray(Object.values(itemsById), args);
     }
   };
   return instance;
@@ -267,7 +270,7 @@ function getFilterInner(operator, whereVal, name, namePrefix) {
   if (operatorFn) {
     return (x) => operatorFn(___default.get(x, name), whereVal);
   }
-  console.warn(`[rads-cache] Operator not supported: ${operator || "eq"}`);
+  console.warn(`[rads-db] Operator not supported: ${operator || "eq"}`);
   return null;
 }
 function prepareArgs(args) {
@@ -705,14 +708,15 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
   const { precomputedFields } = schema[key];
   async function getMany(args, ctx) {
     args = { ...args, where: { ...args?.where } };
-    ctx = { ...options.context, ...ctx };
-    await beforeGet(args, ctx, computedContext);
-    const result = await driverInstance.getMany(args, ctx);
+    ctx = { ...options.context, ...ctx, method: "getMany" };
+    let result2 = await beforeGet(args, ctx, computedContext);
+    if (!result2)
+      result2 = await driverInstance.getMany(args, ctx);
     if (args.include)
-      await handleInclude(computedContext, args.include, result.nodes, ctx);
-    await handleComputed(computedContext, result.nodes, ctx);
-    await afterGet(result.nodes, args, ctx, computedContext);
-    return result;
+      await handleInclude(computedContext, args.include, result2.nodes, ctx);
+    await handleComputed(computedContext, result2.nodes, ctx);
+    await afterGet(result2.nodes, args, ctx, computedContext);
+    return result2;
   }
   async function putMany(docs, ctx) {
     const precomputed = schema[key].decorators.precomputed;
@@ -726,7 +730,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
         throw new Error("Id is required");
       return i.id;
     });
-    ctx = { ...options.context, ...ctx };
+    ctx = { ...options.context, ...ctx, method: "putMany" };
     const oldDocs = await driverInstance.getAll({ where: { id_in: ids } }, ctx);
     const oldDocsById = ___default.keyBy(oldDocs, "id");
     const docArgsToSave = docs.map((doc) => {
@@ -753,7 +757,10 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
     await afterPut(docArgsToSave, ctx, computedContext);
     return docsToSave;
   }
-  return {
+  const result = {
+    createObject() {
+      throw new Error("Not implemented");
+    },
     getMany,
     putMany,
     driver: driverInstance,
@@ -761,34 +768,37 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       args = { ...args, where: { ...args?.where } };
       if (!args.agg)
         throw new Error(`Please provide 'agg' argument`);
-      ctx = { ...options.context, ...ctx };
-      await beforeGet(args, ctx, computedContext);
-      const result = await driverInstance.getAgg(args, ctx);
-      return result;
+      ctx = { ...options.context, ...ctx, method: "getAgg" };
+      let result2 = await beforeGet(args, ctx, computedContext);
+      if (!result2)
+        result2 = await driverInstance.getAgg(args, ctx);
+      return result2;
     },
     get: async (args, ctx) => {
       args = { ...args, where: { ...args?.where } };
-      ctx = { ...options.context, ...ctx };
-      await beforeGet(args, ctx, computedContext);
-      const result = await driverInstance.get(args, ctx);
-      const resultArray = [result];
-      if (result && args.include)
+      ctx = { ...options.context, ...ctx, method: "get" };
+      let result2 = await beforeGet(args, ctx, computedContext);
+      if (!result2)
+        result2 = await driverInstance.get(args, ctx);
+      const resultArray = result2 ? [result2] : [];
+      if (result2 && args.include)
         await handleInclude(computedContext, args.include, resultArray, ctx);
-      if (result)
+      if (result2)
         await handleComputed(computedContext, resultArray, ctx);
       await afterGet(resultArray, args, ctx, computedContext);
-      return result;
+      return result2;
     },
     getAll: async (args, ctx) => {
       args = { ...args, where: { ...args?.where } };
-      ctx = { ...options.context, ...ctx };
-      await beforeGet(args, ctx, computedContext);
-      const result = await driverInstance.getAll(args, ctx);
+      ctx = { ...options.context, ...ctx, method: "getAll" };
+      let result2 = await beforeGet(args, ctx, computedContext);
+      if (!result2)
+        result2 = await driverInstance.getAll(args, ctx);
       if (args.include)
-        await handleInclude(computedContext, args.include, result, ctx);
-      await handleComputed(computedContext, result, ctx);
-      await afterGet(result, args, ctx, computedContext);
-      return result;
+        await handleInclude(computedContext, args.include, result2, ctx);
+      await handleComputed(computedContext, result2, ctx);
+      await afterGet(result2, args, ctx, computedContext);
+      return result2;
     },
     put: async (doc, ctx) => {
       const precomputed = schema[key].decorators.precomputed;
@@ -881,10 +891,17 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       return driverInstance.clear(ctx);
     }
   };
+  for (const f of options.features) {
+    if (f.enhanceEntityMethods)
+      f.enhanceEntityMethods(computedContext, result);
+  }
+  return result;
 }
 async function beforeGet(args, ctx, computedContext) {
   for (const f of computedContext.options.features) {
-    await f.beforeGet?.(args, ctx, computedContext);
+    const result = await f.beforeGet?.(args, ctx, computedContext);
+    if (result)
+      return result;
   }
 }
 async function afterGet(items, args, ctx, computedContext) {
@@ -980,6 +997,14 @@ function generateMethods(schema, validators, options) {
   }
   verifyEventSourcingSetup(schema, effects);
   verifyRelationsSetup(schema, effects);
+  const computedContextGlobal = {
+    schema,
+    validators,
+    options: opts,
+    drivers,
+    effects,
+    db
+  };
   for (const key in schema) {
     if (!schema[key].decorators.entity)
       continue;
@@ -987,17 +1012,17 @@ function generateMethods(schema, validators, options) {
     if (!handle)
       throw new Error(`Missing handle for entity ${key}`);
     const computedContext = {
-      schema,
+      ...computedContextGlobal,
       typeName: key,
-      validators,
-      options: opts,
-      drivers,
-      effects,
-      db
+      handle: schema[key].handle
     };
     const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
     db[handle] = getRadsDbMethods(key, computedContext, driverInstance);
   }
+  for (const f of opts.features) {
+    if (f.init)
+      f.init(db, computedContextGlobal);
+  }
   return db;
 }
 function getDriverInstance(schema, key, driver, drivers) {
@@ -1011,6 +1036,7 @@ function getDriverInstanceInner(schema, key, driverConstructor) {
   addDryRunSupport(driverInstance, key);
   async function getAll(args, ctx) {
     const result = [];
+    args = args || {};
     let cursor = args.cursor;
     let maxItemCount = args.maxItemCount || 1e3;
     if (maxItemCount < 1e3)
@@ -1122,6 +1148,7 @@ exports.computed = computed;
 exports.createRads = createRads;
 exports.entity = entity;
 exports.field = field;
+exports.getDriverInstance = getDriverInstance;
 exports.precomputed = precomputed;
 exports.ui = ui;
 exports.validate = validate;

package/dist/index.d.ts

@@ -234,15 +234,18 @@ interface FieldDefinition {
     comment?: string;
     decorators?: Record<string, Record<string, any>>;
 }
-interface ComputedContext {
+interface ComputedContextGlobal {
     db: RadsDb;
     schema: Schema;
-    typeName: string;
     validators: SchemaValidators;
     options: CreateRadsArgs;
     drivers: Record<string, Driver>;
     effects: Record<string, PutEffect[]>;
 }
+interface ComputedContext extends ComputedContextGlobal {
+    typeName: string;
+    handle: string;
+}
 interface PutEffect {
     beforePut?: (computedContext: ComputedContext, docs: {
         oldDoc: any;
@@ -290,6 +293,11 @@ interface RadsRequestContext {
     silent?: boolean;
     /** Mostly for internal use. When entity name is specified, indicates that calling put* on this entity is allowed, even if it's marked as @precomputed or @readonly */
     skipPrecomputedCheckFor?: string;
+    /** Mostly for internal use. Method that was called - get, getAll, getMany, getAgg, put, putMany, etc */
+    method?: string;
+    /** if true, all cache layers will be bypassed */
+    noCache?: boolean;
+    [key: string]: any;
 }
 interface FileSystemNode {
     path: string;
@@ -298,7 +306,9 @@ interface FileSystemNode {
 }
 interface RadsFeature {
     name: string;
-    beforeGet?: (args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<void>;
+    init?: (db: Record<string, any>, context: ComputedContextGlobal) => void;
+    enhanceEntityMethods?: (context: ComputedContext, entityMethodsObj: EntityMethods<any, any, any>) => void;
+    beforeGet?: (args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<any>;
     afterGet?: (items: any[], args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<void>;
     beforePut?: (items: {
         oldDoc: any;
@@ -317,6 +327,8 @@ declare function field(meta?: FieldDecoratorArgs): (a: any, b?: ClassFieldDecora
 declare function precomputed(meta?: ComputedDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext | ClassDecoratorContext) => void;
 declare function computed(meta?: ComputedDecoratorArgs): (a: any, b?: ClassFieldDecoratorContext | ClassDecoratorContext) => void;
 
+declare function getDriverInstance(schema: Schema, key: string, driver: DriverConstructor, drivers: Record<string, Driver>): Driver;
+
 declare function createRads(args?: CreateRadsArgs): RadsDb;
 
-export { Change, ComputedContext, ComputedDecoratorArgs, CreateRadsArgs, DeepPartial, Driver, DriverConstructor, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, FileSystemNode, FileUploadArgs, FileUploadDriver, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, GetRestRoutesArgs, GetRestRoutesOptions, GetRestRoutesResponse, MinimalDriver, PutArgs, PutEffect, RadsFeature, RadsRequestContext, RadsVitePluginOptions, Relation, RestFileUploadDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, ValidateEntityDecoratorArgs, ValidateFieldDecoratorArgs, ValidateStringDecoratorArgs, VerifyManyArgs, VerifyManyArgsAny, VerifyManyResponse, computed, createRads, entity, field, precomputed, ui, validate };
+export { Change, ComputedContext, ComputedContextGlobal, ComputedDecoratorArgs, CreateRadsArgs, DeepPartial, Driver, DriverConstructor, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, FileSystemNode, FileUploadArgs, FileUploadDriver, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, GetRestRoutesArgs, GetRestRoutesOptions, GetRestRoutesResponse, MinimalDriver, PutArgs, PutEffect, RadsFeature, RadsRequestContext, RadsVitePluginOptions, Relation, RestFileUploadDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, ValidateEntityDecoratorArgs, ValidateFieldDecoratorArgs, ValidateStringDecoratorArgs, VerifyManyArgs, VerifyManyArgsAny, VerifyManyResponse, computed, createRads, entity, field, getDriverInstance, precomputed, ui, validate };

package/dist/index.mjs

@@ -124,23 +124,26 @@ const operatorFns = {
   }
 };
 const memory = (options) => (schema, entity) => {
-  let cache = {};
+  let itemsById = {};
   function getItemById(id) {
-    return cache[id] ?? null;
+    return itemsById[id] ?? null;
   }
   function getItemByIds(ids) {
-    return ids.map((id) => cache[id]);
+    return ids.map((id) => itemsById[id]);
   }
   const instance = {
     driverName: "memory",
+    get itemsById() {
+      return itemsById;
+    },
     clear() {
-      cache = {};
+      itemsById = {};
     },
     putMany(items) {
       for (const item of items) {
         if (!item?.id)
           throw new Error(`You must provide an id`);
-        cache[item.id] = item;
+        itemsById[item.id] = item;
       }
     },
     getMany(args) {
@@ -153,7 +156,7 @@ const memory = (options) => (schema, entity) => {
         if (whereKeys[0] === "id_in")
           return { nodes: _.cloneDeep(getItemByIds(where.id_in).filter((x) => x)), cursor: null };
       }
-      return queryArray(Object.values(cache), args);
+      return queryArray(Object.values(itemsById), args);
     }
   };
   return instance;
@@ -260,7 +263,7 @@ function getFilterInner(operator, whereVal, name, namePrefix) {
   if (operatorFn) {
     return (x) => operatorFn(_.get(x, name), whereVal);
   }
-  console.warn(`[rads-cache] Operator not supported: ${operator || "eq"}`);
+  console.warn(`[rads-db] Operator not supported: ${operator || "eq"}`);
   return null;
 }
 function prepareArgs(args) {
@@ -698,14 +701,15 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
   const { precomputedFields } = schema[key];
   async function getMany(args, ctx) {
     args = { ...args, where: { ...args?.where } };
-    ctx = { ...options.context, ...ctx };
-    await beforeGet(args, ctx, computedContext);
-    const result = await driverInstance.getMany(args, ctx);
+    ctx = { ...options.context, ...ctx, method: "getMany" };
+    let result2 = await beforeGet(args, ctx, computedContext);
+    if (!result2)
+      result2 = await driverInstance.getMany(args, ctx);
     if (args.include)
-      await handleInclude(computedContext, args.include, result.nodes, ctx);
-    await handleComputed(computedContext, result.nodes, ctx);
-    await afterGet(result.nodes, args, ctx, computedContext);
-    return result;
+      await handleInclude(computedContext, args.include, result2.nodes, ctx);
+    await handleComputed(computedContext, result2.nodes, ctx);
+    await afterGet(result2.nodes, args, ctx, computedContext);
+    return result2;
   }
   async function putMany(docs, ctx) {
     const precomputed = schema[key].decorators.precomputed;
@@ -719,7 +723,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
         throw new Error("Id is required");
       return i.id;
     });
-    ctx = { ...options.context, ...ctx };
+    ctx = { ...options.context, ...ctx, method: "putMany" };
     const oldDocs = await driverInstance.getAll({ where: { id_in: ids } }, ctx);
     const oldDocsById = _.keyBy(oldDocs, "id");
     const docArgsToSave = docs.map((doc) => {
@@ -746,7 +750,10 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
     await afterPut(docArgsToSave, ctx, computedContext);
     return docsToSave;
   }
-  return {
+  const result = {
+    createObject() {
+      throw new Error("Not implemented");
+    },
     getMany,
     putMany,
     driver: driverInstance,
@@ -754,34 +761,37 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       args = { ...args, where: { ...args?.where } };
       if (!args.agg)
         throw new Error(`Please provide 'agg' argument`);
-      ctx = { ...options.context, ...ctx };
-      await beforeGet(args, ctx, computedContext);
-      const result = await driverInstance.getAgg(args, ctx);
-      return result;
+      ctx = { ...options.context, ...ctx, method: "getAgg" };
+      let result2 = await beforeGet(args, ctx, computedContext);
+      if (!result2)
+        result2 = await driverInstance.getAgg(args, ctx);
+      return result2;
     },
     get: async (args, ctx) => {
       args = { ...args, where: { ...args?.where } };
-      ctx = { ...options.context, ...ctx };
-      await beforeGet(args, ctx, computedContext);
-      const result = await driverInstance.get(args, ctx);
-      const resultArray = [result];
-      if (result && args.include)
+      ctx = { ...options.context, ...ctx, method: "get" };
+      let result2 = await beforeGet(args, ctx, computedContext);
+      if (!result2)
+        result2 = await driverInstance.get(args, ctx);
+      const resultArray = result2 ? [result2] : [];
+      if (result2 && args.include)
         await handleInclude(computedContext, args.include, resultArray, ctx);
-      if (result)
+      if (result2)
         await handleComputed(computedContext, resultArray, ctx);
       await afterGet(resultArray, args, ctx, computedContext);
-      return result;
+      return result2;
     },
     getAll: async (args, ctx) => {
       args = { ...args, where: { ...args?.where } };
-      ctx = { ...options.context, ...ctx };
-      await beforeGet(args, ctx, computedContext);
-      const result = await driverInstance.getAll(args, ctx);
+      ctx = { ...options.context, ...ctx, method: "getAll" };
+      let result2 = await beforeGet(args, ctx, computedContext);
+      if (!result2)
+        result2 = await driverInstance.getAll(args, ctx);
       if (args.include)
-        await handleInclude(computedContext, args.include, result, ctx);
-      await handleComputed(computedContext, result, ctx);
-      await afterGet(result, args, ctx, computedContext);
-      return result;
+        await handleInclude(computedContext, args.include, result2, ctx);
+      await handleComputed(computedContext, result2, ctx);
+      await afterGet(result2, args, ctx, computedContext);
+      return result2;
     },
     put: async (doc, ctx) => {
       const precomputed = schema[key].decorators.precomputed;
@@ -874,10 +884,17 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       return driverInstance.clear(ctx);
     }
   };
+  for (const f of options.features) {
+    if (f.enhanceEntityMethods)
+      f.enhanceEntityMethods(computedContext, result);
+  }
+  return result;
 }
 async function beforeGet(args, ctx, computedContext) {
   for (const f of computedContext.options.features) {
-    await f.beforeGet?.(args, ctx, computedContext);
+    const result = await f.beforeGet?.(args, ctx, computedContext);
+    if (result)
+      return result;
   }
 }
 async function afterGet(items, args, ctx, computedContext) {
@@ -973,6 +990,14 @@ function generateMethods(schema, validators, options) {
   }
   verifyEventSourcingSetup(schema, effects);
   verifyRelationsSetup(schema, effects);
+  const computedContextGlobal = {
+    schema,
+    validators,
+    options: opts,
+    drivers,
+    effects,
+    db
+  };
   for (const key in schema) {
     if (!schema[key].decorators.entity)
       continue;
@@ -980,17 +1005,17 @@ function generateMethods(schema, validators, options) {
     if (!handle)
       throw new Error(`Missing handle for entity ${key}`);
     const computedContext = {
-      schema,
+      ...computedContextGlobal,
       typeName: key,
-      validators,
-      options: opts,
-      drivers,
-      effects,
-      db
+      handle: schema[key].handle
     };
     const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
     db[handle] = getRadsDbMethods(key, computedContext, driverInstance);
   }
+  for (const f of opts.features) {
+    if (f.init)
+      f.init(db, computedContextGlobal);
+  }
   return db;
 }
 function getDriverInstance(schema, key, driver, drivers) {
@@ -1004,6 +1029,7 @@ function getDriverInstanceInner(schema, key, driverConstructor) {
   addDryRunSupport(driverInstance, key);
   async function getAll(args, ctx) {
     const result = [];
+    args = args || {};
     let cursor = args.cursor;
     let maxItemCount = args.maxItemCount || 1e3;
     if (maxItemCount < 1e3)
@@ -1111,4 +1137,4 @@ function createRads(args) {
   return generateMethods(s, validators, args);
 }
 
-export { computed, createRads, entity, field, precomputed, ui, validate };
+export { computed, createRads, entity, field, getDriverInstance, precomputed, ui, validate };

package/drivers/memory.cjs

@@ -39,22 +39,25 @@ const operatorFns = {
   }
 };
 var _default = options => (schema, entity) => {
-  let cache = {};
+  let itemsById = {};
   function getItemById(id) {
-    return cache[id] ?? null;
+    return itemsById[id] ?? null;
   }
   function getItemByIds(ids) {
-    return ids.map(id => cache[id]);
+    return ids.map(id => itemsById[id]);
   }
   const instance = {
     driverName: "memory",
+    get itemsById() {
+      return itemsById;
+    },
     clear() {
-      cache = {};
+      itemsById = {};
     },
     putMany(items) {
       for (const item of items) {
         if (!item?.id) throw new Error(`You must provide an id`);
-        cache[item.id] = item;
+        itemsById[item.id] = item;
       }
     },
     getMany(args) {
@@ -71,7 +74,7 @@ var _default = options => (schema, entity) => {
           cursor: null
         };
       }
-      return queryArray(Object.values(cache), args);
+      return queryArray(Object.values(itemsById), args);
     }
   };
   return instance;
@@ -169,7 +172,7 @@ function getFilterInner(operator, whereVal, name, namePrefix) {
   if (operatorFn) {
     return x => operatorFn(_lodash.default.get(x, name), whereVal);
   }
-  console.warn(`[rads-cache] Operator not supported: ${operator || "eq"}`);
+  console.warn(`[rads-db] Operator not supported: ${operator || "eq"}`);
   return null;
 }
 function prepareArgs(args) {

package/drivers/memory.mjs

@@ -31,23 +31,26 @@ const operatorFns = {
   }
 };
 export default (options) => (schema, entity) => {
-  let cache = {};
+  let itemsById = {};
   function getItemById(id) {
-    return cache[id] ?? null;
+    return itemsById[id] ?? null;
   }
   function getItemByIds(ids) {
-    return ids.map((id) => cache[id]);
+    return ids.map((id) => itemsById[id]);
   }
   const instance = {
     driverName: "memory",
+    get itemsById() {
+      return itemsById;
+    },
     clear() {
-      cache = {};
+      itemsById = {};
     },
     putMany(items) {
       for (const item of items) {
         if (!item?.id)
           throw new Error(`You must provide an id`);
-        cache[item.id] = item;
+        itemsById[item.id] = item;
       }
     },
     getMany(args) {
@@ -60,7 +63,7 @@ export default (options) => (schema, entity) => {
         if (whereKeys[0] === "id_in")
           return { nodes: _.cloneDeep(getItemByIds(where.id_in).filter((x) => x)), cursor: null };
       }
-      return queryArray(Object.values(cache), args);
+      return queryArray(Object.values(itemsById), args);
     }
   };
   return instance;
@@ -167,7 +170,7 @@ function getFilterInner(operator, whereVal, name, namePrefix) {
   if (operatorFn) {
     return (x) => operatorFn(_.get(x, name), whereVal);
   }
-  console.warn(`[rads-cache] Operator not supported: ${operator || "eq"}`);
+  console.warn(`[rads-db] Operator not supported: ${operator || "eq"}`);
   return null;
 }
 function prepareArgs(args) {

package/features/cache.cjs

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+var _memory = _interopRequireDefault(require("@/drivers/memory"));
+var _radsDb = require("rads-db");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _default = options => {
+  const normalizedOptions = normalizeOptions(options);
+  const cacheDrivers = {};
+  const cacheStatus = {};
+  return {
+    name: "cache",
+    init(db, context) {
+      const entitiesToCache = Object.keys(normalizedOptions.entities);
+      const {
+        schema,
+        drivers
+      } = context;
+      for (const typeName of entitiesToCache) {
+        const handle = schema[typeName].handle;
+        const cacheEntityName = `Cache_${typeName}`;
+        schema[cacheEntityName] = {
+          ...schema[typeName],
+          name: cacheEntityName,
+          handle: cacheEntityName,
+          handlePlural: `${cacheEntityName}s`
+        };
+        cacheDrivers[handle] = (0, _radsDb.getDriverInstance)(schema, cacheEntityName, normalizedOptions.driver, drivers);
+        cacheStatus[handle] = {
+          preloadStatus: normalizedOptions.preload ? "neverLoaded" : void 0
+        };
+      }
+      db.cache = {
+        drivers: cacheDrivers,
+        status: cacheStatus,
+        async preload() {
+          if (!entitiesToCache.length) {
+            console.warn('No entities found to preload. Please, add "preload: true" to your cache configuration.');
+          }
+          for (const typeName of entitiesToCache) {
+            const handle = schema[typeName].handle;
+            cacheStatus[handle].preloadStatus = "loading";
+            try {
+              const allData = await db[handle].getAll({}, {
+                noCache: true
+              });
+              const now = Date.now();
+              await cacheDrivers[handle].putMany(allData.map(item => ({
+                ...item,
+                _cacheUpdatedAt: now
+              })));
+              cacheStatus[handle].preloadStatus = "upToDate";
+            } catch (e) {
+              cacheStatus[handle].preloadStatus = "error";
+              console.error(`Error preloading db.${handle}`, e);
+            }
+          }
+        }
+      };
+    },
+    // enhanceEntityMethods(context, entityMethodsObj) {
+    //   if (normalizedOptions.entities && !normalizedOptions.entities[context.typeName]) return
+    //   const { typeName, schema, drivers } = context
+    //   const cacheEntityName = `Cache_${typeName}`
+    //   schema[cacheEntityName] = {
+    //     ...schema[typeName],
+    //     name: cacheEntityName,
+    //     handle: cacheEntityName,
+    //     handlePlural: `${cacheEntityName}s`,
+    //   } // A bit of a hack. Maybe better approach is to adjust driver constructor to accept entityPrefix
+    //   cacheDrivers[typeName] = getDriverInstance(schema, cacheEntityName, normalizedOptions.driver, drivers)
+    //   const emo = entityMethodsObj as any
+    //   emo.cache = {
+    //     driver: cacheDrivers[typeName],
+    //   }
+    // },
+    async beforeGet(args, ctx, context) {
+      if (ctx.noCache) return;
+      const {
+        handle
+      } = context;
+      const d = cacheDrivers[handle];
+      if (!d) return;
+      if (ctx.method === "get") {
+        const result2 = await d[ctx.method](args, ctx);
+        if (!result2) return;
+        const ageMs = Date.now() - result2._cacheUpdatedAt;
+        const maxAge = ctx.maxAge ?? normalizedOptions.maxAge;
+        const staleWhileRevalidate = ctx.staleWhileRevalidate ?? normalizedOptions.staleWhileRevalidate;
+        if (maxAge !== -1 && (maxAge === 0 || ageMs > maxAge * 1e3)) {
+          if (staleWhileRevalidate !== 0 && (staleWhileRevalidate === -1 || ageMs <= staleWhileRevalidate * 1e3)) {
+            const db = context.db;
+            await context.db[handle].get(args, {
+              maxAge: 0,
+              staleWhileRevalidate: 0
+            });
+            return result2;
+          }
+          return;
+        }
+        return result2;
+      }
+      if (cacheStatus[handle].preloadStatus !== "upToDate") return;
+      const result = await d[ctx.method](args, ctx);
+      return result;
+    },
+    async afterGet(items, args, ctx, context) {
+      const {
+        handle
+      } = context;
+      const d = cacheDrivers[handle];
+      if (!d || !items?.length) return;
+      if (items[0]._cacheUpdatedAt) return;
+      const now = Date.now();
+      await d.putMany(items.map(item => ({
+        ...item,
+        _cacheUpdatedAt: now
+      })));
+    },
+    async afterPut(items, ctx, computedContext) {
+      const {
+        handle
+      } = computedContext;
+      const d = cacheDrivers[handle];
+      if (!d) return;
+      const now = Date.now();
+      await d.putMany(items.map(item => item.doc).map(item => ({
+        ...item,
+        _cacheUpdatedAt: now
+      })));
+    }
+  };
+};
+module.exports = _default;
+function normalizeOptions(options) {
+  return {
+    driver: (0, _memory.default)(),
+    maxAge: 300,
+    staleWhileRevalidate: 0,
+    entities: {},
+    ...options
+  };
+}

package/features/cache.d.ts

@@ -0,0 +1,30 @@
+import type { DriverConstructor } from '@/types';
+declare const _default: (options?: CacheOptions) => RadsFeature;
+export default _default;
+export interface CacheOptions {
+    entities: Record<string, boolean>;
+    driver?: DriverConstructor;
+    /**
+     * Number in seconds. If document was stored in cache more than maxAge seconds ago, cache is ignored.
+     * 0 = 0s = all documents immediately expire, so never get anything from cache.
+     * -1 = infinity = documents never expire (always returned from cache if exist)
+     * defaults to 300 (5 minutes)
+     * */
+    maxAge?: number;
+    /**
+     * Number in seconds.
+     * If document was stored in cache more than staleWhileRevalidate seconds ago, cache is ignored.
+     * If document was stored in cache less than staleWhileRevalidate seconds ago,
+     * but more than maxAge seconds ago, it is immediately returned form cache, but also is downloaded again in the background.
+     * 0 = 0s = documents are never revalidated in background
+     * -1 = infinity = documents always are returned from cache immediately and revalidated in background
+     * defaults to 0
+     * */
+    staleWhileRevalidate?: number;
+    /**
+     * Start preloading all data into cache immediately in the background.
+     * After data are preloaded, getAll/getMany queries will start working from cache as well.
+     * If your driver already contains data, "preload" will download only newly changed records (based on `updatedAt`)
+     */
+    preload?: boolean;
+}

package/features/cache.mjs

@@ -0,0 +1,123 @@
+import memory from "@/drivers/memory";
+import { getDriverInstance } from "rads-db";
+export default (options) => {
+  const normalizedOptions = normalizeOptions(options);
+  const cacheDrivers = {};
+  const cacheStatus = {};
+  return {
+    name: "cache",
+    init(db, context) {
+      const entitiesToCache = Object.keys(normalizedOptions.entities);
+      const { schema, drivers } = context;
+      for (const typeName of entitiesToCache) {
+        const handle = schema[typeName].handle;
+        const cacheEntityName = `Cache_${typeName}`;
+        schema[cacheEntityName] = {
+          ...schema[typeName],
+          name: cacheEntityName,
+          handle: cacheEntityName,
+          handlePlural: `${cacheEntityName}s`
+        };
+        cacheDrivers[handle] = getDriverInstance(schema, cacheEntityName, normalizedOptions.driver, drivers);
+        cacheStatus[handle] = { preloadStatus: normalizedOptions.preload ? "neverLoaded" : void 0 };
+      }
+      db.cache = {
+        drivers: cacheDrivers,
+        status: cacheStatus,
+        async preload() {
+          if (!entitiesToCache.length) {
+            console.warn('No entities found to preload. Please, add "preload: true" to your cache configuration.');
+          }
+          for (const typeName of entitiesToCache) {
+            const handle = schema[typeName].handle;
+            cacheStatus[handle].preloadStatus = "loading";
+            try {
+              const allData = await db[handle].getAll({}, { noCache: true });
+              const now = Date.now();
+              await cacheDrivers[handle].putMany(allData.map((item) => ({ ...item, _cacheUpdatedAt: now })));
+              cacheStatus[handle].preloadStatus = "upToDate";
+            } catch (e) {
+              cacheStatus[handle].preloadStatus = "error";
+              console.error(`Error preloading db.${handle}`, e);
+            }
+          }
+        }
+      };
+    },
+    // enhanceEntityMethods(context, entityMethodsObj) {
+    //   if (normalizedOptions.entities && !normalizedOptions.entities[context.typeName]) return
+    //   const { typeName, schema, drivers } = context
+    //   const cacheEntityName = `Cache_${typeName}`
+    //   schema[cacheEntityName] = {
+    //     ...schema[typeName],
+    //     name: cacheEntityName,
+    //     handle: cacheEntityName,
+    //     handlePlural: `${cacheEntityName}s`,
+    //   } // A bit of a hack. Maybe better approach is to adjust driver constructor to accept entityPrefix
+    //   cacheDrivers[typeName] = getDriverInstance(schema, cacheEntityName, normalizedOptions.driver, drivers)
+    //   const emo = entityMethodsObj as any
+    //   emo.cache = {
+    //     driver: cacheDrivers[typeName],
+    //   }
+    // },
+    async beforeGet(args, ctx, context) {
+      if (ctx.noCache)
+        return;
+      const { handle } = context;
+      const d = cacheDrivers[handle];
+      if (!d)
+        return;
+      if (ctx.method === "get") {
+        const result2 = await d[ctx.method](args, ctx);
+        if (!result2)
+          return;
+        const ageMs = Date.now() - result2._cacheUpdatedAt;
+        const maxAge = ctx.maxAge ?? normalizedOptions.maxAge;
+        const staleWhileRevalidate = ctx.staleWhileRevalidate ?? normalizedOptions.staleWhileRevalidate;
+        if (maxAge !== -1 && (maxAge === 0 || ageMs > maxAge * 1e3)) {
+          if (staleWhileRevalidate !== 0 && (staleWhileRevalidate === -1 || ageMs <= staleWhileRevalidate * 1e3)) {
+            const db = context.db;
+            await context.db[handle].get(args, {
+              maxAge: 0,
+              staleWhileRevalidate: 0
+            });
+            return result2;
+          }
+          return;
+        }
+        return result2;
+      }
+      if (cacheStatus[handle].preloadStatus !== "upToDate")
+        return;
+      const result = await d[ctx.method](args, ctx);
+      return result;
+    },
+    async afterGet(items, args, ctx, context) {
+      const { handle } = context;
+      const d = cacheDrivers[handle];
+      if (!d || !items?.length)
+        return;
+      if (items[0]._cacheUpdatedAt)
+        return;
+      const now = Date.now();
+      await d.putMany(items.map((item) => ({ ...item, _cacheUpdatedAt: now })));
+    },
+    async afterPut(items, ctx, computedContext) {
+      const { handle } = computedContext;
+      const d = cacheDrivers[handle];
+      if (!d)
+        return;
+      const now = Date.now();
+      await d.putMany(items.map((item) => item.doc).map((item) => ({ ...item, _cacheUpdatedAt: now })));
+    }
+  };
+};
+function normalizeOptions(options) {
+  return {
+    driver: memory(),
+    maxAge: 300,
+    staleWhileRevalidate: 0,
+    entities: {},
+    ...options
+  };
+}

package/integrations/node.cjs

@@ -150,7 +150,7 @@ function getWhereFieldsFor(schema, type, fieldKey) {
     throw new Error(`Unknown array type: ${fieldTypeName}`);
   }
   const commonWhereFields = [];
-  if (isRequired) commonWhereFields.push(`${name}_isNull?: boolean`);
+  if (!isRequired) commonWhereFields.push(`${name}_isNull?: boolean`);
   if (isRelation) {
     return [`${name}?: ${getRelationWhereType()}`, ...commonWhereFields];
   }

package/integrations/node.mjs

@@ -156,7 +156,7 @@ function getWhereFieldsFor(schema, type, fieldKey) {
     throw new Error(`Unknown array type: ${fieldTypeName}`);
   }
   const commonWhereFields = [];
-  if (isRequired)
+  if (!isRequired)
     commonWhereFields.push(`${name}_isNull?: boolean`);
   if (isRelation) {
     return [`${name}?: ${getRelationWhereType()}`, ...commonWhereFields];

package/integrations/restEndpointsDev.cjs

@@ -14,6 +14,10 @@ var _default = {
     sanitizeFilepath(filepath);
     return await _promises.default.mkdir(filepath, options);
   },
+  async rm(filepath, options) {
+    sanitizeFilepath(filepath);
+    return await _promises.default.rm(filepath, options);
+  },
   async rmdir(filepath, options) {
     sanitizeFilepath(filepath);
     return await _promises.default.rmdir(filepath, options);

package/integrations/restEndpointsDev.d.ts

@@ -1,6 +1,7 @@
 import type { FileSystemNode } from '../types';
 declare const _default: {
     mkdir(filepath: string, options?: any): Promise<any>;
+    rm(filepath: string, options?: any): Promise<any>;
     rmdir(filepath: string, options?: any): Promise<any>;
     readdir(filepath: string, options?: any): Promise<FileSystemNode[]>;
     writeFile(filepath: string, data: string | Uint8Array, options?: any): Promise<any>;

package/integrations/restEndpointsDev.mjs

@@ -7,6 +7,10 @@ export default {
     sanitizeFilepath(filepath);
     return await fs.mkdir(filepath, options);
   },
+  async rm(filepath, options) {
+    sanitizeFilepath(filepath);
+    return await fs.rm(filepath, options);
+  },
   async rmdir(filepath, options) {
     sanitizeFilepath(filepath);
     return await fs.rmdir(filepath, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rads-db",
-  "version": "0.1.92",
+  "version": "0.1.94",
   "files": [
     "dist",
     "drivers",
@@ -95,7 +95,7 @@
     "test": "vitest --run && vitest typecheck --run",
     "link-rads-db": "symlink-dir ./test/_rads-db ./node_modules/_rads-db",
     "generate-test-schema": "rads-db",
-    "dev": "pnpm install && pnpm build && pnpm generate-test-schema && pnpm link-rads-db && vitest --ui",
+    "dev": "pnpm install && pnpm build && pnpm generate-test-schema && pnpm link-rads-db && vitest --ui --test-timeout 300000",
     "lint": "cross-env NODE_ENV=production eslint src/**/*.* test/**/*.*",
     "dev-typecheck": "pnpm install && pnpm build && pnpm generate-test-schema && pnpm link-rads-db && vitest typecheck --ui",
     "build": "unbuild"