@blocklet/uploader-server 0.1.90 → 0.1.92

package/es/middlewares/dynamic-resource.d.ts

@@ -0,0 +1,31 @@
+export type DynamicResourcePath = {
+    path: string;
+    blacklist?: string[];
+    whitelist?: string[];
+};
+export type DynamicResourceOptions = {
+    componentDid?: string;
+    resourcePaths: DynamicResourcePath[];
+    watchOptions?: {
+        ignorePatterns?: string[];
+        persistent?: boolean;
+        usePolling?: boolean;
+        depth?: number;
+    };
+    cacheOptions?: {
+        maxAge?: string | number;
+        immutable?: boolean;
+        etag?: boolean;
+        lastModified?: boolean;
+    };
+    onFileChange?: (filePath: string, event: string) => void;
+    onReady?: (resourceCount: number) => void;
+    setHeaders?: (res: any, filePath: string, stat: any) => void;
+    conflictResolution?: 'first-match' | 'last-match' | 'error';
+};
+/**
+ * 创建动态资源中间件
+ */
+export declare function initDynamicResourceMiddleware(options: DynamicResourceOptions): ((req: any, res: any, next: Function) => any) & {
+    cleanup: () => void;
+};

package/es/middlewares/dynamic-resource.js

@@ -0,0 +1,266 @@
+import { join, basename } from "path";
+import { watch, existsSync, statSync } from "fs";
+import config from "@blocklet/sdk/lib/config";
+import {
+  logger,
+  calculateCacheControl,
+  serveResource,
+  scanDirectory,
+  getFileNameFromReq
+} from "../utils.js";
+import { globSync } from "glob";
+export function initDynamicResourceMiddleware(options) {
+  if (!options.resourcePaths || !options.resourcePaths.length) {
+    throw new Error("resourcePaths is required");
+  }
+  const dynamicResourceMap = /* @__PURE__ */ new Map();
+  const directoryPathConfigMap = /* @__PURE__ */ new Map();
+  let watchers = {};
+  const debounceMap = /* @__PURE__ */ new Map();
+  const DEBOUNCE_TIME = 300;
+  const cacheOptions = {
+    maxAge: "365d",
+    immutable: true,
+    ...options.cacheOptions
+  };
+  const { cacheControl, cacheControlImmutable } = calculateCacheControl(cacheOptions.maxAge, cacheOptions.immutable);
+  function shouldIncludeFile(filename, pathConfig) {
+    if (pathConfig.whitelist?.length && !pathConfig.whitelist.some((ext) => filename.endsWith(ext))) {
+      return false;
+    }
+    if (pathConfig.blacklist?.length && pathConfig.blacklist.some((ext) => filename.endsWith(ext))) {
+      return false;
+    }
+    return true;
+  }
+  function watchDirectory(directory, pathConfig, isParent = false) {
+    if (watchers[directory]) {
+      return watchers[directory];
+    }
+    try {
+      const watchOptions = {
+        persistent: options.watchOptions?.persistent !== false,
+        recursive: options.watchOptions?.depth !== void 0 ? false : true
+      };
+      directoryPathConfigMap.set(directory, pathConfig);
+      const watcher = watch(directory, watchOptions, (eventType, filename) => {
+        if (!filename) return;
+        if (options.watchOptions?.ignorePatterns?.some(
+          (pattern) => filename.startsWith(pattern) || new RegExp(pattern).test(filename)
+        )) {
+          return;
+        }
+        const fullPath = join(directory, filename);
+        if (isParent && eventType === "rename" && existsSync(fullPath)) {
+          try {
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+              const dirPattern = pathConfig.path.substring(pathConfig.path.indexOf("*"));
+              const regex = new RegExp(dirPattern.replace(/\*/g, ".*"));
+              if (regex.test(fullPath)) {
+                watchDirectory(fullPath, pathConfig);
+                if (debounceMap.has("scan")) {
+                  clearTimeout(debounceMap.get("scan"));
+                }
+                debounceMap.set(
+                  "scan",
+                  setTimeout(() => {
+                    scanDirectories();
+                    debounceMap.delete("scan");
+                  }, DEBOUNCE_TIME)
+                );
+              }
+            }
+          } catch (err) {
+          }
+          return;
+        }
+        if (eventType === "change" || eventType === "rename") {
+          const baseName = basename(filename);
+          const debounceKey = `${directory}:${baseName}`;
+          if (debounceMap.has(debounceKey)) {
+            clearTimeout(debounceMap.get(debounceKey));
+          }
+          debounceMap.set(
+            debounceKey,
+            setTimeout(() => {
+              processFileChange(directory, baseName, fullPath, eventType, pathConfig);
+              debounceMap.delete(debounceKey);
+            }, DEBOUNCE_TIME)
+          );
+        }
+      });
+      watchers[directory] = watcher;
+      return watcher;
+    } catch (err) {
+      logger.error(`Error watching directory ${directory}:`, err);
+      return null;
+    }
+  }
+  function processFileChange(directory, baseName, fullPath, eventType, pathConfig) {
+    if (existsSync(fullPath)) {
+      try {
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) return;
+        if (!shouldIncludeFile(baseName, pathConfig)) {
+          return;
+        }
+        try {
+          const resourceFile = scanDirectory(directory, {
+            whitelist: pathConfig.whitelist,
+            blacklist: pathConfig.blacklist,
+            originDir: directory
+          }).get(baseName);
+          if (resourceFile) {
+            let shouldAdd = true;
+            if (dynamicResourceMap.has(baseName) && options.conflictResolution) {
+              switch (options.conflictResolution) {
+                case "last-match":
+                  break;
+                case "error":
+                  logger.error(`Resource conflict: ${baseName} exists in multiple directories`);
+                  break;
+                case "first-match":
+                default:
+                  shouldAdd = false;
+                  break;
+              }
+            }
+            if (shouldAdd) {
+              dynamicResourceMap.set(baseName, resourceFile);
+              if (options.onFileChange) {
+                options.onFileChange(fullPath, eventType);
+              }
+              logger.debug(`Updated resource: ${baseName}`);
+            }
+          }
+        } catch (err) {
+          logger.debug(`Error updating resource for ${fullPath}:`, err);
+        }
+      } catch (err) {
+        logger.debug(`Error handling file change for ${fullPath}:`, err);
+      }
+    } else {
+      if (dynamicResourceMap.has(baseName)) {
+        dynamicResourceMap.delete(baseName);
+        if (options.onFileChange) {
+          options.onFileChange(fullPath, "delete");
+        }
+        logger.debug(`Removed resource: ${baseName}`);
+      }
+    }
+  }
+  async function scanDirectories() {
+    const initialSize = dynamicResourceMap.size;
+    for (const pathConfig of options.resourcePaths) {
+      try {
+        let directories = [];
+        if (pathConfig.path.includes("*")) {
+          try {
+            const pattern = pathConfig.path;
+            const parentDir = pathConfig.path.substring(0, pathConfig.path.indexOf("*")).replace(/\/+$/, "");
+            directories = globSync(pattern).filter((dir) => {
+              try {
+                return existsSync(dir) && statSync(dir).isDirectory();
+              } catch (err) {
+                return false;
+              }
+            });
+            try {
+              watchDirectory(parentDir, pathConfig, true);
+            } catch (err) {
+              logger.debug(`Error watching parent directory ${parentDir}:`, err);
+            }
+          } catch (err) {
+            logger.error(`Error finding directories for pattern ${pathConfig.path}:`, err);
+            const plainPath = pathConfig.path.replace(/\*/g, "");
+            if (existsSync(plainPath)) {
+              directories.push(plainPath);
+            }
+          }
+        } else {
+          if (existsSync(pathConfig.path)) {
+            directories.push(pathConfig.path);
+          }
+        }
+        let totalResources = 0;
+        for (const directory of directories) {
+          watchDirectory(directory, pathConfig);
+          const dirMap = scanDirectory(directory, {
+            whitelist: pathConfig.whitelist,
+            blacklist: pathConfig.blacklist,
+            originDir: directory
+          });
+          if (dirMap.size > 0) {
+            Array.from(dirMap.entries()).forEach(([key, value]) => {
+              if (dynamicResourceMap.has(key)) {
+                switch (options.conflictResolution) {
+                  case "last-match":
+                    dynamicResourceMap.set(key, value);
+                    break;
+                  case "error":
+                    logger.error(`Resource conflict: ${key} exists in multiple directories`);
+                    break;
+                  case "first-match":
+                  default:
+                    break;
+                }
+              } else {
+                dynamicResourceMap.set(key, value);
+                totalResources++;
+              }
+            });
+          }
+        }
+        if (totalResources > 0) {
+          logger.info(`Added ${totalResources} resources from ${pathConfig.path} pattern`);
+        }
+      } catch (err) {
+        logger.error(`Error scanning directories for path ${pathConfig.path}:`, err);
+      }
+    }
+    if ((dynamicResourceMap.size !== initialSize || initialSize === 0) && options.onReady) {
+      options.onReady(dynamicResourceMap.size);
+    }
+    return dynamicResourceMap;
+  }
+  function cleanup() {
+    debounceMap.forEach((timer) => clearTimeout(timer));
+    debounceMap.clear();
+    for (const key in watchers) {
+      try {
+        watchers[key].close();
+      } catch (err) {
+      }
+    }
+    watchers = {};
+    dynamicResourceMap.clear();
+    directoryPathConfigMap.clear();
+    logger.debug("Dynamic resource middleware cleaned up");
+  }
+  if (options.componentDid && config.env.componentDid !== options.componentDid) {
+    const emptyMiddleware = (req, res, next) => next();
+    return Object.assign(emptyMiddleware, { cleanup });
+  }
+  scanDirectories();
+  const middleware = (req, res, next) => {
+    const fileName = getFileNameFromReq(req);
+    try {
+      const resource = dynamicResourceMap.get(fileName);
+      if (resource) {
+        serveResource(req, res, next, resource, {
+          ...cacheOptions,
+          setHeaders: options.setHeaders,
+          cacheControl,
+          cacheControlImmutable
+        });
+      } else {
+        next();
+      }
+    } catch (error) {
+      logger.error("Error serving dynamic resource:", error);
+      next();
+    }
+  };
+  return Object.assign(middleware, { cleanup });
+}

