@ps-aux/nodebup 0.1.0 → 0.2.2

package/lib/bup/AggregateBackupController.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AggregateBackupController = void 0;
+
+var _FsSyncer = require("../fs/fssync/FsSyncer");
+
+var _Config = require("../config/Config");
+
+var _Gpg = require("../tools/gpg/Gpg");
+
+var _Fs = require("../fs/Fs");
+
+var _SshKeyManager = require("../tools/ssh/SshKeyManager");
+
+var _inversify = require("inversify");
+
+var _ContextSymbols = require("../ctx/ContextSymbols");
+
+var _AppLogger = require("../log/AppLogger");
+
+var _StorageBackendProvider = require("../storage/StorageBackendProvider");
+
+var _dec, _dec2, _dec3, _dec4, _class;
+
+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; }
+
+let AggregateBackupController = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
+  return (0, _inversify.inject)(_ContextSymbols.AppConfig_)(target, undefined, 6);
+}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof _Gpg.Gpg === "undefined" ? Object : _Gpg.Gpg, typeof _SshKeyManager.SshKeyManager === "undefined" ? Object : _SshKeyManager.SshKeyManager, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _FsSyncer.FsSyncer === "undefined" ? Object : _FsSyncer.FsSyncer, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger, typeof _StorageBackendProvider.StorageBackendProvider === "undefined" ? Object : _StorageBackendProvider.StorageBackendProvider, typeof _Config.Config === "undefined" ? Object : _Config.Config]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class AggregateBackupController {
+  constructor(gpg, ssh, fs, fsSyncer, log, storageBackendProvider, cfg) {
+    this.gpg = gpg;
+    this.ssh = ssh;
+    this.fs = fs;
+    this.fsSyncer = fsSyncer;
+    this.log = log;
+    this.storageBackendProvider = storageBackendProvider;
+    this.cfg = cfg;
+
+    _defineProperty(this, "backup", async (aggregate, storage) => {
+      const aggrDir = this.cfg.pwd.resolve('.aggr');
+      this.fs.ensureDir(aggrDir);
+      const aggr = this.cfg.aggregates.find(a => a.name === aggregate);
+
+      for (const f of aggr.sources.file) {
+        await this.runFileTask(f, aggrDir);
+      }
+
+      this.storageBackendProvider.provide(storage).store(aggrDir);
+      this.fs.rmDir(aggrDir);
+    });
+
+    _defineProperty(this, "runGpgKeyTask", t => {
+      this.log.info('Running GPG key task', t);
+      const key = this.gpg.exportKey(t.id);
+      const to = this.storagePath(t.to || `keys/gpg/${t.id}.asc`);
+      this.fs.writeFile(to, key);
+    });
+
+    _defineProperty(this, "runSshKeyTask", t => {
+      this.log.info('Running SSH key task', t);
+      const key = this.ssh.exportKey(t.id);
+      const to = this.storagePath(t.to || `keys/ssh/${t.id}`);
+      this.fs.writeFile(to, key);
+    });
+
+    _defineProperty(this, "runFileTask", (f, dir) => {
+      this.log.info('Running file task', f);
+      const {
+        from,
+        to
+      } = f;
+      this.fsSyncer.sync(from, dir.resolve(to));
+    });
+
+    _defineProperty(this, "storagePath", path => {
+      throw new Error('Unspported');
+    });
+  }
+
+}) || _class) || _class) || _class) || _class);
+exports.AggregateBackupController = AggregateBackupController;

package/lib/cli/app.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createApp = void 0;
+
+require("reflect-metadata");
+
+var _nclif = require("@ps-aux/nclif");
+
+var _Config = require("../config/Config");
+
+var _Context = require("../ctx/Context");
+
+var _AggregateBackupController = require("../bup/AggregateBackupController");
+
+var _ResticController = require("../storage/restic/ResticController");
+
+const createApp = () => _nclif.CliApp.of({
+  commands: {
+    restic: (0, _nclif.cmdGroup)({
+      commands: {
+        'init-repo': (0, _nclif.cmd)({
+          positionals: [{
+            name: 'resticStorageName',
+            required: true
+          }],
+          run: (arg, c) => c.get(_ResticController.ResticController).initRepo(arg.resticStorageName)
+        })
+      }
+    }),
+    aggr: (0, _nclif.cmdGroup)({
+      commands: {
+        backup: (0, _nclif.cmd)({
+          description: 'Run backup',
+          positionals: [{
+            name: 'aggregateName',
+            type: 'string',
+            required: true
+          }, {
+            name: 'storageName',
+            type: 'string',
+            required: true
+          }],
+          run: (a, c) => c.get(_AggregateBackupController.AggregateBackupController).backup(a.aggregateName, a.storageName)
+        })
+      }
+    })
+  }
+}).addObjectConfig(pwd => (0, _Config.readConfig)(pwd)).context(({
+  config
+}) => (0, _Context.createContext)(config));
+
+exports.createApp = createApp;

