exodus-framework 2.0.9996 → 2.0.9998

package/lib/services/file/FileLibrary.d.ts

@@ -0,0 +1,25 @@
+import NodeCache from 'node-cache';
+import Service from '../../app/classes/service';
+import MimeType from './classes/Mimetyp';
+import { IMetaFile } from './contracts/meta';
+declare class FileLibraryService extends Service {
+    protected cache: NodeCache;
+    protected path: string;
+    protected mime: MimeType;
+    onServiceInit(): Promise<void>;
+    onStart(): Promise<boolean>;
+    private loadLibrary;
+    private migratePublicPath;
+    getFilePath(md5: string): string;
+    getUrlPath(md5: string): Promise<string>;
+    getFileBuffer(md5: string): Promise<Buffer>;
+    deleteFile(md5: string): Promise<boolean>;
+    getFileMeta(md5: string): Promise<IMetaFile>;
+    saveAndRegisterFile(filePath: string): Promise<string>;
+    saveAndRegisterBuffer(buffer: Buffer, originalName: string, ext: string): Promise<string>;
+    getMD5FromFile(filePath: string): Promise<string>;
+    getMD5FromBuffer(buffer: Buffer): string;
+    isCached(md5: string): boolean;
+}
+export default FileLibraryService;
+//# sourceMappingURL=FileLibrary.d.ts.map

package/lib/services/file/FileLibrary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileLibrary.d.ts","sourceRoot":"","sources":["../../../src/services/file/FileLibrary.ts"],"names":[],"mappings":"AAEA,OAAO,SAAS,MAAM,YAAY,CAAC;AAEnC,OAAO,OAAO,MAAM,2BAA2B,CAAC;AAChD,OAAO,QAAQ,MAAM,mBAAmB,CAAC;AAIzC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,cAAM,kBAAmB,SAAQ,OAAO;IACtC,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC;IAC3B,SAAS,CAAC,IAAI,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC;IAEZ,aAAa;IAQb,OAAO;YAMN,WAAW;YA2BX,iBAAiB;IAwBxB,WAAW,CAAC,GAAG,EAAE,MAAM;IAOjB,UAAU,CAAC,GAAG,EAAE,MAAM;IAO5B,aAAa,CAAC,GAAG,EAAE,MAAM;IAOnB,UAAU,CAAC,GAAG,EAAE,MAAM;IAWtB,WAAW,CAAC,GAAG,EAAE,MAAM;IAcvB,mBAAmB,CAAC,QAAQ,EAAE,MAAM;IAwCpC,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IA2B7E,cAAc,CAAC,QAAQ,EAAE,MAAM;IAW/B,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAMxC,QAAQ,CAAC,GAAG,EAAE,MAAM;CAG5B;AAED,eAAe,kBAAkB,CAAC"}

package/lib/services/file/FileLibrary.js

