@coderich/autograph 0.11.1 → 0.13.0

package/src/query/QueryResolver.js

@@ -1,232 +1,126 @@
-const { get, set, isEmpty } = require('lodash');
-const Boom = require('../core/Boom');
-const QueryService = require('./QueryService');
-const DataService = require('../data/DataService');
-const { createSystemEvent } = require('../service/event.service');
-const { mergeDeep, hashObject, getGQLReturnType } = require('../service/app.service');
-
-module.exports = class QueryResolver {
-  constructor(query) {
-    this.query = query;
-    this.resolver = query.toObject().resolver;
-    this.context = this.resolver.getContext();
-  }
-
-  autoResolve(query) {
-    const { args } = query.toObject();
-    const [,,, info] = args;
-
-    switch (getGQLReturnType(`${info.returnType}`)) {
-      case 'array': {
-        return new QueryResolver(this.query.clone().method('findMany')).resolve();
+const get = require('lodash.get');
+const Util = require('@coderich/util');
+const QueryBuilder = require('./QueryBuilder');
+const { mergeDeep } = require('../service/AppService');
+
+module.exports = class QueryResolver extends QueryBuilder {
+  #model;
+  #schema;
+  #config;
+  #context;
+  #resolver;
+
+  constructor(config) {
+    const { schema, context, resolver, query } = config;
+    super(config);
+    this.#config = config;
+    this.#schema = schema;
+    this.#context = context;
+    this.#resolver = resolver;
+    this.#model = schema.models[query.model];
+  }
+
+  terminate() {
+    const query = super.terminate();
+    const { op, input } = query.toObject();
+
+    // Resolve
+    switch (op) {
+      case 'findOne': case 'findMany': case 'count': case 'createOne': {
+        return this.#resolver.resolve(query);
       }
-      case 'number': {
-        return new QueryResolver(this.query.clone().method('count')).resolve();
+      case 'createMany': {
+        return this.#resolver.transaction(false).run(Promise.all(input.map(el => this.#resolver.match(this.#model.name).save(el))));
       }
-      case 'connection': {
-        return Promise.resolve({
-          count: () => new QueryResolver(this.query.clone().method('count')).resolve(),
-          edges: () => new QueryResolver(this.query.clone().method('findMany')).resolve(),
-          pageInfo: () => new QueryResolver(this.query.clone().method('findMany')).resolve(),
+      case 'updateOne': {
+        return this.#get(query).then((doc) => {
+          const merged = mergeDeep({}, Util.unflatten(doc), Util.unflatten(input));
+          return this.#resolver.resolve(query.clone({ doc, input: merged }));
         });
       }
-      case 'scalar': default: {
-        return new QueryResolver(this.query.clone().method('findOne')).resolve();
+      case 'updateMany': {
+        return this.#find(query).then((docs) => {
+          return this.#resolver.transaction(false).run(Promise.all(docs.map(doc => this.#resolver.match(this.#model.name).id(doc.id).save(input))));
+        });
       }
-    }
-  }
-
-  findOne(query) {
-    return createSystemEvent('Query', { query }, async () => {
-      return this.resolver.resolve(query);
-    });
-  }
-
-  findMany(query) {
-    return createSystemEvent('Query', { query }, async () => {
-      return this.resolver.resolve(query);
-    });
-  }
-
-  count(query) {
-    return createSystemEvent('Query', { query }, async () => {
-      return this.resolver.resolve(query);
-    });
-  }
-
-  createOne(query) {
-    const { model, input } = query.toObject();
-    const inputShape = model.getShape('create', 'input');
-    const docShape = model.getShape('create', 'doc');
-    const doc = model.shapeObject(inputShape, {}, query); // We use input shape here
-    const merged = mergeDeep(doc, input);
-
-    return createSystemEvent('Mutation', { query: query.doc(doc).merged(merged) }, async () => {
-      const payload = model.shapeObject(inputShape, merged, query);
-      await model.validateObject(inputShape, payload, query.payload(payload));
-      return this.resolver.resolve(query.$input(model.shapeObject(docShape, payload, query)));
-    });
-  }
-
-  createMany(query) {
-    const { model, input, transaction } = query.toObject();
-    const txn = this.resolver.transaction(transaction);
-    input.forEach(arg => txn.match(model).save(arg));
-    return txn.run();
-  }
-
-  async updateOne(query) {
-    const { model, match, input, flags } = query.toObject();
-    const inputShape = model.getShape('update', 'input');
-    const docShape = model.getShape('update', 'doc');
-
-    return this.resolver.match(model).match(match).one({ required: true }).then((doc) => {
-      const merged = mergeDeep(doc, input);
-      const docHash = hashObject(doc);
-      const skipUnchanged = get(flags, 'skipUnchanged');
-
-      // Prevent udpates when no data has changed
-      if (skipUnchanged && docHash === hashObject(merged)) return doc;
-
-      return createSystemEvent('Mutation', { query: query.doc(doc).merged(merged) }, async () => {
-        // Prevent udpates when no data has changed (because merged can be mutated)
-        if (skipUnchanged && docHash === hashObject(merged)) return doc;
-
-        // Process
-        const payload = model.shapeObject(inputShape, merged, query);
-        await model.validateObject(inputShape, payload, query.payload(payload));
-        const $doc = model.shapeObject(docShape, payload, query, undefined, undefined, true);
-        return this.resolver.resolve(query.$doc($doc));
-      });
-    });
-  }
-
-  updateMany(query) {
-    const { model, input, match, transaction, flags } = query.toObject();
-
-    return this.resolver.match(model).match(match).many(flags).then((docs) => {
-      const txn = this.resolver.transaction(transaction);
-      docs.forEach(doc => txn.match(model).id(doc.id).save(input, flags));
-      return txn.run();
-    });
-  }
-
-  deleteOne(query) {
-    const { model, id } = query.toObject();
-
-    return this.resolver.match(model).id(id).one({ required: true }).then(async (doc) => {
-      return createSystemEvent('Mutation', { query: query.doc(doc) }, () => {
-        return QueryService.resolveReferentialIntegrity(query).then(() => {
-          return this.resolver.resolve(query).then(() => doc);
+      case 'pushOne': {
+        return this.#get(query).then(async (doc) => {
+          const [key] = Object.keys(input);
+          const values = get(await query.pipeline('input', input), key);
+          const $input = { [key]: (get(doc, key) || []).concat(...values) };
+          return this.#resolver.match(this.#model.name).id(doc.id).save($input);
         });
-      });
-    });
-  }
-
-  deleteMany(query) {
-    const { model, match, transaction, flags } = query.toObject();
-
-    return this.resolver.match(model).where(match).flags(flags).many().then((docs) => {
-      const txn = this.resolver.transaction(transaction);
-      docs.forEach(doc => txn.match(model).id(doc.id).delete());
-      return txn.run();
-    });
-  }
-
-  pushOne(query) {
-    const { args } = query.toObject();
-    const [key, ...values] = args;
-    return this.splice(query.args([key, null, values]));
-  }
-
-  pushMany(query) {
-    const { args } = query.toObject();
-    const { model, match, transaction, flags } = query.toObject();
-    const [key, ...values] = args;
-
-    return this.resolver.match(model).match(match).flags(flags).many().then((docs) => {
-      const txn = this.resolver.transaction(transaction);
-      docs.forEach(doc => txn.match(model).id(doc.id).push(key, ...values));
-      return txn.run();
-    });
-  }
-
-  pullOne(query) {
-    const { args } = query.toObject();
-    const [key, ...values] = args;
-    return this.splice(query.args([key, values]));
-  }
-
-  pullMany(query) {
-    const { model, match, transaction, args, flags } = query.toObject();
-    const [key, ...values] = args;
-
-    return this.resolver.match(model).match(match).flags(flags).many().then((docs) => {
-      const txn = this.resolver.transaction(transaction);
-      docs.forEach(doc => txn.match(model).id(doc.id).pull(key, ...values));
-      return txn.run();
-    });
-  }
-
-  spliceOne(query) {
-    const { args } = query.toObject();
-    const [key, ...values] = args;
-    return this.splice(query.args([key, ...values]));
-  }
-
-  spliceMany(query) {
-    const { model, match, transaction, args, flags } = query.toObject();
-    const [key, ...values] = args;
-
-    return this.resolver.match(model).match(match).flags(flags).many().then((docs) => {
-      const txn = this.resolver.transaction(transaction);
-      docs.forEach(doc => txn.match(model).id(doc.id).splice(key, ...values));
-      return txn.run();
-    });
+      }
+      case 'pushMany': {
+        const [[key, values]] = Object.entries(input[0]);
+        return this.#find(query).then((docs) => {
+          return this.#resolver.transaction(false).run(Promise.all(docs.map(doc => this.#resolver.match(this.#model.name).id(doc.id).push(key, values))));
+        });
+      }
+      case 'pullOne': {
+        return this.#get(query).then(async (doc) => {
+          const [key] = Object.keys(input);
+          const values = get(await query.pipeline('input', input), key);
+          const $input = { [key]: (get(doc, key) || []).filter(el => values.every(v => `${v}` !== `${el}`)) };
+          return this.#resolver.match(this.#model.name).id(doc.id).save($input);
+        });
+      }
+      case 'pullMany': {
+        const [[key, values]] = Object.entries(input[0]);
+        return this.#find(query).then((docs) => {
+          return this.#resolver.transaction(false).run(Promise.all(docs.map(doc => this.#resolver.match(this.#model.name).id(doc.id).pull(key, values))));
+        });
+      }
+      case 'spliceOne': {
+        return this.#get(query).then(async (doc) => {
+          const [key] = Object.keys(input);
+          const [find, replace] = get(await query.pipeline('input', input), key);
+          const $input = { [key]: (get(doc, key) || []).map(el => (`${el}` === `${find}` ? replace : el)) };
+          return this.#resolver.match(this.#model.name).id(doc.id).save($input);
+        });
+      }
+      case 'deleteOne': {
+        return this.#get(query).then((doc) => {
+          return this.#resolveReferentialIntegrity(query).then(() => {
+            return this.#resolver.resolve(query).then(() => doc);
+          });
+        });
+      }
+      case 'deleteMany': {
+        return this.#find(query).then((docs) => {
+          return this.#resolver.transaction(false).run(Promise.all(docs.map(doc => this.#resolver.match(this.#model.name).id(doc.id).delete())));
+        });
+      }
+      default: {
+        throw new Error(`Unknown operation "${op}"`);
+      }
+    }
   }
 
