@sanity/export 2.34.1-canary.0 → 2.34.2-empty-template-cli.0

package/lib/AssetHandler.js

@@ -1,92 +1,136 @@
 "use strict";
 
 var _excluded = ["asset"];
+
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 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; }
+
 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
 function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
 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); }); }; }
+
 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 path = require('path');
+
 var crypto = require('crypto');
+
 var _require = require('url'),
-  parseUrl = _require.parse,
-  formatUrl = _require.format;
+    parseUrl = _require.parse,
+    formatUrl = _require.format;
+
 var fse = require('fs-extra');
+
 var miss = require('mississippi');
+
 var PQueue = require('p-queue');
+
 var _require2 = require('lodash'),
-  omit = _require2.omit,
-  noop = _require2.noop;
+    omit = _require2.omit,
+    noop = _require2.noop;
+
 var pkg = require('../package.json');
+
 var requestStream = require('./requestStream');
+
 var debug = require('./debug');
+
 var EXCLUDE_PROPS = ['_id', '_type', 'assetId', 'extension', 'mimeType', 'path', 'url'];
 var ACTION_REMOVE = 'remove';
 var ACTION_REWRITE = 'rewrite';
 var ASSET_DOWNLOAD_CONCURRENCY = 8;
+
 class AssetHandler {
   constructor(options) {
     var _this = this;
+
     _defineProperty(this, "rewriteAssets", miss.through.obj( /*#__PURE__*/function () {
       var _ref = _asyncToGenerator(function* (doc, enc, callback) {
         if (['sanity.imageAsset', 'sanity.fileAsset'].includes(doc._type)) {
           var type = doc._type === 'sanity.imageAsset' ? 'image' : 'file';
           var filePath = "".concat(type, "s/").concat(generateFilename(doc._id));
+
           _this.assetsSeen.set(doc._id, type);
+
           _this.queueAssetDownload(doc, filePath, type);
+
           callback();
           return;
         }
+
         callback(null, _this.findAndModify(doc, ACTION_REWRITE));
       });
+
       return function (_x, _x2, _x3) {
         return _ref.apply(this, arguments);
       };
     }()));
+
     _defineProperty(this, "stripAssets", miss.through.obj( /*#__PURE__*/function () {
       var _ref2 = _asyncToGenerator(function* (doc, enc, callback) {
         if (['sanity.imageAsset', 'sanity.fileAsset'].includes(doc._type)) {
           callback();
           return;
         }
+
         callback(null, _this.findAndModify(doc, ACTION_REMOVE));
       });
+
       return function (_x4, _x5, _x6) {
         return _ref2.apply(this, arguments);
       };
     }()));
+
     _defineProperty(this, "skipAssets", miss.through.obj((doc, enc, callback) => {
       var isAsset = ['sanity.imageAsset', 'sanity.fileAsset'].includes(doc._type);
+
       if (isAsset) {
         callback();
         return;
       }
+
       callback(null, doc);
     }));
+
     _defineProperty(this, "noop", miss.through.obj((doc, enc, callback) => callback(null, doc)));
+
     _defineProperty(this, "findAndModify", (item, action) => {
       if (Array.isArray(item)) {
         var children = item.map(child => this.findAndModify(child, action));
         return children.filter(Boolean);
       }
+
       if (!item || typeof item !== 'object') {
         return item;
       }
+
       var isAsset = isAssetField(item);
+
       if (isAsset && action === ACTION_REMOVE) {
         return undefined;
       }
+
       if (isAsset && action === ACTION_REWRITE) {
         var asset = item.asset,
-          other = _objectWithoutProperties(item, _excluded);
+            other = _objectWithoutProperties(item, _excluded);
+
         var assetId = asset._ref;
         var assetType = getAssetType(item);
         var filePath = "".concat(assetType, "s/").concat(generateFilename(assetId));
@@ -94,18 +138,23 @@ class AssetHandler {
           _sanityAsset: "".concat(assetType, "@file://./").concat(filePath)
         }, this.findAndModify(other, action));
       }
+
       var newItem = {};
       var keys = Object.keys(item);
+
       for (var i = 0; i < keys.length; i++) {
         var key = keys[i];
         var value = item[key];
         newItem[key] = this.findAndModify(value, action);
+
         if (typeof newItem[key] === 'undefined') {
           delete newItem[key];
         }
       }
+
       return newItem;
     });
+
     var concurrency = options.concurrency || ASSET_DOWNLOAD_CONCURRENCY;
     debug('Using asset download concurrency of %d', concurrency);
     this.client = options.client;
@@ -120,50 +169,58 @@ class AssetHandler {
       concurrency
     });
     this.rejectedError = null;
