@coderich/autograph 0.11.1 → 0.13.0

package/index.js

@@ -1,13 +1,11 @@
-const Schema = require('./src/core/Schema');
-const Resolver = require('./src/core/Resolver');
+const Schema = require('./src/schema/Schema');
+const Resolver = require('./src/data/Resolver');
 const Pipeline = require('./src/data/Pipeline');
-const Driver = require('./src/driver');
-const { eventEmitter: Emitter } = require('./src/service/event.service');
+const Emitter = require('./src/data/Emitter');
 
 module.exports = {
   Schema,
   Resolver,
-  Driver,
-  Emitter,
   Pipeline,
+  Emitter,
 };

package/package.json

@@ -1,59 +1,45 @@
 {
   "name": "@coderich/autograph",
-  "author": "Richard Livolsi (coderich)",
-  "version": "0.11.1",
-  "description": "AutoGraph",
-  "keywords": [
-    "graphql",
-    "mongo",
-    "neo4j",
-    "redis",
-    "dataloader",
-    "resolver",
-    "orm"
-  ],
   "main": "index.js",
-  "license": "MIT",
+  "version": "0.13.0",
+  "publishConfig": {
+    "access": "public"
+  },
   "files": [
-    "src/",
-    "index.js"
+    "src",
+    "!__mocks__"
   ],
-  "engines": {
-    "node": ">=14.17.0"
-  },
   "scripts": {
-    "start": "APP_ROOT_PATH=$(pwd) node ./test/server",
-    "test": "APP_ROOT_PATH=$(pwd) ratchet test",
-    "test:debug": "APP_ROOT_PATH=$(pwd) node --inspect-brk ./node_modules/jest/bin/jest.js --watch --runInBand --logHeapUsage",
-    "lint": "APP_ROOT_PATH=$(pwd) ratchet lint",
-    "inspect": "APP_ROOT_PATH=$(pwd) node --expose-gc --inspect=9222 ./src/server",
-    "ratchet": "ratchet"
+    "test": "NODE_OPTIONS=\"--stack-trace-limit=1000\" jest --config=jest.config.js",
+    "lint": "eslint --config=.eslintrc ./",
+    "dev": "coderich-dev"
   },
   "dependencies": {
-    "@coderich/util": "^0.1.1",
-    "@hapi/boom": "^9.1.0",
-    "dataloader": "^2.0.0",
-    "deepmerge": "^4.2.2",
-    "fill-range": "^7.0.1",
-    "glob": "^7.1.6",
-    "graphql-fields": "^2.0.3",
-    "lodash": "^4.17.21",
-    "mongodb": "4.8.1",
-    "object-hash": "^3.0.0",
-    "picomatch": "^2.1.1"
+    "@coderich/util": "0.1.4",
+    "@graphql-tools/merge": "9.0.0",
+    "@graphql-tools/resolvers-composition": "7.0.0",
+    "@hapi/boom": "10.0.1",
+    "bson-objectid": "2.0.4",
+    "dataloader": "2.2.2",
+    "deepmerge": "4.3.1",
+    "fill-range": "7.0.1",
+    "lodash.get": "4.4.2",
+    "lodash.merge": "4.6.2",
+    "lodash.uniqwith": "4.5.0",
+    "object-hash": "3.0.0",
+    "picomatch": "2.3.1"
   },
   "devDependencies": {
-    "@coderich/ratchet": "^1.5.8",
-    "@graphql-tools/schema": "^9.0.1",
-    "graphql": "^15.5.0",
-    "mongodb-memory-server": "^8.7.2",
-    "validator": "^13.7.0"
+    "@apollo/server": "4.9.5",
+    "@coderich/autograph-mongodb": "0.0.1",
+    "@coderich/dev": "0.1.0",
+    "@graphql-tools/schema": "10.0.0",
+    "graphql": "16.6.0",
+    "mongodb": "5.7.0",
+    "mongodb-memory-server": "8.13.0",
+    "validator": "13.9.0"
   },
   "peerDependencies": {
     "graphql": "*"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:coderich/autograph.git"
   }
 }