package/lib/cli/bin.js

@@ -1,12 +1,6 @@
 #!/usr/bin/env node
 "use strict";
 
-var _entrypoint = _interopRequireDefault(require("./entrypoint"));
+var _app = require("./app");
 
-var _Context = require("../ctx/Context");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const rootDir = process.cwd();
-const ctx = (0, _Context.createContext)(rootDir);
-(0, _entrypoint.default)(ctx);
+(0, _app.createApp)().run();

package/lib/config/Config.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readConfig = void 0;
+
+var _Path = require("../fs/path/Path");
+
+var _readYaml = require("../fs/readYaml");
+
+var _validateConfigAgainstSchema = require("./validateConfigAgainstSchema");
+
+var _expandAndCreatePath = require("./expandAndCreatePath");
+
+const expandPaths = (cfg, exp, cwd) => {
+  cfg.storage.filter(s => s.type === 'file').map(s => s).forEach(s => {
+    s.path = exp(s.path);
+  });
+  cfg.storage.filter(s => s.type === 'restic').map(s => s).forEach(s => {
+    if (s.credentialsFile) s.credentialsFile = exp(s.credentialsFile);
+    s.passwordFile = exp(s.passwordFile);
+    if (s.repo.startsWith('local:')) s.repo = (0, _expandAndCreatePath.expandStrPath)(s.repo, cwd);
+  });
+  cfg.aggregates.forEach(a => {
+    a.sources.file.forEach(f => {
+      f.from = exp(f.from);
+      f.to = _Path.RelativePath.from(f.to);
+    });
+  });
+};
+
+const readConfig = pwdStr => {
+  const cwd = _Path.AbsPath.from(pwdStr);
+
+  const cfgFile = (0, _readYaml.readYaml)(cwd.resolve('bup.yaml').str());
+  (0, _validateConfigAgainstSchema.validateConfigAgainstSchema)(cfgFile);
+  const cfg = cfgFile;
+  cfg.pwd = cwd;
+  cfg.aggregates.forEach(t => {
+    const {
+      sources
+    } = t;
+    sources.file = sources.file ?? [];
+    sources.sshKey = sources.sshKey ?? [];
+    sources.gpgKey = sources.gpgKey ?? [];
+  });
+
+  const expand = str => {
+    const p = (0, _expandAndCreatePath.expandAndCreatePath)(str, cwd);
+    return p;
+  };
+
+  expandPaths(cfg, expand, cwd);
+  return cfg;
+};
+
+exports.readConfig = readConfig;

