@blocklet/uploader-server/lib/middlewares/static-resource.js

blocklet upload server

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.mappingResource = exports.initStaticResourceMiddleware = exports.initProxyToMediaKitUploadsMiddleware = exports.getCanUseResources = void 0;
var _fs = require("fs");
var _path = require("path");
var _config = _interopRequireDefault(require("@blocklet/sdk/lib/config"));
var _component = _interopRequireWildcard(require("@blocklet/sdk/lib/component"));
var _urlJoin = _interopRequireDefault(require("url-join"));
var _utils = require("../utils");
var _constants = require("../constants");
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const ImgResourceType = "imgpack";
let skipRunningCheck = false;
let resourceTypes = [{
  type: ImgResourceType,
  did: _constants.ImageBinDid,
  folder: ""
  // can be string or string[]
}];
let resourcesMap = /* @__PURE__ */new Map();
let canUseResources = [];
const getCanUseResources = () => canUseResources;
exports.getCanUseResources = getCanUseResources;
const mappingResource = async () => {
  try {
    const resources = (0, _component.getResources)({
      types: resourceTypes,
      skipRunningCheck
    });
    canUseResources = resources.map(resource => {
      const originDir = resource.path;
      const resourceType = resourceTypes.find(({
        type
      }) => originDir.endsWith(type));
      if (!(0, _fs.existsSync)(originDir) || !resourceType) {
        return false;
      }
      const folders = Array.isArray(resourceType.folder) ? resourceType.folder : [resourceType.folder || ""];
      return folders.map(folder => ({
        originDir,
        dir: (0, _path.join)(originDir, folder),
        blockletInfo: resource,
        whitelist: resourceType.whitelist,
        blacklist: resourceType.blacklist
      }));
    }).filter(Boolean).flat();
    resourcesMap.clear();
    for (const resource of canUseResources) {
      const {
        dir,
        whitelist,
        blacklist,
        originDir,
        blockletInfo
      } = resource;
      if ((0, _fs.existsSync)(dir)) {
        try {
          const dirResourceMap = (0, _utils.scanDirectory)(dir, {
            whitelist,
            blacklist,
            originDir,
            blockletInfo
          });
          for (const [key, value] of dirResourceMap.entries()) {
            resourcesMap.set(key, value);
          }
        } catch (err) {
          _utils.logger.error(`Error scanning directory ${dir}:`, err);
        }
      }
    }
    _utils.logger.info("Mapping resources: files count:", resourcesMap.size, "directories count:", canUseResources.length);
    return canUseResources;
  } catch (error) {
    _utils.logger.error(error);
  }
  return false;
};
exports.mappingResource = mappingResource;
const {
  events,
  Events
} = _config.default;
events.on(Events.componentAdded, () => mappingResource());
events.on(Events.componentRemoved, () => mappingResource());
events.on(Events.componentStarted, () => mappingResource());
events.on(Events.componentStopped, () => mappingResource());
events.on(Events.componentUpdated, () => mappingResource());
const initStaticResourceMiddleware = ({
  options = {},
  resourceTypes: _resourceTypes = resourceTypes,
  express,
  skipRunningCheck: _skipRunningCheck
} = {}) => {
  skipRunningCheck = !!_skipRunningCheck;
  const {
    cacheControl,
    cacheControlImmutable
  } = (0, _utils.calculateCacheControl)(options.maxAge || "365d", options.immutable !== false);
  if (_resourceTypes?.length > 0) {
    resourceTypes = _resourceTypes.map(item => {
      if (typeof item === "string") {
        return {
          type: item,
          did: _constants.ImageBinDid,
          // not set did, default is ImageBinDid
          folder: ""
          // not set folder, default is root
        };
      }
      return item;
    });
  }
  mappingResource();
  return (req, res, next) => {
    const fileName = (0, _utils.getFileNameFromReq)(req);
    try {
      const resource = resourcesMap.get(fileName);
      if (resource) {
        (0, _utils.serveResource)(req, res, next, resource, {
          ...options,
          cacheControl,
          cacheControlImmutable
        });
      } else {
        next();
      }
    } catch (error) {
      _utils.logger.error("Error serving static file:", error);
      next();
    }
  };
};
exports.initStaticResourceMiddleware = initStaticResourceMiddleware;
const initProxyToMediaKitUploadsMiddleware = ({
  options,
  express
} = {}) => {
  return async (req, res, next) => {
    if (!_component.default.getComponentWebEndpoint(_constants.ImageBinDid)) {
      return next();
    }
    (0, _utils.setPDFDownloadHeader)(req, res);
    try {
      const {
        data,
        status,
        headers
      } = await _component.default.call({
        name: _constants.ImageBinDid,
        path: (0, _urlJoin.default)("/uploads", (0, _path.basename)(req.url)),
        responseType: "stream",
        method: "GET"
      });
      if (data && status >= 200 && status < 400) {
        Object.keys(headers).forEach(key => {
          res.set(key, headers[key]);
        });
        data.on("error", err => {
          next();
        }).pipe(res).on("error", err => {
          next();
        });
      } else {
        next();
      }
    } catch (error) {
      next();
    }
  };
};
exports.initProxyToMediaKitUploadsMiddleware = initProxyToMediaKitUploadsMiddleware;