@coderich/autograph 0.9.12 → 0.10.0

package/src/data/stream/ResultSetItemProxy.js

@@ -0,0 +1,161 @@
+const { get } = require('lodash');
+const ResultSet = require('./ResultSet');
+const { map, keyPaths, mapPromise, toGUID, hashObject } = require('../../service/app.service');
+
+module.exports = class ResultSetItem {
+  constructor(query, doc) {
+    if (doc == null) return doc;
+
+    const cache = new Map();
+    const { resolver, model, sort } = query.toObject();
+    const fields = model.getFields().filter(f => f.getName() !== 'id');
+
+    const proxy = new Proxy(doc, {
+      get(target, prop, rec) {
+        const value = Reflect.get(target, prop, rec);
+        if (typeof value === 'function') return value.bind(target);
+
+        if (cache.has(prop)) return cache.get(prop);
+
+        const field = fields.find(f => `${f}` === prop);
+
+        if (field) {
+          let $value = field.deserialize(query, value);
+
+          if ($value != null && field.isEmbedded()) {
+            const newQuery = query.model(field.getModelRef());
+            $value = new ResultSet(newQuery, map($value, v => new ResultSetItem(newQuery, v)), false);
+          }
+
+          cache.set(prop, $value);
+          return $value;
+        }
+
+        return value;
+      },
+      set(target, prop, value, receiver) {
+        cache.set(prop, value);
+        return Reflect.set(target, prop, value);
+      },
+      deleteProperty(target, prop) {
+        cache.delete(prop);
+        return Reflect.delete(target, prop);
+      },
+    });
+
+    const definition = fields.reduce((prev, field) => {
+      const name = field.getName();
+      const $name = `$${name}`;
+
+      // 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();
+                }
+
+                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;
+          };
+        },
+        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 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,
+      },
+    });
+
+    return Object.defineProperties(proxy, definition);
+  }
+};

package/src/driver/MongoDriver.js

