@tacxou/nestjs_module_factorydrive 1.1.6

package/dist/index.js

@@ -0,0 +1,549 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// src/exceptions/authorization-required.exception.ts
+import { RuntimeException } from "node-exceptions";
+
+class AuthorizationRequiredException extends RuntimeException {
+  raw;
+  constructor(err, path) {
+    super(`Unauthorized to access file ${path}
+${err.message}`, 500, "E_AUTHORIZATION_REQUIRED");
+    this.raw = err;
+  }
+}
+// src/exceptions/driver-not-supported.exception.ts
+import { RuntimeException as RuntimeException2 } from "node-exceptions";
+
+class DriverNotSupportedException extends RuntimeException2 {
+  driver;
+  static driver(name) {
+    const exception = new this(`Driver ${name} is not supported`, 400);
+    exception.driver = name;
+    return exception;
+  }
+}
+// src/exceptions/file-not-found.exception.ts
+import { RuntimeException as RuntimeException3 } from "node-exceptions";
+
+class FileNotFoundException extends RuntimeException3 {
+  raw;
+  constructor(err, path) {
+    super(`The file ${path} doesn't exist
+${err.message}`, 500, "E_FILE_NOT_FOUND");
+    this.raw = err;
+  }
+}
+// src/exceptions/invalid-config.exception.ts
+import { RuntimeException as RuntimeException4 } from "node-exceptions";
+
+class InvalidConfigException extends RuntimeException4 {
+  static missingDiskName() {
+    return new this("Make sure to define a default disk name inside config file", 500, "E_INVALID_CONFIG");
+  }
+  static missingDiskConfig(name) {
+    return new this(`Make sure to define config for ${name} disk`, 500, "E_INVALID_CONFIG");
+  }
+  static missingDiskDriver(name) {
+    return new this(`Make sure to define driver for ${name} disk`, 500, "E_INVALID_CONFIG");
+  }
+  static duplicateDiskName(name) {
+    return new this(`A disk named ${name} is already defined`, 500, "E_INVALID_CONFIG");
+  }
+}
+// src/exceptions/method-not-supported.exception.ts
+import { RuntimeException as RuntimeException5 } from "node-exceptions";
+
+class MethodNotSupportedException extends RuntimeException5 {
+  constructor(name, driver) {
+    super(`Method ${name} is not supported for the driver ${driver}`, 500, "E_METHOD_NOT_SUPPORTED");
+  }
+}
+// src/exceptions/no-such-bucket.exception.ts
+import { RuntimeException as RuntimeException6 } from "node-exceptions";
+
+class NoSuchBucketException extends RuntimeException6 {
+  raw;
+  constructor(err, bucket) {
+    super(`The bucket ${bucket} doesn't exist
+${err.message}`, 500, "E_NO_SUCH_BUCKET");
+    this.raw = err;
+  }
+}
+// src/exceptions/permission-missing.exception.ts
+import { RuntimeException as RuntimeException7 } from "node-exceptions";
+
+class PermissionMissingException extends RuntimeException7 {
+  raw;
+  constructor(err, path) {
+    super(`Missing permission for file ${path}
+${err.message}`, 500, "E_PERMISSION_MISSING");
+    this.raw = err;
+  }
+}
+// src/exceptions/unknown.exception.ts
+import { RuntimeException as RuntimeException8 } from "node-exceptions";
+
+class UnknownException extends RuntimeException8 {
+  raw;
+  constructor(err, errorCode, path) {
+    super(`An unknown error happened with the file ${path}.
+            Error code: ${errorCode}
+            Original stack:
+            ${err.stack}`, 500, "E_UNKNOWN");
+    this.raw = err;
+  }
+}
+// src/exceptions/wrong-key-path.exception.ts
+import { RuntimeException as RuntimeException9 } from "node-exceptions";
+
+class WrongKeyPathException extends RuntimeException9 {
+  raw;
+  constructor(err, path) {
+    super(`The key path does not exist: ${path}
+${err.message}`, 500, "E_WRONG_KEY_PATH");
+    this.raw = err;
+  }
+}
+// src/factorydrive/abstract.storage.ts
+class AbstractStorage {
+  constructor() {
+    if (this.constructor === AbstractStorage) {
+      throw new TypeError('Abstract class "AbstractStorage" cannot be instantiated directly.');
+    }
+  }
+  onStorageInit() {
+    console.log("onStorageInita");
+    return Promise.resolve();
+  }
+  append(_location, _content) {
+    throw new MethodNotSupportedException("append", this.constructor.name);
+  }
+  copy(_src, _dest) {
+    throw new MethodNotSupportedException("copy", this.constructor.name);
+  }
+  delete(_location) {
+    throw new MethodNotSupportedException("delete", this.constructor.name);
+  }
+  driver() {
+    throw new MethodNotSupportedException("driver", this.constructor.name);
+  }
+  exists(_location) {
+    throw new MethodNotSupportedException("exists", this.constructor.name);
+  }
+  get(_location, _encoding) {
+    throw new MethodNotSupportedException("get", this.constructor.name);
+  }
+  getBuffer(_location) {
+    throw new MethodNotSupportedException("getBuffer", this.constructor.name);
+  }
+  getSignedUrl(_location, _options) {
+    throw new MethodNotSupportedException("getSignedUrl", this.constructor.name);
+  }
+  getStat(_location) {
+    throw new MethodNotSupportedException("getStat", this.constructor.name);
+  }
+  getStream(_location) {
+    throw new MethodNotSupportedException("getStream", this.constructor.name);
+  }
+  getUrl(_location) {
+    throw new MethodNotSupportedException("getUrl", this.constructor.name);
+  }
+  move(_src, _dest) {
+    throw new MethodNotSupportedException("move", this.constructor.name);
+  }
+  put(_location, _content) {
+    throw new MethodNotSupportedException("put", this.constructor.name);
+  }
+  prepend(_location, _content) {
+    throw new MethodNotSupportedException("prepend", this.constructor.name);
+  }
+  flatList(_prefix) {
+    throw new MethodNotSupportedException("flatList", this.constructor.name);
+  }
+}
+// src/factorydrive/local-file-system.storage.ts
+import * as fse from "fs-extra";
+import { promises as fs } from "fs";
+import { dirname, join, relative, resolve, sep } from "path";
+
+// src/factorydrive/utils.ts
+import { promisify } from "util";
+import { pipeline as nodePipeline } from "stream";
+function isReadableStream(stream) {
+  return stream !== null && typeof stream === "object" && typeof stream.pipe === "function" && typeof stream._read === "function" && typeof stream._readableState === "object" && stream.readable !== false;
+}
+var pipeline = promisify(nodePipeline);
+
+// src/factorydrive/local-file-system.storage.ts
+function handleError(err, location) {
+  switch (err.code) {
+    case "ENOENT": {
+      return new FileNotFoundException(err, location);
+    }
+    case "EPERM": {
+      return new PermissionMissingException(err, location);
+    }
+    default: {
+      return new UnknownException(err, err.code, location);
+    }
+  }
+}
+
+class LocalFileSystemStorage extends AbstractStorage {
+  $root;
+  constructor(config) {
+    super();
+    this.$root = resolve(config.root);
+  }
+  _fullPath(relativePath) {
+    return join(this.$root, join(sep, relativePath));
+  }
+  async append(location, content) {
+    try {
+      const result = await fse.appendFile(this._fullPath(location), content);
+      return { raw: result };
+    } catch (e) {
+      throw handleError(e, location);
+    }
+  }
+  async copy(src, dest) {
+    try {
+      const result = await fse.copy(this._fullPath(src), this._fullPath(dest));
+      return { raw: result };
+    } catch (e) {
+      throw handleError(e, `${src} -> ${dest}`);
+    }
+  }
+  async delete(location) {
+    try {
+      const result = await fse.unlink(this._fullPath(location));
+      return { raw: result, wasDeleted: true };
+    } catch (e) {
+      e = handleError(e, location);
+      if (e instanceof FileNotFoundException) {
+        return { raw: undefined, wasDeleted: false };
+      }
+      throw e;
+    }
+  }
+  driver() {
+    return fse;
+  }
+  async exists(location) {
+    try {
+      const result = await fse.pathExists(this._fullPath(location));
+      return { exists: result, raw: result };
+    } catch (e) {
+      throw handleError(e, location);
+    }
+  }
+  async get(location, encoding = "utf-8") {
+    try {
+      const result = await fse.readFile(this._fullPath(location), { encoding });
+      return { content: result.toString(), raw: result };
+    } catch (e) {
+      throw handleError(e, location);
+    }
+  }
+  async getBuffer(location) {
+    try {
+      const result = await fse.readFile(this._fullPath(location));
+      return { content: result, raw: result };
+    } catch (e) {
+      throw handleError(e, location);
+    }
+  }
+  async getStat(location) {
+    try {
+      const stat2 = await fse.stat(this._fullPath(location));
+      return {
+        size: stat2.size,
+        modified: stat2.mtime,
+        raw: stat2
+      };
+    } catch (e) {
+      throw handleError(e, location);
+    }
+  }
+  getStream(location) {
+    return new Promise((resolve2) => {
+      resolve2(fse.createReadStream(this._fullPath(location)));
+    });
+  }
+  async move(src, dest) {
+    try {
+      const result = await fse.move(this._fullPath(src), this._fullPath(dest));
+      return { raw: result };
+    } catch (e) {
+      throw handleError(e, `${src} -> ${dest}`);
+    }
+  }
+  async prepend(location, content) {
+    try {
+      const { content: actualContent } = await this.get(location, "utf-8");
+      return this.put(location, `${content}${actualContent}`);
+    } catch (e) {
+      if (e instanceof FileNotFoundException) {
+        return this.put(location, content);
+      }
+      throw e;
+    }
+  }
+  async put(location, content) {
+    const fullPath = this._fullPath(location);
+    try {
+      if (isReadableStream(content)) {
+        const dir = dirname(fullPath);
+        await fse.ensureDir(dir);
+        const ws = fse.createWriteStream(fullPath);
+        await pipeline(content, ws);
+        return { raw: undefined };
+      }
+      const result = await fse.outputFile(fullPath, content);
+      return { raw: result };
+    } catch (e) {
+      throw handleError(e, location);
+    }
+  }
+  flatList(prefix = "") {
+    const fullPrefix = this._fullPath(prefix);
+    return this._flatDirIterator(fullPrefix, prefix);
+  }
+  async* _flatDirIterator(prefix, originalPrefix) {
+    const prefixDirectory = prefix[prefix.length - 1] === sep ? prefix : dirname(prefix);
+    try {
+      const dir = await fs.opendir(prefixDirectory);
+      for await (const file of dir) {
+        const fileName = join(prefixDirectory, file.name);
+        if (fileName.startsWith(prefix)) {
+          if (file.isDirectory()) {
+            yield* this._flatDirIterator(join(fileName, sep), originalPrefix);
+          } else if (file.isFile()) {
+            const path = relative(this.$root, fileName);
+            yield {
+              raw: null,
+              path
+            };
+          }
+        }
+      }
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        throw handleError(e, originalPrefix);
+      }
+    }
+  }
+}
+
+// src/factorydrive/storage.manager.ts
+import { Logger } from "@nestjs/common";
+
+class StorageManager {
+  logger = new Logger(StorageManager.name);
+  defaultDisk;
+  disksConfig;
+  _disks = new Map;
+  _drivers = new Map;
+  constructor(config) {
+    this.defaultDisk = config.default;
+    this.disksConfig = config.disks || {};
+    if (config.registerLocalDriver !== false) {
+      this.registerDriver("local", LocalFileSystemStorage);
+    }
+    this.logger.log("StorageManager initialized \uD83D\uDFE2");
+  }
+  getDisks() {
+    return this._disks;
+  }
+  getDrivers() {
+    return this._drivers;
+  }
+  async initDisks() {
+    for (const diskName of Object.keys(this.disksConfig)) {
+      const disk = this.disk(diskName);
+      this.logger.debug(`Initializing disk <${diskName}> \uD83D\uDCC0`);
+      if (typeof disk.onStorageInit === "function") {
+        await this.disk(diskName).onStorageInit();
+      }
+    }
+    this.logger.log("All disks initialized \uD83D\uDFE2");
+  }
+  disk(name) {
+    name = name || this.defaultDisk;
+    if (!name) {
+      throw InvalidConfigException.missingDiskName();
+    }
+    if (this._disks.has(name)) {
+      return this._disks.get(name);
+    }
+    const diskConfig = this.disksConfig[name];
+    if (!diskConfig) {
+      throw InvalidConfigException.missingDiskConfig(name);
+    }
+    if (!diskConfig.driver) {
+      throw InvalidConfigException.missingDiskDriver(name);
+    }
+    const Driver = this._drivers.get(diskConfig.driver);
+    if (!Driver) {
+      throw DriverNotSupportedException.driver(diskConfig.driver);
+    }
+    const disk = new Driver(diskConfig.config);
+    this._disks.set(name, disk);
+    return disk;
+  }
+  addDisk(name, config) {
+    if (this.disksConfig[name]) {
+      throw InvalidConfigException.duplicateDiskName(name);
+    }
+    this.disksConfig[name] = config;
+  }
+  registerDriver(name, driver) {
+    this._drivers.set(name, driver);
+    this.logger.debug(`Registered <${name}> driver \uD83D\uDE97`);
+  }
+}
+// src/factorydrive.module.ts
+import { Module as Module2 } from "@nestjs/common";
+
+// src/factorydrive.core-module.ts
+import { Global, Module } from "@nestjs/common";
+
+// src/factorydrive.service.ts
+import { Inject, Injectable } from "@nestjs/common";
+
+// src/factorydrive.constants.ts
+var FACTORYDRIVE_MODULE_OPTIONS_TOKEN = "FactorydriveModuleOptionsToken";
+
+// src/factorydrive.service.ts
+class FactorydriveService {
+  options;
+  storageManager;
+  constructor(options) {
+    this.options = options;
+    this.storageManager = new StorageManager(options);
+  }
+  async onModuleInit() {
+    await this.storageManager.initDisks();
+  }
+  getDisk(name) {
+    return this.storageManager.disk(name);
+  }
+  registerDriver(name, driver) {
+    this.storageManager.registerDriver(name, driver);
+  }
+}
+FactorydriveService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(FACTORYDRIVE_MODULE_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof StorageManagerConfig === "undefined" ? Object : StorageManagerConfig
+  ])
+], FactorydriveService);
+
+// src/factorydrive.core-module.ts
+class FactorydriveCoreModule {
+  constructor() {}
+  static forRoot(options) {
+    const storageModuleOptions = {
+      provide: FACTORYDRIVE_MODULE_OPTIONS_TOKEN,
+      useValue: options
+    };
+    return {
+      module: FactorydriveCoreModule,
+      providers: [storageModuleOptions, FactorydriveService],
+      exports: [FactorydriveService]
+    };
+  }
+  static forRootAsync(options) {
+    const asyncProviders = this.createAsyncProviders(options);
+    return {
+      module: FactorydriveCoreModule,
+      imports: options.imports,
+      providers: [...asyncProviders, FactorydriveService],
+      exports: [FactorydriveService]
+    };
+  }
+  static createAsyncProviders(options) {
+    if (options.useFactory)
+      return [this.createAsyncOptionsProvider(options)];
+    const useClass = options.useClass;
+    return [
+      this.createAsyncOptionsProvider(options),
+      {
+        provide: useClass,
+        useClass
+      }
+    ];
+  }
+  static createAsyncOptionsProvider(options) {
+    if (options.useFactory) {
+      return {
+        provide: FACTORYDRIVE_MODULE_OPTIONS_TOKEN,
+        useFactory: options.useFactory,
+        inject: options.inject || []
+      };
+    }
+    const inject = [options.useClass];
+    return {
+      provide: FACTORYDRIVE_MODULE_OPTIONS_TOKEN,
+      useFactory: async (optionsFactory) => optionsFactory.createFactorydriveModuleOptions(),
+      inject
+    };
+  }
+}
+FactorydriveCoreModule = __legacyDecorateClassTS([
+  Global(),
+  Module({}),
+  __legacyMetadataTS("design:paramtypes", [])
+], FactorydriveCoreModule);
+
+// src/factorydrive.module.ts
+class FactorydriveModule {
+  static forRoot(options) {
+    return {
+      module: FactorydriveModule,
+      imports: [FactorydriveCoreModule.forRoot(options)]
+    };
+  }
+  static forRootAsync(options) {
+    return {
+      module: FactorydriveModule,
+      imports: [FactorydriveCoreModule.forRootAsync(options)]
+    };
+  }
+}
+FactorydriveModule = __legacyDecorateClassTS([
+  Module2({})
+], FactorydriveModule);
+export {
+  pipeline,
+  isReadableStream,
+  WrongKeyPathException,
+  UnknownException,
+  StorageManager,
+  PermissionMissingException,
+  NoSuchBucketException,
+  MethodNotSupportedException,
+  LocalFileSystemStorage,
+  InvalidConfigException,
+  FileNotFoundException,
+  FactorydriveService,
+  FactorydriveModule,
+  DriverNotSupportedException,
+  AuthorizationRequiredException,
+  AbstractStorage
+};