+
     this.reject = err => {
       this.rejectedError = err;
     };
   }
+
   clear() {
     this.assetsSeen.clear();
     this.queue.clear();
     this.queueSize = 0;
   }
+
   finish() {
     return new Promise((resolve, reject) => {
       if (this.rejectedError) {
         reject(this.rejectedError);
         return;
       }
+
       this.reject = reject;
       this.queue.onIdle().then(() => resolve(this.assetMap));
     });
-  }
-
-  // Called when we want to download all assets to local filesystem and rewrite documents to hold
+  } // Called when we want to download all assets to local filesystem and rewrite documents to hold
   // placeholder asset references (_sanityAsset: 'image@file:///local/path')
 
+
   queueAssetDownload(assetDoc, dstPath, type) {
     if (!assetDoc.url) {
       debug('Asset document "%s" does not have a URL property, skipping', assetDoc._id);
       return;
     }
+
     debug('Adding download task for %s (destination: %s)', assetDoc._id, dstPath);
     this.queueSize++;
     this.downloading.push(assetDoc.url);
     this.queue.add(() => this.downloadAsset(assetDoc, dstPath));
   }
+
   maybeCreateAssetDirs() {
     if (this.assetDirsCreated) {
       return;
     }
-
     /* eslint-disable no-sync */
+
+
     fse.ensureDirSync(path.join(this.tmpDir, 'files'));
     fse.ensureDirSync(path.join(this.tmpDir, 'images'));
     /* eslint-enable no-sync */
+
     this.assetDirsCreated = true;
   }
