@coderich/autograph 0.9.15 → 0.10.1

package/src/data/Pipeline.js

@@ -0,0 +1,174 @@
+const { uniqWith } = require('lodash');
+const { map, hashObject } = require('../service/app.service');
+const Boom = require('../core/Boom');
+
+module.exports = class Pipeline {
+  constructor() {
+    throw new Error('Pipeline is a singleton; use the static {define|factory} methods');
+  }
+
+  static define(name, factory, options = {}) {
+    // A factory must be a function
+    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 wrapper = Object.defineProperty((args) => {
+      if (ignoreNull && args.value == null) return args.value;
+
+      if (ignoreNull && itemize) {
+        return map(args.value, (val, index) => {
+          const v = factory({ ...args, value: val, index });
+          return v === undefined ? val : v;
+        });
+      }
+
+      const val = factory(args);
+      return val === undefined ? args.value : val;
+    }, 'name', { value: name });
+
+    // Attach enumerable method to the Pipeline
+    Object.defineProperty(Pipeline, name, {
+      value: wrapper,
+      configurable,
+      enumerable: true,
+    });
+  }
+
+  static factory(name, thunk, options = {}) {
+    if (typeof thunk !== 'function') throw new Error(`Pipeline factory for "${name}" must be a thunk`);
+    if (typeof thunk() !== 'function') throw new Error(`Factory thunk() for "${name}" must return a function`);
+    Object.defineProperty(Pipeline, name, { value: Object.defineProperty(thunk, 'options', { value: options }) });
+  }
+
+  // static wrapper(name, factory, { ignoreNull, itemize }) {
+  //   return Object.defineProperty((args) => {
+  //     if (ignoreNull && args.value == null) return args.value;
+
+  //     if (ignoreNull && itemize) {
+  //       return map(args.value, (val, index) => {
+  //         const v = factory({ ...args, value: val, index });
+  //         return v === undefined ? val : v;
+  //       });
+  //     }
+
+  //     const val = factory(args);
+  //     return val === undefined ? args.value : val;
+  //   }, 'name', { value: name });
+  // }
+
+  static createPresets() {
+    // Built-In Javascript String Transformers
+    const jsStringTransformers = ['toLowerCase', 'toUpperCase', 'toString', 'trim', 'trimEnd', 'trimStart'];
+    jsStringTransformers.forEach(name => Pipeline.define(`${name}`, ({ value }) => String(value)[name]()));
+
+    // 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('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('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', ({ field, value }) => map(value, v => field.getIdModel().idValue(v.id || v)));
+
+    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();
+
+      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;
+          }
+        }
+      });
+    }, { itemize: false });
+
+    // Required fields
+    Pipeline.define('required', ({ model, field, value }) => {
+      if (value == null) throw Boom.badRequest(`${model}.${field} is required`);
+    }, { ignoreNull: false });
+
+    // A field cannot hold a reference to itself
+    Pipeline.define('selfless', ({ model, field, parentPath, value }) => {
+      if (`${value}` === `${parentPath('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 hint = { id: parentPath('id') };
+      const oldVal = docPath(path, hint);
+      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 }) {
+      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 }) {
+      if (args.indexOf(value) > -1) throw Boom.badRequest(`${model}.${field} denys ${args}; found '${value}'`);
+    });
+
+    // Min/Max range
+    Pipeline.factory('range', (min, max) => {
+      if (min == null) min = undefined;
+      if (max == null) max = undefined;
+
+      return function range({ model, field, value }) {
+        const num = +value; // Coerce to number if possible
+        const test = Number.isNaN(num) ? value.length : num;
+        if (test < min || test > max) throw Boom.badRequest(`${model}.${field} must satisfy range ${min}:${max}; found '${value}'`);
+      };
+    }, { itemize: false });
+  }
+};
+
+
+// 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 });

package/src/data/Type.js

@@ -1,6 +1,5 @@
 const Type = require('../graphql/ast/Type');
-const Rule = require('../core/Rule');
-const Transformer = require('../core/Transformer');
+const Pipeline = require('./Pipeline');
 
 module.exports = class extends Type {
   constructor(field) {
@@ -8,65 +7,25 @@ module.exports = class extends Type {
     this.field = field;
   }
 
-  getRules() {
-    const rules = [];
-    const scalarType = this.field.getScalarRef();
+  getStructures() {
+    const type = this.field.getType();
     const enumType = this.field.getEnumRef();
-
-    if (scalarType) {
-      Object.entries(scalarType.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-        if (!Array.isArray(value)) value = [value];
-        if (key === 'enforce') rules.push(...value.map(r => Rule.getInstances()[r]));
-      });
-    }
-
-    if (enumType) {
-      const values = enumType.getValue();
-      rules.push(Rule.allow(...values));
-    }
-
-    return rules;
-  }
-
-  getTransformers() {
-    const transformers = [];
-    const scalarType = this.field.getScalarRef();
-
-    if (scalarType) {
-      Object.entries(scalarType.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-        if (!Array.isArray(value)) value = [value];
-        if (key === 'transform') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-      });
-    }
-
-    return transformers;
-  }
-
-  getSerializers() {
-    const transformers = [];
     const scalarType = this.field.getScalarRef();
-
-    if (scalarType) {
-      Object.entries(scalarType.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-        if (!Array.isArray(value)) value = [value];
-        if (key === 'serialize') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-      });
-    }
-
-    return transformers;
-  }
-
-  getDeserializers() {
-    const transformers = [];
-    const scalarType = this.field.getScalarRef();
-
-    if (scalarType) {
-      Object.entries(scalarType.getDirectiveArgs('field', {})).forEach(([key, value]) => {
-        if (!Array.isArray(value)) value = [value];
-        if (key === 'deserialize') transformers.push(...value.map(t => Transformer.getInstances()[t]));
-      });
-    }
-
-    return transformers;
+    const structures = { instructs: [], restructs: [], destructs: [], constructs: [], $serializers: [], serializers: [], $deserializers: [], deserializers: [], transformers: [] };
+
+    if (enumType) structures.serializers.push(Pipeline.define(`$allow:${type}`, Pipeline.allow(...enumType.getValue()), { configurable: true }));
+    if (!scalarType) return structures;
+
+    return Object.entries(scalarType.getDirectiveArgs('field', {})).reduce((prev, [key, value]) => {
+      if (!Array.isArray(value)) value = [value];
+      if (key === 'instruct') prev.instructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'restruct') prev.restructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'destruct') prev.destructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'construct') prev.constructs.push(...value.map(t => Pipeline[t]));
+      if (key === 'serialize') prev.serializers.push(...value.map(t => Pipeline[t]));
+      if (key === 'deserialize') prev.deserializers.push(...value.map(t => Pipeline[t]));
+      if (key === 'transform') prev.transformers.push(...value.map(t => Pipeline[t]));
+      return prev;
+    }, structures);
   }
 };

package/src/driver/MongoDriver.js

@@ -1,19 +1,18 @@
 const Util = require('util');
-const { get, has } = require('lodash');
+const { get } = require('lodash');
 const { MongoClient, ObjectID } = require('mongodb');
-const { proxyDeep, toKeyObj, globToRegex, proxyPromise, isScalarDataType, promiseRetry } = require('../service/app.service');
+const { map, ensureArray, 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);
   }
 
@@ -26,7 +25,8 @@ module.exports = class MongoDriver {
   }
 
   query(collection, method, ...args) {
-    if (has(args[args.length - 1], 'debug')) console.log(collection, method, Util.inspect(args, { depth: null, showHidden: false, colors: true }));
+    if (get(args[args.length - 1], 'debug') === true) console.log(collection, method, Util.inspect(args, { depth: null, showHidden: false, colors: true }));
+    if (method === 'aggregate') args.splice(2);
     return this.raw(collection)[method](...args);
   }
 
@@ -37,19 +37,19 @@ 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 this.query(model, 'aggregate', MongoDriver.aggregateQuery(query), options, flags).then(cursor => cursor.stream());
   }
 
   count(query) {
@@ -64,7 +64,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 }) {
@@ -77,7 +77,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) {
@@ -140,10 +140,10 @@ module.exports = class MongoDriver {
     return proxyDeep(toKeyObj(where), {
       get(target, prop, rec) {
         const value = Reflect.get(target, prop, rec);
-        if (Array.isArray(value)) return { $in: value };
         if (typeof value === 'function') return value.bind(target);
-        if (typeof value === 'string') { return globToRegex(value, { nocase: true, regex: true }); }
-        return value;
+        const $value = map(value, v => (typeof v === 'string' ? globToRegex(v, { nocase: true, regex: true }) : v));
+        if (Array.isArray($value)) return { $in: $value };
+        return $value;
       },
     }).toObject();
   }
@@ -151,18 +151,40 @@ module.exports = class MongoDriver {
   static getAddFields(query) {
     const { shape, where } = query;
 
-    return shape.reduce((prev, { from, type }) => {
-      const value = where[from];
+    return shape.reduce((prev, { from, type, isArray }) => {
+      // Basic checks to see if worth converting for regex
+      let 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, { [from]: { $toString: `$${from}` } });
+
+      // Do regex conversion
+      if (isArray) value = value.$in || value; // Where clause does not always use $in
+      if (!ensureArray(value).some(el => el instanceof RegExp)) return prev;
+      const conversion = isArray ? { $map: { input: `$${from}`, as: 'el', in: { $toString: '$$el' } } } : { $toString: `$${from}` };
+      return Object.assign(prev, { [from]: conversion });
     }, {});
   }
 
+  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, after, before, first } = query;
     const $aggregate = [{ $match }];
 
     // Used for $regex matching
@@ -191,10 +213,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

@@ -1,4 +1,3 @@
-const { get } = require('lodash');
 const Node = require('./Node');
 const Type = require('./Type');
 const { uvl } = require('../../service/app.service');
@@ -44,27 +43,6 @@ module.exports = class Field extends Node {
     return this.getDirectiveArg('field', 'default');
   }
 
-  resolveBoundValue(query, initialValue) {
-    // If no bound value, return default value
-    const defaultValue = uvl(initialValue, this.getDefaultValue());
-    if (!this.hasBoundValue()) return defaultValue;
-
-    // Grab @value definition, if passive then check for initialValue
-    const { scope, path, passive = false } = this.getDirectiveArgs('value');
-    if (passive && initialValue !== undefined) return initialValue;
-
-    // Resolve @value
-    switch (scope) {
-      case 'context': {
-        const { resolver } = query.toObject();
-        const context = resolver.getContext();
-        const value = get(context, path);
-        return uvl((typeof value === 'function') ? value() : value, defaultValue);
-      }
-      default: return this[path];
-    }
-  }
-
   // Model Methods
   getSchema() {
     return this.model.getSchema();
@@ -75,7 +53,8 @@ module.exports = class Field extends Node {
   }
 
   getModelRef() {
-    return this.schema.getModel(this.getType());
+    const refType = this.getDirectiveArg('field', 'id', this.getType());
+    return this.schema.getModel(refType);
   }
 
   getFieldRef() {
@@ -90,6 +69,10 @@ module.exports = class Field extends Node {
     return model ? model.getField(this.getVirtualRef()) : null;
   }
 
+  getIdModel() {
+    return this.getModelRef() || this.getModel();
+  }
+
   resolveField() {
     const field = this.getVirtualField() || this;
     return field === this ? this : field.resolveField();
@@ -101,7 +84,7 @@ module.exports = class Field extends Node {
   }
 
   isDefaulted() {
-    return Boolean(this.hasBoundValue() || this.getDefaultValue() != null);
+    return Boolean(this.getDefaultValue() != null);
   }
 
   isRequired() {
@@ -117,6 +100,16 @@ module.exports = class Field extends Node {
     return Boolean(modelRef && !this.isEmbedded());
   }
 
+  isIdField() {
+    return this.isPrimaryKeyId() || this.isFKReference();
+  }
+
+  isPrimaryKeyId() {
+    const key = this.getKey();
+    const idKey = this.getModel().idKey();
+    return key === idKey;
+  }
+
   getJoinInfo() {
     const modelRef = this.getModelRef();
     if (!modelRef || this.isEmbedded()) return null;
@@ -145,12 +138,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;
   }
 
@@ -180,4 +172,30 @@ module.exports = class Field extends Node {
     if (this.isFKReference()) return this.isArray() ? '[ID]' : 'ID';
     return this.getGQLType();
   }
+
+  initialize() {
+    this.props = {
+      name: this.getName(),
+      type: this.getType(),
+      datatype: this.getDataType(),
+      defaultValue: this.getDefaultValue(),
+      isArray: this.isArray(),
+      isScalar: this.isScalar(),
+      isVirtual: this.isVirtual(),
+      isRequired: this.isRequired(),
+      isEmbedded: this.isEmbedded(),
+      isIdField: this.isIdField(),
+      isPrimaryKeyId: this.isPrimaryKeyId(),
+      isPersistable: this.isPersistable(),
+      modelRef: this.getModelRef(),
+      virtualRef: this.getVirtualRef(),
+      virtualField: this.getVirtualField(),
+    };
+
+    return this;
+  }
+
+  toObject() {
+    return this.props;
+  }
 };

package/src/graphql/ast/Model.js

@@ -92,10 +92,6 @@ module.exports = class Model extends Node {
     return this.getFields().filter(field => field.isDefaulted());
   }
 
-  getBoundValueFields() {
-    return this.getFields().filter(field => field.hasBoundValue());
-  }
-
   getDataRefFields() {
     return this.getFields().filter(field => Boolean(field.getDataRef()));
   }
@@ -104,10 +100,6 @@ module.exports = class Model extends Node {
     return this.getFields().filter(field => Boolean(field.getModelRef()));
   }
 
-  // getDataRefFields() {
-  //   return this.fields.filter(field => Boolean(field.getDataRef() && !field.isEmbedded()));
-  // }
-
   getEmbeddedFields() {
     return this.getFields().filter(field => field.isEmbedded());
   }
@@ -128,14 +120,6 @@ module.exports = class Model extends Node {
     return this.getFields().filter(field => field.isPersistable());
   }
 
-  getSerializeFields() {
-    return this.getFields().filter(field => field.getSerializers().length);
-  }
-
-  getDeserializeFields() {
-    return this.getFields().filter(field => field.getDeserializers().length);
-  }
-
   // Misc
   getIndexes() {
     return this.getDirectives('index').map((d) => {
@@ -153,4 +137,9 @@ module.exports = class Model extends Node {
       }, {});
     });
   }
+
+  initialize() {
+    this.fields.forEach(field => field.initialize());
+    return this;
+  }
 };

package/src/graphql/ast/Node.js

@@ -2,7 +2,6 @@ const { get } = require('lodash');
 const { Kind } = require('graphql');
 const { nvl, uvl } = require('../../service/app.service');
 const { mergeAST } = require('../../service/graphql.service');
-// const Memoizer = require('../../data/Memoizer');
 
 const operations = ['Query', 'Mutation', 'Subscription'];
 const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
@@ -18,7 +17,6 @@ module.exports = class Node {
     this.toString = () => this.getName();
     this.nodeType = nodeType;
     this.name = get(this.ast, 'name.value');
-    // return new Memoizer(this, Object.getOwnPropertyNames(Node.prototype).filter(m => ['getContext'].indexOf(m) === -1));
   }
 
   // Basic AST Methods
@@ -130,14 +128,6 @@ module.exports = class Node {
     return this.getDirectiveArg('model', 'meta');
   }
 
-  getSerialize() {
-    return this.getDirectiveArg('field', 'serialize', this.getDirectiveArg('model', 'serialize'));
-  }
-
-  getDeserialize() {
-    return this.getDirectiveArg('field', 'deserialize', this.getDirectiveArg('model', 'deserialize'));
-  }
-
   // Booleans
   isModel() {
     return Boolean(modelKinds.some(k => this.getKind() === k) && operations.every(o => this.getName() !== o));
@@ -166,13 +156,6 @@ module.exports = class Node {
     return Boolean(this.getDirectiveArg('link', 'by'));
   }
 
-  /**
-   * Does the model/field have a bound @value directive
-   */
-  hasBoundValue() {
-    return Boolean(this.getDirective('value'));
-  }
-
   /**
    * Is a model annotated with @model
    */
@@ -208,21 +191,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
-   */
-  isImmutable() {
-    const enforce = this.getDirectiveArg('field', 'enforce', '');
-    return Boolean(JSON.stringify(enforce).indexOf('immutable') > -1);
-  }
-
   /**
    * Define it's behavior at the Data Access Layer
    *