@coderich/autograph 0.9.12 → 0.9.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "author": "Richard Livolsi (coderich)",
-  "version": "0.9.12",
+  "version": "0.9.13",
   "description": "AutoGraph",
   "keywords": [
     "graphql",

package/src/core/Resolver.js

@@ -1,3 +1,4 @@
+const { isEmpty } = require('lodash');
 const Model = require('../data/Model');
 const Query = require('../query/Query');
 const ResultSet = require('../data/ResultSet');
@@ -89,7 +90,7 @@ module.exports = class Resolver {
         // This is needed in SF tests...
         const key = model.idKey();
         const { where, method } = query.toDriver();
-        if (Object.prototype.hasOwnProperty.call(where, key) && where[key] == null) return Promise.resolve(method === 'findMany' ? [] : null);
+        if (Object.prototype.hasOwnProperty.call(where, key) && isEmpty(where[key])) return Promise.resolve(method === 'findMany' ? [] : null);
 
         //
         return this.loaders.get(`${model}`).load(query);

package/src/data/Model.js

@@ -160,4 +160,24 @@ module.exports = class extends Model {
       }, {});
     });
   }
+
+  getShape(serdes = 'deserialize', recursive = true) {
+    return this.getSelectFields().map((field) => {
+      const [from, to] = serdes === 'serialize' ? [field.getName(), field.getKey()] : [field.getKey(), field.getName()];
+      const shape = recursive && field.isEmbedded() ? field.getModelRef().getShape(serdes, recursive) : null;
+      return { from, to, type: field.getDataType(), isArray: field.isArray(), shape };
+    });
+  }
+
+  shape(data, serdes = (() => { throw new Error('No Sir Sir SerDes!'); }), shape) {
+    shape = shape || this.getShape(serdes);
+
+    return map(data, (doc) => {
+      return shape.reduce((prev, { from, to, shape: subShape }) => {
+        const value = doc[from];
+        if (value === undefined) return prev;
+        return Object.assign(prev, { [to]: subShape ? this.shape(value, serdes, subShape) : value });
+      }, {});
+    });
+  }
 };

package/src/data/ResultSet.js

@@ -2,169 +2,50 @@ const { get } = require('lodash');
 const DataService = require('./DataService');
 const { map, ensureArray, keyPaths, mapPromise, toGUID, hashObject } = require('../service/app.service');
 