+
   getAssetRequestOptions(assetDoc) {
     var token = this.client.config().token;
     var headers = {
@@ -171,62 +228,78 @@ class AssetHandler {
     };
     var isImage = assetDoc._type === 'sanity.imageAsset';
     var url = parseUrl(assetDoc.url, true);
+
     if (isImage && ['cdn.sanity.io', 'cdn.sanity.work'].includes(url.hostname) && token) {
       headers.Authorization = "Bearer ".concat(token);
       url.query = _objectSpread(_objectSpread({}, url.query || {}), {}, {
         dlRaw: 'true'
       });
     }
+
     return {
       url: formatUrl(url),
       headers
     };
   }
+
   downloadAsset(assetDoc, dstPath) {
     var _arguments = arguments,
-      _this2 = this;
+        _this2 = this;
+
     return _asyncToGenerator(function* () {
       var attemptNum = _arguments.length > 2 && _arguments[2] !== undefined ? _arguments[2] : 0;
       var url = assetDoc.url;
+
       var options = _this2.getAssetRequestOptions(assetDoc);
+
       var stream;
+
       try {
         stream = yield requestStream(options);
       } catch (err) {
         _this2.reject(err);
+
         return false;
       }
+
       if (stream.statusCode !== 200) {
         _this2.queue.clear();
+
         var err = yield tryGetErrorFromStream(stream);
         var errMsg = "Referenced asset URL \"".concat(url, "\" returned HTTP ").concat(stream.statusCode);
+
         if (err) {
           errMsg = "".concat(errMsg, ":\n\n").concat(err);
         }
+
         _this2.reject(new Error(errMsg));
+
         return false;
       }
+
       _this2.maybeCreateAssetDirs();
+
       debug('Asset stream ready, writing to filesystem at %s', dstPath);
       var tmpPath = path.join(_this2.tmpDir, dstPath);
+
       var _yield$writeHashedStr = yield writeHashedStream(tmpPath, stream),
-        sha1 = _yield$writeHashedStr.sha1,
-        md5 = _yield$writeHashedStr.md5,
-        size = _yield$writeHashedStr.size;
+          sha1 = _yield$writeHashedStr.sha1,
+          md5 = _yield$writeHashedStr.md5,
+          size = _yield$writeHashedStr.size; // Verify it against our downloaded stream to make sure we have the same copy
+
 
-      // Verify it against our downloaded stream to make sure we have the same copy
       var contentLength = stream.headers['content-length'];
       var remoteSha1 = stream.headers['x-sanity-sha1'];
       var remoteMd5 = stream.headers['x-sanity-md5'];
       var hasHash = Boolean(remoteSha1 || remoteMd5);
-      var method = sha1 ? 'sha1' : 'md5';
-
-      // Asset validity is primarily determined by the sha1 hash. However, the sha1 hash is computed
+      var method = sha1 ? 'sha1' : 'md5'; // Asset validity is primarily determined by the sha1 hash. However, the sha1 hash is computed
       // before certain processes (i.e. svg sanitization) which can result in a different hash.
       // When the sha1 hashes don't match, fallback to using the md5 hash.
+
       var sha1Differs = remoteSha1 && sha1 !== remoteSha1;
       var md5Differs = remoteMd5 && md5 !== remoteMd5;
       var differs = sha1Differs && md5Differs;
+
       if (differs && attemptNum < 3) {
         debug('%s does not match downloaded asset, retrying (#%d) [%s]', method, attemptNum + 1, url);
         return _this2.downloadAsset(assetDoc, dstPath, attemptNum + 1);
@@ -234,47 +307,64 @@ class AssetHandler {
         var details = [hasHash && (method === 'md5' ? "md5 should be ".concat(remoteMd5, ", got ").concat(md5) : "sha1 should be ".concat(remoteSha1, ", got ").concat(sha1)), contentLength && parseInt(contentLength, 10) !== size && "Asset should be ".concat(contentLength, " bytes, got ").concat(size), "Did not succeed after ".concat(attemptNum, " attempts.")];
         var detailsString = "Details:\n - ".concat(details.filter(Boolean).join('\n - '));
         yield fse.unlink(tmpPath);
+
         _this2.queue.clear();
+
         var error = new Error("Failed to download asset at ".concat(assetDoc.url, ", giving up. ").concat(detailsString));
+
         _this2.reject(error);
+
         return false;
       }
+
       var isImage = assetDoc._type === 'sanity.imageAsset';
       var type = isImage ? 'image' : 'file';
       var id = "".concat(type, "-").concat(sha1);
       var metaProps = omit(assetDoc, EXCLUDE_PROPS);
+
       if (Object.keys(metaProps).length > 0) {
         _this2.assetMap[id] = metaProps;
       }
+
       _this2.downloading.splice(_this2.downloading.findIndex(datUrl => datUrl === url), 1);
+
       _this2.filesWritten++;
       return true;
     })();
   }
+
 }
+
 function isAssetField(item) {
   return item.asset && item.asset._ref && isSanityAsset(item.asset._ref);
 }
+
 function getAssetType(item) {
   if (!item.asset || typeof item.asset._ref !== 'string') {
     return null;
   }
+
   var _ref3 = item.asset._ref.match(/^(image|file)-/) || [],
-    _ref4 = _slicedToArray(_ref3, 2),
-    type = _ref4[1];
+      _ref4 = _slicedToArray(_ref3, 2),
+      type = _ref4[1];
+
   return type || null;
 }
+
 function isSanityAsset(assetId) {
   return /^image-[a-f0-9]{40}-\d+x\d+-[a-z]+$/.test(assetId) || /^file-[a-f0-9]{40}-[a-z0-9]+$/.test(assetId);
 }
+
 function generateFilename(assetId) {
   var _ref5 = assetId.match(/^(image|file)-(.*?)(-[a-z]+)?$/) || [],
-    _ref6 = _slicedToArray(_ref5, 4),
-    asset = _ref6[2],
-    ext = _ref6[3];
+      _ref6 = _slicedToArray(_ref5, 4),
+      asset = _ref6[2],
+      ext = _ref6[3];
+
   var extension = (ext || 'bin').replace(/^-/, '');
   return asset ? "".concat(asset, ".").concat(extension) : "".concat(assetId, ".bin");
 }
+
 function writeHashedStream(filePath, stream) {
   var size = 0;
   var md5 = crypto.createHash('md5');
@@ -290,6 +380,7 @@ function writeHashedStream(filePath, stream) {
       reject(err);
       return;
     }
+
     resolve({
       size,
       sha1: sha1.digest('hex'),
@@ -297,9 +388,11 @@ function writeHashedStream(filePath, stream) {
     });
   }));
 }