package/es/middlewares/static-resource.d.ts

@@ -6,6 +6,5 @@ type initStaticResourceMiddlewareOptions = {
     skipRunningCheck?: boolean;
 };
 export declare const initStaticResourceMiddleware: ({ options, resourceTypes: _resourceTypes, express, skipRunningCheck: _skipRunningCheck, }?: initStaticResourceMiddlewareOptions) => (req: any, res: any, next: Function) => void;
-export declare const getCanUseResources: () => any;
 export declare const initProxyToMediaKitUploadsMiddleware: ({ options, express }?: any) => (req: any, res: any, next: Function) => Promise<any>;
 export {};

package/es/middlewares/static-resource.js

@@ -4,7 +4,14 @@ import config from "@blocklet/sdk/lib/config";
 import { getResources } from "@blocklet/sdk/lib/component";
 import joinUrl from "url-join";
 import component from "@blocklet/sdk/lib/component";
-import { setPDFDownloadHeader, logger } from "../utils.js";
+import {
+  setPDFDownloadHeader,
+  logger,
+  calculateCacheControl,
+  serveResource,
+  scanDirectory,
+  getFileNameFromReq
+} from "../utils.js";
 import { ImageBinDid } from "../constants.js";
 const ImgResourceType = "imgpack";
 let skipRunningCheck = false;
