@coderich/autograph 0.9.12 → 0.10.0

package/src/data/ResultSet3.js

@@ -1,186 +0,0 @@
-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) {
-    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 validKeys = [];
-
-      const definition = {
-        get id() { return doc.id || doc[model.idKey()]; },
-        get $id() { return toGUID(model.getName(), this.id); },
-        get $$data() { return data; },
-        get $$model() { return model; },
-        get $$isResultSetItem() { return true; },
-        get $$save() { return input => resolver.match(model).id(this.id).save({ ...this, ...input }); },
-        get $$remove() { return () => resolver.match(model).id(this.id).remove(); },
-        get $$delete() { return () => resolver.match(model).id(this.id).delete(); },
-        get $$cursor() {
-          return () => {
-            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');
-          };
-        },
-        get toObject() {
-          return () => validKeys.reduce((prev, key) => Object.assign(prev, { [key]: this[key] }), {});
-        },
-      };
-
-      fields.forEach((field) => {
-        const key = field.getKey();
-        const name = field.getName();
-        const $name = `$${name}`;
-        const value = doc[key];
-        validKeys.push(name);
-
-        // Field attributes
-        Object.assign(definition, {
-          get [name]() {
-            let $value = field.deserialize(query, value);
-            $value = $value != null && field.isEmbedded() ? new ResultSet(query.model(field.getModelRef()), $value, false) : $value;
-            return $value;
-          },
-        });
-
-        // Hydrated field attributes
-        Object.assign(definition, {
-          get [$name]() {
-            return (args = {}) => {
-              // Ensure where clause
-              args.where = args.where || {};
-
-              return 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);
-                });
-              });
-            };
-          },
-        });
-
-        // Field count (let's assume it's a Connection Type - meaning dont try with anything else)
-        Object.assign(definition, {
-          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();
-            };
-          },
-        });
-      });
-
-      // Create and return ResultSetItem
-      const idk = new Proxy(definition, {
-        get(target, prop, rec) {
-          if (cache.has(prop)) return cache.get(prop);
-          const value = Reflect.get(target, prop, rec);
-          if (typeof value === 'function') return value.bind(target);
-          cache.set(prop, value);
-          return value;
-        },
-        set(target, prop, value) {
-          cache.set(prop, value);
-          return true;
-        },
-        ownKeys() {
-          return validKeys;
-        },
-        getOwnPropertyDescriptor(target, prop) {
-          if (validKeys.indexOf(prop) === -1) {
-            return {
-              writable: true,
-              enumerable: true,
-              configurable: true,
-            };
-          }
-
-          return {
-            writable: false,
-            enumerable: false,
-            configurable: false,
-          };
-        },
-      });
-
-      // console.log(idk);
-      // // console.log(idk.toObject());
-      return idk;
-    });
-
-    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,
-      },
-    });
-  }
-};

package/src/graphql/core/Field.js

@@ -1,20 +0,0 @@
-const { Kind, visit } = require('graphql');
-const Node = require('./Node');
-
-module.exports = class Field extends Node {
-  constructor(ast) {
-    super(ast);
-    // this.fields = {};
-    // if (ast) this.appendAST(ast);
-  }
-
-  appendAST(ast) {
-    // visit(ast, {
-    //   [Kind.FIELD_DEFINITION]: (node) => {
-    //     const name = node.name.value;
-    //     if (this.fields[name]) this.fields[name].appendAST(node);
-    //     else this.fields[name] = new Field(node);
-    //   },
-    // });
-  }
-};

package/src/graphql/core/GraphQL.js

@@ -1,21 +0,0 @@
-const { graphql, execute, validate } = require('graphql');
-const Schema = require('./Schema');
-
-module.exports = class GraphQL {
-  constructor(schema) {
-    this.schema = (schema instanceof Schema ? schema : new Schema(schema)).makeExecutableSchema();
-  }
-
-  exec(source, variableValues) {
-    const { schema } = this.schema;
-    return graphql({ schema, source, variableValues, contextValue: schema.context });
-  }
-
-  execute(source, variableValues) {
-
-  }
-
-  validate(source, variableValues) {
-
-  }
-};