+
 function tryGetErrorFromStream(stream) {
   return new Promise((resolve, reject) => {
     miss.pipe(stream, miss.concat(parse), err => err ? reject(err) : noop);
+
     function parse(body) {
       try {
         var parsed = JSON.parse(body.toString('utf8'));
@@ -310,4 +403,5 @@ function tryGetErrorFromStream(stream) {
     }
   });
 }
+
 module.exports = AssetHandler;

package/lib/export.js

@@ -1,26 +1,47 @@
 "use strict";
 
 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 os = require('os');
+
 var path = require('path');
+
 var zlib = require('zlib');
+
 var fse = require('fs-extra');
+
 var miss = require('mississippi');
+
 var split = require('split2');
+
 var archiver = require('archiver');
+
 var debug = require('./debug');
+
 var AssetHandler = require('./AssetHandler');
+
 var stringifyStream = require('./stringifyStream');
+
 var validateOptions = require('./validateOptions');
+
 var rejectOnApiError = require('./rejectOnApiError');
+
 var getDocumentsStream = require('./getDocumentsStream');
+
 var filterSystemDocuments = require('./filterSystemDocuments');
+
 var filterDocumentTypes = require('./filterDocumentTypes');
+
 var filterDrafts = require('./filterDrafts');
+
 var logFirstChunk = require('./logFirstChunk');
+
 var tryParseJson = require('./tryParseJson');
+
 var noop = () => null;
+
 function exportDataset(opts) {
   var options = validateOptions(opts);
   var onProgress = options.onProgress || noop;
@@ -33,9 +54,11 @@ function exportDataset(opts) {
   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);
+
   var cleanup = () => fse.remove(tmpDir).catch(err => {
     debug("Error while cleaning up temporary files: ".concat(err.message));
   });
+
   var assetHandler = new AssetHandler({
     client: options.client,
     tmpDir,
@@ -45,15 +68,19 @@ function exportDataset(opts) {
   debug('Outputting assets (temporarily) to %s', tmpDir);
   debug('Outputting to %s', options.outputPath === '-' ? 'stdout' : options.outputPath);
   var outputStream;
+
   if (isWritableStream(options.outputPath)) {
     outputStream = options.outputPath;
   } else {
     outputStream = options.outputPath === '-' ? process.stdout : fse.createWriteStream(options.outputPath);
   }
+
   var assetStreamHandler = assetHandler.noop;
+
   if (!options.raw) {
     assetStreamHandler = options.assets ? assetHandler.rewriteAssets : assetHandler.stripAssets;
   }
+
   return new Promise( /*#__PURE__*/function () {
     var _ref = _asyncToGenerator(function* (resolve, reject) {
       miss.finished(archive, /*#__PURE__*/function () {
@@ -64,8 +91,10 @@ function exportDataset(opts) {
             reject(archiveErr);
             return;
           }
+
           debug('Archive finished!');
         });
+
         return function (_x3) {
           return _ref2.apply(this, arguments);
         };
@@ -76,9 +105,11 @@ function exportDataset(opts) {
       });
       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...',
@@ -88,8 +119,10 @@ function exportDataset(opts) {
           });
           lastReported = now;
         }
+
         cb(null, chunk);
       };
+
       var inputStream = yield getDocumentsStream(options.client, options.dataset);
       debug('Got HTTP %d', inputStream.statusCode);
       debug('Response headers: %o', inputStream.headers);
@@ -99,23 +132,28 @@ function exportDataset(opts) {
           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...',
@@ -125,10 +163,10 @@ function exportDataset(opts) {
             });
           }, 500);
           debug('Waiting for asset handler to complete downloads');
+
           try {
-            var assetMap = yield assetHandler.finish();
+            var assetMap = yield assetHandler.finish(); // Make sure we mark the progress as done (eg 100/100 instead of 99/100)
 
-            // Make sure we mark the progress as done (eg 100/100 instead of 99/100)
             onProgress({
               step: 'Downloading assets...',
               current: assetHandler.queueSize,
@@ -145,9 +183,9 @@ function exportDataset(opts) {
             yield cleanup();
             reject(assetErr);
             return;
-          }
+          } // Add all downloaded assets to archive
+
 
-          // Add all downloaded assets to archive
           archive.directory(path.join(tmpDir, 'files'), "".concat(prefix, "/files"), {
             store: true
           });
@@ -160,6 +198,7 @@ function exportDataset(opts) {
           });
           archive.finalize();
         });
+
         return function (_x4) {
           return _ref3.apply(this, arguments);
         };
@@ -172,19 +211,23 @@ function exportDataset(opts) {
         prefix
       });
       miss.pipe(archive, outputStream, onComplete);
+
       function onComplete(_x5) {
         return _onComplete.apply(this, arguments);
       }
+
       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);
@@ -192,12 +235,15 @@ function exportDataset(opts) {
         return _onComplete.apply(this, arguments);
       }
     });
