rads-db 0.1.72 → 0.1.74

package/dist/index.cjs

@@ -2,8 +2,8 @@
 
 const zod = require('zod');
 const _ = require('lodash');
-const createMerge = require('@fastify/deepmerge');
 const uuid = require('uuid');
+const createMerge = require('@fastify/deepmerge');
 const _radsDb = require('_rads-db');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
@@ -98,42 +98,6 @@ function getFieldZodSchemaBase(zodSchemas, schema, field, shouldBeLazy) {
   throw new Error(`Unknown type: ${field.type}`);
 }
 
-const mergeFn = createMerge__default({
-  mergeArray(options) {
-    const clone = options.clone;
-    return function(target, source) {
-      return clone(source);
-    };
-  }
-});
-function merge(target, source) {
-  cleanUndefined(source);
-  const result = mergeFn(target, source);
-  return result;
-}
-function cleanUndefined(obj) {
-  if (!obj || !___default.isPlainObject(obj))
-    return;
-  cleanUndefinedInner(obj);
-}
-function cleanUndefinedInner(obj) {
-  for (const key in obj) {
-    if (obj[key] === void 0)
-      delete obj[key];
-    if (___default.isPlainObject(obj[key]))
-      cleanUndefinedInner(obj[key]);
-  }
-}
-
-function cleanUndefinedAndNull(obj) {
-  for (const key in obj) {
-    if (obj[key] == null)
-      delete obj[key];
-    if (___default.isPlainObject(obj[key]))
-      cleanUndefinedAndNull(obj[key]);
-  }
-}
-
 const operatorFns = {
   eq: (x, w) => x === w,
   ieq: (x, w) => x?.toLowerCase() === w?.toLowerCase(),
@@ -446,6 +410,33 @@ async function handleEffectsAfterPut(context, docs, beforePutResults, ctx) {
   );
 }
 