package/dist/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@tacxou/nestjs_module_factorydrive",
+  "version": "1.1.6",
+  "description": "Factory drive module for NestJS framework",
+  "repository": "https://github.com/tacxou/nestjs_module_factorydrive.git",
+  "author": "tacxou <12997062+tacxou@users.noreply.github.com> (https://github.com/tacxou)",
+  "contributors": [
+    {
+      "name": " tacxou",
+      "email": "12997062+tacxou@users.noreply.github.com",
+      "url": "https://github.com/tacxou"
+    },
+    {
+      "name": "Contributors",
+      "url": "https://github.com/tacxou/nestjs_module_factorydrive/graphs/contributors"
+    }
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "factory",
+    "node",
+    "nodejs",
+    "disk",
+    "driver",
+    "local",
+    "drive",
+    "abstract",
+    "abstraction",
+    "nestjs",
+    "storage",
+    "filesystem",
+    "file",
+    "promise",
+    "async",
+    "spaces",
+    "factorydrive"
+  ],
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --splitting --packages external",
+    "build:type": "tsc --emitDeclarationOnly",
+    "build:cpr": "cpr README.md dist/README.md && cpr LICENSE dist/LICENSE && cpr package.json dist/package.json",
+    "postbuild": "bun build:type && bun build:cpr",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:coverage": "bun test --coverage --coverage-reporter lcov"
+  },
+  "dependencies": {
+    "fs-extra": "^11.3.4",
+    "node-exceptions": "^4.0.1"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "@nestjs/common": "^11.1.16",
+    "@nestjs/core": "^11.1.16",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "latest",
+    "@types/bun": "latest",
+    "cpr": "^3.0.1",
+    "eslint": "^10.0.2",
+    "prettier": "^3.8.1",
+    "reflect-metadata": "^0.2.2",
+    "rimraf": "^6.1.3",
+    "rxjs": "^7.8.2",
+    "ts-node": "^10.9.2"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0 || ^11.0.0",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.0.0",
+    "bun": ">=1.0.0"
+  },
+  "packageManager": "bun@1.3.10"
+}