WIP - add extractor, generate snippet_data

node_modules/gatsby/dist/query/queue.js

@@ -0,0 +1,107 @@
+"use strict";
+
+const Queue = require(`better-queue`);
+
+const FastMemoryStore = require(`../query/better-queue-custom-store`);
+
+const queryRunner = require(`../query/query-runner`);
+
+const websocketManager = require(`../utils/websocket-manager`);
+
+const createBaseOptions = () => {
+  return {
+    concurrent: 4,
+    store: FastMemoryStore()
+  };
+};
+
+const createBuildQueue = () => {
+  const handler = (queryJob, callback) => queryRunner(queryJob).then(result => callback(null, result)).catch(callback);
+
+  return new Queue(handler, createBaseOptions());
+};
+
+const createDevelopQueue = () => {
+  let queue;
+  const processing = new Set();
+  const waiting = new Map();
+  const queueOptions = Object.assign({}, createBaseOptions(), {
+    priority: (job, cb) => {
+      const activePaths = Array.from(websocketManager.activePaths.values());
+
+      if (job.id && activePaths.includes(job.id)) {
+        cb(null, 10);
+      } else {
+        cb(null, 1);
+      }
+    },
+    merge: (oldTask, newTask, cb) => {
+      cb(null, newTask);
+    },
+    // Filter out new query jobs if that query is already running.
+    // When the query finshes, it checks the waiting map and pushes
+    // another job to make sure all the user changes are captured.
+    filter: (job, cb) => {
+      if (processing.has(job.id)) {
+        waiting.set(job.id, job);
+        cb(`already running`);
+      } else {
+        cb(null, job);
+      }
+    }
+  });
+
+  const handler = (queryJob, callback) => {
+    queryRunner(queryJob).then(result => {
+      if (queryJob.isPage) {
+        websocketManager.emitPageData({
+          result,
+          id: queryJob.id
+        });
+      } else {
+        websocketManager.emitStaticQueryData({
+          result,
+          id: queryJob.id
+        });
+      }
+
+      processing.delete(queryJob.id);
+
+      if (waiting.has(queryJob.id)) {
+        queue.push(waiting.get(queryJob.id));
+        waiting.delete(queryJob.id);
+      }
+
+      callback(null, result);
+    }, error => callback(error));
+  };
+
+  queue = new Queue(handler, queueOptions);
+  return queue;
+};
+
+const pushJob = (queue, job) => new Promise((resolve, reject) => queue.push(job).on(`finish`, resolve).on(`failed`, reject));
+/**
+ * Returns a promise that pushes jobs onto queue and resolves onces
+ * they're all finished processing (or rejects if one or more jobs
+ * fail)
+ */
+
+
+const processBatch = async (queue, jobs) => {
+  let numJobs = jobs.length;
+
+  if (numJobs === 0) {
+    return Promise.resolve();
+  }
+
+  const runningJobs = jobs.map(job => pushJob(queue, job));
+  return await Promise.all(runningJobs);
+};
+
+module.exports = {
+  createBuildQueue,
+  createDevelopQueue,
+  processBatch
+};
+//# sourceMappingURL=queue.js.map