@@ -3,16 +3,15 @@ const { MongoClient, ObjectID } = require('mongodb');
 const { proxyDeep, toKeyObj, globToRegex, proxyPromise, isScalarDataType, promiseRetry } = require('../service/app.service');
 
 module.exports = class MongoDriver {
-  constructor(config, schema) {
+  constructor(config) {
     this.config = config;
-    this.schema = schema;
     this.connection = this.connect();
     this.getDirectives = () => get(config, 'directives', {});
   }
 
   connect() {
     const { uri, options = {} } = this.config;
-    options.ignoreUndefined = true;
+    options.ignoreUndefined = false;
     return MongoClient.connect(uri, options);
   }
 
@@ -25,7 +24,8 @@ module.exports = class MongoDriver {
   }
 
   query(collection, method, ...args) {
-    if (has(args[args.length - 1], 'debug')) console.log(collection, method, JSON.stringify(args));
+    if (has(args[args.length - 1], 'debug')) console.log(collection, method, JSON.stringify(args, null, 2));
+    if (method === 'aggregate') args.splice(2);
     return this.raw(collection)[method](...args);
   }
 
@@ -36,18 +36,21 @@ module.exports = class MongoDriver {
   }
 
   findOne(query) {
-    return this.findMany(Object.assign(query, { first: 1 })).then(docs => docs[0]);
+    return this.findMany(Object.assign(query, { first: 1 })).then((stream) => {
+      return new Promise((resolve, reject) => {
+        stream.on('data', resolve);
+        stream.on('error', reject);
+        stream.on('end', resolve);
+      });
+    });
   }
 
   findMany(query) {
-    const { model, options = {}, last, flags } = query;
+    const { model, options = {}, flags } = query;
     Object.assign(options, this.config.query || {});
 
     return this.query(model, 'aggregate', MongoDriver.aggregateQuery(query), options, flags).then((cursor) => {
-      return cursor.toArray().then((results) => {
-        if (last) return results.splice(-last);
-        return results;
-      });
+      return cursor.stream();
     });
   }
 
@@ -63,7 +66,7 @@ module.exports = class MongoDriver {
   }
 
   createOne({ model, input, options, flags }) {
-    return this.query(model, 'insertOne', input, options, flags).then(result => Object.assign(input, { _id: result.insertedId }));
+    return this.query(model, 'insertOne', input, options, flags).then(result => Object.assign(input, { id: result.insertedId }));
   }
 
   updateOne({ model, where, $doc, options, flags }) {
@@ -76,7 +79,7 @@ module.exports = class MongoDriver {
   }
 
   deleteOne({ model, where, options, flags }) {
-    return this.query(model, 'deleteOne', where, options, flags);
+    return this.query(model, 'deleteOne', where, options, flags).then(() => true);
   }
 
   dropModel(model) {
@@ -148,20 +151,38 @@ 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}` } });
     }, {});
   }
 
+  static getProjectFields(parentShape, currentShape = { _id: 0, id: '$_id' }, isEmbedded, isEmbeddedArray, path = []) {
+    return parentShape.reduce((project, value) => {
+      const { from, to, shape: subShape, isArray } = value;
+      const $key = isEmbedded && isEmbeddedArray ? `$$embedded.${from}` : `$${path.concat(from).join('.')}`;
+
+      if (subShape) {
+        const $project = MongoDriver.getProjectFields(subShape, {}, true, isArray, path.concat(from));
+        Object.assign(project, { [to]: isArray ? { $map: { input: $key, as: 'embedded', in: $project } } : $project });
+      } else if (isEmbedded) {
+        Object.assign(project, { [to]: $key });
+      } else {
+        Object.assign(project, { [to]: from === to ? 1 : $key });
+      }
+
+      return project;
+    }, currentShape);
+  }
+
   static aggregateQuery(query, count = false) {
-    const { where: $match, sort, skip, limit, joins } = query;
+    const { where: $match, sort = {}, skip, limit, joins, shape, after, before, first } = query;
     const $aggregate = [{ $match }];
 
     // Used for $regex matching
@@ -190,10 +211,13 @@ module.exports = class MongoDriver {
       if (limit) $aggregate.push({ $limit: limit });
 
       // Pagination
-      const { after, before, first } = query;
       if (after) $aggregate.push({ $match: { $or: Object.entries(after).reduce((prev, [key, value]) => prev.concat({ [key]: { [sort[key] === 1 ? '$gte' : '$lte']: value } }), []) } });
       if (before) $aggregate.push({ $match: { $or: Object.entries(before).reduce((prev, [key, value]) => prev.concat({ [key]: { [sort[key] === 1 ? '$lte' : '$gte']: value } }), []) } });
       if (first) $aggregate.push({ $limit: first });
+
+      // Projection
+      const $project = MongoDriver.getProjectFields(shape);
+      $aggregate.push({ $project });
     }
 
     return $aggregate;

package/src/graphql/ast/Field.js

@@ -145,12 +145,11 @@ module.exports = class Field extends Node {
   // GQL Schema Methods
   getGQLType(suffix, options = {}) {
     let type = this.getType();
-    // if (suffix === 'InputUpdate' && this.isSpliceable()) suffix = 'InputSplice';
     const modelType = `${type}${suffix}`;
     if (suffix && !this.isScalar()) type = this.isEmbedded() ? modelType : 'ID';
     type = this.isArray() ? `[${type}${this.isArrayElementRequired() ? '!' : ''}]` : type;
     if (!suffix && this.isRequired()) type += '!';
-    if (!options.splice && suffix === 'InputCreate' && this.isRequired() && !this.isDefaulted()) type += '!';
+    if (suffix === 'InputCreate' && this.isRequired() && !this.isDefaulted()) type += '!';
     return type;
   }
 

package/src/graphql/ast/Node.js

@@ -208,13 +208,6 @@ module.exports = class Node {
     }
   }
 
-  /**
-   * Is this API embedded in another document
-   */
-  isEmbeddedApi() {
-    return this.isEmbedded() && Boolean(this.getDirectiveArg('field', 'embedApi'));
-  }
-
   /**
    * Can the field be changed after it's set
    */

package/src/graphql/ast/SchemaDecorator.js

@@ -35,6 +35,9 @@ module.exports = class SchemaDecorator extends TypeDefApi {
    * Synchronously merge a schema
    */
   mergeSchema(schema, options = {}) {
+    // Ensure this is a schema of sorts otherwise skip it
+    if (typeof schema !== 'string' && ['context', 'typeDefs', 'resolvers', 'schemaDirectives'].every(key => !schema[key])) return this;
+
     // Here we want to normalize the schema into the shape { context, typeDefs, resolvers, schemaDirectives }
     // We do NOT want to modify the schema object because that may cause unwanted side-effects.
     const normalizedSchema = { ...schema };
@@ -96,8 +99,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/graphql/extension/api.js

@@ -3,7 +3,7 @@ const { Kind } = require('graphql');
 const ServerResolver = require('../../core/ServerResolver');
 const { ucFirst, fromGUID } = require('../../service/app.service');
 const { findGQLModels } = require('../../service/schema.service');
-const { makeCreateAPI, makeReadAPI, makeUpdateAPI, makeDeleteAPI, makeSubscriptionAPI, makeInputSplice, makeQueryResolver, makeMutationResolver } = require('../../service/decorator.service');
+const { makeCreateAPI, makeReadAPI, makeUpdateAPI, makeDeleteAPI, makeSubscriptionAPI, makeQueryResolver, makeMutationResolver } = require('../../service/decorator.service');
 
 const interfaceKinds = [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
 
@@ -25,8 +25,6 @@ module.exports = (schema) => {
   const createModels = findGQLModels('c', markedModels, allModels);
   const readModels = findGQLModels('r', markedModels, allModels);
   const updateModels = findGQLModels('u', markedModels, allModels);
-  const deleteModels = findGQLModels('d', markedModels, allModels);
-  const spliceModels = [...new Set([...createModels, ...updateModels, ...deleteModels])];
 
   return ({
     typeDefs: [
@@ -40,7 +38,6 @@ module.exports = (schema) => {
         input ${model.getName()}InputUpdate {
           ${model.getFields().filter(field => field.hasGQLScope('u') && !field.isVirtual()).map(field => `${field.getName()}: ${field.getGQLType('InputUpdate')}`)}
         }
-        # ${makeInputSplice(model)}
       `),
 
       ...readModels.map(model => `
@@ -50,19 +47,14 @@ module.exports = (schema) => {
         input ${model.getName()}InputSort {
           ${getGQLWhereFields(model).map(field => `${field.getName()}: ${field.getModelRef() ? `${ucFirst(field.getDataRef())}InputSort` : 'SortOrderEnum'}`)}
         }
-      `),
-
-      ...readModels.map(model => `
         extend ${interfaceKinds.indexOf(model.getKind()) > -1 ? 'interface' : 'type'} ${model.getName()} {
           ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}${field.getExtendArgs()}: ${field.getPayloadType()}`)}
         }