+
     return function (_x, _x2) {
       return _ref.apply(this, arguments);
     };
   }());
 }
+
 function isWritableStream(val) {
   return val !== null && typeof val === 'object' && typeof val.pipe === 'function' && typeof val._write === 'function' && typeof val._writableState === 'object';
 }
+
 module.exports = exportDataset;

package/lib/filterDocumentTypes.js

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

package/lib/filterDrafts.js

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

package/lib/filterSystemDocuments.js

@@ -1,12 +1,16 @@
 "use strict";
 
 var miss = require('mississippi');
+
 var debug = require('./debug');
+
 var isSystemDocument = doc => doc && doc._id && doc._id.indexOf('_.') === 0;
+
 module.exports = () => miss.through.obj((doc, enc, callback) => {
   if (isSystemDocument(doc)) {
     debug('%s is a system document, skipping', doc && doc._id);
     return callback();
   }
+
   return callback(null, doc);
 });

package/lib/getDocumentsStream.js

@@ -1,20 +1,27 @@
 "use strict";
 
 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; }
+
 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.
   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,7 +1,9 @@
 "use strict";
 
 var miss = require('mississippi');
+
 var debug = require('./debug');
+
 module.exports = () => {
   var firstChunk = true;
   return miss.through((chunk, enc, callback) => {
@@ -10,6 +12,7 @@ module.exports = () => {
       debug('First chunk received: %s', string.slice(0, 300));
       firstChunk = false;
     }
+
     callback(null, chunk);
   });
 };

package/lib/rejectOnApiError.js

@@ -1,14 +1,17 @@
 "use strict";
 
 var miss = require('mississippi');
+
 module.exports = () => miss.through.obj((doc, enc, callback) => {
   if (doc.error && doc.statusCode) {
     callback(new Error([doc.statusCode, doc.error].join(': ')));
     return;
   }
+
   if (!doc._id && doc.error) {
     callback(new Error(doc.error.description || doc.error.message || JSON.stringify(doc)));
     return;
   }
+
   callback(null, doc);
 });

package/lib/requestStream.js

@@ -1,30 +1,43 @@
 "use strict";
 
 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; }
