@sanity/export 2.29.5-purple-unicorn-remix.873 → 2.30.2-shopify.0

package/lib/export.js

@@ -1,63 +1,65 @@
 "use strict";
 
-const os = require('os');
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 
-const path = require('path');
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
-const zlib = require('zlib');
+var os = require('os');
 
-const fs = require('fs');
+var path = require('path');
 
-const miss = require('mississippi');
+var zlib = require('zlib');
 
-const split = require('split2');
+var fse = require('fs-extra');
 
-const archiver = require('archiver');
+var miss = require('mississippi');
 
-const rimraf = require('./util/rimraf');
+var split = require('split2');
 
-const debug = require('./debug');
+var archiver = require('archiver');
 
-const AssetHandler = require('./AssetHandler');
+var debug = require('./debug');
 
-const stringifyStream = require('./stringifyStream');
+var AssetHandler = require('./AssetHandler');
 
-const validateOptions = require('./validateOptions');
+var stringifyStream = require('./stringifyStream');
 
-const rejectOnApiError = require('./rejectOnApiError');
+var validateOptions = require('./validateOptions');
 
-const getDocumentsStream = require('./getDocumentsStream');
+var rejectOnApiError = require('./rejectOnApiError');
 
-const filterSystemDocuments = require('./filterSystemDocuments');
+var getDocumentsStream = require('./getDocumentsStream');
 
-const filterDocumentTypes = require('./filterDocumentTypes');
+var filterSystemDocuments = require('./filterSystemDocuments');
 
-const filterDrafts = require('./filterDrafts');
+var filterDocumentTypes = require('./filterDocumentTypes');
 
-const logFirstChunk = require('./logFirstChunk');
+var filterDrafts = require('./filterDrafts');
 
-const tryParseJson = require('./tryParseJson');
+var logFirstChunk = require('./logFirstChunk');
 