+const mergeFn = createMerge__default({
+  mergeArray(options) {
+    const clone = options.clone;
+    return function(target, source) {
+      return clone(source);
+    };
+  }
+});
+function merge(target, source) {
+  cleanUndefined(source);
+  const result = mergeFn(target, source);
+  return result;
+}
+function cleanUndefined(obj) {
+  if (!obj || !___default.isPlainObject(obj))
+    return;
+  cleanUndefinedInner(obj);
+}
+function cleanUndefinedInner(obj) {
+  for (const key in obj) {
+    if (obj[key] === void 0)
+      delete obj[key];
+    if (___default.isPlainObject(obj[key]))
+      cleanUndefinedInner(obj[key]);
+  }
+}
+
 function diff(object, base, includeDenormFields = false) {
   if (!base)
     return object;
@@ -640,154 +631,172 @@ async function fillDenormFieldsBeforePut(computedContext, docUpdates, ctx) {
   await Promise.all(promises);
 }
 
-function generateMethods(schema, validators, options) {
-  const drivers = {};
-  const opts = { computed: {}, driver: memory(), features: [], ...options };
-  const db = {
-    _schema: schema,
-    uploadFile(args) {
-      if (!opts.fileUploadDriver)
-        throw new Error(`Missing configuration. Please specify "fileUploadDriver" argument in "createRads()".`);
-      if (!args.containerName)
-        args.containerName = "files";
-      return opts.fileUploadDriver.uploadFile(args);
-    }
-  };
-  const effects = {};
-  for (const key in schema) {
-    effects[key] = [];
+function cleanUndefinedAndNull(obj) {
+  for (const key in obj) {
+    if (obj[key] == null)
+      delete obj[key];
+    if (___default.isPlainObject(obj[key]))
+      cleanUndefinedAndNull(obj[key]);
   }
-  if (!opts.skipComputed) {
-    verifyComputedPresense(schema, opts.computed);
+}
+
+function getRadsDbMethods(key, computedContext, driverInstance) {
+  const { schema, options, validators } = computedContext;
+  const mustCleanNulls = driverInstance.driverName !== "restApi";
+  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);
+    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;
   }
-  verifyEventSourcingSetup(schema, effects);
-  verifyRelationsSetup(schema, effects);
-  for (const key in schema) {
-    if (!schema[key].decorators.entity)
-      continue;
-    const { handle } = schema[key];
-    if (!handle)
-      throw new Error(`Missing handle for entity ${key}`);
-    const computedContext = {
-      schema,
-      typeName: key,
-      validators,
-      options: opts,
-      drivers,
-      effects,
-      db
-    };
-    const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
-    const mustCleanNulls = driverInstance.driverName !== "restApi";
-    const { precomputedFields } = schema[key];
-    db[handle] = {
-      getAgg: async (args, ctx) => {
-        args = { ...args, where: { ...args?.where } };
-        if (!args.agg)
-          throw new Error(`Please provide 'agg' argument`);
-        ctx = { ...opts.context, ...ctx };
-        await beforeGet(args, ctx, computedContext);
-        const result = await driverInstance.getAgg(args, ctx);
-        return result;
-      },
-      get: async (args, ctx) => {
-        args = { ...args, where: { ...args?.where } };
-        ctx = { ...opts.context, ...ctx };
-        await beforeGet(args, ctx, computedContext);
-        const result = await driverInstance.get(args, ctx);
-        const resultArray = [result];
-        if (result && args.include)
-          await handleInclude(computedContext, args.include, resultArray, ctx);
-        if (result)
-          await handleComputed(computedContext, resultArray, ctx);
-        await afterGet(resultArray, args, ctx, computedContext);
-        return result;
-      },
-      getMany: async (args, ctx) => {
-        args = { ...args, where: { ...args?.where } };
-        ctx = { ...opts.context, ...ctx };
-        await beforeGet(args, ctx, computedContext);
-        const result = 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;
-      },
-      getAll: async (args, ctx) => {
-        args = { ...args, where: { ...args?.where } };
-        ctx = { ...opts.context, ...ctx };
-        await beforeGet(args, ctx, computedContext);
-        const result = 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;
-      },
-      put: async (doc, ctx) => {
-        if (schema[key].decorators.precomputed)
-          throw new Error("Forbidden. Use events instead.");
-        if (!doc?.id)
-          throw new Error("Id is required");
-        ctx = { ...opts.context, ...ctx };
-        const oldDoc = await driverInstance.get({ where: { id: doc.id } }, ctx);
-        if (oldDoc)
-          doc = merge(oldDoc, doc);
+  async function putMany(docs, ctx) {
+    if (schema[key].decorators.precomputed)
+      throw new Error("Forbidden. Use events instead.");
+    const ids = docs.map((i) => {
+      if (!i?.id)
+        throw new Error("Id is required");
+      return i.id;
+    });
+    ctx = { ...options.context, ...ctx };
+    const oldDocs = await driverInstance.getAll({ where: { id_in: ids } }, ctx);
+    const oldDocsById = ___default.keyBy(oldDocs, "id");
+    const docArgsToSave = docs.map((doc) => {
+      const oldDoc = oldDocsById[doc.id];
+      doc = merge(oldDoc, doc);
+      if (mustCleanNulls)
+        cleanUndefinedAndNull(doc);
+      doc = validators[key](doc);
+      return { oldDoc, doc };
+    });
+    const docsToSave = docArgsToSave.map((x) => x.doc);
+    await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+    await handlePrecomputed(computedContext, docArgsToSave, ctx);
+    const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave, ctx);
+    await beforePut(docArgsToSave, ctx, computedContext);
+    await driverInstance.putMany(docsToSave, ctx);
+    await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
+    await afterPut(docArgsToSave, ctx, computedContext);
+    return docsToSave;
+  }
+  return {
+    getMany,
+    putMany,
+    driver: driverInstance,
+    getAgg: async (args, ctx) => {
+      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;
+    },
+    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)
+        await handleInclude(computedContext, args.include, resultArray, ctx);
+      if (result)
+        await handleComputed(computedContext, resultArray, ctx);
+      await afterGet(resultArray, args, ctx, computedContext);
+      return result;
+    },
+    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);
+      if (args.include)
+        await handleInclude(computedContext, args.include, result, ctx);
+      await handleComputed(computedContext, result, ctx);
+      await afterGet(result, args, ctx, computedContext);
+      return result;
+    },
+    put: async (doc, ctx) => {
+      if (schema[key].decorators.precomputed)
+        throw new Error("Forbidden. Use events instead.");
+      if (!doc?.id)
+        throw new Error("Id is required");
+      ctx = { ...options.context, ...ctx };
+      const oldDoc = await driverInstance.get({ where: { id: doc.id } }, ctx);
+      if (oldDoc)
+        doc = merge(oldDoc, doc);
+      if (mustCleanNulls)
+        cleanUndefinedAndNull(doc);
+      doc = validators[key](doc);
+      if (oldDoc && precomputedFields) {
+        for (const f of precomputedFields) {
+          ___default.set(doc, f, ___default.get(oldDoc, f));
+        }
+      }
+      const docArgsToSave = [{ doc, oldDoc }];
+      await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+      await handlePrecomputed(computedContext, docArgsToSave, ctx);
+      const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave, ctx);
+      await beforePut(docArgsToSave, ctx, computedContext);
+      await driverInstance.put(doc, ctx);
+      await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
+      await afterPut(docArgsToSave, ctx, computedContext);
+      return doc;
+    },
+    async verifyMany(args, ctx) {
+      ctx = { ...options.context, ...ctx };
+      if (args?.dryRun) {
+        ctx._logs = ctx._logs || [];
+        ctx.dryRun = true;
+      }
+      const { _logs } = ctx;
+      const { nodes, cursor } = await driverInstance.getMany(args, ctx);
+      let correctCount = 0;
+      let incorrectCount = 0;
+      const incorrectDocs = [];
+      const oldDocs = nodes;
+      const docArgsToSave = oldDocs.map((oldDoc) => {
+        let doc = merge(oldDoc, {});
+        if (args?.recompute) {
+          for (const p of args.recompute) {
+            delete doc[p];
+          }
+        }
         if (mustCleanNulls)
           cleanUndefinedAndNull(doc);
         doc = validators[key](doc);
-        if (oldDoc && precomputedFields) {
-          for (const f of precomputedFields) {
-            ___default.set(doc, f, ___default.get(oldDoc, f));
-          }
+        return { oldDoc, doc };
+      });
+      await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+      await handlePrecomputed(computedContext, docArgsToSave, ctx);
+      const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave, ctx);
+      await beforePut(docArgsToSave, ctx, computedContext);
+      for (const { oldDoc, doc } of docArgsToSave) {
+        const d = diff(doc, oldDoc);
+        if (___default.isEmpty(d))
+          correctCount++;
+        else {
+          incorrectCount++;
+          const objToAdd = { id: doc.id, diff: d };
+          incorrectDocs.push(objToAdd);
         }
-        const docArgsToSave = [{ doc, oldDoc }];
-        await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
-        await handlePrecomputed(computedContext, docArgsToSave, ctx);
-        const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave, ctx);
-        await beforePut(docArgsToSave, ctx, computedContext);
-        await driverInstance.put(doc, ctx);
-        await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
-        await afterPut(docArgsToSave, ctx, computedContext);
-        return doc;
-      },
-      putMany: async (docs, ctx) => {
-        if (schema[key].decorators.precomputed)
-          throw new Error("Forbidden. Use events instead.");
-        const ids = docs.map((i) => {
-          if (!i?.id)
-            throw new Error("Id is required");
-          return i.id;
-        });
-        ctx = { ...opts.context, ...ctx };
-        const oldDocs = await driverInstance.getAll({ where: { id_in: ids } }, ctx);
-        const oldDocsById = ___default.keyBy(oldDocs, "id");
-        const docArgsToSave = docs.map((doc) => {
-          const oldDoc = oldDocsById[doc.id];
-          doc = merge(oldDoc, doc);
-          if (mustCleanNulls)
-            cleanUndefinedAndNull(doc);
-          doc = validators[key](doc);
-          return { oldDoc, doc };
-        });
-        const docsToSave = docArgsToSave.map((x) => x.doc);
-        await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
-        await handlePrecomputed(computedContext, docArgsToSave, ctx);
-        const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave, ctx);
-        await beforePut(docArgsToSave, ctx, computedContext);
-        await driverInstance.putMany(docsToSave, ctx);
-        await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
-        await afterPut(docArgsToSave, ctx, computedContext);
-        return docsToSave;
-      },
-      clear: (ctx) => {
-        ctx = { ...opts.context, ...ctx };
-        return driverInstance.clear(ctx);
       }
