@coderich/autograph 0.9.10 → 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,25 +3,29 @@ 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);
   }
 
+  disconnect() {
+    return this.connection.then(client => client.close());
+  }
+
   raw(collection) {
     return proxyPromise(this.connection.then(client => client.db().collection(collection)));
   }
 
   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);
   }
 
@@ -32,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();
     });
   }
 
@@ -59,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 }) {
@@ -72,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) {
@@ -144,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
@@ -186,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/Model.js

@@ -12,6 +12,10 @@ module.exports = class Model extends Node {
     this.key = uvl(this.getDirectiveArg('model', 'key'), this.getName());
   }
 
+  idKey() {
+    return this.getDirectiveArg('model', 'id', '_id');
+  }
+
   getSchema() {
     return this.schema;
   }

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/Schema.js

@@ -1,14 +1,13 @@
 const FS = require('fs');
 const Glob = require('glob');
-const Path = require('path');
 const Merge = require('deepmerge');
 const { nvl, uvl } = require('../../service/app.service');
 const { validateSchema, makeExecutableSchema, mergeASTSchema, mergeASTArray } = require('../../service/graphql.service');
 const Node = require('./Node');
 const Model = require('./Model');
 
-const loadFile = file => FS.readFileSync(Path.resolve(file), 'utf8');
-const reqFile = file => require(Path.resolve(file)); // eslint-disable-line global-require,import/no-dynamic-require
+const loadFile = file => FS.readFileSync(file, 'utf8');
+const reqFile = file => require(file); // eslint-disable-line global-require,import/no-dynamic-require
 
 module.exports = class Schema extends Node {
   constructor(schema) {

package/src/graphql/ast/SchemaDecorator.js

@@ -0,0 +1,141 @@
+const FS = require('fs');
+const Glob = require('glob');
+const Merge = require('deepmerge');
+const { Kind, print, parse, visit } = require('graphql');
+const { mergeASTArray, makeExecutableSchema } = require('../../service/graphql.service');
+const { deleteKeys } = require('../../service/app.service');
+const frameworkExt = require('../extension/framework');
+const typeExt = require('../extension/type');
+const apiExt = require('../extension/api');
+const TypeDefApi = require('./TypeDefApi');
+const Node = require('./Node');
+
+/**
+ * SchemaDecorator
+ *
+ * This class helps facilitate dynamic modification of a schema before it is passed to makeExecutableSchema(). It allows
+ * for "intelligent" merging of schemas and exposes an API wrapper for typeDefs.
+ *
+ * A "schema" is defined by the following object attributes:
+ *
+ *    context <Object> - Globally shared object by all resolvers
+ *    typeDefs <String|Object> - GQL String or AST Object (also supports a mixed array of both)
+ *    resolvers <Object> - GraphQL resolvers
+ *    schemaDirectives <Object> - GraphQL directives
+ *
+ */
+module.exports = class SchemaDecorator extends TypeDefApi {
+  constructor(schema) {
+    super();
+    this.schema = { context: {}, typeDefs: [], resolvers: {}, schemaDirectives: {} };
+    if (schema) this.mergeSchema(schema);
+  }
+
+  /**
+   * 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 };
+    if (typeof schema === 'string') normalizedSchema.typeDefs = [schema];
+    else if (schema.typeDefs && !Array.isArray(schema.typeDefs)) normalizedSchema.typeDefs = [schema.typeDefs];
+
+    // For typeDefs we want the AST so that it can be intelligently merged. Here we convert
+    // GQL strings to AST objects and also filter out anything that does not parse to AST.
+    if (normalizedSchema.typeDefs && normalizedSchema.typeDefs.length) {
+      normalizedSchema.typeDefs = deleteKeys(normalizedSchema.typeDefs.map((td) => {
+        try {
+          const ast = typeof td === 'object' ? td : parse(td);
+          return ast.definitions;
+        } catch (e) {
+          return null;
+        }
+      }), ['loc']).filter(Boolean).flat();
+    }
+
+    // Now we're ready to merge the schema
+    const [left, right] = options.passive ? [normalizedSchema, this.schema] : [this.schema, normalizedSchema];
+    if (normalizedSchema.typeDefs && normalizedSchema.typeDefs.length) this.schema.typeDefs = mergeASTArray(left.typeDefs.concat(right.typeDefs));
+    if (normalizedSchema.context) this.schema.context = Merge(left.context, right.context);
+    if (normalizedSchema.resolvers) this.schema.resolvers = Merge(left.resolvers, right.resolvers);
+    if (normalizedSchema.schemaDirectives) this.schema.schemaDirectives = Merge(left.schemaDirectives, right.schemaDirectives);
+
+    // Chaining
+    return this;
+  }
+
+  /**
+   * Asynchronously load files from a given glob pattern and merge each schema
+   */
+  mergeSchemaFromFiles(globPattern, options) {
+    return new Promise((resolve, reject) => {
+      Glob(globPattern, options, (err, files) => {
+        if (err) return reject(err);
+
+        return Promise.all(files.map((file) => {
+          return new Promise((res) => {
+            if (file.endsWith('.js')) res(require(file)); // eslint-disable-line global-require,import/no-dynamic-require
+            else res(FS.readFileSync(file, 'utf8'));
+          }).then(schema => this.mergeSchema(schema, options));
+        })).then(() => resolve(this)).catch(e => reject(e));
+      });
+    });
+  }
+
+  /**
+   * Traverses the current schema's typeDefs in order to keep the TypeDefApi in sync. This operation
+   * only needs to be called when typeDefs have been changed and you want to keep the data model in sync.
+   */
+  initialize() {
+    return super.initialize(this.schema.typeDefs);
+  }
+
+  /**
+   * Decorate the schema with Autograph's default api/definitions
+   */
+  decorate() {
+    this.initialize();
+    this.mergeSchema(frameworkExt(this), { passive: true });
+    this.mergeSchema(typeExt(this), { passive: true });
+    this.initialize();
+    this.mergeSchema(apiExt(this), { passive: true });
+    this.finalize();
+    return this;
+  }
+
+  /**
+   * This should be called once before passing to makeExecutableSchema()
+   */
+  finalize() {
+    const definitions = visit(this.schema.typeDefs, {
+      [Kind.FIELD_DEFINITION]: (node) => {
+        const scope = new Node(node, 'field').getDirectiveArg('field', 'gqlScope', 'crud');
+        if (scope === null || scope.indexOf('r') === -1) return null; // Delete node
+        return false; // Stop traversing this node
+      },
+    });
+
+    this.schema.typeDefs = { kind: Kind.DOCUMENT, definitions };
+    return this;
+  }
+
+  makeExecutableSchema() {
+    return makeExecutableSchema(this.schema);
+  }
+
+  getContext() {
+    return this.schema.context;
+  }
+
+  toObject() {
+    return this.schema;
+  }
+
+  toString() {
+    return print(this.typeDefs);
+  }
+};

package/src/graphql/ast/TypeDefApi.js

@@ -0,0 +1,93 @@
+const { Kind, visit } = require('graphql');
+const Model = require('./Model');
+const Node = require('./Node');
+
+const operations = ['Query', 'Mutation', 'Subscription'];
+const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
+const inputKinds = [Kind.INPUT_OBJECT_TYPE_DEFINITION, Kind.INPUT_OBJECT_TYPE_EXTENSION];
+const scalarKinds = [Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION];
+const enumKinds = [Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION];
+
+module.exports = class TypeDefApi {
+  constructor() {
+    this.models = [];
+    this.scalars = [];
+    this.inputs = [];
+    this.enums = [];
+  }
+
+  initialize(typeDefs) {
+    this.models.length = 0;
+    this.scalars.length = 0;
+    this.inputs.length = 0;
+    this.enums.length = 0;
+
+    visit(typeDefs, {
+      enter: (node) => {
+        if (modelKinds.indexOf(node.kind) > -1 && operations.indexOf(node.name.value) === -1) {
+          this.models.push(new Model(this, node));
+        } else if (scalarKinds.indexOf(node.kind) > -1) {
+          this.scalars.push(new Node(node));
+        } else if (inputKinds.indexOf(node.kind) > -1) {
+          this.inputs.push(new Node(node));
+        } else if (enumKinds.indexOf(node.kind) > -1) {
+          this.enums.push(new Node(node));
+        }
+
+        return false; // Stop traversing this node
+      },
+    });
+
+    return this;
+  }
+
+  // Models
+  getModel(name) {
+    return this.models.find(m => m.getName() === name);
+  }
+
+  getModels() {
+    return this.models;
+  }
+
+  getModelNames() {
+    return this.getModels().map(model => model.getName());
+  }
+
+  getModelMap() {
+    return this.getModels().reduce((prev, model) => Object.assign(prev, { [model.getName()]: model }), {});
+  }
+
+  getMarkedModels() {
+    return Object.values(this.models).filter(model => model.isMarkedModel());
+  }
+
+  getEntityModels() {
+    return Object.values(this.models).filter(model => model.isEntity());
+  }
+
+  // Definitions
+  getInput(name) {
+    return this.getInputs().find(input => input.getName() === name);
+  }
+
+  getInputs() {
+    return this.inputs;
+  }
+
+  getScalar(name) {
+    return this.getScalars().find(scalar => scalar.getName() === name);
+  }
+
+  getScalars() {
+    return this.scalars;
+  }
+
+  getEnum(name) {
+    return this.getEnums().find(el => el.getName() === name);
+  }
+
+  getEnums() {
+    return this.enums;
+  }
+};

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