-
         type ${model.getName()}Connection {
           pageInfo: PageInfo!
           edges: [${model.getName()}Edge]
           count: Int!
         }
-
         type ${model.getName()}Edge {
           node: ${model.getName()}
           cursor: String!
@@ -105,13 +97,6 @@ module.exports = (schema) => {
           ${model.getFields().filter(field => field.hasGQLScope('r')).map(field => `${field.getName()}: ${field.getPayloadType()}`)}
         }
       `),
-
-      ...spliceModels.map(model => `
-        #input ${model.getName()}InputSplice {
-        #  with: ${model}InputWhere
-        #  put: ${model}InputUpdate
-        #}
-      `),
     ].concat([
       `type PageInfo {
         startCursor: String!

package/src/graphql/extension/framework.js

@@ -40,7 +40,6 @@ module.exports = (schema) => {
         fieldScope: AutoGraphMixed # Dictate how a FIELD may use me
         persist: Boolean # Persist this field (default true)
         default: AutoGraphMixed # Define a default value
-        embedApi: Boolean # Should we also create an embedded API from this (default false)
         connection: Boolean # Treat this field as a connection type (default false - rolling this out slowly)
 
         noRepeat: Boolean

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(),
       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/query/QueryBuilder.js

@@ -1,6 +1,6 @@
 const Query = require('./Query');
 const QueryResolver = require('./QueryResolver');
-const { unravelObject } = require('../service/app.service');
+const { toKeyObj, unravelObject } = require('../service/app.service');
 
 /*
 * QueryBuilder
@@ -14,7 +14,8 @@ module.exports = class QueryBuilder {
 
     // Chainable commands
     this.id = (id) => { this.query.id(id); return this; };
-    this.select = (select) => { this.query.select(select); return this; };
+    // this.select = (select) => { this.query.select(select); return this; };
+    this.select = (select) => { this.query.select(Object.entries(toKeyObj(select)).reduce((prev, [key, value]) => Object.assign(prev, { [key.replace(/edges.node./g, '')]: !!value }), {})); return this; };
     this.where = (where) => { this.query.where(where); return this; };
     this.match = (match) => { this.query.match(match); return this; };
     this.native = (native) => { this.query.native(native); return this; };

package/src/query/QueryResolver.js

@@ -33,14 +33,13 @@ module.exports = class QueryResolver {
     const { model, input, flags } = query.toObject();
     model.appendDefaultFields(query, input);
 
-    return createSystemEvent('Mutation', { method: 'create', query }, () => {
+    return createSystemEvent('Mutation', { method: 'create', query }, async () => {
       const $input = model.serialize(query, model.appendCreateFields(input));
       query.$input($input);
-      const promise = get(flags, 'novalidate') ? this.resolver.resolve(query) : model.validate(query, $input).then(() => this.resolver.resolve(query));
-      return promise.then((doc) => {
-        query.doc(doc);
-        return doc;
-      });
+      if (!get(flags, 'novalidate')) await model.validate(query, $input);
+      const doc = await this.resolver.resolve(query);
+      query.doc(doc);
+      return doc;
     });
   }
 
@@ -174,7 +173,7 @@ module.exports = class QueryResolver {
     return this.findMany(query.method('findMany'));
   }
 
-  async resolve() {
+  resolve() {
     const { model, method, flags } = this.query.toObject();
 
     return this[method](this.query).then((data) => {