@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-ZNH6NR3H.cjs

@@ -0,0 +1,462 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkLQNW3ABPcjs = require('./chunk-LQNW3ABP.cjs');
+
+
+var _chunk5DX3O6TTcjs = require('./chunk-5DX3O6TT.cjs');
+
+
+var _chunkLNVGXUL3cjs = require('./chunk-LNVGXUL3.cjs');
+
+// src/middleware/chain.ts
+var DEFAULT_MEMORY_RATE_LIMIT_ENTRIES = 1e5;
+var UnsupportedRateLimitStorageError = class 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";
+  }
+};
+function memoryRateLimitStorage(options = {}) {
+  const maxEntries = _nullishCoalesce(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;
+  }
+  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);
+    }
+  }
+  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;
+    }
+  };
+}
+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;
+}
+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();
+  };
+}
+function requireRateLimitClientAddress(ctx) {
+  const address = _optionalChain([ctx, 'access', _ => _.request, 'access', _2 => _2.socket, 'optionalAccess', _3 => _3.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."
+  );
+}
+function assertAtomicRateLimitStorage(storage) {
+  if (!storage || typeof storage.increment !== "function") {
+    throw new UnsupportedRateLimitStorageError();
+  }
+}
+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."
+    );
+  }
+}
+function setRateLimitHeaders(ctx, limit, remaining, resetIn, windowSeconds) {
+  setMiddlewareResponseHeader(ctx, "RateLimit-Policy", `"farm";q=${limit};w=${windowSeconds}`);
+  setMiddlewareResponseHeader(ctx, "RateLimit", `"farm";r=${remaining};t=${resetIn}`);
+}
+function setMiddlewareResponseHeader(ctx, name, value) {
+  ctx.headers.set(name, value);
+  if (!ctx.response.headersSent && !ctx.response.writableEnded) {
+    ctx.response.setHeader(name, value);
+  }
+}
+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);
+}
+var MiddlewareChainImpl = class {
+  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 = async (ctx, next) => {
+      const shouldRun = typeof condition === "function" ? _chunk5DX3O6TTcjs.matchesMiddlewarePredicate.call(void 0, 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 = 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;
+        };
+        return executeNext();
+      }
+    };
+    this.handlers.push(conditionalMiddleware);
+    return this;
+  }
+  rateLimit(config) {
+    this.handlers.push(createRateLimitMiddleware(config));
+    return this;
+  }
+  redirect(source, destination, permanent = false) {
+    const redirectMiddleware = async (ctx, next) => {
+      const normalizedSource = this.normalizePattern(source);
+      if (matchPattern(normalizedSource, ctx.pathname)) {
+        ctx.redirect(destination, permanent ? 308 : 307);
+        return;
+      }
+      return next();
+    };
+    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 = 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();
+    };
+    this.handlers.push(rewriteMiddleware);
+    return this;
+  }
+  build() {
+    return {
+      handlers: this.handlers,
+      config: this.config
+    };
+  }
+};
+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
+  };
+}
+function middleware(basePath = "/") {
+  return new MiddlewareChainImpl(basePath);
+}
+
+// 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;
+}
+function getFromMiddleware(middleware2, key, defaultValue) {
+  if (!middleware2) {
+    return defaultValue;
+  }
+  const value = middleware2.data.get(key);
+  return value !== void 0 ? value : defaultValue;
+}
+function hasMiddlewareData(middleware2) {
+  if (!middleware2) return false;
+  return middleware2.data.size > 0;
+}
+
+// src/middleware/vite-plugin.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function getMiddlewareAppDirectory(root, srcDir) {
+  const sourceDirectory = _path2.default.join(root, srcDir);
+  const appDirectory = _path2.default.join(sourceDirectory, "app");
+  return _fs2.default.existsSync(appDirectory) ? appDirectory : sourceDirectory;
+}
+function farmMiddlewarePlugin(options = {}) {
+  const srcDir = _nullishCoalesce(options.srcDir, () => ( "src"));
+  let manager = null;
+  let discoveryComplete = false;
+  let discoveryPromise = null;
+  const discover = async (server) => {
+    const i18n = _chunkLNVGXUL3cjs.resolveFarmI18nConfig.call(void 0, false, {
+      root: server.config.root,
+      mode: server.config.mode === "production" ? "production" : "development",
+      basePath: _nullishCoalesce(options.basePath, () => ( "/"))
+    });
+    manager = new (0, _chunkLQNW3ABPcjs.MiddlewareManager)(
+      getMiddlewareAppDirectory(server.config.root, srcDir),
+      server,
+      options.middleware,
+      i18n,
+      void 0,
+      options.apiBasePath
+    );
+    await manager.discover();
+    discoveryComplete = true;
+  };
+  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 = 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;
+      };
+      server.__farmMiddleware__ = {
+        execute,
+        getMiddlewares: () => _nullishCoalesce(_optionalChain([manager, 'optionalAccess', _4 => _4.getMiddlewares, 'call', _5 => _5()]), () => ( [])),
+        isReady: () => discoveryComplete,
+        waitForDiscovery: () => discoveryPromise
+      };
+    },
+    async handleHotUpdate({ file, server, modules }) {
+      if (!/^middleware\.[tj]sx?$/.test(_path2.default.basename(file))) {
+        return;
+      }
+      for (const module of modules) {
+        server.moduleGraph.invalidateModule(module);
+      }
+      await _optionalChain([manager, 'optionalAccess', _6 => _6.reload, 'call', _7 => _7()]);
+      server.ws.send({ type: "full-reload", path: "*" });
+      return [];
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+exports.UnsupportedRateLimitStorageError = UnsupportedRateLimitStorageError; exports.memoryRateLimitStorage = memoryRateLimitStorage; exports.getRateLimitStatus = getRateLimitStatus; exports.middleware = middleware; exports.unwrapMiddleware = unwrapMiddleware; exports.getFromMiddleware = getFromMiddleware; exports.hasMiddlewareData = hasMiddlewareData; exports.farmMiddlewarePlugin = farmMiddlewarePlugin;

package/dist/chunk-ZNXTU4YH.mjs

@@ -0,0 +1,114 @@
+// src/nitro/mobile-client.ts
+import fs from "fs/promises";
+import path from "path";
+var FARM_MOBILE_CLIENT_ENTRY_NAME = "farm-mobile-client";
+var FARM_MOBILE_CLIENT_MANIFEST_FILE = "mobile-client.json";
+var HASHED_FILE = /-h[0-9a-f]{8,}\.[A-Za-z0-9]+$/;
+function isFarmContentHashedFile(file) {
+  return HASHED_FILE.test(file);
+}
+function manifestPath(buildDir) {
+  return path.join(buildDir, FARM_MOBILE_CLIENT_MANIFEST_FILE);
+}
+async function removeFarmMobileClientManifest(buildDir) {
+  await fs.rm(manifestPath(buildDir), { force: true });
+}
+function createFarmMobileClientManifestPlugin(options) {
+  return {
+    name: "farm-mobile-client-manifest",
+    enforce: "post",
+    async generateBundle(_output, bundle) {
+      const entry = Object.entries(bundle).find(
+        ([, output]) => output.type === "chunk" && output.isEntry && output.name === options.entryName
+      )?.[0];
+      const record = entry ? {
+        entry,
+        files: Object.keys(bundle).filter((file) => !file.endsWith(".css") && !file.endsWith(".map")).sort()
+      } : null;
+      await fs.mkdir(options.buildDir, { recursive: true });
+      await fs.writeFile(manifestPath(options.buildDir), JSON.stringify(record));
+    }
+  };
+}
+async function hasFarmMobileClientEntry(buildDir, clientOutputDir) {
+  let record = null;
+  try {
+    record = JSON.parse(await fs.readFile(manifestPath(buildDir), "utf8"));
+  } catch {
+    return false;
+  }
+  if (!record) return false;
+  return fs.stat(path.join(clientOutputDir, record.entry)).then(
+    (stat) => stat.isFile() && stat.size > 0,
+    () => false
+  );
+}
+function stylesheetUrls(css) {
+  const urls = [];
+  for (const match of css.matchAll(/url\(\s*(["']?)(\/[^"')?#]+)[^"')]*\1\s*\)/g)) {
+    urls.push(match[2]);
+  }
+  return urls;
+}
+async function finalizeFarmMobileClient(options) {
+  let record = null;
+  try {
+    record = JSON.parse(await fs.readFile(manifestPath(options.buildDir), "utf8"));
+  } catch {
+    return null;
+  }
+  if (!record) return null;
+  const mobileFiles = new Set(record.files);
+  const files = new Set(record.files.filter(isFarmContentHashedFile).map((file) => `/${file}`));
+  const stylesheetFile = options.stylesheet.replace(/^\/+/, "");
+  if (isFarmContentHashedFile(stylesheetFile)) {
+    files.add(`/${stylesheetFile}`);
+    const css = await fs.readFile(path.join(options.clientOutputDir, stylesheetFile), "utf8").catch(() => "");
+    for (const url of stylesheetUrls(css)) {
+      const file = url.replace(/^\/+/, "");
+      if (!isFarmContentHashedFile(file)) continue;
+      const exists = await fs.stat(path.join(options.clientOutputDir, file)).then(
+        (stat) => stat.isFile(),
+        () => false
+      );
+      if (exists) files.add(`/${file}`);
+    }
+  }
+  const manifest = {
+    version: 1,
+    webEntry: options.webEntry,
+    entry: `/${record.entry}`,
+    stylesheet: options.stylesheet,
+    files: [...files].sort()
+  };
+  await fs.writeFile(manifestPath(options.buildDir), `${JSON.stringify(manifest, null, 2)}
+`);
+  return {
+    webEntry: options.webEntry,
+    entry: manifest.entry,
+    webOnly: options.webFiles.filter((file) => !mobileFiles.has(file)).sort()
+  };
+}
+async function readFarmMobileClientManifest(buildDir) {
+  try {
+    const manifest = JSON.parse(await fs.readFile(manifestPath(buildDir), "utf8"));
+    return manifest && manifest.version === 1 ? manifest : null;
+  } catch {
+    return null;
+  }
+}
+function encodeFarmMobileShellClient(client) {
+  return JSON.stringify(JSON.stringify(client)).slice(1, -1).replace(/'/g, "\\u0027").replace(/`/g, "\\u0060").replace(/\$/g, "\\u0024").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+var FARM_MOBILE_SHELL_CLIENT_PLACEHOLDER = "__farm_mobile_shell_client__";
+
+export {
+  FARM_MOBILE_CLIENT_ENTRY_NAME,
+  removeFarmMobileClientManifest,
+  createFarmMobileClientManifestPlugin,
+  hasFarmMobileClientEntry,
+  finalizeFarmMobileClient,
+  readFarmMobileClientManifest,
+  encodeFarmMobileShellClient,
+  FARM_MOBILE_SHELL_CLIENT_PLACEHOLDER
+};