package/src/data/DataLoader.js

@@ -1,82 +1,89 @@
-const FBDataLoader = require('dataloader');
-const { map, ensureArray, hashObject } = require('../service/app.service');
-const Query = require('../query/Query');
+const get = require('lodash.get');
+const Util = require('@coderich/util');
+const DataLoader = require('dataloader');
+const { hashObject } = require('../service/AppService');
 
-const handleData = (data, model, query) => {
-  if (data == null || typeof data !== 'object') return data;
-  return model.deserialize(data, query);
-};
-
-module.exports = class DataLoader extends FBDataLoader {
-  constructor(resolver, model) {
-    const driver = model.getDriver();
+module.exports = class Loader {
+  #model;
+  #loader;
 
-    return new FBDataLoader((queries) => {
-      let performBatchQuery = false; // If we don't have to batch it's faster to resolve normal
-      const defaultBatchName = '__default__'; // Something that won't collide with an actual field name
+  constructor(model) {
+    this.#model = model;
+    model.loader.cacheKeyFn ??= (query => hashObject(query.toCacheKey()));
+    this.#loader = new DataLoader(keys => this.#resolve(keys), model.loader);
+  }
 
-      /**
-       * Batch queries can save resources and network round-trip latency. However, we have to be careful to
-       * preserve the order and adhere to the DataLoader API. This step simply creates a map of batch
-       * queries to run; saving the order ("i") along with useful meta information
-       */
-      const batchQueries = queries.reduce((prev, query, i) => {
-        const { batch = defaultBatchName, where, cmd } = query.toObject();
-        const key = batch && (cmd === 'one' || cmd === 'many') ? batch : defaultBatchName;
-        if (key !== defaultBatchName) performBatchQuery = true;
-        prev[key] = prev[key] || [];
-        prev[key].push({ query, where, cmd, i });
-        return prev;
-      }, {});
+  clearAll() {
+    return this.#loader.clearAll();
+  }
 
-      // Don't batch unless it's worth it!
-      if (!performBatchQuery) {
-        return Promise.all(queries.map((query) => {
-          return driver.resolve(query.toDriver()).then(data => handleData(data, model, query));
-        }));
-      }
+  resolve(query) {
+    return this.#loader.load(query);
+  }
 
-      /**
-       * We have reduced the number of queries down to a smaller set of batch queries to run. The dance
-       * performed below retreives the data and then expands the results back into the original queries
-       */
-      const whereShape = model.getShape('create', 'where');
+  #resolve(queries) {
+    return Promise.all(queries.map((query) => {
+      const dquery = query.toDriver();
+      const $query = dquery.toObject();
 
-      return Promise.all(Object.entries(batchQueries).map(([key, values]) => {
-        switch (key) {
-          case defaultBatchName: {
-            return values.map(({ query, i }) => driver.resolve(query.toDriver()).then(data => handleData(data, model, query)).then(data => ({ data, i })));
-          }
-          default: {
-            const keys = Array.from(new Set(values.map(({ where }) => map(where[key], el => `${el}`)).flat()));
-            const batchQuery = new Query({ resolver, model, method: 'findMany', crud: 'read' });
-            const batchWhere = model.shapeObject(whereShape, { ...values[0].where, [key]: keys }, batchQuery); // All where's should be the same - this is for idKey on keys etc
+      return this.#model.source.client.resolve($query).then((data) => {
+        if (data == null) return null; // Explicit return null;
+        if ($query.isCursorPaging && Array.isArray(data)) return Loader.#paginateResults(data, query.toObject());
+        return data;
+      });
+    }));
+  }
 
-            return driver.resolve(batchQuery.where(batchWhere).toDriver()).then(data => handleData(data, model, batchQuery)).then((results) => {
-              // One-time data transformation on results to make matching back faster (below)
-              const resultsByKey = results.reduce((prev, row) => {
-                ensureArray(row[key]).forEach((id) => {
-                  prev[id] = prev[id] || [];
-                  prev[id].push(row);
-                });
-                return prev;
-              }, {});
+  static #paginateResults(rs, query) {
+    let hasNextPage = false;
+    let hasPreviousPage = false;
+    const { first, after, last, before, sort = {} } = query;
+    const sortPaths = Object.keys(Util.flatten(sort, { safe: true }));
+    const limiter = first || last;
 
-              // Match back
-              return values.map(({ where, cmd, i }) => {
-                const targets = ensureArray(where[key]).map(t => `${t}`);
-                const data = targets.map(t => resultsByKey[t] || null).flat();
-                return { i, data: cmd === 'many' ? data.filter(d => d != null) : data[0] };
-              });
-            });
-          }
-        }
-      }).flat()).then((results) => {
-        return results.flat().sort((a, b) => a.i - b.i).map(({ data }) => data);
+    // Add $cursor data (but only if sort is defined!)
+    if (sortPaths.length) {
+      Util.map(rs, (doc) => {
+        const sortValues = sortPaths.reduce((prev, path) => Object.assign(prev, { [path]: get(doc, path) }), {});
+        Object.defineProperty(doc, '$cursor', { value: Buffer.from(JSON.stringify(sortValues)).toString('base64') });
       });
-    }, {
-      cache: true,
-      cacheKeyFn: query => hashObject(query.getCacheKey()),
+    }
+
+    // First try to take off the "bookends" ($gte | $lte)
+    if (rs.length && rs[0].$cursor === after) {
+      rs.shift();
+      hasPreviousPage = true;
+    }
+
+    if (rs.length && rs[rs.length - 1].$cursor === before) {
+      rs.pop();
+      hasNextPage = true;
+    }
+
+    // Next, remove any overage
+    const overage = rs.length - (limiter - 2);
+
+    if (overage > 0) {
+      if (first) {
+        rs.splice(-overage);
+        hasNextPage = true;
+      } else if (last) {
+        rs.splice(0, overage);
+        hasPreviousPage = true;
+      } else {
+        rs.splice(-overage);
+        hasNextPage = true;
+      }
+    }
+
+    // Add $pageInfo
+    return Object.defineProperty(rs, '$pageInfo', {
+      value: {
+        startCursor: get(rs, '0.$cursor', ''),
+        endCursor: get(rs, `${rs.length - 1}.$cursor`, ''),
+        hasPreviousPage,
+        hasNextPage,
+      },
     });
   }
 };

package/src/data/Emitter.js

@@ -0,0 +1,89 @@
+const EventEmitter = require('events');
+const Util = require('@coderich/util');
+const { AbortEarlyError } = require('../service/ErrorService');
+
+/**
+ * EventEmitter.
+ *
+ * The difference is that I'm looking at each raw listeners to determine how many arguments it's expecting.
+ * If it expects more than 1 we block and wait for it to finish.
+ */
+class Emitter extends EventEmitter {
+  emit(event, data) {
+    // Here we pull out functions with "next" vs those without
+    const [basicFuncs, nextFuncs] = this.rawListeners(event).reduce((prev, wrapper) => {
+      const listener = wrapper.listener || wrapper;
+      const isBasic = listener.length < 2;
+      return prev[isBasic ? 0 : 1].push(wrapper) && prev;
+    }, [[], []]);
+
+    return new Promise((resolve, reject) => {
+      // Basic functions run first; if they return a value they abort the flow of execution
+      basicFuncs.forEach((fn) => {
+        const value = fn(data);
+        if (value !== undefined && !(value instanceof Promise)) throw new AbortEarlyError(value);
+      });
+
+      // Next functions are async and control the timing of the next phase
+      Promise.all(nextFuncs.map((fn) => {
+        return new Promise((next) => {
+          Promise.resolve(fn(data, next));
+        }).then((result) => {
+          if (result !== undefined) throw new AbortEarlyError(result);
+        }).catch(reject);
+      })).then(() => resolve()); // Resolve to undefined
+    }).catch((e) => {
+      if (e instanceof AbortEarlyError) return e.data;
+      throw e;
+    });
+  }
+
+  /**
+   * Syntactic sugar to listen on query keys
+   */
+  onKeys(...args) {
+    return this.#createWrapper(...args, 'key');
+  }
+
+  /**
+   * Syntactic sugar to listen once on query keys
+   */
+  onceKeys(...args) {
+    return this.#createWrapper(...args, 'key', true);
+  }
+
+  /**
+   * Syntactic sugar to listen on query models
+   */
+  onModels(...args) {
+    return this.#createWrapper(...args, 'model');
+  }
+
+  /**
+   * Syntactic sugar to listen once on query models
+   */
+  onceModels(...args) {
+    return this.#createWrapper(...args, 'model', true);
+  }
+
+  #createWrapper(eventName, arr, listener, prop, once) {
+    arr = Util.ensureArray(arr);
+
+    const wrapper = listener.length < 2 ? (event) => {
+      if (arr.includes(`${event.query[prop]}`)) {
+        if (once) this.removeListener(eventName, wrapper);
+        return listener(event);
+      }
+      return undefined;
+    } : (event, next) => {
+      if (arr.includes(`${event.query[prop]}`)) {
+        if (once) this.removeListener(eventName, wrapper);
+        next(listener(event, next));
+      }
+    };
+
+    return this.on(eventName, wrapper);
+  }
+}
+
+module.exports = new Emitter().setMaxListeners(100);

package/src/data/Loader.js

@@ -0,0 +1,33 @@
+const DataLoader = require('dataloader');
+const { hashObject } = require('../service/AppService');
+
+module.exports = class Loader {
+  #loader;
+  #resolver;
+
+  constructor(resolver, config = {}) {
+    config.cacheKeyFn ??= event => hashObject(event.args);
+    this.#loader = new DataLoader(events => this.#resolve(events), config);
+    this.#resolver = resolver;
+  }
+
+  load(args, context) {
+    return this.#loader.load({ args, context });
+  }
+
+  prime(args, value) {
+    return this.#loader.prime({ args }, value);
+  }
+
+  clear(args) {
+    return this.#loader.clear({ args });
+  }
+
+  clearAll() {
+    return this.#loader.clearAll();
+  }
+
+  #resolve(events) {
+    return Promise.all(events.map(event => this.#resolver(event.args, event.context)));
+  }
+};

package/src/data/Pipeline.js

@@ -1,6 +1,8 @@
-const { uniqWith } = require('lodash');
-const { map, ensureArray, hashObject } = require('../service/app.service');
-const Boom = require('../core/Boom');
+const Boom = require('@hapi/boom');
+const get = require('lodash.get');
+const Util = require('@coderich/util');
+const uniqWith = require('lodash.uniqwith');
+const { hashObject } = require('../service/AppService');
 
 module.exports = class Pipeline {
   constructor() {
@@ -12,20 +14,25 @@ module.exports = class Pipeline {
     if (typeof factory !== 'function') throw new Error(`Pipeline definition for "${name}" must be a function`);
 
     // Determine options; which may come from the factory function
-    const { ignoreNull = true, itemize = true, configurable = false } = Object.assign({}, factory.options, options);
+    const { ignoreNull = true, itemize = true, configurable = false } = { ...factory.options, ...options };
 
     const wrapper = Object.defineProperty((args) => {
-      if (ignoreNull && args.value == null) return args.value;
+      try {
+        if (ignoreNull && args.value == null) return args.value;
+
+        if (ignoreNull && itemize) {
+          return Util.map(args.value, (value) => {
+            const v = factory({ ...args, value });
+            return v === undefined ? value : v;
+          });
+        }
 
-      if (ignoreNull && itemize) {
-        return map(args.value, (val, index) => {
-          const v = factory({ ...args, value: val, index });
-          return v === undefined ? val : v;
-        });
+        const value = factory(args);
+        return value === undefined ? args.value : value;
+      } catch (e) {
+        const { data = {} } = e;
+        throw Boom.boomify(e, { data: { ...args, ...data } });
       }
-
-      const val = factory(args);
-      return val === undefined ? args.value : val;
     }, 'name', { value: name });
 
     // Attach enumerable method to the Pipeline
@@ -50,93 +57,89 @@ module.exports = class Pipeline {
     // Additional Transformers
     Pipeline.define('toTitleCase', ({ value }) => value.replace(/\w\S*/g, w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()));
     Pipeline.define('toSentenceCase', ({ value }) => value.charAt(0).toUpperCase() + value.slice(1));
-    Pipeline.define('toId', ({ model, value }) => model.idValue(value));
     Pipeline.define('toArray', ({ value }) => (Array.isArray(value) ? value : [value]), { itemize: false });
     Pipeline.define('toDate', ({ value }) => new Date(value), { configurable: true });
-    Pipeline.define('timestamp', ({ value }) => Date.now(), { ignoreNull: false });
-    Pipeline.define('createdAt', ({ value }) => value || Date.now(), { ignoreNull: false });
+    Pipeline.define('updatedAt', () => new Date(), { ignoreNull: false });
+    Pipeline.define('createdAt', ({ value }) => value || new Date(), { ignoreNull: false });
+    Pipeline.define('timestamp', () => Date.now(), { ignoreNull: false });
     Pipeline.define('dedupe', ({ value }) => uniqWith(value, (b, c) => hashObject(b) === hashObject(c)), { itemize: false });
-    Pipeline.define('idKey', ({ model, value }) => (value == null ? model.idValue() : value), { ignoreNull: false });
-    Pipeline.define('idField', ({ model, field, value }) => field.getIdModel().idValue(value.id || value));
-    Pipeline.define('ensureArrayValue', ({ field, value }) => (field.toObject().isArray && !Array.isArray(value) ? [value] : value), { itemize: false });
-
-    Pipeline.define('ensureId', ({ resolver, model, field, value }) => {
-      const path = `${model}.${field}`;
-      const { type } = field.toObject();
-      const ids = Array.from(new Set(ensureArray(value).map(v => `${v}`)));
-
-      return resolver.match(type).where({ id: ids }).count().then((count) => {
-        if (count !== ids.length) throw Boom.notFound(`${type} Not Found`, { path });
-      });
-    }, { itemize: false });
-
-    Pipeline.define('defaultValue', ({ field, value }) => {
-      const { defaultValue } = field.toObject();
-      return value === undefined ? defaultValue : value;
-    }, { ignoreNull: false });
-
-    Pipeline.define('castValue', ({ field, value }) => {
-      const { type, isEmbedded } = field.toObject();
 
+    // Structures
+    Pipeline.define('$instruct', params => Pipeline.resolve(params, 'instruct'), { ignoreNull: false });
+    Pipeline.define('$normalize', params => Pipeline.resolve(params, 'normalize'), { ignoreNull: false });
+    Pipeline.define('$construct', params => Pipeline.resolve(params, 'construct'), { ignoreNull: false });
+    Pipeline.define('$restruct', params => Pipeline.resolve(params, 'restruct'), { ignoreNull: false });
+    Pipeline.define('$serialize', params => Pipeline.resolve(params, 'serialize'), { ignoreNull: false });
+    Pipeline.define('$finalize', params => Pipeline.resolve(params, 'finalize'), { ignoreNull: false });
+
+    //
+    Pipeline.define('$pk', ({ query, model, value, path }) => model.source.idValue(get(query.doc, path) || value?.id || value), { ignoreNull: false });
+    Pipeline.define('$fk', ({ model, value }) => model.source.idValue(value.id || value));
+    Pipeline.define('$default', ({ field: { defaultValue }, value }) => (value === undefined ? defaultValue : value), { ignoreNull: false });
+
+    //
+    Pipeline.define('$cast', ({ field, value }) => {
+      const { type, isEmbedded } = field;
       if (isEmbedded) return value;
 
-      return map(value, (v) => {
-        switch (type) {
-          case 'String': {
-            return `${v}`;
-          }
-          case 'Float': case 'Number': {
-            const num = Number(v);
-            if (!Number.isNaN(num)) return num;
-            return v;
-          }
-          case 'Int': {
-            const num = Number(v);
-            if (!Number.isNaN(num)) return parseInt(v, 10);
-            return v;
-          }
-          case 'Boolean': {
-            if (v === 'true') return true;
-            if (v === 'false') return false;
-            return v;
-          }
-          default: {
-            return v;
-          }
+      switch (type.toLowerCase()) {
+        case 'string': {
+          return `${value}`;
+        }
+        case 'float': case 'number': {
+          const num = Number(value);
+          if (!Number.isNaN(num)) return num;
+          return value;
         }
+        case 'int': {
+          const num = Number(value);
+          if (!Number.isNaN(num)) return parseInt(value, 10);
+          return value;
+        }
+        case 'boolean': {
+          if (value === 'true') return true;
+          if (value === 'false') return false;
+          return value;
+        }
+        default: {
+          return value;
+        }
+      }
+    });
+
+    //
+    Pipeline.define('ensureId', ({ query, resolver, model, field, value }) => {
+      const { type } = field;
+      const ids = Util.filterBy(Util.ensureArray(value), (a, b) => `${a}` === `${b}`);
+      return resolver.match(type).flags(query.flags).where({ id: ids }).count().then((count) => {
+        if (count !== ids.length) throw Boom.notFound(`${type} Not Found`);
       });
     }, { itemize: false });
 
     // Required fields
-    Pipeline.define('required', ({ model, field, value }) => {
-      const path = `${model}.${field}`;
-      if (value == null) throw Boom.badRequest(`${path} is required`, { path });
+    Pipeline.define('required', ({ query, model, field, value }) => {
+      if ((query.crud === 'create' && value == null) || (query.crud === 'update' && value === null)) throw Boom.badRequest(`${model.name}.${field.name} is required`);
     }, { ignoreNull: false });
 
     // A field cannot hold a reference to itself
-    Pipeline.define('selfless', ({ model, field, parent, parentPath, value }) => {
-      const path = `${model}.${field}`;
-      if (`${value}` === `${parentPath('id')}`) throw Boom.badData(`${path} cannot hold a reference to itself`, { path });
+    Pipeline.define('selfless', ({ query, model, field, value }) => {
+      if (`${value}` === `${query.doc?.id}`) throw Boom.badRequest(`${model}.${field} cannot hold a reference to itself`);
     });
 
     // Once set it cannot be changed
-    Pipeline.define('immutable', ({ model, field, docPath, parentPath, path, value }) => {
-      const $path = `${model}.${field}`;
-      const hint = { id: parentPath('id') };
-      const oldVal = docPath(path, hint);
-      if (oldVal !== undefined && value !== undefined && `${hashObject(oldVal)}` !== `${hashObject(value)}`) throw Boom.badData(`${$path} is immutable; cannot be changed once set ${oldVal} -> ${value}`, { path: $path });
+    Pipeline.define('immutable', ({ query, model, field, value, path }) => {
+      const oldVal = get(query.doc, path);
+      if (oldVal !== undefined && value !== undefined && `${hashObject(oldVal)}` !== `${hashObject(value)}`) throw Boom.badRequest(`${model}.${field} is immutable; cannot be changed once set ${oldVal} -> ${value}`);
     });
 
     // List of allowed values
     Pipeline.factory('Allow', (...args) => function allow({ model, field, value }) {
-      const path = `${model}.${field}`;
-      if (args.indexOf(value) === -1) throw Boom.badData(`${path} allows ${args}; found '${value}'`, { path });
+      if (args.indexOf(value) === -1) throw Boom.badRequest(`${model}.${field} allows ${args}; found '${value}'`);
     });
 
     // List of disallowed values
     Pipeline.factory('Deny', (...args) => function deny({ model, field, value }) {
-      const path = `${model}.${field}`;
-      if (args.indexOf(value) > -1) throw Boom.badData(`${path} denys ${args}; found '${value}'`, { path });
+      if (args.indexOf(value) > -1) throw Boom.badRequest(`${model}.${field} denys ${args}; found '${value}'`);
     });
 
     // Min/Max range
@@ -145,31 +148,20 @@ module.exports = class Pipeline {
       if (max == null) max = undefined;
 
       return function range({ model, field, value }) {
-        const path = `${model}.${field}`;
         const num = +value; // Coerce to number if possible
         const test = Number.isNaN(num) ? value.length : num;
-        if (test < min || test > max) throw Boom.badData(`${path} must satisfy range ${min}:${max}; found '${value}'`, { path });
+        if (test < min || test > max) throw Boom.badRequest(`${model}.${field} must satisfy range ${min}:${max}; found '${value}'`);
       };
     }, { itemize: false });
   }
+
+  static resolve(params, pipeline) {
+    const transformers = params.field.pipelines[pipeline] || [];
+
+    return Util.pipeline(transformers.map(t => async (value) => {
+      return Pipeline[t]({ ...params, value });
+    }), params.value);
+  }
 };
 
-// const jsStringMethods = [
-//   'charAt', 'charCodeAt', 'codePointAt', 'concat', 'indexOf', 'lastIndexOf', 'localeCompare',
-//   'normalize', 'padEnd', 'padStart', 'repeat', 'replace', 'search', 'slice', 'split', 'substr', 'substring',
-//   'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toString', 'toUpperCase', 'trim', 'trimEnd', 'trimStart', 'raw',
-// ];
-
-// Transformer.factory('toTitleCase', () => ({ value }) => value.replace(/\w\S*/g, w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()), { enumerable: true });
-// Transformer.factory('toLocaleTitleCase', (...args) => ({ value }) => value.replace(/\w\S*/g, w => w.charAt(0).toLocaleUpperCase(...args) + w.slice(1).toLocaleLowerCase()));
-// Transformer.factory('toSentenceCase', () => ({ value }) => value.charAt(0).toUpperCase() + value.slice(1), { enumerable: true });
-// Transformer.factory('toLocaleSentenceCase', (...args) => ({ value }) => value.charAt(0).toLocaleUpperCase(...args) + value.slice(1));
-// Transformer.factory('toArray', () => ({ value }) => (Array.isArray(value) ? value : [value]), { itemize: false, enumerable: true });
-// Transformer.factory('toDate', () => ({ value }) => new Date(value), { enumerable: true, writable: true });
-// Transformer.factory('dedupe', () => ({ value }) => uniqWith(value, (b, c) => hashObject(b) === hashObject(c)), { ignoreNull: false, enumerable: true });
-// Transformer.factory('dedupeBy', key => ({ value }) => uniqWith(value, (b, c) => hashObject(b[key]) === hashObject(c[key])), { ignoreNull: false, enumerable: true });
-// Transformer.factory('timestamp', () => () => Date.now(), { enumerable: true, ignoreNull: false });
-// Transformer.factory('createdAt', () => ({ value }) => value || Date.now(), { enumerable: true, ignoreNull: false });
-// Transformer.factory('first', () => ({ value }) => (Array.isArray(value) ? value[0] : value), { enumerable: true });
-// Transformer.factory('get', path => ({ value }) => get(value, path), { enumerable: true });
-// Transformer.factory('set', path => ({ value }) => set({}, path, value), { enumerable: true });
+module.exports.createPresets();