-  splice(query) {
-    const { model, match, args } = query.toObject();
-    const docShape = model.getShape('update', 'doc');
-    const inputShape = model.getShape('update', 'input');
-    const spliceShape = model.getShape('update', 'splice');
-    const [key, from, to] = args;
-
-    // Can only splice arrays
-    const field = model.getField(key);
-    const isArray = field.isArray();
-    const path = `${model}.${field}`;
-    if (!isArray) throw Boom.badRequest(`Cannot splice field '${path}'`, { path });
-
-    return this.resolver.match(model).match(match).one({ required: true }).then(async (doc) => {
-      const array = get(doc, key) || [];
-      const $to = model.shapeObject(spliceShape, { [key]: to }, query)[key] || to;
-      const $from = model.shapeObject(spliceShape, { [key]: from }, query)[key] || from;
-      set(doc, key, DataService.spliceEmbeddedArray(array, $from, $to));
-
-      return createSystemEvent('Mutation', { query: query.method('updateOne').doc(doc).merged(doc) }, async () => {
-        const payload = model.shapeObject(inputShape, doc, query);
-        await model.validateObject(inputShape, payload, query.payload(payload));
-        return this.resolver.resolve(query.$doc(model.shapeObject(docShape, payload, query)));
-      });
-    });
+  #get(query) {
+    return this.#resolver.match(this.#model.name).id(query.toObject().id).one({ required: true });
   }
 