+
 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; }
+
 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;
+    keepAlive = _require.keepAlive,
+    promise = _require.promise;
+
 var debug = require('./debug');
+
 var request = getIt([keepAlive(), promise({
   onlyBody: true
 })]);
 var socketsWithTimeout = new WeakSet();
 var CONNECTION_TIMEOUT = 15 * 1000; // 15 seconds
+
 var READ_TIMEOUT = 3 * 60 * 1000; // 3 minutes
+
 var MAX_RETRIES = 5;
+
 function delay(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
-
 /* eslint-disable no-await-in-loop, max-depth */
+
+
 module.exports = /*#__PURE__*/function () {
   var _ref = _asyncToGenerator(function* (options) {
     var error;
+
     for (var i = 0; i < MAX_RETRIES; i++) {
       try {
         var _ret = yield* function* () {
@@ -36,28 +49,35 @@ module.exports = /*#__PURE__*/function () {
               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")));
             });
           }
+
           return {
             v: response
           };
         }();
+
         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);
         yield delay(1500);
       }
     }
+
     throw error;
   });
+
   return function (_x) {
     return _ref.apply(this, arguments);
   };

package/lib/stringifyStream.js

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

package/lib/tryParseJson.js

@@ -6,16 +6,20 @@ module.exports = line => {
   } catch (err) {
     // Catch half-done lines with an error at the end
     var errorPosition = line.lastIndexOf('{"error":');
+
     if (errorPosition === -1) {
       err.message = "".concat(err.message, " (").concat(line, ")");
       throw err;
     }
+
     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"));
     }
+
     throw err;
   }
 };

package/lib/validateOptions.js

@@ -1,6 +1,7 @@
 "use strict";
 
 var defaults = require('lodash/defaults');
+
 var clientMethods = ['getUrl', 'config'];
 var booleanFlags = ['assets', 'raw', 'compress', 'drafts'];
 var exportDefaults = {
@@ -9,36 +10,49 @@ var exportDefaults = {
   assets: true,
   raw: false
 };
+
 function validateOptions(opts) {
   var options = defaults({}, opts, exportDefaults);
+
   if (typeof options.dataset !== 'string' || options.dataset.length < 1) {
     throw new Error("options.dataset must be a valid dataset name");
   }
+
   if (options.onProgress && typeof options.onProgress !== 'function') {
     throw new Error("options.onProgress must be a function");
   }
+
   if (!options.client) {
     throw new Error('`options.client` must be set to an instance of @sanity/client');
   }
+
   var missing = clientMethods.find(key => typeof options.client[key] !== 'function');
+
   if (missing) {
     throw new Error("`options.client` is not a valid @sanity/client instance - no \"".concat(missing, "\" method found"));
   }
+
   var clientConfig = options.client.config();
+
   if (!clientConfig.token) {
     throw new Error('Client is not instantiated with a `token`');
   }
+
   booleanFlags.forEach(flag => {
     if (typeof options[flag] !== 'boolean') {
       throw new Error("Flag ".concat(flag, " must be a boolean (true/false)"));
     }
   });
+
   if (!options.outputPath) {
     throw new Error('outputPath must be specified (- for stdout)');
   }
+
   if (options.assetConcurrency && (options.assetConcurrency < 1 || options.assetConcurrency > 24)) {
     throw new Error('`assetConcurrency` must be between 1 and 24');
   }
+
   return options;
 }
+
 module.exports = validateOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/export",
-  "version": "2.34.1-canary.0+b3e58b8893",
+  "version": "2.34.2-empty-template-cli.0+184a9350e5",
   "description": "Export Sanity documents and assets",
   "main": "lib/export.js",
   "engines": {
@@ -49,5 +49,5 @@
     "url": "https://github.com/sanity-io/sanity/issues"
   },
   "homepage": "https://www.sanity.io/",
-  "gitHead": "b3e58b8893c9573844279488896df2313df914f1"
+  "gitHead": "184a9350e50aa05877a3b10e052ce4e2ca743ef0"
 }