+const modelCache = new WeakMap();
+
 module.exports = class ResultSet {
   constructor(query, data, adjustForPagination = true) {
     if (data == null) return data;
-    const { resolver, model, sort, first, after, last, before } = query.toObject();
-    const fields = model.getFields().filter(f => f.getName() !== 'id');
 
-    const rs = map(data, (doc) => {
-      if (doc == null || typeof doc !== 'object') return doc;
-
-      //
-      const cache = new Map();
-
-      const definition = fields.reduce((prev, field) => {
-        const key = field.getKey();
-        const name = field.getName();
-        const $name = `$${name}`;
-        const value = doc[key];
-
-        // Field attributes
-        prev[name] = {
-          get() {
-            if (cache.has(name)) return cache.get(name);
-            let $value = field.deserialize(query, value);
-            $value = $value != null && field.isEmbedded() ? new ResultSet(query.model(field.getModelRef()), $value, false) : $value;
-            cache.set(name, $value);
-            return $value;
-          },
-          set($value) {
-            cache.set(name, $value);
-          },
-          enumerable: true,
-          configurable: true, // Allows things like delete
-        };
-
-        // Hydrated field attributes
-        prev[`$${name}`] = {
-          get() {
-            return (args = {}) => {
-              // Ensure where clause
-              args.where = args.where || {};
-
-              // Cache
-              const cacheKey = `${$name}-${hashObject(args)}`;
-              if (cache.has(cacheKey)) return cache.get(cacheKey);
-
-              const promise = new Promise((resolve, reject) => {
-                (() => {
-                  const $value = this[name];
-
-                  if (field.isScalar() || field.isEmbedded()) return Promise.resolve($value);
-
-                  const modelRef = field.getModelRef();
-
-                  if (field.isArray()) {
-                    if (field.isVirtual()) {
-                      args.where[[field.getVirtualField()]] = this.id; // Is where[[field.getVirtualField()]] correct?
-                      return resolver.match(modelRef).merge(args).many();
-                    }
-
-                    // Not a "required" query + strip out nulls
-                    args.where.id = $value;
-                    return resolver.match(modelRef).merge(args).many();
-                  }
+    const { resolver, model, sort, first, after, last, before } = query.toObject();
 
-                  if (field.isVirtual()) {
-                    args.where[[field.getVirtualField()]] = this.id;
-                    return resolver.match(modelRef).merge(args).one();
-                  }
+    ResultSet.ensureModelCache(model);
 
-                  return resolver.match(modelRef).id($value).one({ required: field.isRequired() });
-                })().then((results) => {
-                  if (results == null) return field.resolve(query, results); // Allow field to determine
-                  return mapPromise(results, result => field.resolve(query, result)).then(() => results); // Resolve the inside fields but still return "results"!!!!
-                }).then((resolved) => {
-                  resolve(resolved);
-                }).catch((e) => {
-                  reject(e);
-                });
-              });
-
-              cache.set(cacheKey, promise);
-              return promise;
-            };
-          },
-          enumerable: false,
-        };
-
-        // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
-        prev[`$${name}:count`] = {
-          get() {
-            return (q = {}) => {
-              q.where = q.where || {};
-              if (field.isVirtual()) q.where[field.getVirtualField()] = this.id;
-              else q.where.id = this[name];
-              return resolver.match(field.getModelRef()).merge(q).count();
-            };
-          },
-          enumerable: false,
-        };
-
-        return prev;
-      }, {
-        id: {
-          get() { return doc.id || doc[model.idKey()]; },
-          set(id) { doc.id = id; }, // Embedded array of documents need to set id
-          enumerable: true,
-        },
+    const { template, fieldDefs } = modelCache.get(model);
 
-        $id: {
-          get() { return toGUID(model.getName(), this.id); },
-          enumerable: false,
-        },
+    const rs = map(data, (doc) => {
+      if (doc == null || typeof doc !== 'object') return doc;
 
-        $$cursor: {
-          get() {
-            const sortPaths = keyPaths(sort);
-            const sortValues = sortPaths.reduce((prv, path) => Object.assign(prv, { [path]: get(this, path) }), {});
-            const sortJSON = JSON.stringify(sortValues);
-            return Buffer.from(sortJSON).toString('base64');
+      const instance = Object.create(template, {
+        $$services: {
+          value: {
+            cache: new Map(),
+            data: doc,
+            resolver,
+            query,
+            sort,
           },
           enumerable: false,
         },
+      });
 
-        $$model: {
-          value: model,
-          enumerable: false,
-        },
-
-        $$isResultSetItem: {
-          value: true,
-          enumerable: false,
-        },
-
-        $$save: {
-          get() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
-          enumerable: false,
+      return new Proxy(instance, {
+        ownKeys(target) {
+          return Reflect.ownKeys(target).concat('id', fieldDefs.map(d => d.name));
         },
-
-        $$remove: {
-          get() { return () => resolver.match(model).id(this.id).remove(); },
-          enumerable: false,
+        getOwnPropertyDescriptor(target, prop) {
+          return (prop === 'id' || fieldDefs.find(el => el.name === prop)) ? { enumerable: true, configurable: true } : Reflect.getOwnPropertyDescriptor(target, prop);
         },
-
-        $$delete: {
-          get() { return () => resolver.match(model).id(this.id).delete(); },
-          enumerable: false,
+        getPrototypeOf() {
+          return { $$services: instance.$$services };
         },
-
-        toObject: {
-          get() {
-            return () => map(this, obj => Object.entries(obj).reduce((prev, [key, value]) => {
-              if (value === undefined) return prev;
-              prev[key] = get(value, '$$isResultSet') ? value.toObject() : value;
-              return prev;
-            }, {}));
-          },
-          enumerable: false,
-          configurable: true,
+        deleteProperty(target, prop) {
+          const { key = prop } = fieldDefs.find(d => d.name === prop);
+          delete instance[prop];
+          delete instance.$$services.data[key];
         },
       });
-
-      // Create and return ResultSetItem
-      return Object.defineProperties({}, definition);
     });
 
     let hasNextPage = false;
@@ -202,4 +83,177 @@ module.exports = class ResultSet {
       },
     });
   }
+
+  static ensureModelCache(model) {
+    if (!modelCache.has(model)) {
+      const fields = model.getFields().filter(f => f.getName() !== 'id');
+
+      const fieldDefs = fields.map(field => ({
+        field,
+        key: field.getKey(),
+        name: field.getName(),
+        isArray: field.isArray(),
+        isScalar: field.isScalar(),
+        isVirtual: field.isVirtual(),
+        isRequired: field.isRequired(),
+        isEmbedded: field.isEmbedded(),
+        modelRef: field.getModelRef(),
+        virtualField: field.getVirtualField(),
+        // deserialize: field.deserialize.bind(field),
+        // fieldResolve: field.resolve.bind(field),
+        get useDefaultResolver() { return Boolean((this.isScalar || this.isEmbedded) && !field.getResolvers().length); },
+      }));
+
+      const template = ResultSet.makeModelTemplate(model, fieldDefs);
+
+      modelCache.set(model, { template, fieldDefs });
+    }
+  }
+
+  static makeModelTemplate(model, fieldDefs) {
+    const definition = fieldDefs.reduce((prev, fieldDef) => {
+      const { field, key, name, isArray, isScalar, isVirtual, isRequired, isEmbedded, modelRef, virtualField, useDefaultResolver } = fieldDef;
+      const $name = `$${name}`;
+
+      // Deserialized field attributes
+      prev[name] = {
+        get() {
+          if (this.$$services.cache.has(name)) return this.$$services.cache.get(name);
+          let $value = field.deserialize(this.$$services.query, this.$$services.data[key]);
+          if ($value != null && isEmbedded) {
+            $value = new ResultSet(this.$$services.query.model(modelRef), $value, false);
+          }
+          this.$$services.cache.set(name, $value);
+          return $value;
+        },
+        set($value) {
+          this.$$services.cache.set(name, $value);
+        },
+        enumerable: true,
+        configurable: true, // Allows things like delete
+      };
+
+      // Fully deserialized, hydrated, and resolved field attributes
+      prev[$name] = {
+        get() {
+          return (args = {}) => {
+            // Grab deserialized value
+            const $value = this[name];
+
+            // Default resolver return immediately!
+            if (useDefaultResolver) return $value;
+
+            // There are FIELD resolvers to run
+            return new Promise((resolve, reject) => {
+              return new Promise((res) => {
+                // Scalars and Embeds do not need DB lookup
+                if (isScalar || isEmbedded) return res($value);
+
+                // Ensure where clause for DB lookup
+                args.where = args.where || {};
+
+                if (isArray) {
+                  if (isVirtual) {
+                    args.where[[virtualField]] = this.id; // Is where[[virtualField]] correct?
+                    return res(this.$$services.resolver.match(modelRef).merge(args).many());
+                  }
+
+                  // Not a "required" query + strip out nulls
+                  args.where.id = $value;
+                  return res(this.$$services.resolver.match(modelRef).merge(args).many());
+                }
+
+                if (isVirtual) {
+                  args.where[[virtualField]] = this.id;
+                  return res(this.$$services.resolver.match(modelRef).merge(args).one());
+                }
+
+                return res(this.$$services.resolver.match(modelRef).id($value).one({ required: isRequired }));
+              }).then((results) => {
+                if (results == null) return field.resolve(this.$$services.query, results); // Allow field to determine
+                return mapPromise(results, result => field.resolve(this.$$services.query, result)).then(() => results); // Resolve the inside fields but still return "results"!!!!
+              }).then(resolve).catch(reject);
+            });
+          };
+        },
+        enumerable: false,
+      };
+
+      // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
+      prev[`${$name}:count`] = {
+        get() {
+          return (q = {}) => {
+            q.where = q.where || {};
+            if (isVirtual) q.where[virtualField] = this.id;
+            else q.where.id = this[name];
+            return this.$$services.resolver.match(modelRef).merge(q).count();
+          };
+        },
+        enumerable: false,
+      };
+
+      return prev;
+    }, {
+      id: {
+        get() { return this.$$services.data.id || this.$$services.data[model.idKey()]; },
+        set(id) { this.$$services.data.id = id; }, // Embedded array of documents need to set id
+        enumerable: true,
+      },
+
+      $id: {
+        get() { return toGUID(model.getName(), this.id); },
+        enumerable: false,
+      },
+
+      $$cursor: {
+        get() {
+          const sortPaths = keyPaths(this.$$services.sort);
+          const sortValues = sortPaths.reduce((prv, path) => Object.assign(prv, { [path]: get(this, path) }), {});
+          const sortJSON = JSON.stringify(sortValues);
+          return Buffer.from(sortJSON).toString('base64');
+        },
+        enumerable: false,
+      },
+
+      $$model: {
+        value: model,
+        enumerable: false,
+      },
+
+      $$isResultSetItem: {
+        value: true,
+        enumerable: false,
+      },
+
+      $$save: {
+        get() { return input => this.$$services.resolver.match(model).id(this.id).save({ ...this, ...input }); },
+        enumerable: false,
+      },
+
+      $$remove: {
+        get() { return () => this.$$services.resolver.match(model).id(this.id).remove(); },
+        enumerable: false,
+      },
+
+      $$delete: {
+        get() { return () => this.$$services.resolver.match(model).id(this.id).delete(); },
+        enumerable: false,
+      },
+
+      toObject: {
+        get() {
+          return () => map(this, obj => Object.entries(obj).reduce((prev, [key, value]) => {
+            if (value === undefined) return prev;
+            prev[key] = get(value, '$$isResultSet') ? value.toObject() : value;
+            return prev;
+          }, {}));
+        },
+        enumerable: false,
+        configurable: true,
+      },
+    });
+
+    // return Object.defineProperties({}, definition);
+    return Object.create(null, definition);
+  }
 };

package/src/data/ResultSetItem.js

@@ -0,0 +1,178 @@
+const { get } = require('lodash');
+const { map, keyPaths, mapPromise, toGUID, hashObject } = require('../service/app.service');
+
+module.exports = class ResultSetItem {
+  constructor(model) {
+    const fields = model.getFields().filter(f => f.getName() !== 'id');
+    this.resultSetItem = this.createResultSetItem(fields);
+  }
+
+  create(query, data) {
+    if (data == null || typeof data !== 'object') return data;
+    Object.assign(this, query.toObject());
+    this.data = data;
+    this.query = query;
+    return this.resultSetItem;
+  }
+
+  createResultSetItem(fields) {
+    const self = this;
+    const cache = new Map();
+
+    const definition = fields.reduce((prev, field) => {
+      const key = field.getKey();
+      const name = field.getName();
+      const $name = `$${name}`;
+
+      // Deserialized field attributes
+      prev[name] = {
+        get() {
+          const value = self.data[key];
+          if (cache.has(name)) return cache.get(name);
+          let $value = field.deserialize(self.query, value);
+          if ($value != null && field.isEmbedded()) {
+            const modelRef = field.getModelRef();
+            const newQuery = self.query.model(modelRef);
+            $value = map($value, $v => modelRef.getResultSetItem().create(newQuery, $v));
+          }
+          cache.set(name, $value);
+          return $value;
+        },
+        set($value) {
+          cache.set(name, $value);
+        },
+        enumerable: true,
+        configurable: true, // Allows things like delete
+      };
+
+      // Fully deserialized, hydrated, and resolved field attributes
+      prev[$name] = {
+        get() {
+          return (args = {}) => {
+            // Ensure where clause
+            args.where = args.where || {};
+
+            // Cache
+            const cacheKey = `${$name}-${hashObject(args)}`;
+            if (cache.has(cacheKey)) return cache.get(cacheKey);
+
+            const promise = new Promise((resolve, reject) => {
+              (() => {
+                const $value = this[name];
+
+                if (field.isScalar() || field.isEmbedded()) return Promise.resolve($value);
+
+                const modelRef = field.getModelRef();
+
+                if (field.isArray()) {
+                  if (field.isVirtual()) {
+                    args.where[[field.getVirtualField()]] = this.id; // Is where[[field.getVirtualField()]] correct?
+                    return self.resolver.match(modelRef).merge(args).many();
+                  }
+
+                  // Not a "required" query + strip out nulls
+                  args.where.id = $value;
+                  return self.resolver.match(modelRef).merge(args).many();
+                }
+
+                if (field.isVirtual()) {
+                  args.where[[field.getVirtualField()]] = this.id;
+                  return self.resolver.match(modelRef).merge(args).one();
+                }
+
+                return self.resolver.match(modelRef).id($value).one({ required: field.isRequired() });
+              })().then((results) => {
+                if (results == null) return field.resolve(self.query, results); // Allow field to determine
+                return mapPromise(results, result => field.resolve(self.query, result)).then(() => results); // Resolve the inside fields but still return "results"!!!!
+              }).then((resolved) => {
+                resolve(resolved);
+              }).catch((e) => {
+                reject(e);
+              });
+            });
+
+            cache.set(cacheKey, promise);
+            return promise;
+          };
+        },
+        enumerable: false,
+      };
+
+      // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
+      prev[`${$name}:count`] = {
+        get() {
+          return (q = {}) => {
+            q.where = q.where || {};
+            if (field.isVirtual()) q.where[field.getVirtualField()] = this.id;
+            else q.where.id = this[name];
+            return self.resolver.match(field.getModelRef()).merge(q).count();
+          };
+        },
+        enumerable: false,
+      };
+
+      return prev;
+    }, {
+      id: {
+        get() { return self.data.id || self.data[self.model.idKey()]; },
+        set(id) { self.data.id = id; }, // Embedded array of documents need to set id
+        enumerable: true,
+      },
+
+      $id: {
+        get() { return toGUID(self.model.getName(), this.id); },
+        enumerable: false,
+      },
+
+      $$cursor: {
+        get() {
+          const sortPaths = keyPaths(self.sort);
+          const sortValues = sortPaths.reduce((prv, path) => Object.assign(prv, { [path]: get(this, path) }), {});
+          const sortJSON = JSON.stringify(sortValues);
+          return Buffer.from(sortJSON).toString('base64');
+        },
+        enumerable: false,
+      },
+
+      $$model: {
+        value: self.model,
+        enumerable: false,
+      },
+
+      $$isResultSetItem: {
+        value: true,
+        enumerable: false,
+      },
+
+      $$save: {
+        get() { return input => self.resolver.match(self.model).id(this.id).save({ ...this, ...input }); },
+        enumerable: false,
+      },
+
+      $$remove: {
+        get() { return () => self.resolver.match(self.model).id(this.id).remove(); },
+        enumerable: false,
+      },
+
+      $$delete: {
+        get() { return () => self.resolver.match(self.model).id(this.id).delete(); },
+        enumerable: false,
+      },
+
+      toObject: {
+        get() {
+          return () => map(this, obj => Object.entries(obj).reduce((prev, [key, value]) => {
+            if (value === undefined) return prev;
+            prev[key] = get(value, '$$isResultSet') ? value.toObject() : value;
+            return prev;
+          }, {}));
+        },
+        enumerable: false,
+        configurable: true,
+      },
+    });
+
+    // Create and return ResultSetItem
+    return Object.defineProperties({}, definition);
+  }
+};

package/src/data/ResultSetNew.js

@@ -0,0 +1,47 @@
+const { get } = require('lodash');
+const DataService = require('./DataService');
+const { map, ensureArray } = require('../service/app.service');
+
+module.exports = class ResultSet {
+  constructor(query, data, adjustForPagination = true) {
+    if (data == null) return data;
+
+    const { model, first, after, last, before } = query.toObject();
+    const rs = map(data, doc => model.getResultSetItem().create(query, doc));
+
+    let hasNextPage = false;
+    let hasPreviousPage = false;
+    if (adjustForPagination && rs.length) (({ hasPreviousPage, hasNextPage } = DataService.paginateResultSet(rs, first, after, last, before)));
+
+    return Object.defineProperties(rs, {
+      $$pageInfo: {
+        get() {
+          const edges = ensureArray(rs);
+
+          return {
+            startCursor: get(edges, '0.$$cursor', ''),
+            endCursor: get(edges, `${edges.length - 1}.$$cursor`, ''),
+            hasPreviousPage,
+            hasNextPage,
+          };
+        },
+        enumerable: false,
+      },
+      $$isResultSet: {
+        value: true,
+        enumerable: false,
+      },
+      toObject: {
+        get() {
+          return () => map(this, doc => Object.entries(doc).reduce((prev, [key, value]) => {
+            if (value === undefined) return prev;
+            prev[key] = get(value, '$$isResultSet') ? value.toObject() : value;
+            return prev;
+          }, {}));
+        },
+        enumerable: false,
+        configurable: true,
+      },
+    });
+  }
+};