package/lib/config/expandAndCreatePath.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.expandStrPath = exports.expandAndCreatePath = void 0;
+
+var _Path = require("../fs/path/Path");
+
+var _os = _interopRequireDefault(require("os"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const expandStrPath = (path, pwd) => {
+  path = path.replace('<cwd>', pwd.str());
+  path = path.replace('~', _os.default.homedir());
+  return path;
+};
+
+exports.expandStrPath = expandStrPath;
+
+const expandAndCreatePath = (path, pwd) => _Path.AbsPath.from(expandStrPath(path, pwd));
+
+exports.expandAndCreatePath = expandAndCreatePath;

package/lib/config/validateConfigAgainstSchema.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateConfigAgainstSchema = void 0;
+
+var _joi = _interopRequireDefault(require("@hapi/joi"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const DirTaskSchema = _joi.default.object({
+  from: _joi.default.string(),
+  to: _joi.default.string()
+});
+
+const FileTaskSchema = DirTaskSchema;
+
+const KeyTaskSchema = _joi.default.object({
+  id: _joi.default.string(),
+  to: _joi.default.string().optional()
+});
+
+const createStorageSchema = props => _joi.default.object({
+  name: _joi.default.string(),
+  type: _joi.default.string(),
+  ...props
+});
+
+const FileStorageSchema = createStorageSchema({
+  path: _joi.default.string()
+});
+const ResticStorageSchema = createStorageSchema({
+  repo: _joi.default.string(),
+  credentialsFile: _joi.default.string().optional(),
+  passwordFile: _joi.default.string()
+});
+
+const Sources = _joi.default.object({
+  dir: _joi.default.array().items(DirTaskSchema).optional(),
+  file: _joi.default.array().items(FileTaskSchema).optional(),
+  gpgKey: _joi.default.array().items(KeyTaskSchema).optional(),
+  sshKey: _joi.default.array().items(KeyTaskSchema).optional()
+});
+
+const Aggregate = _joi.default.object({
+  name: _joi.default.string(),
+  sources: Sources
+});
+
+const Schema = () => _joi.default.object({
+  // TODO undescriptive error msg. Invalid config."storage[0]" does not match any of the allowed types
+  storage: _joi.default.array().items(FileStorageSchema, ResticStorageSchema),
+  aggregates: _joi.default.array().items(Aggregate)
+});
+
+const validateConfigAgainstSchema = cfg => {
+  const r = Schema().validate(cfg, {
+    presence: 'required',
+    allowUnknown: false
+  });
+  if (r.error) throw new Error('Invalid config.' + r.error.message);
+};
+
+exports.validateConfigAgainstSchema = validateConfigAgainstSchema;

package/lib/config/validateConfigAgainstSchema.spec.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _validateConfigAgainstSchema = require("./validateConfigAgainstSchema");
+
+const f1 = {
+  storage: [{
+    name: 'fs',
+    type: 'file',
+    path: '~/tmp/nodepub/test-store'
+  }, {
+    name: 'restic',
+    type: 'restic',
+    repo: 'b2:reo',
+    credentialsFile: '.b2-credentials.json',
+    passwordFile: 'pass-file'
+  }],
+  aggregates: [{
+    name: 'my-task',
+    sources: {
+      file: [{
+        from: 'foo',
+        to: 'foo'
+      }]
+    }
+  }]
+};
+it('validate', () => {
+  (0, _validateConfigAgainstSchema.validateConfigAgainstSchema)(f1);
+});

package/lib/ctx/Context.js

@@ -5,32 +5,39 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createContext = void 0;
 
-var _ConsoleLogger = require("../log/ConsoleLogger");
+var _Shell = require("../tools/shell/Shell");
 
-var _LocalShellCmdExecutor = require("../shell/LocalShellCmdExecutor");
+var _FsSyncer = require("../fs/fssync/FsSyncer");
 
-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 _Gpg = require("../tools/gpg/Gpg");
 
-class ContextImpl {
-  constructor(rootDir) {
-    _defineProperty(this, "_log", void 0);
+var _Fs = require("../fs/Fs");
 
-    _defineProperty(this, "sh", void 0);
+var _SshKeyManager = require("../tools/ssh/SshKeyManager");
 
-    _defineProperty(this, "shell", () => this.sh);
+var _inversify = require("inversify");
 
-    _defineProperty(this, "log", () => this._log);
+var _ContextSymbols = require("./ContextSymbols");
 
-    _defineProperty(this, "now", () => new Date());
+var _AggregateBackupController = require("../bup/AggregateBackupController");
 
-    this._log = new _ConsoleLogger.ConsoleLogger();
-    this.sh = new _LocalShellCmdExecutor.LocalShellCmdExecutor(this._log);
-  }
+var _AppLogger = require("../log/AppLogger");
 
-}
+var _StorageBackendProvider = require("../storage/StorageBackendProvider");
 
-const createContext = rootDir => {
-  return new ContextImpl(rootDir);
+var _ResticClientFactory = require("../storage/restic/ResticClientFactory");
+
+var _ResticController = require("../storage/restic/ResticController");
+
+const createContext = cfg => {
+  const c = new _inversify.Container();
+  c.bind(_ContextSymbols.AppConfig_).toConstantValue(cfg);
+  const log = new _AppLogger.AppLogger();
+  c.bind(_ContextSymbols.Log_).toConstantValue(log);
+  c.bind(_AppLogger.AppLogger).toConstantValue(log);
+  const self = [_Gpg.Gpg, _Shell.Shell, _Fs.Fs, _FsSyncer.FsSyncer, _SshKeyManager.SshKeyManager, _StorageBackendProvider.StorageBackendProvider, _ResticClientFactory.ResticClientFactory, _AggregateBackupController.AggregateBackupController, _ResticController.ResticController];
+  self.forEach(s => c.bind(s).toSelf());
+  return c;
 };
 
 exports.createContext = createContext;

package/lib/ctx/ContextSymbols.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TaskConfig_ = exports.StorageConfig_ = exports.Log_ = exports.AppConfig_ = void 0;
+const Log_ = Symbol.for('Log');
+exports.Log_ = Log_;
+const TaskConfig_ = Symbol.for('config.Tasks');
+exports.TaskConfig_ = TaskConfig_;
+const StorageConfig_ = Symbol.for('config.Storage');
+exports.StorageConfig_ = StorageConfig_;
+const AppConfig_ = Symbol.for('config.app');
+exports.AppConfig_ = AppConfig_;

package/lib/fs/Fs.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Fs = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _inversify = require("inversify");
+
+var _AppLogger = require("../log/AppLogger");
+
+var _dec, _dec2, _dec3, _class;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+let Fs = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:type", Function), _dec3 = Reflect.metadata("design:paramtypes", [typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger]), _dec(_class = _dec2(_class = _dec3(_class = class Fs {
+  constructor(log) {
+    this.log = log;
+
+    _defineProperty(this, "writeFile", (path, content) => {
+      this.log.debug('Writing into file', path);
+      this.ensureParentDir(path);
+
+      _fs.default.writeFileSync(path.str(), content);
+    });
+
+    _defineProperty(this, "isFile", path => !this.isDir(path));
+
+    _defineProperty(this, "ensureIsFile", p => {
+      if (!this.isFile(p)) throw new Error(`${p} is not a file`);
+    });
+
+    _defineProperty(this, "isDir", path => _fs.default.lstatSync(path.str()).isDirectory());
+
+    _defineProperty(this, "rmDir", path => {
+      _fs.default.rmdirSync(path.str(), {
+        recursive: true
+      });
+    });
+
+    _defineProperty(this, "ensureIsDir", p => {
+      if (!this.isDir(p)) throw new Error(`${p} is not a dir`);
+    });
+
+    _defineProperty(this, "readFile", path => {
+      this.log.debug('Reading from file', path.str());
+      return _fs.default.readFileSync(path.str()).toString();
+    });
+
+    _defineProperty(this, "readJson", path => {
+      const file = this.readFile(path);
+      return JSON.parse(file);
+    });
+
+    _defineProperty(this, "ensureDir", path => {
+      if (!this.exists(path)) {
+        this.log.debug('Dir ', path, 'does not exist. Wil be created');
+
+        _fs.default.mkdirSync(path.str(), {
+          recursive: true
+        });
+      } else {
+        if (this.isFile(path)) throw new Error(`${path.str()} exists and is not a directory`);
+      }
+    });
+
+    _defineProperty(this, "ensureParentDir", path => {
+      const parent = path.parent();
+      if (this.exists(parent)) return;
+      this.ensureDir(parent);
+    });
+
+    _defineProperty(this, "exists", path => _fs.default.existsSync(path.str()));
+  }
+
+}) || _class) || _class) || _class);
+exports.Fs = Fs;