-  first(query) {
-    return this.findMany(query.method('findMany'));
+  #find(query) {
+    return this.#resolver.resolve(query.clone({ op: 'findMany', key: `find${this.#model.name}`, crud: 'read', isMutation: false }));
   }
 
-  last(query) {
-    return this.findMany(query.method('findMany'));
-  }
+  #resolveReferentialIntegrity(query) {
+    const { id } = query.toObject();
+    const txn = this.#resolver.transaction(false);
 
-  async resolve() {
-    const { model, method, flags } = this.query.toObject();
+    // if (this.#model.name === 'Person') console.log(this.#model.referentialIntegrity);
+    return txn.run(Util.promiseChain(this.#model.referentialIntegrity.map(({ model, field, fieldRef, isArray, op }) => () => {
+      const fieldStr = fieldRef ? `${field}.${fieldRef}` : `${field.name}`;
+      const $where = { [fieldStr]: id };
 
-    return this[method](this.query).then((data) => {
-      if (flags.required && isEmpty(data)) throw Boom.notFound(`${model} Not Found`);
-      if (data == null) return null; // Explicitly return null here
-      return data;
-    });
+      switch (op) {
+        case 'cascade': return isArray ? txn.match(model).where($where).pull(fieldStr, id) : txn.match(model).where($where).remove();
+        case 'nullify': return txn.match(model).where($where).save({ [fieldStr]: null });
+        case 'restrict': return txn.match(model).where($where).count().then(count => (count ? Promise.reject(new Error('Restricted')) : count));
+        case 'defer': return Promise.resolve(); // Used for embedded models (could be improved)
+        default: throw new Error(`Unknown onDelete operator: '${op}'`);
+      }
+    })));
   }
 };

package/src/query/QueryResolverTransaction.js

@@ -0,0 +1,16 @@
+const QueryResolver = require('./QueryResolver');
+
+module.exports = class QueryResolverTransaction extends QueryResolver {
+  #config;
+
+  constructor(config) {
+    super(config);
+    this.#config = config;
+  }
+
+  terminate() {
+    return this.#config.transaction.then((transaction) => {
+      return super.terminate(super.options(transaction));
+    });
+  }
+};