-const noop = () => null;
+var tryParseJson = require('./tryParseJson');
+
+var noop = () => null;
 
 function exportDataset(opts) {
-  const options = validateOptions(opts);
-  const onProgress = options.onProgress || noop;
-  const archive = archiver('tar', {
+  var options = validateOptions(opts);
+  var onProgress = options.onProgress || noop;
+  var archive = archiver('tar', {
     gzip: true,
     gzipOptions: {
       level: options.compress ? zlib.Z_DEFAULT_COMPRESSION : zlib.Z_NO_COMPRESSION
     }
   });
-  const slugDate = new Date().toISOString().replace(/[^a-z0-9]/gi, '-').toLowerCase();
-  const prefix = "".concat(opts.dataset, "-export-").concat(slugDate);
-  const tmpDir = path.join(os.tmpdir(), prefix);
+  var slugDate = new Date().toISOString().replace(/[^a-z0-9]/gi, '-').toLowerCase();
+  var prefix = "".concat(opts.dataset, "-export-").concat(slugDate);
+  var tmpDir = path.join(os.tmpdir(), prefix);
 
-  const cleanup = () => rimraf(tmpDir).catch(err => {
+  var cleanup = () => fse.remove(tmpDir).catch(err => {
     debug("Error while cleaning up temporary files: ".concat(err.message));
   });
 
-  const assetHandler = new AssetHandler({
+  var assetHandler = new AssetHandler({
     client: options.client,
     tmpDir,
     prefix,
@@ -65,154 +67,179 @@ function exportDataset(opts) {
   });
   debug('Outputting assets (temporarily) to %s', tmpDir);
   debug('Outputting to %s', options.outputPath === '-' ? 'stdout' : options.outputPath);
-  let outputStream;
+  var outputStream;
 
   if (isWritableStream(options.outputPath)) {
     outputStream = options.outputPath;
   } else {
-    outputStream = options.outputPath === '-' ? process.stdout : fs.createWriteStream(options.outputPath);
+    outputStream = options.outputPath === '-' ? process.stdout : fse.createWriteStream(options.outputPath);
   }
 
-  let assetStreamHandler = assetHandler.noop;
+  var assetStreamHandler = assetHandler.noop;
 
   if (!options.raw) {
     assetStreamHandler = options.assets ? assetHandler.rewriteAssets : assetHandler.stripAssets;
   }
 
-  return new Promise(async (resolve, reject) => {
-    miss.finished(archive, async archiveErr => {
-      if (archiveErr) {
-        debug('Archiving errored! %s', archiveErr.stack);
-        await cleanup();
-        reject(archiveErr);
-        return;
-      }
-
-      debug('Archive finished!');
-    });
-    debug('Getting dataset export stream');
-    onProgress({
-      step: 'Exporting documents...'
-    });
-    let documentCount = 0;
-    let lastReported = Date.now();
-
-    const reportDocumentCount = (chunk, enc, cb) => {
-      ++documentCount;
-      const now = Date.now();
-
-      if (now - lastReported > 50) {
-        onProgress({
-          step: 'Exporting documents...',
-          current: documentCount,
-          total: '?',
-          update: true
+  return new Promise( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (resolve, reject) {
+      miss.finished(archive, /*#__PURE__*/function () {
+        var _ref2 = _asyncToGenerator(function* (archiveErr) {
+          if (archiveErr) {
+            debug('Archiving errored! %s', archiveErr.stack);
+            yield cleanup();
+            reject(archiveErr);
+            return;
+          }
+
+          debug('Archive finished!');
         });
-        lastReported = now;
-      }
-
-      cb(null, chunk);
-    };
-
-    const inputStream = await getDocumentsStream(options.client, options.dataset);
-    debug('Got HTTP %d', inputStream.statusCode);
-    debug('Response headers: %o', inputStream.headers);
-    const jsonStream = miss.pipeline(inputStream, logFirstChunk(), split(tryParseJson), rejectOnApiError(), filterSystemDocuments(), assetStreamHandler, filterDocumentTypes(options.types), options.drafts ? miss.through.obj() : filterDrafts(), stringifyStream(), miss.through(reportDocumentCount));
-    miss.finished(jsonStream, async err => {
-      if (err) {
-        return;
-      }
 
+        return function (_x3) {
+          return _ref2.apply(this, arguments);
+        };
+      }());
+      debug('Getting dataset export stream');
       onProgress({
-        step: 'Exporting documents...',
-        current: documentCount,
-        total: documentCount,
-        update: true
+        step: 'Exporting documents...'
       });
-
-      if (!options.raw && options.assets) {
-        onProgress({
-          step: 'Downloading assets...'
-        });
-      }
-
-      let prevCompleted = 0;
-      const progressInterval = setInterval(() => {
-        const completed = assetHandler.queueSize - assetHandler.queue.size - assetHandler.queue.pending;
-
-        if (prevCompleted === completed) {
-          return;
+      var documentCount = 0;
+      var lastReported = Date.now();
+
+      var reportDocumentCount = (chunk, enc, cb) => {
+        ++documentCount;
+        var now = Date.now();
+
+        if (now - lastReported > 50) {
+          onProgress({
+            step: 'Exporting documents...',
+            current: documentCount,
+            total: '?',
+            update: true
+          });
+          lastReported = now;
         }
 
-        prevCompleted = completed;
-        onProgress({
-          step: 'Downloading assets...',
-          current: completed,
-          total: assetHandler.queueSize,
-          update: true
+        cb(null, chunk);
+      };
+
+      var inputStream = yield getDocumentsStream(options.client, options.dataset);
+      debug('Got HTTP %d', inputStream.statusCode);
+      debug('Response headers: %o', inputStream.headers);
+      var jsonStream = miss.pipeline(inputStream, logFirstChunk(), split(tryParseJson), rejectOnApiError(), filterSystemDocuments(), assetStreamHandler, filterDocumentTypes(options.types), options.drafts ? miss.through.obj() : filterDrafts(), stringifyStream(), miss.through(reportDocumentCount));
+      miss.finished(jsonStream, /*#__PURE__*/function () {
+        var _ref3 = _asyncToGenerator(function* (err) {
+          if (err) {
+            return;
+          }
+
+          onProgress({
+            step: 'Exporting documents...',
+            current: documentCount,
+            total: documentCount,
+            update: true
+          });
+
+          if (!options.raw && options.assets) {
+            onProgress({
+              step: 'Downloading assets...'
+            });
+          }
+
+          var prevCompleted = 0;
+          var progressInterval = setInterval(() => {
+            var completed = assetHandler.queueSize - assetHandler.queue.size - assetHandler.queue.pending;
+
+            if (prevCompleted === completed) {
+              return;
+            }
+
+            prevCompleted = completed;
+            onProgress({
+              step: 'Downloading assets...',
+              current: completed,
+              total: assetHandler.queueSize,
+              update: true
+            });
+          }, 500);
+          debug('Waiting for asset handler to complete downloads');
+
+          try {
+            var assetMap = yield assetHandler.finish(); // Make sure we mark the progress as done (eg 100/100 instead of 99/100)
+
+            onProgress({
+              step: 'Downloading assets...',
+              current: assetHandler.queueSize,
+              total: assetHandler.queueSize,
+              update: true
+            });
+            archive.append(JSON.stringify(assetMap), {
+              name: 'assets.json',
+              prefix
+            });
+            clearInterval(progressInterval);
+          } catch (assetErr) {
+            clearInterval(progressInterval);
+            yield cleanup();
+            reject(assetErr);
+            return;
+          } // Add all downloaded assets to archive
+
+
+          archive.directory(path.join(tmpDir, 'files'), "".concat(prefix, "/files"), {
+            store: true
+          });
+          archive.directory(path.join(tmpDir, 'images'), "".concat(prefix, "/images"), {
+            store: true
+          });
+          debug('Finalizing archive, flushing streams');
+          onProgress({
+            step: 'Adding assets to archive...'
+          });
+          archive.finalize();
         });
-      }, 500);
-      debug('Waiting for asset handler to complete downloads');
 
-      try {
-        const assetMap = await assetHandler.finish(); // Make sure we mark the progress as done (eg 100/100 instead of 99/100)
-
-        onProgress({
-          step: 'Downloading assets...',
-          current: assetHandler.queueSize,
-          total: assetHandler.queueSize,
-          update: true
-        });
-        archive.append(JSON.stringify(assetMap), {
-          name: 'assets.json',
-          prefix
-        });
-        clearInterval(progressInterval);
-      } catch (assetErr) {
-        clearInterval(progressInterval);
-        await cleanup();
-        reject(assetErr);
-        return;
-      } // Add all downloaded assets to archive
-
-
-      archive.directory(path.join(tmpDir, 'files'), "".concat(prefix, "/files"), {
-        store: true
-      });
-      archive.directory(path.join(tmpDir, 'images'), "".concat(prefix, "/images"), {
-        store: true
+        return function (_x4) {
+          return _ref3.apply(this, arguments);
+        };
+      }());
+      archive.on('warning', err => {
+        debug('Archive warning: %s', err.message);
       });
-      debug('Finalizing archive, flushing streams');
-      onProgress({
-        step: 'Adding assets to archive...'
+      archive.append(jsonStream, {
+        name: 'data.ndjson',
+        prefix
       });
-      archive.finalize();
-    });
-    archive.on('warning', err => {
-      debug('Archive warning: %s', err.message);
-    });
-    archive.append(jsonStream, {
-      name: 'data.ndjson',
-      prefix
-    });
-    miss.pipe(archive, outputStream, onComplete);
+      miss.pipe(archive, outputStream, onComplete);
 
-    async function onComplete(err) {
-      onProgress({
-        step: 'Clearing temporary files...'
-      });
-      await cleanup();
+      function onComplete(_x5) {
+        return _onComplete.apply(this, arguments);
+      }
 
-      if (!err) {
-        resolve();
-        return;
+      function _onComplete() {
+        _onComplete = _asyncToGenerator(function* (err) {
+          onProgress({
+            step: 'Clearing temporary files...'
+          });
+          yield cleanup();
+
+          if (!err) {
+            resolve();
+            return;
+          }
+
+          debug('Error during streaming: %s', err.stack);
+          assetHandler.clear();
+          reject(err);
+        });
+        return _onComplete.apply(this, arguments);
       }
+    });
 
-      debug('Error during streaming: %s', err.stack);
-      assetHandler.clear();
-      reject(err);
-    }
-  });
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }());
 }
 
 function isWritableStream(val) {

package/lib/filterDocumentTypes.js

@@ -1,9 +1,9 @@
 "use strict";
 
-const miss = require('mississippi');
+var miss = require('mississippi');
 
 module.exports = allowedTypes => allowedTypes ? miss.through.obj((doc, enc, callback) => {
-  const type = doc && doc._type;
+  var type = doc && doc._type;
 
   if (allowedTypes.includes(type)) {
     callback(null, doc);

package/lib/filterDrafts.js

@@ -1,8 +1,8 @@
 "use strict";
 
-const miss = require('mississippi');
+var miss = require('mississippi');
 
-const isDraft = doc => doc && doc._id && doc._id.indexOf('drafts.') === 0;
+var isDraft = doc => doc && doc._id && doc._id.indexOf('drafts.') === 0;
 
 module.exports = () => miss.through.obj((doc, enc, callback) => {
   if (isDraft(doc)) {

package/lib/filterSystemDocuments.js

@@ -1,10 +1,10 @@
 "use strict";
 
-const miss = require('mississippi');
+var miss = require('mississippi');
 
-const debug = require('./debug');
+var debug = require('./debug');
 
-const isSystemDocument = doc => doc && doc._id && doc._id.indexOf('_.') === 0;
+var isSystemDocument = doc => doc && doc._id && doc._id.indexOf('_.') === 0;
 
 module.exports = () => miss.through.obj((doc, enc, callback) => {
   if (isSystemDocument(doc)) {

package/lib/getDocumentsStream.js

@@ -1,20 +1,27 @@
 "use strict";
 
-const pkg = require('../package.json');
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-const requestStream = require('./requestStream');
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var pkg = require('../package.json');
+
+var requestStream = require('./requestStream');
 
 module.exports = (client, dataset) => {
   // Sanity client doesn't handle streams natively since we want to support node/browser
   // with same API. We're just using it here to get hold of URLs and tokens.
-  const url = client.getUrl("/data/export/".concat(dataset));
-  const token = client.config().token;
-  const headers = {
-    'User-Agent': "".concat(pkg.name, "@").concat(pkg.version),
-    ...(token ? {
-      Authorization: "Bearer ".concat(token)
-    } : {})
-  };
+  var url = client.getUrl("/data/export/".concat(dataset));
+  var token = client.config().token;
+
+  var headers = _objectSpread({
+    'User-Agent': "".concat(pkg.name, "@").concat(pkg.version)
+  }, token ? {
+    Authorization: "Bearer ".concat(token)
+  } : {});
+
   return requestStream({
     url,
     headers

package/lib/logFirstChunk.js

@@ -1,14 +1,14 @@
 "use strict";
 
-const miss = require('mississippi');
+var miss = require('mississippi');
 
-const debug = require('./debug');
+var debug = require('./debug');
 
 module.exports = () => {
-  let firstChunk = true;
+  var firstChunk = true;
   return miss.through((chunk, enc, callback) => {
     if (firstChunk) {
-      const string = chunk.toString('utf8').split('\n')[0];
+      var string = chunk.toString('utf8').split('\n')[0];
       debug('First chunk received: %s', string.slice(0, 300));
       firstChunk = false;
     }

package/lib/rejectOnApiError.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const miss = require('mississippi');
+var miss = require('mississippi');
 
 module.exports = () => miss.through.obj((doc, enc, callback) => {
   if (doc.error && doc.statusCode) {

package/lib/requestStream.js

@@ -1,23 +1,32 @@
 "use strict";
 
-const getIt = require('get-it');
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-const {
-  keepAlive,
-  promise
-} = require('get-it/middleware');
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
-const debug = require('./debug');
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-const request = getIt([keepAlive(), promise({
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var getIt = require('get-it');
+
+var _require = require('get-it/middleware'),
+    keepAlive = _require.keepAlive,
+    promise = _require.promise;
+
+var debug = require('./debug');
+
+var request = getIt([keepAlive(), promise({
   onlyBody: true
 })]);
-const socketsWithTimeout = new WeakSet();
-const CONNECTION_TIMEOUT = 15 * 1000; // 15 seconds
+var socketsWithTimeout = new WeakSet();
+var CONNECTION_TIMEOUT = 15 * 1000; // 15 seconds
 
-const READ_TIMEOUT = 3 * 60 * 1000; // 3 minutes
+var READ_TIMEOUT = 3 * 60 * 1000; // 3 minutes
 
-const MAX_RETRIES = 5;
+var MAX_RETRIES = 5;
 
 function delay(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
@@ -25,39 +34,51 @@ function delay(ms) {
 /* eslint-disable no-await-in-loop, max-depth */
 
 
-module.exports = async options => {
-  let error;
+module.exports = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* (options) {
+    var error;
 
-  for (let i = 0; i < MAX_RETRIES; i++) {
-    try {
-      const response = await request({ ...options,
-        stream: true,
-        maxRedirects: 0,
-        timeout: {
-          connect: CONNECTION_TIMEOUT,
-          socket: READ_TIMEOUT
-        }
-      });
+    for (var i = 0; i < MAX_RETRIES; i++) {
+      try {
+        var _ret = yield* function* () {
+          var response = yield request(_objectSpread(_objectSpread({}, options), {}, {
+            stream: true,
+            maxRedirects: 0,
+            timeout: {
+              connect: CONNECTION_TIMEOUT,
+              socket: READ_TIMEOUT
+            }
+          }));
 
-      if (response.connection && typeof response.connection.setTimeout === 'function' && !socketsWithTimeout.has(response.connection)) {
-        socketsWithTimeout.add(response.connection);
-        response.connection.setTimeout(READ_TIMEOUT, () => {
-          response.destroy(new Error("Read timeout: No data received on socket for ".concat(READ_TIMEOUT, " ms")));
-        });
-      }
+          if (response.connection && typeof response.connection.setTimeout === 'function' && !socketsWithTimeout.has(response.connection)) {
+            socketsWithTimeout.add(response.connection);
+            response.connection.setTimeout(READ_TIMEOUT, () => {
+              response.destroy(new Error("Read timeout: No data received on socket for ".concat(READ_TIMEOUT, " ms")));
+            });
+          }
 
-      return response;
-    } catch (err) {
-      error = err;
+          return {
+            v: response
+          };
+        }();
 
-      if (err.response && err.response.statusCode && err.response.statusCode < 500) {
-        break;
-      }
+        if (typeof _ret === "object") return _ret.v;
+      } catch (err) {
+        error = err;
+
+        if (err.response && err.response.statusCode && err.response.statusCode < 500) {
+          break;
+        }
 
-      debug('Error, retrying after 1500ms: %s', err.message);
-      await delay(1500);
+        debug('Error, retrying after 1500ms: %s', err.message);
+        yield delay(1500);
+      }
     }
-  }
 
-  throw error;
-};
+    throw error;
+  });
+
+  return function (_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/lib/stringifyStream.js

@@ -1,5 +1,5 @@
 "use strict";
 
-const miss = require('mississippi');
+var miss = require('mississippi');
 
 module.exports = () => miss.through.obj((doc, enc, callback) => callback(null, "".concat(JSON.stringify(doc), "\n")));

package/lib/tryParseJson.js

@@ -5,16 +5,16 @@ module.exports = line => {
     return JSON.parse(line);
   } catch (err) {
     // Catch half-done lines with an error at the end
-    const errorPosition = line.lastIndexOf('{"error":');
+    var errorPosition = line.lastIndexOf('{"error":');
 
     if (errorPosition === -1) {
       err.message = "".concat(err.message, " (").concat(line, ")");
       throw err;
     }
 
-    const errorJson = line.slice(errorPosition);
-    const errorLine = JSON.parse(errorJson);
-    const error = errorLine && errorLine.error;
+    var errorJson = line.slice(errorPosition);
+    var errorLine = JSON.parse(errorJson);
+    var error = errorLine && errorLine.error;
 
     if (error && error.description) {
       throw new Error("Error streaming dataset: ".concat(error.description, "\n\n").concat(errorJson, "\n"));