package/lib/fs/areDirsSame.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.areDirsSame = void 0;
+
+var _dirCompare = require("dir-compare");
+
+const opts = {
+  compareContent: true,
+  compareDate: true
+};
+
+const areDirsSame = (a, b) => {
+  const res = (0, _dirCompare.compareSync)(a.str(), b.str(), opts);
+  return res.same;
+};
+
+exports.areDirsSame = areDirsSame;

package/lib/fs/areDirsSame.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _areDirsSame = require("./areDirsSame");
+
+var _test = require("../../test");
+
+var _Path = require("./path/Path");
+
+const thisDir = _Path.AbsPath.from(__dirname);
+
+it('same', () => {
+  const res = (0, _areDirsSame.areDirsSame)(thisDir, thisDir);
+  expect(res).toBe(true);
+});
+it('not same', () => {
+  const otherDir = _Path.AbsPath.from((0, _test.testDir)());
+
+  const res = (0, _areDirsSame.areDirsSame)(thisDir, otherDir);
+  expect(res).toBe(false);
+});

package/lib/fs/fssync/FsSync.spec.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _FsSyncer = require("./FsSyncer");
+
+var _Shell = require("../../tools/shell/Shell");
+
+var _test = require("../../../test");
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _areDirsSame = require("../areDirsSame");
+
+var _Fs = require("../Fs");
+
+var _Path = require("../path/Path");
+
+var _AppLogger = require("../../log/AppLogger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+describe('FsSync', () => {
+  const from = _Path.AbsPath.from((0, _test.testDir)('fs/fssync/src'));
+
+  const to = _Path.AbsPath.from((0, _test.testDir)('fs/fssync/dst/inner'));
+
+  it('syncs dir', () => {
+    const l = new _AppLogger.AppLogger();
+    const sut = new _FsSyncer.FsSyncer(new _Shell.Shell(l), new _Fs.Fs(l), l);
+    sut.syncDirs(from, to);
+    expect((0, _areDirsSame.areDirsSame)(from, to)).toBe(true);
+  });
+  afterAll(() => {
+    _fs.default.rmdirSync(to.str(), {
+      recursive: true
+    });
+  });
+});