@@ -0,0 +1,179 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _crypto = require("crypto");
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+var _nodeCache = _interopRequireDefault(require("node-cache"));
+var _path = _interopRequireDefault(require("path"));
+var _service = _interopRequireDefault(require("../../app/classes/service"));
+var _Mimetyp = _interopRequireDefault(require("./classes/Mimetyp"));
+var _mimes = require("./constants/mimes");
+var _core = _interopRequireDefault(require("../../app/core"));
+var _FileCache = _interopRequireDefault(require("./classes/FileCache"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class FileLibraryService extends _service.default {
+  cache;
+  path;
+  mime;
+  async onServiceInit() {
+    this.cache = new _nodeCache.default();
+    this.mime = new _Mimetyp.default(_mimes.MimeStandardTypes, _mimes.MimeOtherTypes);
+    this.path = _path.default.resolve(_core.default.getSettings().getHttp().publicPath + '/library');
+    await _fsExtra.default.ensureDir(this.path);
+  }
+  async onStart() {
+    await this.loadLibrary();
+    await this.migratePublicPath(_core.default.getSettings().getHttp().publicPath);
+    return true;
+  }
+  async loadLibrary() {
+    const files = await _fsExtra.default.readdir(this.path);
+    this.log(`Carregando biblioteca de arquivos. Encontrados ${files.length} arquivos`, 'info');
+    for (const file of files) {
+      const filePath = _path.default.join(this.path, file);
+      const fileCache = new _FileCache.default(filePath);
+      await fileCache.onInit();
+      if (!fileCache.isValid()) {
+        this.log(`arquivo inválido. excluindo:${filePath}`, 'warning');
+        await _fsExtra.default.unlink(filePath);
+        continue;
+      }
+      if (this.cache.has(fileCache.getMD5())) {
+        this.log(`arquivo duplicado. excluindo:${filePath}, `, 'warning');
+        await _fsExtra.default.unlink(filePath);
+        continue;
+      }
+      this.cache.set(fileCache.getMD5(), fileCache);
+    }
+  }
+  async migratePublicPath(target) {
+    if (target == this.path) return;
+    const items = await _fsExtra.default.readdir(target);
+    for (const item of items) {
+      const itemPath = _path.default.join(target, item);
+      const stat = await _fsExtra.default.stat(itemPath);
+      if (stat.isDirectory()) {
+        this.migratePublicPath(itemPath);
+        continue;
+      }
+      const md5 = await this.getMD5FromFile(itemPath);
+      if (md5 && !this.cache.has(md5)) {
+        await this.saveAndRegisterFile(itemPath);
+      }
+      await _fsExtra.default.unlink(itemPath);
+    }
+  }
+  getFilePath(md5) {
+    const cachedFile = this.cache.get(md5);
+    if (!cachedFile) return null;
+    return cachedFile.getFilePath();
+  }
+  async getUrlPath(md5) {
+    const cachedFile = this.cache.get(md5);
+    if (!cachedFile) return null;
+    return cachedFile.getPublicUrl();
+  }
+  getFileBuffer(md5) {
+    const cachedFile = this.cache.get(md5);
+    if (!cachedFile) return null;
+    return cachedFile.getBuffer();
+  }
+  async deleteFile(md5) {
+    const cachedFile = this.cache.get(md5);
+    if (!cachedFile) return false;
+    await _fsExtra.default.unlink(cachedFile.getFilePath());
+    await _fsExtra.default.unlink(cachedFile.getMetaFilePath());
+    this.cache.del(md5);
+    return true;
+  }
+  async getFileMeta(md5) {
+    const cachedFile = this.cache.get(md5);
+    if (!cachedFile) return null;
+    return cachedFile.getMetadata();
+  }
+
+  /**
+   * Save a file to the library and register it in the cache
+   *
+   * @param {string} filePath
+   * @return {string} MD5 hash of the saved file
+   * @memberof FileLibraryService
+   */
+  async saveAndRegisterFile(filePath) {
+    const md5 = await this.getMD5FromFile(filePath);
+    if (!md5) throw new Error('Falha ao gerar o md5 do arquivo');
+    if (this.isCached(md5)) return;
+    const ext = this.mime.getExtension(filePath);
+    const newFilePath = _path.default.join(this.path, `${md5}.${ext}`);
+    const metaFilePath = _path.default.join(this.path, `${md5}.meta`);
+    await _fsExtra.default.move(filePath, newFilePath, {
+      overwrite: true
+    });
+    const metaData = {
+      originalName: _path.default.basename(newFilePath),
+      extension: ext,
+      size: (await _fsExtra.default.stat(newFilePath)).size,
+      md5,
+      cachedAt: new Date().toISOString()
+    };
+    await _fsExtra.default.writeJSON(metaFilePath, metaData, {
+      spaces: 2
+    });
+    const cachedFile = new _FileCache.default(metaFilePath);
+    await cachedFile.onInit();
+    this.cache.set(cachedFile.getMD5(), cachedFile);
+    return cachedFile.getMD5();
+  }
+
+  /**
+   * Save a file buffer to the library and register it in the cache
+   *
+   * @param {Buffer} buffer
+   * @param {string} originalName
+   * @param {string} ext
+   * @return {string} MD5 hash of the saved file
+   * @memberof FileLibraryService
+   */
+  async saveAndRegisterBuffer(buffer, originalName, ext) {
+    const md5 = this.getMD5FromBuffer(buffer);
+    if (!md5) throw new Error('Falha ao gerar o md5 do arquivo');
+    const newFilePath = _path.default.join(this.path, `${md5}${ext}`);
+    const metaFilePath = _path.default.join(this.path, `${md5}.meta`);
+    await _fsExtra.default.outputFile(newFilePath, buffer);
+    const metaData = {
+      originalName: originalName,
+      extension: ext,
+      size: (await _fsExtra.default.stat(newFilePath)).size,
+      md5,
+      cachedAt: new Date().toISOString()
+    };
+    await _fsExtra.default.writeJSON(metaFilePath, metaData, {
+      spaces: 2
+    });
+    const cachedFile = new _FileCache.default(metaFilePath);
+    await cachedFile.onInit();
+    this.cache.set(cachedFile.getMD5(), cachedFile);
+    return cachedFile.getMD5();
+  }
+  getMD5FromFile(filePath) {
+    return new Promise((resolve, reject) => {
+      const hash = (0, _crypto.createHash)('md5');
+      const stream = _fsExtra.default.createReadStream(filePath);
+      stream.on('data', dados => hash.update(dados));
+      stream.on('error', error => reject(error));
+      stream.on('end', () => resolve(hash.digest('hex')));
+    });
+  }
+  getMD5FromBuffer(buffer) {
+    const hash = (0, _crypto.createHash)('md5');
+    hash.update(buffer);
+    return hash.digest('hex');
+  }
+  isCached(md5) {
+    return this.cache.has(md5);
+  }
+}
+var _default = exports.default = FileLibraryService;

package/lib/services/file/classes/FileCache.d.ts

@@ -0,0 +1,26 @@
+import System from '../../../app/classes/system';
+import { IMetaFile } from '../contracts/meta';
+declare class FileCache extends System {
+    metaPath: string;
+    protected metadata: IMetaFile;
+    protected filePath: string;
+    protected valid: boolean;
+    constructor(metaPath: string);
+    onInit(): Promise<void>;
+    private loadFile;
+    private loadMetadata;
+    getMD5(): string;
+    getTitle(): string;
+    getExtension(): string;
+    getSize(): number;
+    getCachedAt(): string;
+    getFilePath(): string;
+    getMetaFilePath(): string;
+    getMetadata(): IMetaFile;
+    getBuffer(): Promise<Buffer>;
+    getCachedFileName(): string;
+    getPublicUrl(): string;
+    isValid(): boolean;
+}
+export default FileCache;
+//# sourceMappingURL=FileCache.d.ts.map

package/lib/services/file/classes/FileCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileCache.d.ts","sourceRoot":"","sources":["../../../../src/services/file/classes/FileCache.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,6BAA6B,CAAC;AAGjD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAG9C,cAAM,SAAU,SAAQ,MAAM;IAKT,QAAQ,EAAE,MAAM;IAJnC,SAAS,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC9B,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC;gBAEN,QAAQ,EAAE,MAAM;IAItB,MAAM;YAIL,QAAQ;YAiBR,YAAY;IAInB,MAAM;IAIN,QAAQ;IAIR,YAAY;IAIZ,OAAO;IAIP,WAAW;IAIX,WAAW;IAIX,eAAe;IAIf,WAAW;IAIX,SAAS;IAIT,iBAAiB;IAIjB,YAAY;IAIZ,OAAO;CAGf;AAED,eAAe,SAAS,CAAC"}

package/lib/services/file/classes/FileCache.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _system = _interopRequireDefault(require("../../../app/classes/system"));
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+var _path = _interopRequireDefault(require("path"));
+var _core = _interopRequireDefault(require("../../../app/core"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class FileCache extends _system.default {
+  metadata;
+  filePath;
+  valid;
+  constructor(metaPath) {
+    super();
+    this.metaPath = metaPath;
+  }
+  async onInit() {
+    this.valid = await this.loadFile();
+  }
+  async loadFile() {
+    const stat = await _fsExtra.default.stat(this.metaPath);
+    if (!stat.isFile()) return false;
+    await this.loadMetadata();
+    const hasFile = await _fsExtra.default.exists(this.getFilePath());
+    if (!hasFile) return false;
+    this.filePath = _path.default.resolve(_core.default.getSettings().getHttp().publicPath + '/library', this.getCachedFileName());
+    return true;
+  }
+  async loadMetadata() {
+    this.metadata = await _fsExtra.default.readJSON(this.metaPath, {
+      throws: false
+    });
+  }
+  getMD5() {
+    return this.metadata.md5;
+  }
+  getTitle() {
+    return this.metadata.originalName;
+  }
+  getExtension() {
+    return this.metadata.extension;
+  }
+  getSize() {
+    return this.metadata.size;
+  }
+  getCachedAt() {
+    return this.metadata.cachedAt;
+  }
+  getFilePath() {
+    return this.filePath;
+  }
+  getMetaFilePath() {
+    return this.metaPath;
+  }
+  getMetadata() {
+    return this.metadata;
+  }
+  getBuffer() {
+    return _fsExtra.default.readFile(this.filePath);
+  }
+  getCachedFileName() {
+    return `${this.getMD5()}.${this.getExtension()}`;
+  }
+  getPublicUrl() {
+    return '/public/library/' + this.getCachedFileName();
+  }
+  isValid() {
+    return this.valid;
+  }
+}
+var _default = exports.default = FileCache;

package/lib/services/file/classes/Mimetyp.d.ts

@@ -0,0 +1,20 @@
+type TypeMap = {
+    [key: string]: string[];
+};
+declare class MimeType {
+    extensionToType: Map<string, string>;
+    typeToExtension: Map<string, string>;
+    typeToExtensions: Map<string, Set<string>>;
+    constructor(...args: TypeMap[]);
+    define(typeMap: TypeMap, force?: boolean): this;
+    getType(path: string): string;
+    getExtension(type: string): string;
+    getAllExtensions(type: string): Set<string>;
+    _freeze(): this;
+    _getTestState(): {
+        types: Map<string, string>;
+        extensions: Map<string, string>;
+    };
+}
+export default MimeType;
+//# sourceMappingURL=Mimetyp.d.ts.map

package/lib/services/file/classes/Mimetyp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mimetyp.d.ts","sourceRoot":"","sources":["../../../../src/services/file/classes/Mimetyp.ts"],"names":[],"mappings":"AAAA,KAAK,OAAO,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAAE,CAAC;AAE3C,cAAM,QAAQ;IACZ,eAAe,sBAA6B;IAC5C,eAAe,sBAA6B;IAC5C,gBAAgB,2BAAkC;gBAEtC,GAAG,IAAI,EAAE,OAAO,EAAE;IAMvB,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,UAAQ;IA8CtC,OAAO,CAAC,IAAI,EAAE,MAAM;IAqBpB,YAAY,CAAC,IAAI,EAAE,MAAM;IAYzB,gBAAgB,CAAC,IAAI,EAAE,MAAM;IAUpC,OAAO;IAgBP,aAAa;;;;CAMd;AAED,eAAe,QAAQ,CAAC"}

package/lib/services/file/classes/Mimetyp.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class MimeType {
+  extensionToType = new Map();
+  typeToExtension = new Map();
+  typeToExtensions = new Map();
+  constructor(...args) {
+    for (const arg of args) {
+      this.define(arg);
+    }
+  }
+  define(typeMap, force = false) {
+    for (let [type, extensions] of Object.entries(typeMap)) {
+      // Lowercase thingz
+      type = type.toLowerCase();
+      extensions = extensions.map(ext => ext.toLowerCase());
+      if (!this.typeToExtensions.has(type)) {
+        this.typeToExtensions.set(type, new Set());
+      }
+      const allExtensions = this.typeToExtensions.get(type);
+      let first = true;
+      for (let extension of extensions) {
+        const starred = extension.startsWith('*');
+        extension = starred ? extension.slice(1) : extension;
+
+        // Add to list of extensions for the type
+        allExtensions?.add(extension);
+        if (first) {
+          // Map type to default extension (first in list)
+          this.typeToExtension.set(type, extension);
+        }
+        first = false;
+
+        // Starred types are not eligible to be the default extension
+        if (starred) continue;
+
+        // Map extension to type
+        const currentType = this.extensionToType.get(extension);
+        if (currentType && currentType != type && !force) {
+          throw new Error(`"${type} -> ${extension}" conflicts with "${currentType} -> ${extension}". Pass \`force=true\` to override this definition.`);
+        }
+        this.extensionToType.set(extension, type);
+      }
+    }
+    return this;
+  }
+
+  /**
+   * Get mime type associated with an extension
+   */
+  getType(path) {
+    if (typeof path !== 'string') return null;
+
+    // Remove chars preceeding `/` or `\`
+    const last = path.replace(/^.*[/\\]/, '').toLowerCase();
+
+    // Remove chars preceeding '.'
+    const ext = last.replace(/^.*\./, '').toLowerCase();
+    const hasPath = last.length < path.length;
+    const hasDot = ext.length < last.length - 1;
+
+    // Extension-less file?
+    if (!hasDot && hasPath) return null;
+    return this.extensionToType.get(ext) ?? null;
+  }
+
+  /**
+   * Get default file extension associated with a mime type
+   */
+  getExtension(type) {
+    if (typeof type !== 'string') return null;
+
+    // Remove http header parameter(s) (specifically, charset)
+    type = type?.split?.(';')[0];
+    return (type && this.typeToExtension.get(type.trim().toLowerCase())) ?? null;
+  }
+
+  /**
+   * Get all file extensions associated with a mime type
+   */
+  getAllExtensions(type) {
+    if (typeof type !== 'string') return null;
+    return this.typeToExtensions.get(type.toLowerCase()) ?? null;
+  }
+
+  //
+  // Private API, for internal use only.  These APIs may change at any time
+  //
+
+  _freeze() {
+    this.define = () => {
+      throw new Error('define() not allowed for built-in Mime objects. See https://github.com/broofa/mime/blob/main/README.md#custom-mime-instances');
+    };
+    Object.freeze(this);
+    for (const extensions of this.typeToExtensions.values()) {
+      Object.freeze(extensions);
+    }
+    return this;
+  }
+  _getTestState() {
+    return {
+      types: this.extensionToType,
+      extensions: this.typeToExtension
+    };
+  }
+}
+var _default = exports.default = MimeType;

package/lib/services/file/constants/mimes.d.ts

@@ -0,0 +1,7 @@
+export declare const MimeOtherTypes: {
+    [key: string]: string[];
+};
+export declare const MimeStandardTypes: {
+    [key: string]: string[];
+};
+//# sourceMappingURL=mimes.d.ts.map

package/lib/services/file/constants/mimes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mimes.d.ts","sourceRoot":"","sources":["../../../../src/services/file/constants/mimes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAupBrD,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CA8VxD,CAAC"}