@coderich/autograph 0.9.12 → 0.9.13

package/src/data/ResultSetObj.js

@@ -0,0 +1,299 @@
+const { get } = require('lodash');
+const DataService = require('./DataService');
+const { map, ensureArray, keyPaths, mapPromise, toGUID, hashObject } = require('../service/app.service');
+
+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 = {
+        // $$model: model,
+        $$isResultSetItem: true,
+
+        get id() { return doc.id || doc[model.idKey()]; },
+        set id(id) { doc.id = id; }, // Embedded array of documents need to set id
+        get $id() { return toGUID(model.getName(), this.id); },
+
+        get $$cursor() {
+          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');
+        },
+
+        $$save: input => resolver.match(model).id(this.id).save({ ...this, ...input }),
+        $$remove: () => resolver.match(model).id(this.id).remove(),
+        $$delete: () => resolver.match(model).id(this.id).delete(),
+
+        get toObject() {
+          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;
+          }, {}));
+        },
+
+        ...fields.reduce((prev, field) => {
+          const key = field.getKey();
+          const name = field.getName();
+          const $name = `$${name}`;
+          const value = doc[key];
+
+          return {
+            ...prev,
+
+            // Deserialized field attributes
+            get [name]() {
+              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 [name]($value) {
+              cache.set(name, $value);
+            },
+
+            // Fully deserialized, hydrated, and resolved field attributes
+            get [$name]() {
+              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();
+                    }
+
+                    if (field.isVirtual()) {
+                      args.where[[field.getVirtualField()]] = this.id;
+                      return resolver.match(modelRef).merge(args).one();
+                    }
+
+                    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;
+              };
+            },
+
+            // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
+            get [`${$name}:count`]() {
+              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();
+              };
+            },
+          };
+        }, {}),
+      };
+
+      // const definition = fields.reduce((prev, field) => {
+      //   const key = field.getKey();
+      //   const name = field.getName();
+      //   const $name = `$${name}`;
+      //   const value = doc[key];
+
+      //   return {
+      //     ...prev,
+
+      //     // Deserialized field attributes
+      //     get [name]() {
+      //       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 [name]($value) {
+      //       cache.set(name, $value);
+      //     },
+
+      //     // Fully deserialized, hydrated, and resolved field attributes
+      //     get [$name]() {
+      //       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();
+      //             }
+
+      //             if (field.isVirtual()) {
+      //               args.where[[field.getVirtualField()]] = this.id;
+      //               return resolver.match(modelRef).merge(args).one();
+      //             }
+
+      //             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;
+      //       };
+      //     },
+
+      //     // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
+      //     get [`${$name}:count`]() {
+      //       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();
+      //       };
+      //     },
+      //   };
+      // }, {
+      //   get id() { return doc.id || doc[model.idKey()]; },
+      //   set id(id) { doc.id = id; }, // Embedded array of documents need to set id
+
+      //   get $id() { return toGUID(model.getName(), this.id); },
+
+      //   get $$cursor() {
+      //     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');
+      //   },
+
+      //   $$model: model,
+      //   $$isResultSetItem: true,
+      //   $$save: input => resolver.match(model).id(this.id).save({ ...this, ...input }),
+      //   $$remove: () => resolver.match(model).id(this.id).remove(),
+      //   $$delete: () => resolver.match(model).id(this.id).delete(),
+
+      //   get toObject() {
+      //     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;
+      //     }, {}));
+      //   },
+      // });
+
+      return definition;
+    });
+
+    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,
+      },
+    });
+
+    // const idk = {
+    //   ...rs,
+    //   $$isResultSet: true,
+    //   get $$pageInfo() {
+    //     const edges = ensureArray(rs);
+
+    //     return {
+    //       startCursor: get(edges, '0.$$cursor', ''),
+    //       endCursor: get(edges, `${edges.length - 1}.$$cursor`, ''),
+    //       hasPreviousPage,
+    //       hasNextPage,
+    //     };
+    //   },
+    //   get toObject() {
+    //     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;
+    //     }, {}));
+    //   },
+    // };
+
+    // return idk;
+  }
+};

package/src/data/{ResultSet2.js → ResultSetOriginal.js}

