@blocklet/uploader-server 0.1.91 → 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.js

@@ -1,13 +1,18 @@
-import { existsSync, readdirSync, statSync, createReadStream } from "fs";
+import { existsSync } from "fs";
 import { join, basename } from "path";
 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 mime from "mime-types";
-import { setPDFDownloadHeader, logger } from "../utils.js";
+import {
+  setPDFDownloadHeader,
+  logger,
+  calculateCacheControl,
+  serveResource,
+  scanDirectory,
+  getFileNameFromReq
+} from "../utils.js";
 import { ImageBinDid } from "../constants.js";
-import ms from "ms";
 const ImgResourceType = "imgpack";
 let skipRunningCheck = false;
 let resourceTypes = [
@@ -46,34 +51,14 @@ export const mappingResource = async () => {
       const { dir, whitelist, blacklist, originDir, blockletInfo } = resource;
       if (existsSync(dir)) {
         try {
-          const files = readdirSync(dir);
-          for (const file of files) {
-            const filePath = join(dir, file);
-            let stat;
-            try {
-              stat = statSync(filePath);
-              if (stat.isDirectory()) continue;
-            } catch (e) {
-              continue;
-            }
-            if (whitelist?.length && !whitelist.some((ext) => file.endsWith(ext))) {
-              continue;
-            }
-            if (blacklist?.length && blacklist.some((ext) => file.endsWith(ext))) {
-              continue;
-            }
-            const contentType = mime.lookup(filePath) || "application/octet-stream";
-            resourcesMap.set(file, {
-              filePath,
-              dir,
-              originDir,
-              blockletInfo,
-              whitelist,
-              blacklist,
-              mtime: stat.mtime,
-              size: stat.size,
-              contentType
-            });
+          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);
@@ -100,20 +85,10 @@ export const initStaticResourceMiddleware = ({
   skipRunningCheck: _skipRunningCheck
 } = {}) => {
   skipRunningCheck = !!_skipRunningCheck;
-  let maxAgeInSeconds = 31536e3;
-  const maxAge = options.maxAge || "365d";
-  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`;
+  const { cacheControl, cacheControlImmutable } = calculateCacheControl(
+    options.maxAge || "365d",
+    options.immutable !== false
+  );
   if (_resourceTypes?.length > 0) {
     resourceTypes = _resourceTypes.map((item) => {
       if (typeof item === "string") {
@@ -130,33 +105,15 @@ export const initStaticResourceMiddleware = ({
   }
   mappingResource();
   return (req, res, next) => {
-    const fileName = basename(req.path || req.url?.split("?")[0]);
+    const fileName = getFileNameFromReq(req);
     try {
       const resource = resourcesMap.get(fileName);
       if (resource) {
-        res.setHeader("Content-Type", resource.contentType);
-        res.setHeader("Content-Length", resource.size);
-        res.setHeader("Last-Modified", resource.mtime.toUTCString());
-        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);
+        serveResource(req, res, next, resource, {
+          ...options,
+          cacheControl,
+          cacheControlImmutable
         });
-        fileStream.pipe(res);
       } else {
         next();
       }

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.js

@@ -9,10 +9,8 @@ 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 _mimeTypes = _interopRequireDefault(require("mime-types"));
 var _utils = require("../utils");
 var _constants = require("../constants");
-var _ms = _interopRequireDefault(require("ms"));
 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 }; }
@@ -60,34 +58,14 @@ const mappingResource = async () => {
       } = resource;
       if ((0, _fs.existsSync)(dir)) {
         try {
-          const files = (0, _fs.readdirSync)(dir);
-          for (const file of files) {
-            const filePath = (0, _path.join)(dir, file);
-            let stat;
-            try {
-              stat = (0, _fs.statSync)(filePath);
-              if (stat.isDirectory()) continue;
-            } catch (e) {
-              continue;
-            }
-            if (whitelist?.length && !whitelist.some(ext => file.endsWith(ext))) {
-              continue;
-            }
-            if (blacklist?.length && blacklist.some(ext => file.endsWith(ext))) {
-              continue;
-            }
-            const contentType = _mimeTypes.default.lookup(filePath) || "application/octet-stream";
-            resourcesMap.set(file, {
-              filePath,
-              dir,
-              originDir,
-              blockletInfo,
-              whitelist,
-              blacklist,
-              mtime: stat.mtime,
-              size: stat.size,
-              contentType
-            });
+          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);
@@ -118,20 +96,10 @@ const initStaticResourceMiddleware = ({
   skipRunningCheck: _skipRunningCheck
 } = {}) => {
   skipRunningCheck = !!_skipRunningCheck;
-  let maxAgeInSeconds = 31536e3;
-  const maxAge = options.maxAge || "365d";
-  if (typeof maxAge === "string") {
-    try {
-      const milliseconds = (0, _ms.default)(maxAge);
-      maxAgeInSeconds = typeof milliseconds === "number" ? milliseconds / 1e3 : 31536e3;
-    } catch (e) {
-      _utils.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`;
+  const {
+    cacheControl,
+    cacheControlImmutable
+  } = (0, _utils.calculateCacheControl)(options.maxAge || "365d", options.immutable !== false);
   if (_resourceTypes?.length > 0) {
     resourceTypes = _resourceTypes.map(item => {
       if (typeof item === "string") {
@@ -148,36 +116,15 @@ 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 resource = resourcesMap.get(fileName);
       if (resource) {
-        res.setHeader("Content-Type", resource.contentType);
-        res.setHeader("Content-Length", resource.size);
-        res.setHeader("Last-Modified", resource.mtime.toUTCString());
-        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 => {
-          _utils.logger.error(`Error streaming file ${resource.filePath}:`, error);
-          next(error);
+        (0, _utils.serveResource)(req, res, next, resource, {
+          ...options,
+          cacheControl,
+          cacheControlImmutable
         });
-        fileStream.pipe(res);
       } else {
         next();
       }

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.91",
+  "version": "0.1.92",
   "description": "blocklet upload server",
   "publishConfig": {
     "access": "public"
@@ -59,6 +59,7 @@
     "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",