@@ -16,13 +23,14 @@ let resourceTypes = [
     // can be string or string[]
   }
 ];
-let canUseResources = [];
+let resourcesMap = /* @__PURE__ */ new Map();
 export const mappingResource = async () => {
   try {
     const resources = getResources({
       types: resourceTypes,
       skipRunningCheck
     });
+    let canUseResources = [];
     canUseResources = resources.map((resource) => {
       const originDir = resource.path;
       const resourceType = resourceTypes.find(({ type }) => originDir.endsWith(type));
@@ -38,11 +46,26 @@ export const mappingResource = async () => {
         blacklist: resourceType.blacklist
       }));
     }).filter(Boolean).flat();
-    logger.info(
-      "Mapping can use resources count: ",
-      canUseResources.length
-      // canUseResources
-    );
+    resourcesMap.clear();
+    for (const resource of canUseResources) {
+      const { dir, whitelist, blacklist, originDir, blockletInfo } = resource;
+      if (existsSync(dir)) {
+        try {
+          const dirResourceMap = scanDirectory(dir, {
+            whitelist,
+            blacklist,
+            originDir,
+            blockletInfo
+          });
+          for (const [key, value] of dirResourceMap.entries()) {
+            resourcesMap.set(key, value);
+          }
+        } catch (err) {
+          logger.error(`Error scanning directory ${dir}:`, err);
+        }
+      }
+    }
+    logger.info("Mapping resources: files count:", resourcesMap.size, "directories count:", canUseResources.length);
     return canUseResources;
   } catch (error) {
     logger.error(error);
@@ -56,12 +79,16 @@ events.on(Events.componentStarted, () => mappingResource());
 events.on(Events.componentStopped, () => mappingResource());
 events.on(Events.componentUpdated, () => mappingResource());
 export const initStaticResourceMiddleware = ({
-  options,
+  options = {},
   resourceTypes: _resourceTypes = resourceTypes,
   express,
   skipRunningCheck: _skipRunningCheck
 } = {}) => {
   skipRunningCheck = !!_skipRunningCheck;
+  const { cacheControl, cacheControlImmutable } = calculateCacheControl(
+    options.maxAge || "365d",
+    options.immutable !== false
+  );
   if (_resourceTypes?.length > 0) {
     resourceTypes = _resourceTypes.map((item) => {
       if (typeof item === "string") {
@@ -78,41 +105,24 @@ export const initStaticResourceMiddleware = ({
   }
   mappingResource();
   return (req, res, next) => {
-    const fileName = basename(req.path || req.url?.split("?")[0]);
+    const fileName = getFileNameFromReq(req);
     try {
-      const matchCanUseResourceItem = canUseResources.find((item) => {
-        const normalizedPath = join(item.dir, fileName);
-        if (!normalizedPath?.startsWith(item.dir)) {
-          return false;
-        }
-        if (!existsSync(normalizedPath)) {
-          return false;
-        }
-        const { whitelist, blacklist } = item;
-        if (whitelist?.length && !whitelist.some((ext) => fileName?.endsWith(ext))) {
-          return false;
-        }
-        if (blacklist?.length && blacklist.some((ext) => fileName?.endsWith(ext))) {
-          return false;
-        }
-        return true;
-      });
-      if (matchCanUseResourceItem) {
-        express.static(matchCanUseResourceItem.dir, {
-          maxAge: "365d",
-          immutable: true,
-          index: false,
-          ...options
-        })(req, res, next);
+      const resource = resourcesMap.get(fileName);
+      if (resource) {
+        serveResource(req, res, next, resource, {
+          ...options,
+          cacheControl,
+          cacheControlImmutable
+        });
       } else {
         next();
       }
     } catch (error) {
+      logger.error("Error serving static file:", error);
       next();
     }
   };
 };
-export const getCanUseResources = () => canUseResources;
 export const initProxyToMediaKitUploadsMiddleware = ({ options, express } = {}) => {
   return async (req, res, next) => {
     if (!component.getComponentWebEndpoint(ImageBinDid)) {

package/es/middlewares.d.ts

@@ -1,3 +1,4 @@
 export * from './middlewares/local-storage';
 export * from './middlewares/companion';
 export * from './middlewares/static-resource';
+export * from './middlewares/dynamic-resource';

package/es/middlewares.js

@@ -1,3 +1,4 @@
 export * from "./middlewares/local-storage.js";
 export * from "./middlewares/companion.js";
 export * from "./middlewares/static-resource.js";
+export * from "./middlewares/dynamic-resource.js";

package/es/utils.d.ts

@@ -25,4 +25,28 @@ export declare function uploadToMediaKit({ filePath, fileName, base64, extraComp
     extraComponentCallOptions?: CallComponentOptions;
 }): Promise<import("axios").AxiosResponse<import("http").IncomingMessage, any> | undefined>;
 export declare function getMediaKitFileStream(filePath: string): Promise<import("axios").AxiosResponse<import("http").IncomingMessage, any>>;
+export type ResourceFile = {
+    filePath: string;
+    dir: string;
+    originDir: string;
+    blockletInfo: any;
+    whitelist?: string[];
+    blacklist?: string[];
+    mtime: Date;
+    size: number;
+    contentType: string;
+};
+export declare function calculateCacheControl(maxAge?: string | number, immutable?: boolean): {
+    cacheControl: string;
+    cacheControlImmutable: string;
+    maxAgeInSeconds: number;
+};
+export declare function serveResource(req: any, res: any, next: Function, resource: ResourceFile, options?: any): void;
+export declare function scanDirectory(directory: string, options?: {
+    whitelist?: string[];
+    blacklist?: string[];
+    originDir?: string;
+    blockletInfo?: any;
+}): Map<string, ResourceFile>;
+export declare function getFileNameFromReq(req: any): any;
 export {};

package/es/utils.js

@@ -9,6 +9,10 @@ import crypto from "crypto";
 import { getSignData } from "@blocklet/sdk/lib/util/verify-sign";
 import FormData from "form-data";
 import omit from "lodash/omit";
+import ms from "ms";
+import mime from "mime-types";
+import { existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
 export let logger = console;
 if (process.env.BLOCKLET_LOG_DIR) {
   try {
@@ -175,3 +179,101 @@ export async function getMediaKitFileStream(filePath) {
   });
   return res;
 }
+export function calculateCacheControl(maxAge = "365d", immutable = true) {
+  let maxAgeInSeconds = 31536e3;
+  if (typeof maxAge === "string") {
+    try {
+      const milliseconds = ms(maxAge);
+      maxAgeInSeconds = typeof milliseconds === "number" ? milliseconds / 1e3 : 31536e3;
+    } catch (e) {
+      logger.warn(`Invalid maxAge format: ${maxAge}, using default 1 year (31536000 seconds)`);
+    }
+  } else {
+    maxAgeInSeconds = maxAge;
+  }
+  const cacheControl = `public, max-age=${maxAgeInSeconds}`;
+  const cacheControlImmutable = `${cacheControl}, immutable`;
+  return {
+    cacheControl,
+    cacheControlImmutable,
+    maxAgeInSeconds
+  };
+}
+export function serveResource(req, res, next, resource, options = {}) {
+  try {
+    res.setHeader("Content-Type", resource.contentType);
+    res.setHeader("Content-Length", resource.size);
+    res.setHeader("Last-Modified", resource.mtime.toUTCString());
+    const { cacheControl, cacheControlImmutable } = calculateCacheControl(
+      options.maxAge || "365d",
+      options.immutable !== false
+    );
+    res.setHeader("Cache-Control", options.immutable === false ? cacheControl : cacheControlImmutable);
+    if (options.setHeaders && typeof options.setHeaders === "function") {
+      const statObj = { mtime: resource.mtime, size: resource.size };
+      options.setHeaders(res, resource.filePath, statObj);
+    }
+    const ifModifiedSince = req.headers["if-modified-since"];
+    if (ifModifiedSince) {
+      const ifModifiedSinceDate = new Date(ifModifiedSince);
+      if (resource.mtime <= ifModifiedSinceDate) {
+        res.statusCode = 304;
+        res.end();
+        return;
+      }
+    }
+    const fileStream = createReadStream(resource.filePath);
+    fileStream.on("error", (error) => {
+      logger.error(`Error streaming file ${resource.filePath}:`, error);
+      next(error);
+    });
+    fileStream.pipe(res);
+  } catch (error) {
+    logger.error("Error serving static file:", error);
+    next(error);
+  }
+}
+export function scanDirectory(directory, options = {}) {
+  const resourceMap = /* @__PURE__ */ new Map();
+  if (!existsSync(directory)) {
+    return resourceMap;
+  }
+  try {
+    const files = readdirSync(directory);
+    for (const file of files) {
+      const filePath = join(directory, file);
+      let stat;
+      try {
+        stat = statSync(filePath);
+        if (stat.isDirectory()) continue;
+      } catch (e) {
+        continue;
+      }
+      if (options.whitelist?.length && !options.whitelist.some((ext) => file.endsWith(ext))) {
+        continue;
+      }
+      if (options.blacklist?.length && options.blacklist.some((ext) => file.endsWith(ext))) {
+        continue;
+      }
+      const contentType = mime.lookup(filePath) || "application/octet-stream";
+      resourceMap.set(file, {
+        filePath,
+        dir: directory,
+        originDir: options.originDir || directory,
+        blockletInfo: options.blockletInfo || {},
+        whitelist: options.whitelist,
+        blacklist: options.blacklist,
+        mtime: stat.mtime,
+        size: stat.size,
+        contentType
+      });
+    }
+  } catch (err) {
+    logger.error(`Error scanning directory ${directory}:`, err);
+  }
+  return resourceMap;
+}
+export function getFileNameFromReq(req) {
+  const pathname = req.path || req.url?.split("?")[0];
+  return path.basename(decodeURIComponent(pathname || ""));
+}

package/lib/middlewares/dynamic-resource.d.ts

@@ -0,0 +1,31 @@
+export type DynamicResourcePath = {
+    path: string;
+    blacklist?: string[];
+    whitelist?: string[];
+};
+export type DynamicResourceOptions = {
+    componentDid?: string;
+    resourcePaths: DynamicResourcePath[];
+    watchOptions?: {
+        ignorePatterns?: string[];
+        persistent?: boolean;
+        usePolling?: boolean;
+        depth?: number;
+    };
+    cacheOptions?: {
+        maxAge?: string | number;
+        immutable?: boolean;
+        etag?: boolean;
+        lastModified?: boolean;
+    };
+    onFileChange?: (filePath: string, event: string) => void;
+    onReady?: (resourceCount: number) => void;
+    setHeaders?: (res: any, filePath: string, stat: any) => void;
+    conflictResolution?: 'first-match' | 'last-match' | 'error';
+};
+/**
+ * 创建动态资源中间件
+ */
+export declare function initDynamicResourceMiddleware(options: DynamicResourceOptions): ((req: any, res: any, next: Function) => any) & {
+    cleanup: () => void;
+};

package/lib/middlewares/dynamic-resource.js

@@ -0,0 +1,264 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initDynamicResourceMiddleware = initDynamicResourceMiddleware;
+var _path = require("path");
+var _fs = require("fs");
+var _config = _interopRequireDefault(require("@blocklet/sdk/lib/config"));
+var _utils = require("../utils");
+var _glob = require("glob");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function initDynamicResourceMiddleware(options) {
+  if (!options.resourcePaths || !options.resourcePaths.length) {
+    throw new Error("resourcePaths is required");
+  }
+  const dynamicResourceMap = /* @__PURE__ */new Map();
+  const directoryPathConfigMap = /* @__PURE__ */new Map();
+  let watchers = {};
+  const debounceMap = /* @__PURE__ */new Map();
+  const DEBOUNCE_TIME = 300;
+  const cacheOptions = {
+    maxAge: "365d",
+    immutable: true,
+    ...options.cacheOptions
+  };
+  const {
+    cacheControl,
+    cacheControlImmutable
+  } = (0, _utils.calculateCacheControl)(cacheOptions.maxAge, cacheOptions.immutable);
+  function shouldIncludeFile(filename, pathConfig) {
+    if (pathConfig.whitelist?.length && !pathConfig.whitelist.some(ext => filename.endsWith(ext))) {
+      return false;
+    }
+    if (pathConfig.blacklist?.length && pathConfig.blacklist.some(ext => filename.endsWith(ext))) {
+      return false;
+    }
+    return true;
+  }
+  function watchDirectory(directory, pathConfig, isParent = false) {
+    if (watchers[directory]) {
+      return watchers[directory];
+    }
+    try {
+      const watchOptions = {
+        persistent: options.watchOptions?.persistent !== false,
+        recursive: options.watchOptions?.depth !== void 0 ? false : true
+      };
+      directoryPathConfigMap.set(directory, pathConfig);
+      const watcher = (0, _fs.watch)(directory, watchOptions, (eventType, filename) => {
+        if (!filename) return;
+        if (options.watchOptions?.ignorePatterns?.some(pattern => filename.startsWith(pattern) || new RegExp(pattern).test(filename))) {
+          return;
+        }
+        const fullPath = (0, _path.join)(directory, filename);
+        if (isParent && eventType === "rename" && (0, _fs.existsSync)(fullPath)) {
+          try {
+            const stat = (0, _fs.statSync)(fullPath);
+            if (stat.isDirectory()) {
+              const dirPattern = pathConfig.path.substring(pathConfig.path.indexOf("*"));
+              const regex = new RegExp(dirPattern.replace(/\*/g, ".*"));
+              if (regex.test(fullPath)) {
+                watchDirectory(fullPath, pathConfig);
+                if (debounceMap.has("scan")) {
+                  clearTimeout(debounceMap.get("scan"));
+                }
+                debounceMap.set("scan", setTimeout(() => {
+                  scanDirectories();
+                  debounceMap.delete("scan");
+                }, DEBOUNCE_TIME));
+              }
+            }
+          } catch (err) {}
+          return;
+        }
+        if (eventType === "change" || eventType === "rename") {
+          const baseName = (0, _path.basename)(filename);
+          const debounceKey = `${directory}:${baseName}`;
+          if (debounceMap.has(debounceKey)) {
+            clearTimeout(debounceMap.get(debounceKey));
+          }
+          debounceMap.set(debounceKey, setTimeout(() => {
+            processFileChange(directory, baseName, fullPath, eventType, pathConfig);
+            debounceMap.delete(debounceKey);
+          }, DEBOUNCE_TIME));
+        }
+      });
+      watchers[directory] = watcher;
+      return watcher;
+    } catch (err) {
+      _utils.logger.error(`Error watching directory ${directory}:`, err);
+      return null;
+    }
+  }
+  function processFileChange(directory, baseName, fullPath, eventType, pathConfig) {
+    if ((0, _fs.existsSync)(fullPath)) {
+      try {
+        const stat = (0, _fs.statSync)(fullPath);
+        if (stat.isDirectory()) return;
+        if (!shouldIncludeFile(baseName, pathConfig)) {
+          return;
+        }
+        try {
+          const resourceFile = (0, _utils.scanDirectory)(directory, {
+            whitelist: pathConfig.whitelist,
+            blacklist: pathConfig.blacklist,
+            originDir: directory
+          }).get(baseName);
+          if (resourceFile) {
+            let shouldAdd = true;
+            if (dynamicResourceMap.has(baseName) && options.conflictResolution) {
+              switch (options.conflictResolution) {
+                case "last-match":
+                  break;
+                case "error":
+                  _utils.logger.error(`Resource conflict: ${baseName} exists in multiple directories`);
+                  break;
+                case "first-match":
+                default:
+                  shouldAdd = false;
+                  break;
+              }
+            }
+            if (shouldAdd) {
+              dynamicResourceMap.set(baseName, resourceFile);
+              if (options.onFileChange) {
+                options.onFileChange(fullPath, eventType);
+              }
+              _utils.logger.debug(`Updated resource: ${baseName}`);
+            }
+          }
+        } catch (err) {
+          _utils.logger.debug(`Error updating resource for ${fullPath}:`, err);
+        }
+      } catch (err) {
+        _utils.logger.debug(`Error handling file change for ${fullPath}:`, err);
+      }
+    } else {
+      if (dynamicResourceMap.has(baseName)) {
+        dynamicResourceMap.delete(baseName);
+        if (options.onFileChange) {
+          options.onFileChange(fullPath, "delete");
+        }
+        _utils.logger.debug(`Removed resource: ${baseName}`);
+      }
+    }
+  }
+  async function scanDirectories() {
+    const initialSize = dynamicResourceMap.size;
+    for (const pathConfig of options.resourcePaths) {
+      try {
+        let directories = [];
+        if (pathConfig.path.includes("*")) {
+          try {
+            const pattern = pathConfig.path;
+            const parentDir = pathConfig.path.substring(0, pathConfig.path.indexOf("*")).replace(/\/+$/, "");
+            directories = (0, _glob.globSync)(pattern).filter(dir => {
+              try {
+                return (0, _fs.existsSync)(dir) && (0, _fs.statSync)(dir).isDirectory();
+              } catch (err) {
+                return false;
+              }
+            });
+            try {
+              watchDirectory(parentDir, pathConfig, true);
+            } catch (err) {
+              _utils.logger.debug(`Error watching parent directory ${parentDir}:`, err);
+            }
+          } catch (err) {
+            _utils.logger.error(`Error finding directories for pattern ${pathConfig.path}:`, err);
+            const plainPath = pathConfig.path.replace(/\*/g, "");
+            if ((0, _fs.existsSync)(plainPath)) {
+              directories.push(plainPath);
+            }
+          }
+        } else {
+          if ((0, _fs.existsSync)(pathConfig.path)) {
+            directories.push(pathConfig.path);
+          }
+        }
+        let totalResources = 0;
+        for (const directory of directories) {
+          watchDirectory(directory, pathConfig);
+          const dirMap = (0, _utils.scanDirectory)(directory, {
+            whitelist: pathConfig.whitelist,
+            blacklist: pathConfig.blacklist,
+            originDir: directory
+          });
+          if (dirMap.size > 0) {
+            Array.from(dirMap.entries()).forEach(([key, value]) => {
+              if (dynamicResourceMap.has(key)) {
+                switch (options.conflictResolution) {
+                  case "last-match":
+                    dynamicResourceMap.set(key, value);
+                    break;
+                  case "error":
+                    _utils.logger.error(`Resource conflict: ${key} exists in multiple directories`);
+                    break;
+                  case "first-match":
+                  default:
+                    break;
+                }
+              } else {
+                dynamicResourceMap.set(key, value);
+                totalResources++;
+              }
+            });
+          }
+        }
+        if (totalResources > 0) {
+          _utils.logger.info(`Added ${totalResources} resources from ${pathConfig.path} pattern`);
+        }
+      } catch (err) {
+        _utils.logger.error(`Error scanning directories for path ${pathConfig.path}:`, err);
+      }
+    }
+    if ((dynamicResourceMap.size !== initialSize || initialSize === 0) && options.onReady) {
+      options.onReady(dynamicResourceMap.size);
+    }
+    return dynamicResourceMap;
+  }
+  function cleanup() {
+    debounceMap.forEach(timer => clearTimeout(timer));
+    debounceMap.clear();
+    for (const key in watchers) {
+      try {
+        watchers[key].close();
+      } catch (err) {}
+    }
+    watchers = {};
+    dynamicResourceMap.clear();
+    directoryPathConfigMap.clear();
+    _utils.logger.debug("Dynamic resource middleware cleaned up");
+  }
+  if (options.componentDid && _config.default.env.componentDid !== options.componentDid) {
+    const emptyMiddleware = (req, res, next) => next();
+    return Object.assign(emptyMiddleware, {
+      cleanup
+    });
+  }
+  scanDirectories();
+  const middleware = (req, res, next) => {
+    const fileName = (0, _utils.getFileNameFromReq)(req);
+    try {
+      const resource = dynamicResourceMap.get(fileName);
+      if (resource) {
+        (0, _utils.serveResource)(req, res, next, resource, {
+          ...cacheOptions,
+          setHeaders: options.setHeaders,
+          cacheControl,
+          cacheControlImmutable
+        });
+      } else {
+        next();
+      }
+    } catch (error) {
+      _utils.logger.error("Error serving dynamic resource:", error);
+      next();
+    }
+  };
+  return Object.assign(middleware, {
+    cleanup
+  });
+}

package/lib/middlewares/static-resource.d.ts

@@ -6,6 +6,5 @@ type initStaticResourceMiddlewareOptions = {
     skipRunningCheck?: boolean;
 };
 export declare const initStaticResourceMiddleware: ({ options, resourceTypes: _resourceTypes, express, skipRunningCheck: _skipRunningCheck, }?: initStaticResourceMiddlewareOptions) => (req: any, res: any, next: Function) => void;
-export declare const getCanUseResources: () => any;
 export declare const initProxyToMediaKitUploadsMiddleware: ({ options, express }?: any) => (req: any, res: any, next: Function) => Promise<any>;
 export {};

package/lib/middlewares/static-resource.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.mappingResource = exports.initStaticResourceMiddleware = exports.initProxyToMediaKitUploadsMiddleware = exports.getCanUseResources = void 0;
+exports.mappingResource = exports.initStaticResourceMiddleware = exports.initProxyToMediaKitUploadsMiddleware = void 0;
 var _fs = require("fs");
 var _path = require("path");
 var _config = _interopRequireDefault(require("@blocklet/sdk/lib/config"));
@@ -22,13 +22,14 @@ let resourceTypes = [{
   folder: ""
   // can be string or string[]
 }];
-let canUseResources = [];
+let resourcesMap = /* @__PURE__ */new Map();
 const mappingResource = async () => {
   try {
     const resources = (0, _component.getResources)({
       types: resourceTypes,
       skipRunningCheck
     });
+    let canUseResources = [];
     canUseResources = resources.map(resource => {
       const originDir = resource.path;
       const resourceType = resourceTypes.find(({
@@ -46,9 +47,32 @@ const mappingResource = async () => {
         blacklist: resourceType.blacklist
       }));
     }).filter(Boolean).flat();
-    _utils.logger.info("Mapping can use resources count: ", canUseResources.length
-    // canUseResources
-    );
+    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);
@@ -66,12 +90,16 @@ events.on(Events.componentStarted, () => mappingResource());
 events.on(Events.componentStopped, () => mappingResource());
 events.on(Events.componentUpdated, () => mappingResource());
 const initStaticResourceMiddleware = ({
-  options,
+  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") {
@@ -88,46 +116,25 @@ const initStaticResourceMiddleware = ({
   }
   mappingResource();
   return (req, res, next) => {
-    const fileName = (0, _path.basename)(req.path || req.url?.split("?")[0]);
+    const fileName = (0, _utils.getFileNameFromReq)(req);
     try {
-      const matchCanUseResourceItem = canUseResources.find(item => {
-        const normalizedPath = (0, _path.join)(item.dir, fileName);
-        if (!normalizedPath?.startsWith(item.dir)) {
-          return false;
-        }
-        if (!(0, _fs.existsSync)(normalizedPath)) {
-          return false;
-        }
-        const {
-          whitelist,
-          blacklist
-        } = item;
-        if (whitelist?.length && !whitelist.some(ext => fileName?.endsWith(ext))) {
-          return false;
-        }
-        if (blacklist?.length && blacklist.some(ext => fileName?.endsWith(ext))) {
-          return false;
-        }
-        return true;
-      });
-      if (matchCanUseResourceItem) {
-        express.static(matchCanUseResourceItem.dir, {
-          maxAge: "365d",
-          immutable: true,
-          index: false,
-          ...options
-        })(req, res, next);
+      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 getCanUseResources = () => canUseResources;
-exports.getCanUseResources = getCanUseResources;
 const initProxyToMediaKitUploadsMiddleware = ({
   options,
   express

package/lib/middlewares.d.ts

@@ -1,3 +1,4 @@
 export * from './middlewares/local-storage';
 export * from './middlewares/companion';
 export * from './middlewares/static-resource';
+export * from './middlewares/dynamic-resource';

package/lib/middlewares.js

@@ -35,4 +35,15 @@ Object.keys(_staticResource).forEach(function (key) {
       return _staticResource[key];
     }
   });
+});
+var _dynamicResource = require("./middlewares/dynamic-resource");
+Object.keys(_dynamicResource).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _dynamicResource[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _dynamicResource[key];
+    }
+  });
 });

package/lib/utils.d.ts

@@ -25,4 +25,28 @@ export declare function uploadToMediaKit({ filePath, fileName, base64, extraComp
     extraComponentCallOptions?: CallComponentOptions;
 }): Promise<import("axios").AxiosResponse<import("http").IncomingMessage, any> | undefined>;
 export declare function getMediaKitFileStream(filePath: string): Promise<import("axios").AxiosResponse<import("http").IncomingMessage, any>>;
+export type ResourceFile = {
+    filePath: string;
+    dir: string;
+    originDir: string;
+    blockletInfo: any;
+    whitelist?: string[];
+    blacklist?: string[];
+    mtime: Date;
+    size: number;
+    contentType: string;
+};
+export declare function calculateCacheControl(maxAge?: string | number, immutable?: boolean): {
+    cacheControl: string;
+    cacheControlImmutable: string;
+    maxAgeInSeconds: number;
+};
+export declare function serveResource(req: any, res: any, next: Function, resource: ResourceFile, options?: any): void;
+export declare function scanDirectory(directory: string, options?: {
+    whitelist?: string[];
+    blacklist?: string[];
+    originDir?: string;
+    blockletInfo?: any;
+}): Map<string, ResourceFile>;
+export declare function getFileNameFromReq(req: any): any;
 export {};

package/lib/utils.js

@@ -3,16 +3,20 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.calculateCacheControl = calculateCacheControl;
 exports.checkTrustedReferer = checkTrustedReferer;
 exports.getFileHash = void 0;
+exports.getFileNameFromReq = getFileNameFromReq;
 exports.getMediaKitFileStream = getMediaKitFileStream;
 exports.getTrustedDomainsCache = getTrustedDomainsCache;
 exports.logger = void 0;
 exports.proxyImageDownload = proxyImageDownload;
+exports.scanDirectory = scanDirectory;
+exports.serveResource = serveResource;
 exports.setPDFDownloadHeader = setPDFDownloadHeader;
 exports.uploadToMediaKit = uploadToMediaKit;
 var _axios = _interopRequireDefault(require("axios"));
-var _path = _interopRequireDefault(require("path"));
+var _path = _interopRequireWildcard(require("path"));
 var _urlJoin = _interopRequireDefault(require("url-join"));
 var _isbot = require("isbot");
 var _component = _interopRequireDefault(require("@blocklet/sdk/lib/component"));
@@ -22,6 +26,10 @@ var _crypto = _interopRequireDefault(require("crypto"));
 var _verifySign = require("@blocklet/sdk/lib/util/verify-sign");
 var _formData = _interopRequireDefault(require("form-data"));
 var _omit = _interopRequireDefault(require("lodash/omit"));
+var _ms = _interopRequireDefault(require("ms"));
+var _mimeTypes = _interopRequireDefault(require("mime-types"));
+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 }; }
 let logger = exports.logger = console;
 if (process.env.BLOCKLET_LOG_DIR) {
@@ -191,4 +199,105 @@ async function getMediaKitFileStream(filePath) {
     method: "GET"
   });
   return res;
+}
+function calculateCacheControl(maxAge = "365d", immutable = true) {
+  let maxAgeInSeconds = 31536e3;
+  if (typeof maxAge === "string") {
+    try {
+      const milliseconds = (0, _ms.default)(maxAge);
+      maxAgeInSeconds = typeof milliseconds === "number" ? milliseconds / 1e3 : 31536e3;
+    } catch (e) {
+      logger.warn(`Invalid maxAge format: ${maxAge}, using default 1 year (31536000 seconds)`);
+    }
+  } else {
+    maxAgeInSeconds = maxAge;
+  }
+  const cacheControl = `public, max-age=${maxAgeInSeconds}`;
+  const cacheControlImmutable = `${cacheControl}, immutable`;
+  return {
+    cacheControl,
+    cacheControlImmutable,
+    maxAgeInSeconds
+  };
+}
+function serveResource(req, res, next, resource, options = {}) {
+  try {
+    res.setHeader("Content-Type", resource.contentType);
+    res.setHeader("Content-Length", resource.size);
+    res.setHeader("Last-Modified", resource.mtime.toUTCString());
+    const {
+      cacheControl,
+      cacheControlImmutable
+    } = calculateCacheControl(options.maxAge || "365d", options.immutable !== false);
+    res.setHeader("Cache-Control", options.immutable === false ? cacheControl : cacheControlImmutable);
+    if (options.setHeaders && typeof options.setHeaders === "function") {
+      const statObj = {
+        mtime: resource.mtime,
+        size: resource.size
+      };
+      options.setHeaders(res, resource.filePath, statObj);
+    }
+    const ifModifiedSince = req.headers["if-modified-since"];
+    if (ifModifiedSince) {
+      const ifModifiedSinceDate = new Date(ifModifiedSince);
+      if (resource.mtime <= ifModifiedSinceDate) {
+        res.statusCode = 304;
+        res.end();
+        return;
+      }
+    }
+    const fileStream = (0, _fs.createReadStream)(resource.filePath);
+    fileStream.on("error", error => {
+      logger.error(`Error streaming file ${resource.filePath}:`, error);
+      next(error);
+    });
+    fileStream.pipe(res);
+  } catch (error) {
+    logger.error("Error serving static file:", error);
+    next(error);
+  }
+}
+function scanDirectory(directory, options = {}) {
+  const resourceMap = /* @__PURE__ */new Map();
+  if (!(0, _fs.existsSync)(directory)) {
+    return resourceMap;
+  }
+  try {
+    const files = (0, _fs.readdirSync)(directory);
+    for (const file of files) {
+      const filePath = (0, _path.join)(directory, file);
+      let stat;
+      try {
+        stat = (0, _fs.statSync)(filePath);
+        if (stat.isDirectory()) continue;
+      } catch (e) {
+        continue;
+      }
+      if (options.whitelist?.length && !options.whitelist.some(ext => file.endsWith(ext))) {
+        continue;
+      }
+      if (options.blacklist?.length && options.blacklist.some(ext => file.endsWith(ext))) {
+        continue;
+      }
+      const contentType = _mimeTypes.default.lookup(filePath) || "application/octet-stream";
+      resourceMap.set(file, {
+        filePath,
+        dir: directory,
+        originDir: options.originDir || directory,
+        blockletInfo: options.blockletInfo || {},
+        whitelist: options.whitelist,
+        blacklist: options.blacklist,
+        mtime: stat.mtime,
+        size: stat.size,
+        contentType
+      });
+    }
+  } catch (err) {
+    logger.error(`Error scanning directory ${directory}:`, err);
+  }
+  return resourceMap;
+}
+function getFileNameFromReq(req) {
+  const pathname = req.path || req.url?.split("?")[0];
+  return _path.default.basename(decodeURIComponent(pathname || ""));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blocklet/uploader-server",
-  "version": "0.1.90",
+  "version": "0.1.92",
   "description": "blocklet upload server",
   "publishConfig": {
     "access": "public"
@@ -59,8 +59,10 @@
     "axios": "^1.7.8",
     "body-parser": "^1.20.3",
     "express-session": "1.17.3",
+    "glob": "^11.0.1",
     "isbot": "^5.1.17",
     "mime-types": "^2.1.35",
+    "ms": "^2.1.3",
     "p-queue": "6.6.2",
     "ufo": "^1.5.4",
     "url-join": "^4.0.1"