verdaccio-memory/lib/memory-handler.js

Storage implementation in memory

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _path = _interopRequireDefault(require("path"));
var _core = require("@verdaccio/core");
var _memoryFs = _interopRequireDefault(require("memory-fs"));
var _streams = require("@verdaccio/streams");
var _utils = require("./utils");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
const fs = new _memoryFs.default();
const {
  getBadRequest,
  getInternalError,
  getConflict,
  getNotFound
} = _core.errorUtils;
class MemoryHandler {
  constructor(packageName, data, logger) {
    _defineProperty(this, "data", void 0);
    _defineProperty(this, "name", void 0);
    _defineProperty(this, "path", void 0);
    _defineProperty(this, "logger", void 0);
    // this is not need it
    this.data = data;
    this.name = packageName;
    this.logger = logger;
    this.path = `/${packageName}`;
  }
  updatePackage(pkgFileName, updateHandler, onWrite, transformPackage, onEnd) {
    const json = this._getStorage(pkgFileName);
    let pkg;
    try {
      pkg = (0, _utils.parsePackage)(json);
    } catch (err) {
      return onEnd(err);
    }
    updateHandler(pkg, err => {
      if (err) {
        return onEnd(err);
      }
      try {
        onWrite(pkgFileName, transformPackage(pkg), onEnd);
      } catch (err) {
        return onEnd(getInternalError('error on parse the metadata'));
      }
    });
  }
  deletePackage(pkgName, callback) {
    delete this.data[pkgName];
    return callback(null);
  }
  removePackage(callback) {
    return callback(null);
  }
  createPackage(name, value, cb) {
    this.savePackage(name, value, cb);
  }
  savePackage(name, value, cb) {
    try {
      const json = (0, _utils.stringifyPackage)(value);
      this.data[name] = json;
      return cb(null);
    } catch (err) {
      return cb(getInternalError(err.message));
    }
  }
  readPackage(name, cb) {
    const json = this._getStorage(name);
    const isJson = typeof json === 'undefined';
    try {
      return cb(isJson ? getNotFound() : null, (0, _utils.parsePackage)(json));
    } catch (err) {
      return cb(getNotFound());
    }
  }
  writeTarball(name) {
    const uploadStream = new _streams.UploadTarball({});
    const temporalName = `${this.path}/${name}`;
    process.nextTick(function () {
      fs.mkdirp(_path.default.dirname(temporalName), function (mkdirpError) {
        if (mkdirpError) {
          return uploadStream.emit('error', mkdirpError);
        }
        fs.stat(temporalName, function (fileError, stats) {
          if (!fileError && stats) {
            return uploadStream.emit('error', getConflict());
          }
          try {
            const file = fs.createWriteStream(temporalName);
            uploadStream.pipe(file);
            uploadStream.done = function () {
              const onEnd = function () {
                uploadStream.emit('success');
              };
              uploadStream.on('end', onEnd);
            };
            uploadStream.abort = function () {
              uploadStream.emit('error', getBadRequest('transmision aborted'));
              file.end();
            };
            uploadStream.emit('open');
            return;
          } catch (err) {
            uploadStream.emit('error', err);
            return;
          }
        });
      });
    });
    return uploadStream;
  }
  readTarball(name) {
    const pathName = `${this.path}/${name}`;
    const readTarballStream = new _streams.ReadTarball({});
    process.nextTick(function () {
      fs.stat(pathName, function (fileError, stats) {
        if (fileError && !stats) {
          return readTarballStream.emit('error', getNotFound());
        }
        try {
          const readStream = fs.createReadStream(pathName);
          const pathMeta = fs.meta(pathName);
          const contentLength = pathMeta && pathMeta.length || 0;
          readTarballStream.emit('content-length', contentLength);
          readTarballStream.emit('open');
          readStream.pipe(readTarballStream);
          readStream.on('error', error => {
            readTarballStream.emit('error', error);
          });
          readTarballStream.abort = function () {
            readStream.destroy(getBadRequest('read has been aborted'));
          };
          return;
        } catch (err) {
          readTarballStream.emit('error', err);
          return;
        }
      });
    });
    return readTarballStream;
  }
  _getStorage(name = '') {
    return this.data[name];
  }
}
var _default = exports.default = MemoryHandler;
//# sourceMappingURL=memory-handler.js.map