package/src/graphql/core/Model.js

@@ -1,23 +0,0 @@
-const { Kind, visit } = require('graphql');
-const Field = require('./Field');
-const Node = require('./Node');
-
-module.exports = class Model extends Node {
-  constructor(ast) {
-    super(ast);
-    this.fields = {};
-    if (ast) this.appendAST(ast);
-  }
-
-  appendAST(ast) {
-    visit(ast, {
-      [Kind.FIELD_DEFINITION]: (node) => {
-        const name = node.name.value;
-        if (this.fields[name]) this.fields[name].appendAST(node);
-        else this.fields[name] = new Field(node);
-      },
-    });
-
-    return this;
-  }
-};

package/src/graphql/core/Node.js

@@ -1,34 +0,0 @@
-const { Kind } = require('graphql');
-
-module.exports = class Node {
-  constructor(ast) {
-    this.ast = ast;
-  }
-
-  getKind() {
-    return this.ast.kind;
-  }
-
-  getName() {
-    return this.ast.name.value;
-  }
-
-  getValue(ast = this.ast) {
-    const { value = {} } = ast;
-
-    switch (value.kind) {
-      case Kind.NULL: return null;
-      case Kind.LIST: return value.values.map(el => this.getValue({ value: el }));
-      case Kind.OBJECT: {
-        return value.fields.reduce((prev, field) => {
-          const node = new Node(field);
-          return Object.assign(prev, { [node.getName()]: node.getValue() });
-        }, {});
-      }
-      default: {
-        if (ast.values) return ast.values.map(v => v.name.value);
-        return value.value;
-      }
-    }
-  }
-};

package/src/graphql/core/Schema.js

@@ -1,63 +0,0 @@
-const FS = require('fs');
-const Glob = require('glob');
-const Merge = require('deepmerge');
-const { Kind, parse, visit, printSchema, buildSchema } = require('graphql');
-const { makeExecutableSchema } = require('graphql-tools');
-const Model = require('./Model');
-
-const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
-
-module.exports = class Schema {
-  constructor(schema) {
-    this.models = {};
-    this.schema = { typeDefs: [], context: {}, resolvers: {}, schemaDirectives: {} };
-    if (schema) this.appendSchema(schema);
-  }
-
-  appendSchema(schema) {
-    // Normalize schema
-    if (typeof schema === 'string') schema = { typeDefs: [schema] };
-    else if (schema.typeDefs && !Array.isArray(schema.typeDefs)) schema.typeDefs = [schema.typeDefs];
-
-    // Merge schema
-    this.schema = Merge(this.schema, schema);
-
-    // Visit AST to maintain model definitions
-    if (schema.typeDefs) {
-      visit(parse(schema.typeDefs.join('\n')), {
-        enter: (node) => {
-          if (modelKinds.indexOf(node.kind) > -1) {
-            const name = node.name.value;
-            if (this.models[name]) this.models[name].appendAST(node);
-            else this.models[name] = new Model(node);
-          }
-        },
-      });
-    }
-
-    return this;
-  }
-
-  appendSchemaFromFile(file) {
-    if (file.endsWith('.js')) this.appendSchema(require(file)); // eslint-disable-line global-require,import/no-dynamic-require
-    else this.appendSchema(FS.readFileSync(file, 'utf8'));
-    return this;
-  }
-
-  appendSchemaFromDirectory(dir, options) {
-    Glob.sync(`${dir}/**/*.{js,gql,graphql}`, options).forEach(file => this.appendSchemaFromFile(file));
-    return this;
-  }
-
-  makeExecutableSchema() {
-    return makeExecutableSchema(this.schema);
-  }
-
-  printSchema() {
-    return printSchema(buildSchema(this.toString()));
-  }
-
-  toString() {
-    return this.schema.typeDefs.join('\n');
-  }
-};