@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-4KQDHTWX.mjs

@@ -1,487 +0,0 @@
-import {
-  MiddlewareManager
-} from "./chunk-HJ64F4GS.mjs";
-import {
-  matchesMiddlewarePredicate
-} from "./chunk-HKFBMHCD.mjs";
-import {
-  resolveFarmI18nConfig
-} from "./chunk-BCMSYSN2.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/middleware/chain.ts
-var DEFAULT_MEMORY_RATE_LIMIT_ENTRIES = 1e5;
-var _UnsupportedRateLimitStorageError = class _UnsupportedRateLimitStorageError extends TypeError {
-  constructor() {
-    super(
-      "RateLimitStorage must implement atomic increment(key, windowMs). Legacy get/set adapters can lose increments under concurrency. Use memoryRateLimitStorage() for one process or redisRateLimitStorage() from @farm.js/cache-redis for production."
-    );
-    this.name = "UnsupportedRateLimitStorageError";
-  }
-};
-__name(_UnsupportedRateLimitStorageError, "UnsupportedRateLimitStorageError");
-var UnsupportedRateLimitStorageError = _UnsupportedRateLimitStorageError;
-function memoryRateLimitStorage(options = {}) {
-  const maxEntries = options.maxEntries ?? DEFAULT_MEMORY_RATE_LIMIT_ENTRIES;
-  if (!Number.isSafeInteger(maxEntries) || maxEntries <= 0) {
-    throw new TypeError("memoryRateLimitStorage maxEntries must be a positive safe integer.");
-  }
-  const records = /* @__PURE__ */ new Map();
-  let earliestExpiry = Infinity;
-  function read(key, now) {
-    const record = records.get(key);
-    if (!record) return null;
-    if (record.resetAt <= now) {
-      records.delete(key);
-      return null;
-    }
-    return record;
-  }
-  __name(read, "read");
-  function pruneExpired(now) {
-    if (now < earliestExpiry) return;
-    earliestExpiry = Infinity;
-    for (const [key, record] of records) {
-      if (record.resetAt <= now) records.delete(key);
-      else earliestExpiry = Math.min(earliestExpiry, record.resetAt);
-    }
-  }
-  __name(pruneExpired, "pruneExpired");
-  return {
-    increment(key, windowMs) {
-      if (!Number.isSafeInteger(windowMs) || windowMs <= 0) {
-        throw new TypeError("Rate-limit windowMs must be a positive safe integer.");
-      }
-      const now = Date.now();
-      const current = read(key, now);
-      if (current) {
-        current.count++;
-        return { ...current };
-      }
-      if (records.size >= maxEntries) pruneExpired(now);
-      if (records.size >= maxEntries) {
-        throw new Error(
-          `Process-local rate-limit storage reached its ${maxEntries} active-key capacity. Configure a shared production adapter or increase maxEntries.`
-        );
-      }
-      const next = { count: 1, resetAt: now + windowMs };
-      records.set(key, next);
-      earliestExpiry = Math.min(earliestExpiry, next.resetAt);
-      return { ...next };
-    },
-    get(key) {
-      const record = read(key, Date.now());
-      return record ? { ...record } : null;
-    }
-  };
-}
-__name(memoryRateLimitStorage, "memoryRateLimitStorage");
-var defaultRateLimitStorage = memoryRateLimitStorage();
-function parseTimeWindow(window) {
-  const match = window.match(/^(\d+)(ms|s|m|h|d)$/);
-  if (!match) throw new Error(`Invalid time window: ${window}`);
-  const [, amount, unit] = match;
-  const value = Number.parseInt(amount, 10);
-  const multipliers = {
-    ms: 1,
-    s: 1e3,
-    m: 60 * 1e3,
-    h: 60 * 60 * 1e3,
-    d: 24 * 60 * 60 * 1e3
-  };
-  const windowMs = value * multipliers[unit];
-  if (!Number.isSafeInteger(windowMs) || windowMs <= 0) {
-    throw new Error(`Invalid time window: ${window}`);
-  }
-  return windowMs;
-}
-__name(parseTimeWindow, "parseTimeWindow");
-function createRateLimitMiddleware(config) {
-  if (!Number.isSafeInteger(config.requests) || config.requests <= 0) {
-    throw new TypeError("Rate limit requests must be a positive safe integer.");
-  }
-  const windowMs = parseTimeWindow(config.window);
-  const storage = config.storage || defaultRateLimitStorage;
-  assertAtomicRateLimitStorage(storage);
-  return async (ctx, next) => {
-    const key = config.keyGenerator ? config.keyGenerator(ctx) : `${requireRateLimitClientAddress(ctx)}:${ctx.pathname}`;
-    const current = await storage.increment(key, windowMs);
-    assertRateLimitIncrementResult(current);
-    const now = Date.now();
-    const resetIn = Math.max(1, Math.ceil((current.resetAt - now) / 1e3));
-    const remaining = Math.max(0, config.requests - current.count);
-    setRateLimitHeaders(ctx, config.requests, remaining, resetIn, Math.ceil(windowMs / 1e3));
-    if (current.count > config.requests) {
-      setMiddlewareResponseHeader(ctx, "Retry-After", String(resetIn));
-      if (config.onLimit) {
-        const result = await config.onLimit(ctx);
-        if (result) return result;
-      }
-      ctx.json(
-        {
-          error: "Rate limit exceeded",
-          retryAfter: resetIn
-        },
-        429
-      );
-      return;
-    }
-    return next();
-  };
-}
-__name(createRateLimitMiddleware, "createRateLimitMiddleware");
-function requireRateLimitClientAddress(ctx) {
-  const address = ctx.request.socket?.remoteAddress;
-  if (address) return address;
-  throw new Error(
-    "Rate limiting could not identify the caller: this runtime reports no client address. Set `server.trustProxy` so a proxy's x-forwarded-for is trusted, or pass a `keyGenerator` that derives the bucket from something you do have, such as a session or an API key."
-  );
-}
-__name(requireRateLimitClientAddress, "requireRateLimitClientAddress");
-function assertAtomicRateLimitStorage(storage) {
-  if (!storage || typeof storage.increment !== "function") {
-    throw new UnsupportedRateLimitStorageError();
-  }
-}
-__name(assertAtomicRateLimitStorage, "assertAtomicRateLimitStorage");
-function assertRateLimitIncrementResult(result) {
-  if (!result || !Number.isSafeInteger(result.count) || result.count <= 0 || !Number.isFinite(result.resetAt) || result.resetAt <= 0) {
-    throw new TypeError(
-      "RateLimitStorage.increment() must return a positive integer count and a resetAt timestamp."
-    );
-  }
-}
-__name(assertRateLimitIncrementResult, "assertRateLimitIncrementResult");
-function setRateLimitHeaders(ctx, limit, remaining, resetIn, windowSeconds) {
-  setMiddlewareResponseHeader(ctx, "RateLimit-Policy", `"farm";q=${limit};w=${windowSeconds}`);
-  setMiddlewareResponseHeader(ctx, "RateLimit", `"farm";r=${remaining};t=${resetIn}`);
-}
-__name(setRateLimitHeaders, "setRateLimitHeaders");
-function setMiddlewareResponseHeader(ctx, name, value) {
-  ctx.headers.set(name, value);
-  if (!ctx.response.headersSent && !ctx.response.writableEnded) {
-    ctx.response.setHeader(name, value);
-  }
-}
-__name(setMiddlewareResponseHeader, "setMiddlewareResponseHeader");
-function matchPattern(pattern, pathname) {
-  if (pattern instanceof RegExp) {
-    return pattern.test(pathname);
-  }
-  const regexPattern = pattern.replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "__SINGLE_STAR__").replace(/[.+?^${}()|[\]\\/]/g, "\\$&").replace(/__DOUBLE_STAR__/g, ".*").replace(/__SINGLE_STAR__/g, "[^/]+");
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(pathname);
-}
-__name(matchPattern, "matchPattern");
-var _MiddlewareChainImpl = class _MiddlewareChainImpl {
-  constructor(basePath = "/") {
-    this.handlers = [];
-    this.basePath = basePath === "/" ? "/" : basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
-  }
-  /**
-   * Set the base path for this middleware chain (called by manager when loading)
-   */
-  setBasePath(path2) {
-    this.basePath = path2 === "/" ? "/" : path2.endsWith("/") ? path2.slice(0, -1) : path2;
-  }
-  use(fn) {
-    this.handlers.push(fn);
-    return this;
-  }
-  /**
-   * Normalize a path pattern - auto-scope to middleware route
-   * If middleware is in /contact, then "/api" becomes "/contact/api"
-   */
-  normalizePattern(pattern) {
-    if (this.basePath === "/") {
-      return pattern.startsWith("/") ? pattern : `/${pattern}`;
-    }
-    const cleanPattern = pattern.startsWith("/") ? pattern.slice(1) : pattern;
-    return `${this.basePath}/${cleanPattern}`;
-  }
-  /**
-   * Conditionally run middleware based on a condition.
-   * Only supports boolean values or functions that evaluate to boolean.
-   * Route-based string matching has been removed - use function conditions instead.
-   *
-   * @example
-   * .when(true, (ctx, next) => { ... })  // Always run
-   * .when((ctx) => ctx.data.get('flag'), (ctx, next) => { ... })  // Conditional
-   * .when((ctx) => ctx.pathname === '/contact', (ctx, next) => { ... })  // Path-based condition
-   */
-  when(condition, fn) {
-    const conditionalMiddleware = /* @__PURE__ */ __name(async (ctx, next) => {
-      const shouldRun = typeof condition === "function" ? matchesMiddlewarePredicate(condition, ctx) : condition;
-      if (!shouldRun) {
-        return next();
-      }
-      if (typeof fn === "function" && fn.length === 2) {
-        return fn(ctx, next);
-      } else {
-        const subChain = middleware(this.basePath);
-        fn(subChain);
-        const { handlers } = subChain.build();
-        let index = 0;
-        let returnedResponse;
-        const executeNext = /* @__PURE__ */ __name(async () => {
-          if (index < handlers.length) {
-            const handler = handlers[index++];
-            const result = await handler(ctx, executeNext);
-            if (result instanceof Response) {
-              returnedResponse = result;
-              return result;
-            }
-          } else {
-            const result = await next();
-            if (result instanceof Response) {
-              returnedResponse = result;
-              return result;
-            }
-          }
-          return returnedResponse;
-        }, "executeNext");
-        return executeNext();
-      }
-    }, "conditionalMiddleware");
-    this.handlers.push(conditionalMiddleware);
-    return this;
-  }
-  rateLimit(config) {
-    this.handlers.push(createRateLimitMiddleware(config));
-    return this;
-  }
-  redirect(source, destination, permanent = false) {
-    const redirectMiddleware = /* @__PURE__ */ __name(async (ctx, next) => {
-      const normalizedSource = this.normalizePattern(source);
-      if (matchPattern(normalizedSource, ctx.pathname)) {
-        ctx.redirect(destination, permanent ? 308 : 307);
-        return;
-      }
-      return next();
-    }, "redirectMiddleware");
-    this.handlers.push(redirectMiddleware);
-    return this;
-  }
-  /**
-   * Rewrite the current middleware route to a new destination.
-   * Since each middleware file is route-specific, the source is automatically
-   * the middleware's route, so you only need to specify the destination.
-   *
-   * @param destination - The destination path to rewrite to
-   * @param condition - Optional boolean or function that evaluates to boolean.
-   *                    If provided and evaluates to false, rewrite is skipped.
-   *                    If not provided, rewrite always happens.
-   *
-   * @example
-   * // In /contact/middleware.ts
-   * .rewrite('/about')  // Always rewrites /contact to /about
-   * .rewrite('/about', true)  // Always rewrites
-   * .rewrite('/about', false)  // Never rewrites
-   * .rewrite('/about', (ctx) => ctx.data.get('shouldRewrite'))  // Conditional rewrite
-   */
-  rewrite(destination, condition) {
-    const rewriteMiddleware = /* @__PURE__ */ __name(async (ctx, next) => {
-      if (condition !== void 0) {
-        const shouldRewrite = typeof condition === "function" ? condition(ctx) : condition;
-        if (!shouldRewrite) {
-          return next();
-        }
-      }
-      if (this.basePath !== "/") {
-        if (ctx.pathname === this.basePath) {
-          ctx.rewrite(destination);
-        } else if (ctx.pathname.startsWith(this.basePath + "/")) {
-          const subPath = ctx.pathname.slice(this.basePath.length);
-          const newPath = destination + subPath;
-          ctx.rewrite(newPath);
-        }
-      } else {
-        ctx.rewrite(destination);
-      }
-      return next();
-    }, "rewriteMiddleware");
-    this.handlers.push(rewriteMiddleware);
-    return this;
-  }
-  build() {
-    return {
-      handlers: this.handlers,
-      config: this.config
-    };
-  }
-};
-__name(_MiddlewareChainImpl, "MiddlewareChainImpl");
-var MiddlewareChainImpl = _MiddlewareChainImpl;
-async function getRateLimitStatus(key, limit, storage = defaultRateLimitStorage) {
-  if (!Number.isSafeInteger(limit) || limit <= 0) {
-    throw new TypeError("Rate limit must be a positive safe integer.");
-  }
-  assertAtomicRateLimitStorage(storage);
-  if (typeof storage.get !== "function") {
-    throw new TypeError(
-      "getRateLimitStatus() requires a RateLimitStorage adapter that implements get(key)."
-    );
-  }
-  const record = await storage.get(key);
-  if (!record) {
-    return {
-      requests: 0,
-      limit,
-      remaining: limit,
-      resetIn: null,
-      resetAt: null,
-      isLimited: false
-    };
-  }
-  assertRateLimitIncrementResult(record);
-  const now = Date.now();
-  if (record.resetAt && now > record.resetAt) {
-    return {
-      requests: 0,
-      limit,
-      remaining: limit,
-      resetIn: null,
-      resetAt: null,
-      isLimited: false
-    };
-  }
-  const requests = record.count || 0;
-  const remaining = Math.max(0, limit - requests);
-  const isLimited = requests >= limit;
-  let resetIn = null;
-  let resetAt = null;
-  if (record.resetAt) {
-    const remainingMs = record.resetAt - now;
-    resetIn = remainingMs > 0 ? Math.ceil(remainingMs / 1e3) : null;
-    resetAt = new Date(record.resetAt);
-  }
-  return {
-    requests,
-    limit,
-    remaining,
-    resetIn,
-    resetAt,
-    isLimited
-  };
-}
-__name(getRateLimitStatus, "getRateLimitStatus");
-function middleware(basePath = "/") {
-  return new MiddlewareChainImpl(basePath);
-}
-__name(middleware, "middleware");
-
-// src/middleware/helpers.ts
-function unwrapMiddleware(middleware2, defaults) {
-  if (!middleware2) {
-    return defaults || {};
-  }
-  const result = { ...defaults };
-  for (const [key, value] of middleware2.data) {
-    result[key] = value;
-  }
-  return result;
-}
-__name(unwrapMiddleware, "unwrapMiddleware");
-function getFromMiddleware(middleware2, key, defaultValue) {
-  if (!middleware2) {
-    return defaultValue;
-  }
-  const value = middleware2.data.get(key);
-  return value !== void 0 ? value : defaultValue;
-}
-__name(getFromMiddleware, "getFromMiddleware");
-function hasMiddlewareData(middleware2) {
-  if (!middleware2) return false;
-  return middleware2.data.size > 0;
-}
-__name(hasMiddlewareData, "hasMiddlewareData");
-
-// src/middleware/vite-plugin.ts
-import fs from "fs";
-import path from "path";
-function getMiddlewareAppDirectory(root, srcDir) {
-  const sourceDirectory = path.join(root, srcDir);
-  const appDirectory = path.join(sourceDirectory, "app");
-  return fs.existsSync(appDirectory) ? appDirectory : sourceDirectory;
-}
-__name(getMiddlewareAppDirectory, "getMiddlewareAppDirectory");
-function farmMiddlewarePlugin(options = {}) {
-  const srcDir = options.srcDir ?? "src";
-  let manager = null;
-  let discoveryComplete = false;
-  let discoveryPromise = null;
-  const discover = /* @__PURE__ */ __name(async (server) => {
-    const i18n = resolveFarmI18nConfig(false, {
-      root: server.config.root,
-      mode: server.config.mode === "production" ? "production" : "development",
-      basePath: options.basePath ?? "/"
-    });
-    manager = new MiddlewareManager(
-      getMiddlewareAppDirectory(server.config.root, srcDir),
-      server,
-      options.middleware,
-      i18n,
-      void 0,
-      options.apiBasePath
-    );
-    await manager.discover();
-    discoveryComplete = true;
-  }, "discover");
-  return {
-    name: "@farm.js/core:middleware",
-    enforce: "pre",
-    configureServer(server) {
-      discoveryPromise = discover(server);
-      void discoveryPromise.catch((error) => {
-        console.error("[FARM] Middleware discovery error:", error);
-      });
-      const execute = /* @__PURE__ */ __name(async (req, res, _pathname, sharedData) => {
-        if (discoveryPromise) {
-          await discoveryPromise;
-        }
-        if (!manager) {
-          return false;
-        }
-        const handled = await manager.execute(req, res);
-        const middlewareData = req.__FARM_MIDDLEWARE_DATA__;
-        if (sharedData && middlewareData instanceof Map) {
-          for (const [key, value] of middlewareData) {
-            sharedData.set(key, value);
-          }
-        }
-        return handled;
-      }, "execute");
-      server.__farmMiddleware__ = {
-        execute,
-        getMiddlewares: /* @__PURE__ */ __name(() => manager?.getMiddlewares() ?? [], "getMiddlewares"),
-        isReady: /* @__PURE__ */ __name(() => discoveryComplete, "isReady"),
-        waitForDiscovery: /* @__PURE__ */ __name(() => discoveryPromise, "waitForDiscovery")
-      };
-    },
-    async handleHotUpdate({ file, server, modules }) {
-      if (!/^middleware\.[tj]sx?$/.test(path.basename(file))) {
-        return;
-      }
-      for (const module of modules) {
-        server.moduleGraph.invalidateModule(module);
-      }
-      await manager?.reload();
-      server.ws.send({ type: "full-reload", path: "*" });
-      return [];
-    }
-  };
-}
-__name(farmMiddlewarePlugin, "farmMiddlewarePlugin");
-
-export {
-  UnsupportedRateLimitStorageError,
-  memoryRateLimitStorage,
-  getRateLimitStatus,
-  middleware,
-  unwrapMiddleware,
-  getFromMiddleware,
-  hasMiddlewareData,
-  farmMiddlewarePlugin
-};