@@ -4,6 +4,8 @@ const { map, ensureArray, keyPaths, mapPromise, toGUID, hashObject } = require('
 
 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');
 
@@ -13,80 +15,15 @@ module.exports = class ResultSet {
       //
       const cache = new Map();
 
-      // Base definition all results have
-      const definition = {
-        id: {
-          get() { return doc.id || doc[model.idKey()]; },
-          set(id) { doc.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(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,
-        },
-
-        $$data: {
-          value: data,
-          enumerable: false,
-        },
-
-        $$isResultSetItem: {
-          value: true,
-          enumerable: false,
-        },
-
-        $$save: {
-          get() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
-          enumerable: false,
-        },
-
-        $$remove: {
-          get() { return () => resolver.match(model).id(this.id).remove(); },
-          enumerable: false,
-        },
-
-        $$delete: {
-          get() { return () => 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,
-        },
-      };
-
-      fields.forEach((field) => {
+      const definition = fields.reduce((prev, field) => {
         const key = field.getKey();
         const name = field.getName();
         const $name = `$${name}`;
         const value = doc[key];
 
-        // Field attributes
-        definition[name] = {
+        // Deserialized field attributes
+        prev[name] = {
+          // value,
           get() {
             if (cache.has(name)) return cache.get(name);
             let $value = field.deserialize(query, value);
@@ -101,8 +38,9 @@ module.exports = class ResultSet {
           configurable: true, // Allows things like delete
         };
 
-        // Hydrated field attributes
-        definition[`$${name}`] = {
+        // Fully deserialized, hydrated, and resolved field attributes
+        prev[$name] = {
+          // value: () => value,
           get() {
             return (args = {}) => {
               // Ensure where clause
@@ -155,7 +93,7 @@ module.exports = class ResultSet {
         };
 
         // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
-        definition[`$${name}:count`] = {
+        prev[`${$name}:count`] = {
           get() {
             return (q = {}) => {
               q.where = q.where || {};
@@ -166,6 +104,66 @@ module.exports = class ResultSet {
           },
           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,
+        },
+
+        $id: {
+          get() { return toGUID(model.getName(), this.id); },
+          enumerable: false,
+        },
+
+        $$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');
+          },
+          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,
+        },
+
+        $$remove: {
+          get() { return () => resolver.match(model).id(this.id).remove(); },
+          enumerable: false,
+        },
+
+        $$delete: {
+          get() { return () => 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,
+        },
       });
 
       // Create and return ResultSetItem

package/src/driver/MongoDriver.js

@@ -148,15 +148,15 @@ module.exports = class MongoDriver {
   }
 
   static getAddFields(query) {
-    const { schema, where } = query;
+    const { shape, where } = query;
 
-    return Object.entries(schema).reduce((prev, [key, { type }]) => {
-      const value = where[key];
+    return shape.reduce((prev, { from, type }) => {
+      const value = where[from];
       if (value === undefined) return prev;
       if (!isScalarDataType(type)) return prev;
       const stype = String((type === 'Float' || type === 'Int' ? 'Number' : type)).toLowerCase();
       if (String(typeof value) === `${stype}`) return prev;
-      return Object.assign(prev, { [key]: { $toString: `$${key}` } });
+      return Object.assign(prev, { [from]: { $toString: `$${from}` } });
     }, {});
   }
 

package/src/graphql/ast/SchemaDecorator.js

@@ -96,8 +96,8 @@ module.exports = class SchemaDecorator extends TypeDefApi {
    */
   decorate() {
     this.initialize();
-    this.mergeSchema(frameworkExt(this));
-    this.mergeSchema(typeExt(this));
+    this.mergeSchema(frameworkExt(this), { passive: true });
+    this.mergeSchema(typeExt(this), { passive: true });
     this.initialize();
     this.mergeSchema(apiExt(this), { passive: true });
     this.finalize();

package/src/query/Query.js

@@ -251,7 +251,7 @@ module.exports = class Query {
     return {
       isNative: Boolean(this.props.native),
       model: model.getKey(),
-      schema: Query.getSchema(model),
+      shape: model.getShape('deserialize', false),
       method: this.props.method,
       select: this.props.$select,
       joins: this.props.joins,
@@ -292,22 +292,4 @@ module.exports = class Query {
       options: this.props.options,
     };
   }
-
-  static getSchema(model, name = false) {
-    return model.getSelectFields().reduce((prev, field) => {
-      const key = name ? field.getName() : field.getKey();
-      // const modelRef = field.getModelRef();
-      // const isEmbedded = field.isEmbedded();
-
-      return Object.assign(prev, {
-        [key]: {
-          field,
-          alias: name ? field.getKey() : field.getName(),
-          type: field.getDataType(),
-          isArray: field.isArray(),
-          // schema: isEmbedded ? Query.getSchema(modelRef, name) : null,
-        },
-      });
-    }, {});
-  }
 };

package/src/service/app.service.js

@@ -90,7 +90,7 @@ exports.map = (mixed, fn) => {
   if (mixed == null) return mixed;
   const isArray = Array.isArray(mixed);
   const arr = isArray ? mixed : [mixed];
-  const results = arr.map(el => fn(el));
+  const results = arr.map((...args) => fn(...args));
   return isArray ? results : results[0];
 };
 
@@ -266,3 +266,14 @@ exports.proxyDeep = (obj, handler, proxyMap = new WeakMap(), path = '') => {
 
   return finalProxy;
 };
+
+exports.resolveDataObject = (obj) => {
+  return Promise.all(Object.keys(obj).map(async (key) => {
+    const value = await obj[key];
+    return { key, value };
+  })).then((results) => {
+    return results.reduce((prev, { key, value }) => {
+      return Object.assign(prev, { [key]: value });
+    }, {});
+  });
+};