-    };
-  }
-  return db;
+      const docsToSave = docArgsToSave.map((x) => x.doc);
+      await driverInstance.putMany(docsToSave, ctx);
+      await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
+      await afterPut(docArgsToSave, ctx, computedContext);
+      return { _logs, cursor, correctCount, incorrectCount, incorrectDocs };
+    },
+    clear: (ctx) => {
+      ctx = { ...options.context, ...ctx };
+      return driverInstance.clear(ctx);
+    }
+  };
 }
 async function beforeGet(args, ctx, computedContext) {
   for (const f of computedContext.options.features) {
@@ -864,6 +873,49 @@ function getExistingDriverInstance(entityName, drivers) {
   }
   return drivers[entityName];
 }
+
+function generateMethods(schema, validators, options) {
+  const drivers = {};
+  const opts = { computed: {}, driver: memory(), features: [], ...options };
+  const db = {
+    _schema: schema,
+    uploadFile(args) {
+      if (!opts.fileUploadDriver)
+        throw new Error(`Missing configuration. Please specify "fileUploadDriver" argument in "createRads()".`);
+      if (!args.containerName)
+        args.containerName = "files";
+      return opts.fileUploadDriver.uploadFile(args);
+    }
+  };
+  const effects = {};
+  for (const key in schema) {
+    effects[key] = [];
+  }
+  if (!opts.skipComputed) {
+    verifyComputedPresense(schema, opts.computed);
+  }
+  verifyEventSourcingSetup(schema, effects);
+  verifyRelationsSetup(schema, effects);
+  for (const key in schema) {
+    if (!schema[key].decorators.entity)
+      continue;
+    const { handle } = schema[key];
+    if (!handle)
+      throw new Error(`Missing handle for entity ${key}`);
+    const computedContext = {
+      schema,
+      typeName: key,
+      validators,
+      options: opts,
+      drivers,
+      effects,
+      db
+    };
+    const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
+    db[handle] = getRadsDbMethods(key, computedContext, driverInstance);
+  }
+  return db;
+}
 function getDriverInstance(schema, key, driver, drivers) {
   if (!drivers[key]) {
     drivers[key] = getDriverInstanceInner(schema, key, driver);
@@ -872,6 +924,7 @@ function getDriverInstance(schema, key, driver, drivers) {
 }
 function getDriverInstanceInner(schema, key, driverConstructor) {
   const driverInstance = driverConstructor(schema, key);
+  addDryRunSupport(driverInstance, key);
   async function getAll(args, ctx) {
     const result = [];
     let cursor = args.cursor;
@@ -914,6 +967,40 @@ function getDriverInstanceInner(schema, key, driverConstructor) {
     ...driverInstance
   };
 }
+function addDryRunSupport(driverInstance, entity) {
+  const { clear, put, putMany } = driverInstance;
+  if (clear) {
+    driverInstance.clear = (ctx) => {
+      if (ctx?.dryRun) {
+        if (!ctx._logs)
+          ctx._logs = [];
+        ctx._logs.push({ method: "clear", entity });
+        return;
+      }
+      return clear(ctx);
+    };
+  }
+  if (put) {
+    driverInstance.put = (data, ctx) => {
+      if (ctx?.dryRun) {
+        if (!ctx._logs)
+          ctx._logs = [];
+        ctx._logs.push({ method: "put", entity, data });
+        return;
+      }
+      return put(data, ctx);
+    };
+  }
+  driverInstance.putMany = (data, ctx) => {
+    if (ctx?.dryRun) {
+      if (!ctx._logs)
+        ctx._logs = [];
+      ctx._logs.push({ method: "putMany", entity, data });
+      return;
+    }
+    return putMany(data, ctx);
+  };
+}
 
 function entity(meta) {
   return function(classConstructor, _ctx) {

package/dist/index.d.ts

@@ -10,6 +10,20 @@ interface GetManyArgs<E, EN extends keyof EntityMeta, W> extends GetArgs<E, EN,
     maxItemCount?: number;
     orderBy?: string;
 }
+interface VerifyManyArgs<E, EN extends keyof EntityMeta, W> extends GetManyArgs<E, EN, W> {
+    recompute?: string[];
+    dryRun?: boolean;
+}
+interface VerifyManyResponse {
+    cursor: string | null;
+    correctCount: number;
+    incorrectCount: number;
+    incorrectDocs: {
+        id: string;
+        diff: any;
+        toRemove?: any;
+    }[];
+}
 interface GetArgs<E, EN extends keyof EntityMeta, W> {
     where?: W;
     include?: GetArgsInclude<E, EN>;
@@ -22,6 +36,7 @@ type GetAggArgsAgg<EN extends keyof EntityMeta, F extends string = EntityMeta[EN
 type GetManyArgsAny = GetManyArgs<any, any, any>;
 type GetArgsAny = GetArgs<any, any, any>;
 type GetAggArgsAny = GetAggArgs<any, any>;
+type VerifyManyArgsAny = VerifyManyArgs<any, any, any>;
 type GetArgsInclude<E, EN extends keyof EntityMeta, R extends keyof E = keyof EntityMeta[EN]['relations'] & keyof E> = [R] extends [never] ? Record<string, never> : {
     _pick?: EntityMeta[EN]['primitives'][];
 } & {
@@ -61,12 +76,16 @@ type PutArgs<T> = {
 } & DeepPartialNullable<T>;
 interface EntityMethods<E, EN extends keyof EntityMeta, W> {
     createObject(defaultValues: Partial<E>): E;
+    /** Used to access underlying mechanism of storage directly.
+     * Warning: bypasses all rads features - schema won't be validated, default values won't be filled, etc. */
+    driver: Driver;
     get<A extends GetArgs<E, EN, W>>(args: A): MaybePromise$1<GetResponse<E, EN, A>>;
     getMany<A extends GetManyArgs<E, EN, W>>(args?: A): MaybePromise$1<GetManyResponse<E, EN, A>>;
     getAgg<A extends GetAggArgs<EN, W>>(args: A): MaybePromise$1<GetAggResponse<EN, A>>;
     getAll<A extends GetManyArgs<E, EN, W>>(args?: A): MaybePromise$1<GetManyResponse<E, EN, A>['nodes']>;
     put(data: PutArgs<E>): MaybePromise$1<GetResponseNoInclude<E, EN>>;
     putMany(data: PutArgs<E>[]): MaybePromise$1<GetResponseNoInclude<E, EN>[]>;
+    verifyMany<A extends VerifyManyArgs<E, EN, W>>(args?: A): MaybePromise$1<VerifyManyResponse>;
 }
 
 type MaybePromise<T> = Promise<T> | T;
@@ -142,7 +161,7 @@ interface CreateRadsArgs {
     skipComputed?: boolean;
     computed?: Record<string, Record<string, Function>>;
     beforeGet?: (args: GetArgsAny, ctx: RadsRequestContext, context: ComputedContext) => MaybePromise<void>;
-    context?: Record<string, any> & RadsRequestContext;
+    context?: Record<string, any> & Omit<RadsRequestContext, 'dryRun' | 'silent'>;
     features?: RadsFeature[];
 }
 type Schema = Record<string, TypeDefinition>;
@@ -253,11 +272,16 @@ interface RadsVitePluginOptions extends GenerateClientOptions {
     exposeModulesInDev?: boolean | RegExp;
 }
 interface RadsRequestContext {
+    _logs?: any[];
     log?: (requestInfo: any) => void;
     getUser?: () => {
         id: string;
         role: string;
     } | undefined;
+    /** If true, no changes made to the database - instead, all changes are returned as logs */
+    dryRun?: boolean;
+    /** (Not supported yet) If true, updatedAt/updatedBy properties are not updated, and log records are not created */
+    silent?: boolean;
 }
 interface GithubTreeResponse {
     sha: string;
@@ -295,4 +319,4 @@ declare function computed(meta?: ComputedDecoratorArgs): (a: any, b?: ClassField
 
 declare function createRads(args?: CreateRadsArgs): RadsDb;
 
-export { Change, ComputedContext, ComputedDecoratorArgs, CreateRadsArgs, DeepPartial, DeepPartialNullable, Driver, DriverConstructor, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, FileUploadArgs, FileUploadDriver, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, GetRestRoutesArgs, GetRestRoutesOptions, GetRestRoutesResponse, GithubTreeItem, GithubTreeResponse, MinimalDriver, PutArgs, PutEffect, RadsFeature, RadsRequestContext, RadsVitePluginOptions, Relation, RestFileUploadDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, ValidateEntityDecoratorArgs, ValidateFieldDecoratorArgs, ValidateStringDecoratorArgs, computed, createRads, entity, field, precomputed, ui, validate };
+export { Change, ComputedContext, ComputedDecoratorArgs, CreateRadsArgs, DeepPartial, DeepPartialNullable, Driver, DriverConstructor, EntityDecoratorArgs, EntityMethods, FieldDecoratorArgs, FieldDefinition, FileUploadArgs, FileUploadDriver, GenerateClientNormalizedOptions, GenerateClientOptions, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, GetRestRoutesArgs, GetRestRoutesOptions, GetRestRoutesResponse, GithubTreeItem, GithubTreeResponse, 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 };

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import _ from 'lodash';
-import createMerge from '@fastify/deepmerge';
 import { v4 } from 'uuid';
+import createMerge from '@fastify/deepmerge';
 import { schema } from '_rads-db';
 
 function generateValidators(schema) {
@@ -91,42 +91,6 @@ function getFieldZodSchemaBase(zodSchemas, schema, field, shouldBeLazy) {
   throw new Error(`Unknown type: ${field.type}`);
 }
 
-const mergeFn = createMerge({
-  mergeArray(options) {
-    const clone = options.clone;
-    return function(target, source) {
-      return clone(source);
-    };
-  }
-});
-function merge(target, source) {
-  cleanUndefined(source);
-  const result = mergeFn(target, source);
-  return result;
-}
-function cleanUndefined(obj) {
-  if (!obj || !_.isPlainObject(obj))
-    return;
-  cleanUndefinedInner(obj);
-}
-function cleanUndefinedInner(obj) {
-  for (const key in obj) {
-    if (obj[key] === void 0)
-      delete obj[key];
-    if (_.isPlainObject(obj[key]))
-      cleanUndefinedInner(obj[key]);
-  }
-}
-
-function cleanUndefinedAndNull(obj) {
-  for (const key in obj) {
-    if (obj[key] == null)
-      delete obj[key];
-    if (_.isPlainObject(obj[key]))
-      cleanUndefinedAndNull(obj[key]);
-  }
-}
-
 const operatorFns = {
   eq: (x, w) => x === w,
   ieq: (x, w) => x?.toLowerCase() === w?.toLowerCase(),
@@ -439,6 +403,33 @@ async function handleEffectsAfterPut(context, docs, beforePutResults, ctx) {
   );
 }
 
+const mergeFn = createMerge({
+  mergeArray(options) {
+    const clone = options.clone;
+    return function(target, source) {
+      return clone(source);
+    };
+  }
+});
+function merge(target, source) {
+  cleanUndefined(source);
+  const result = mergeFn(target, source);
+  return result;
+}
+function cleanUndefined(obj) {
+  if (!obj || !_.isPlainObject(obj))
+    return;
+  cleanUndefinedInner(obj);
+}
+function cleanUndefinedInner(obj) {
+  for (const key in obj) {
+    if (obj[key] === void 0)
+      delete obj[key];
+    if (_.isPlainObject(obj[key]))
+      cleanUndefinedInner(obj[key]);
+  }
+}
+
 function diff(object, base, includeDenormFields = false) {
   if (!base)
     return object;
@@ -633,154 +624,172 @@ async function fillDenormFieldsBeforePut(computedContext, docUpdates, ctx) {
   await Promise.all(promises);
 }
 
-function generateMethods(schema, validators, options) {
-  const drivers = {};
-  const opts = { computed: {}, driver: memory(), features: [], ...options };
-  const db = {
-    _schema: schema,
-    uploadFile(args) {
-      if (!opts.fileUploadDriver)
-        throw new Error(`Missing configuration. Please specify "fileUploadDriver" argument in "createRads()".`);
-      if (!args.containerName)
-        args.containerName = "files";
-      return opts.fileUploadDriver.uploadFile(args);
-    }
-  };
-  const effects = {};
-  for (const key in schema) {
-    effects[key] = [];
+function cleanUndefinedAndNull(obj) {
+  for (const key in obj) {
+    if (obj[key] == null)
+      delete obj[key];
+    if (_.isPlainObject(obj[key]))
+      cleanUndefinedAndNull(obj[key]);
   }
-  if (!opts.skipComputed) {
-    verifyComputedPresense(schema, opts.computed);
+}
+
+function getRadsDbMethods(key, computedContext, driverInstance) {
+  const { schema, options, validators } = computedContext;
+  const mustCleanNulls = driverInstance.driverName !== "restApi";
+  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);
+    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;
   }
-  verifyEventSourcingSetup(schema, effects);
-  verifyRelationsSetup(schema, effects);
-  for (const key in schema) {
-    if (!schema[key].decorators.entity)
-      continue;
-    const { handle } = schema[key];
-    if (!handle)
-      throw new Error(`Missing handle for entity ${key}`);
-    const computedContext = {
-      schema,
-      typeName: key,
-      validators,
-      options: opts,
-      drivers,
-      effects,
-      db
-    };
-    const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
-    const mustCleanNulls = driverInstance.driverName !== "restApi";
-    const { precomputedFields } = schema[key];
-    db[handle] = {
-      getAgg: async (args, ctx) => {
-        args = { ...args, where: { ...args?.where } };
-        if (!args.agg)
-          throw new Error(`Please provide 'agg' argument`);
-        ctx = { ...opts.context, ...ctx };
-        await beforeGet(args, ctx, computedContext);
-        const result = await driverInstance.getAgg(args, ctx);
-        return result;
-      },
-      get: async (args, ctx) => {
-        args = { ...args, where: { ...args?.where } };
-        ctx = { ...opts.context, ...ctx };
-        await beforeGet(args, ctx, computedContext);
-        const result = await driverInstance.get(args, ctx);
-        const resultArray = [result];
-        if (result && args.include)
-          await handleInclude(computedContext, args.include, resultArray, ctx);
-        if (result)
-          await handleComputed(computedContext, resultArray, ctx);
-        await afterGet(resultArray, args, ctx, computedContext);
-        return result;
-      },
-      getMany: async (args, ctx) => {
-        args = { ...args, where: { ...args?.where } };
-        ctx = { ...opts.context, ...ctx };
-        await beforeGet(args, ctx, computedContext);
-        const result = 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;
-      },
-      getAll: async (args, ctx) => {
-        args = { ...args, where: { ...args?.where } };
-        ctx = { ...opts.context, ...ctx };
-        await beforeGet(args, ctx, computedContext);
-        const result = 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;
-      },
-      put: async (doc, ctx) => {
-        if (schema[key].decorators.precomputed)
-          throw new Error("Forbidden. Use events instead.");
-        if (!doc?.id)
-          throw new Error("Id is required");
-        ctx = { ...opts.context, ...ctx };
-        const oldDoc = await driverInstance.get({ where: { id: doc.id } }, ctx);
-        if (oldDoc)
-          doc = merge(oldDoc, doc);
+  async function putMany(docs, ctx) {
+    if (schema[key].decorators.precomputed)
+      throw new Error("Forbidden. Use events instead.");
+    const ids = docs.map((i) => {
+      if (!i?.id)
+        throw new Error("Id is required");
+      return i.id;
+    });
+    ctx = { ...options.context, ...ctx };
+    const oldDocs = await driverInstance.getAll({ where: { id_in: ids } }, ctx);
+    const oldDocsById = _.keyBy(oldDocs, "id");
+    const docArgsToSave = docs.map((doc) => {
+      const oldDoc = oldDocsById[doc.id];
+      doc = merge(oldDoc, doc);
+      if (mustCleanNulls)
+        cleanUndefinedAndNull(doc);
+      doc = validators[key](doc);
+      return { oldDoc, doc };
+    });
+    const docsToSave = docArgsToSave.map((x) => x.doc);
+    await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+    await handlePrecomputed(computedContext, docArgsToSave, ctx);
+    const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave, ctx);
+    await beforePut(docArgsToSave, ctx, computedContext);
+    await driverInstance.putMany(docsToSave, ctx);
+    await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
+    await afterPut(docArgsToSave, ctx, computedContext);
+    return docsToSave;
+  }
+  return {
+    getMany,
+    putMany,
+    driver: driverInstance,
+    getAgg: async (args, ctx) => {
+      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;
+    },
+    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)
+        await handleInclude(computedContext, args.include, resultArray, ctx);
+      if (result)
+        await handleComputed(computedContext, resultArray, ctx);
+      await afterGet(resultArray, args, ctx, computedContext);
+      return result;
+    },
+    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);
+      if (args.include)
+        await handleInclude(computedContext, args.include, result, ctx);
+      await handleComputed(computedContext, result, ctx);
+      await afterGet(result, args, ctx, computedContext);
+      return result;
+    },
+    put: async (doc, ctx) => {
+      if (schema[key].decorators.precomputed)
+        throw new Error("Forbidden. Use events instead.");
+      if (!doc?.id)
+        throw new Error("Id is required");
+      ctx = { ...options.context, ...ctx };
+      const oldDoc = await driverInstance.get({ where: { id: doc.id } }, ctx);
+      if (oldDoc)
+        doc = merge(oldDoc, doc);
+      if (mustCleanNulls)
+        cleanUndefinedAndNull(doc);
+      doc = validators[key](doc);
+      if (oldDoc && precomputedFields) {
+        for (const f of precomputedFields) {
+          _.set(doc, f, _.get(oldDoc, f));
+        }
+      }
+      const docArgsToSave = [{ doc, oldDoc }];
+      await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+      await handlePrecomputed(computedContext, docArgsToSave, ctx);
+      const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave, ctx);
+      await beforePut(docArgsToSave, ctx, computedContext);
+      await driverInstance.put(doc, ctx);
+      await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
+      await afterPut(docArgsToSave, ctx, computedContext);
+      return doc;
+    },
+    async verifyMany(args, ctx) {
+      ctx = { ...options.context, ...ctx };
+      if (args?.dryRun) {
+        ctx._logs = ctx._logs || [];
+        ctx.dryRun = true;
+      }
+      const { _logs } = ctx;
+      const { nodes, cursor } = await driverInstance.getMany(args, ctx);
+      let correctCount = 0;
+      let incorrectCount = 0;
+      const incorrectDocs = [];
+      const oldDocs = nodes;
+      const docArgsToSave = oldDocs.map((oldDoc) => {
+        let doc = merge(oldDoc, {});
+        if (args?.recompute) {
+          for (const p of args.recompute) {
+            delete doc[p];
+          }
+        }
         if (mustCleanNulls)
           cleanUndefinedAndNull(doc);
         doc = validators[key](doc);
-        if (oldDoc && precomputedFields) {
-          for (const f of precomputedFields) {
-            _.set(doc, f, _.get(oldDoc, f));
-          }
+        return { oldDoc, doc };
+      });
+      await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+      await handlePrecomputed(computedContext, docArgsToSave, ctx);
+      const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave, ctx);
+      await beforePut(docArgsToSave, ctx, computedContext);
+      for (const { oldDoc, doc } of docArgsToSave) {
+        const d = diff(doc, oldDoc);
+        if (_.isEmpty(d))
+          correctCount++;
+        else {
+          incorrectCount++;
+          const objToAdd = { id: doc.id, diff: d };
+          incorrectDocs.push(objToAdd);
         }
-        const docArgsToSave = [{ doc, oldDoc }];
-        await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
-        await handlePrecomputed(computedContext, docArgsToSave, ctx);
-        const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave, ctx);
-        await beforePut(docArgsToSave, ctx, computedContext);
-        await driverInstance.put(doc, ctx);
-        await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
-        await afterPut(docArgsToSave, ctx, computedContext);
-        return doc;
-      },
-      putMany: async (docs, ctx) => {
-        if (schema[key].decorators.precomputed)
-          throw new Error("Forbidden. Use events instead.");
-        const ids = docs.map((i) => {
-          if (!i?.id)
-            throw new Error("Id is required");
-          return i.id;
-        });
-        ctx = { ...opts.context, ...ctx };
-        const oldDocs = await driverInstance.getAll({ where: { id_in: ids } }, ctx);
-        const oldDocsById = _.keyBy(oldDocs, "id");
-        const docArgsToSave = docs.map((doc) => {
-          const oldDoc = oldDocsById[doc.id];
-          doc = merge(oldDoc, doc);
-          if (mustCleanNulls)
-            cleanUndefinedAndNull(doc);
-          doc = validators[key](doc);
-          return { oldDoc, doc };
-        });
-        const docsToSave = docArgsToSave.map((x) => x.doc);
-        await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
-        await handlePrecomputed(computedContext, docArgsToSave, ctx);
-        const beforePutResults = await handleEffectsBeforePut(computedContext, docArgsToSave, ctx);
-        await beforePut(docArgsToSave, ctx, computedContext);
-        await driverInstance.putMany(docsToSave, ctx);
-        await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
-        await afterPut(docArgsToSave, ctx, computedContext);
-        return docsToSave;
-      },
-      clear: (ctx) => {
-        ctx = { ...opts.context, ...ctx };
-        return driverInstance.clear(ctx);
       }
-    };
-  }
-  return db;
+      const docsToSave = docArgsToSave.map((x) => x.doc);
+      await driverInstance.putMany(docsToSave, ctx);
+      await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
+      await afterPut(docArgsToSave, ctx, computedContext);
+      return { _logs, cursor, correctCount, incorrectCount, incorrectDocs };
+    },
+    clear: (ctx) => {
+      ctx = { ...options.context, ...ctx };
+      return driverInstance.clear(ctx);
+    }
+  };
 }
 async function beforeGet(args, ctx, computedContext) {
   for (const f of computedContext.options.features) {
@@ -857,6 +866,49 @@ function getExistingDriverInstance(entityName, drivers) {
   }
   return drivers[entityName];
 }
+
+function generateMethods(schema, validators, options) {
+  const drivers = {};
+  const opts = { computed: {}, driver: memory(), features: [], ...options };
+  const db = {
+    _schema: schema,
+    uploadFile(args) {
+      if (!opts.fileUploadDriver)
+        throw new Error(`Missing configuration. Please specify "fileUploadDriver" argument in "createRads()".`);
+      if (!args.containerName)
+        args.containerName = "files";
+      return opts.fileUploadDriver.uploadFile(args);
+    }
+  };
+  const effects = {};
+  for (const key in schema) {
+    effects[key] = [];
+  }
+  if (!opts.skipComputed) {
+    verifyComputedPresense(schema, opts.computed);
+  }
+  verifyEventSourcingSetup(schema, effects);
+  verifyRelationsSetup(schema, effects);
+  for (const key in schema) {
+    if (!schema[key].decorators.entity)
+      continue;
+    const { handle } = schema[key];
+    if (!handle)
+      throw new Error(`Missing handle for entity ${key}`);
+    const computedContext = {
+      schema,
+      typeName: key,
+      validators,
+      options: opts,
+      drivers,
+      effects,
+      db
+    };
+    const driverInstance = getDriverInstance(schema, key, opts.driver, drivers);
+    db[handle] = getRadsDbMethods(key, computedContext, driverInstance);
+  }
+  return db;
+}
 function getDriverInstance(schema, key, driver, drivers) {
   if (!drivers[key]) {
     drivers[key] = getDriverInstanceInner(schema, key, driver);
@@ -865,6 +917,7 @@ function getDriverInstance(schema, key, driver, drivers) {
 }
 function getDriverInstanceInner(schema, key, driverConstructor) {
   const driverInstance = driverConstructor(schema, key);
+  addDryRunSupport(driverInstance, key);
   async function getAll(args, ctx) {
     const result = [];
     let cursor = args.cursor;
@@ -907,6 +960,40 @@ function getDriverInstanceInner(schema, key, driverConstructor) {
     ...driverInstance
   };
 }
+function addDryRunSupport(driverInstance, entity) {
+  const { clear, put, putMany } = driverInstance;
+  if (clear) {
+    driverInstance.clear = (ctx) => {
+      if (ctx?.dryRun) {
+        if (!ctx._logs)
+          ctx._logs = [];
+        ctx._logs.push({ method: "clear", entity });
+        return;
+      }
+      return clear(ctx);
+    };
+  }
+  if (put) {
+    driverInstance.put = (data, ctx) => {
+      if (ctx?.dryRun) {
+        if (!ctx._logs)
+          ctx._logs = [];
+        ctx._logs.push({ method: "put", entity, data });
+        return;
+      }
+      return put(data, ctx);
+    };
+  }
+  driverInstance.putMany = (data, ctx) => {
+    if (ctx?.dryRun) {
+      if (!ctx._logs)
+        ctx._logs = [];
+      ctx._logs.push({ method: "putMany", entity, data });
+      return;
+    }
+    return putMany(data, ctx);
+  };
+}
 
 function entity(meta) {
   return function(classConstructor, _ctx) {

package/features/softDelete.cjs

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = void 0;
+var _default = () => {
+  return {
+    name: "softDelete",
+    beforeGet(args, ctx, context) {
+      if (!context.schema[context.typeName]?.fields?.isDeleted) return;
+      if (args.where.isDeleted || args.where.isDeleted_in) return;
+      args.where._and = [...(args.where._and || []), {
+        isDeleted: false
+      }];
+    }
+  };
+};
+module.exports = _default;

package/features/softDelete.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => RadsFeature;
+export default _default;

package/features/softDelete.mjs

@@ -0,0 +1,12 @@
+export default () => {
+  return {
+    name: "softDelete",
+    beforeGet(args, ctx, context) {
+      if (!context.schema[context.typeName]?.fields?.isDeleted)
+        return;
+      if (args.where.isDeleted || args.where.isDeleted_in)
+        return;
+      args.where._and = [...args.where._and || [], { isDeleted: false }];
+    }
+  };
+};

package/package.json

@@ -4,7 +4,8 @@
     "dist",
     "drivers",
     "fileUploadDrivers",
-    "integrations"
+    "integrations",
+    "features"
   ],
   "bin": {
     "rads-db": "integrations/cli.cjs"
@@ -32,9 +33,14 @@
       "types": "./integrations/*.d.ts",
       "import": "./integrations/*.mjs",
       "require": "./integrations/*.cjs"
+    },
+    "./features/*": {
+      "types": "./features/*.d.ts",
+      "import": "./features/*.mjs",
+      "require": "./features/*.cjs"
     }
   },
-  "version": "0.1.72",
+  "version": "0.1.74",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "keywords": [],
   "author": "",