package/lib/fs/fssync/FsSyncer.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FsSyncer = void 0;
+
+var _Shell = require("../../tools/shell/Shell");
+
+var _Fs = require("../Fs");
+
+var _inversify = require("inversify");
+
+var _AppLogger = require("../../log/AppLogger");
+
+var _dec, _dec2, _dec3, _class;
+
+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 toUnixDirString = path => {
+  const val = path.str();
+  if (val.endsWith('/')) return val;
+  return val + '/';
+};
+
+let FsSyncer = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:type", Function), _dec3 = Reflect.metadata("design:paramtypes", [typeof _Shell.Shell === "undefined" ? Object : _Shell.Shell, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger]), _dec(_class = _dec2(_class = _dec3(_class = class FsSyncer {
+  constructor(sh, fs, log) {
+    this.sh = sh;
+    this.fs = fs;
+    this.log = log;
+
+    _defineProperty(this, "sync", (from, to) => {
+      if (this.fs.isFile(from)) this.syncFile(from, to);else this.syncDirs(from, to);
+    });
+
+    _defineProperty(this, "syncDirs", (from, to) => {
+      this.fs.ensureIsDir(from);
+      this.log.info('Syncing dir', from.str(), '==>', to.str());
+      const fromPath = toUnixDirString(from);
+      const toPath = toUnixDirString(to);
+      this.fs.ensureParentDir(to);
+      this.sh.exec(`rsync -rtv --delete ${fromPath} ${toPath}`);
+    });
+
+    _defineProperty(this, "syncFile", (from, to) => {
+      this.fs.ensureIsFile(from);
+      this.log.info('Syncing file', from.str(), '==>', to.str());
+      this.fs.ensureParentDir(to);
+      this.sh.exec(`rsync -rtv ${from.str()} ${to.str()}`);
+    });
+  }
+
+}) || _class) || _class) || _class);
+exports.FsSyncer = FsSyncer;

package/lib/fs/path/Path.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RelativePath = exports.AbsPath = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+class AbsPath {
+  constructor(path) {
+    this.path = path;
+
+    _defineProperty(this, "resolve", path => {
+      const str = typeof path === 'string' ? path : path.str();
+      return AbsPath.from(_path.default.resolve(this.str(), str));
+    });
+
+    _defineProperty(this, "parent", () => {
+      return AbsPath.from(_path.default.resolve(this.path, '..'));
+    });
+
+    _defineProperty(this, "str", () => this.path);
+
+    if (!_path.default.isAbsolute(path)) throw new Error(`Path ${path} must be absolute`);
+  }
+
+  toString() {
+    return `AbsPath(${this.str()})`;
+  }
+
+}
+
+exports.AbsPath = AbsPath;
+
+_defineProperty(AbsPath, "from", str => {
+  const p = new AbsPath(str);
+  return p;
+});
+
+class RelativePath {
+  constructor(path) {
+    this.path = path;
+
+    _defineProperty(this, "str", () => this.path);
+
+    if (_path.default.isAbsolute(path)) throw new Error(`Path ${path} must be relative`);
+  }
+
+} // AbsPath.prototype.toString = () => 'hovno'
+
+
+exports.RelativePath = RelativePath;
+
+_defineProperty(RelativePath, "from", str => new RelativePath(str));