@coderich/autograph 0.10.0 → 0.10.1

package/src/data/stream/ResultSetItemProxy.js

@@ -1,161 +0,0 @@
-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/graphql/ast/SchemaDecorator.js

@@ -1,141 +0,0 @@
-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/directive/authz.directive.js

@@ -1,84 +0,0 @@
-const PicoMatch = require('picomatch');
-const { SchemaDirectiveVisitor } = require('graphql-tools');
-
-const getCrudOperation = (mutationName) => {
-  const crudMap = {
-    create: 'C',
-    add: 'C',
-    findOrCreate: 'C',
-    get: 'R',
-    find: 'R',
-    count: 'R',
-    update: 'U',
-    replace: 'U',
-    edit: 'U',
-    set: 'U',
-    move: 'U',
-    delete: 'D',
-    remove: 'D',
-    subscribe: 'S',
-  };
-
-  return Object.entries(crudMap).reduce((prev, [key, value]) => {
-    if (prev) return prev;
-    if (mutationName.indexOf(key) === 0) return value;
-    return null;
-  }, null);
-};
-
-const authorize = (context, model, fields, crud) => {
-  const { schema, permissions = [] } = context.autograph;
-  const namespace = schema.getModel(model).getNamespace();
-  const parts = namespace.split('/').reverse();
-
-  // const flags = fields.reduce((obj, field) => {
-  //   const directTargets = parts.reduce((prev, part, i) => prev.concat(`${part}/${prev[i]}`), [`${model}/${field}/${crud}`]);
-  //   let result = directTargets.some(target => PicoMatch.isMatch(target, permissions, { nocase: true }));
-
-  //   if (!result) {
-  //     const authorTargets = parts.reduce((prev, part, i) => prev.concat(`${part}/${prev[i]}`), [`${model}/${field}/${crud}`]);
-  //     result = authorTargets.some(target => PicoMatch.isMatch(target, permissions, { nocase: true })) ? 1 : false;
-  //   }
-
-  //   return Object.assign(obj, { [field]: result });
-  // }, {});
-
-  // console.log(flags);
-  // console.log('------');
-
-  const authorized = fields.every((field) => {
-    const targets = parts.reduce((prev, part, i) => prev.concat(`${part}/${prev[i]}`), [`${model}/${field}/${crud}`]);
-    return targets.some(target => PicoMatch.isMatch(target, permissions, { nocase: true }));
-  });
-
-  if (!authorized) throw new Error('Not Authorized');
-};
-
-module.exports = class extends SchemaDirectiveVisitor {
-  visitObject(type) { // eslint-disable-line
-    const fields = type.getFields();
-
-    Object.keys(fields).forEach((fieldName) => {
-      const field = fields[fieldName];
-      const { resolve = root => root[fieldName] } = field;
-      const { model = `${type}` } = this.args;
-
-      field.resolve = async function resolver(root, args, context, info) {
-        authorize(context, model, [fieldName], 'R');
-        return resolve.call(this, root, args, context, info);
-      };
-    });
-  }
-
-  visitFieldDefinition(field, details) { // eslint-disable-line
-    const { name, type, resolve = root => root[name] } = field;
-    const dataType = type.toString().replace(/[[\]!]/g, '');
-    const crudOperation = getCrudOperation(name);
-    const { model = dataType } = this.args;
-
-    field.resolve = async function resolver(root, args, context, info) {
-      authorize(context, model, Object.keys(args.input || { id: 1 }), crudOperation);
-      return resolve.call(this, root, args, context, info);
-    };
-  }
-};