@farm.js/core 0.1.0-beta.4 → 0.1.0-beta.6

package/dist/chunk-MIUW47JX.mjs

@@ -1,639 +0,0 @@
-import {
-  normalizeMiddlewareModule
-} from "./chunk-P7QDS5AT.mjs";
-import {
-  sendWebResponse
-} from "./chunk-QGOHVJ6J.mjs";
-import {
-  logger
-} from "./chunk-J4FNJ5IU.mjs";
-import {
-  stripFarmLocaleFromPathname
-} from "./chunk-44ZCFSKE.mjs";
-import {
-  emitFarmEvent
-} from "./chunk-7ZY5AIJO.mjs";
-import {
-  __name,
-  __require
-} from "./chunk-CGILA3WO.mjs";
-
-// src/middleware/context.ts
-function parseCookies(cookieHeader) {
-  if (!cookieHeader) return {};
-  return cookieHeader.split(";").reduce(
-    (cookies, cookie) => {
-      const [name, ...rest] = cookie.split("=");
-      const value = rest.join("=").trim();
-      if (name && value) {
-        cookies[name.trim()] = decodeURIComponent(value);
-      }
-      return cookies;
-    },
-    {}
-  );
-}
-__name(parseCookies, "parseCookies");
-function serializeCookie(name, value, options = {}) {
-  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-  if (options.maxAge) {
-    cookie += `; Max-Age=${options.maxAge}`;
-  }
-  if (options.expires) {
-    cookie += `; Expires=${options.expires.toUTCString()}`;
-  }
-  if (options.path) {
-    cookie += `; Path=${options.path}`;
-  } else {
-    cookie += "; Path=/";
-  }
-  if (options.domain) {
-    cookie += `; Domain=${options.domain}`;
-  }
-  if (options.secure) {
-    cookie += "; Secure";
-  }
-  if (options.httpOnly) {
-    cookie += "; HttpOnly";
-  }
-  if (options.sameSite) {
-    cookie += `; SameSite=${options.sameSite.charAt(0).toUpperCase() + options.sameSite.slice(1)}`;
-  }
-  return cookie;
-}
-__name(serializeCookie, "serializeCookie");
-var _CookieJarImpl = class _CookieJarImpl {
-  constructor(req, res) {
-    this.req = req;
-    this.res = res;
-    this.setCookies = [];
-    this.cookies = parseCookies(req.headers.cookie);
-  }
-  get(name) {
-    return this.cookies[name];
-  }
-  set(name, value, options = {}) {
-    this.cookies[name] = value;
-    const cookieString = serializeCookie(name, value, options);
-    this.setCookies.push(cookieString);
-    this.res.setHeader("Set-Cookie", this.setCookies);
-  }
-  delete(name) {
-    delete this.cookies[name];
-    const cookieString = serializeCookie(name, "", {
-      maxAge: 0,
-      expires: /* @__PURE__ */ new Date(0)
-    });
-    this.setCookies.push(cookieString);
-    this.res.setHeader("Set-Cookie", this.setCookies);
-  }
-  getAll() {
-    return { ...this.cookies };
-  }
-};
-__name(_CookieJarImpl, "CookieJarImpl");
-var CookieJarImpl = _CookieJarImpl;
-function createContext(req, res, viteServer, parent) {
-  const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
-  const headers = /* @__PURE__ */ new Map();
-  const data = parent?.data ? new Map(parent.data) : /* @__PURE__ */ new Map();
-  const locals = parent?.locals ? new Map(parent.locals) : /* @__PURE__ */ new Map();
-  const cookies = new CookieJarImpl(req, res);
-  Object.entries(req.headers).forEach(([key, value]) => {
-    if (typeof value === "string") {
-      headers.set(key, value);
-    } else if (Array.isArray(value)) {
-      headers.set(key, value.join(", "));
-    }
-  });
-  if (parent?.headers) {
-    for (const [key, value] of Object.entries(parent.headers)) {
-      headers.set(key, value);
-    }
-  }
-  let handled = false;
-  const ctx = {
-    request: req,
-    response: res,
-    url,
-    pathname: url.pathname,
-    searchParams: url.searchParams,
-    method: req.method || "GET",
-    params: {},
-    route: url.pathname,
-    parent,
-    vite: {
-      isDev: process.env.NODE_ENV !== "production",
-      hmr: !!viteServer?.hot,
-      server: viteServer
-    },
-    data,
-    locals,
-    headers,
-    cookies,
-    _handled: false,
-    redirect(redirectUrl, status = 307) {
-      if (handled) {
-        console.warn("Response already sent, cannot redirect");
-        return;
-      }
-      ctx._redirectUrl = redirectUrl;
-      ctx._handled = true;
-      handled = true;
-      res.writeHead(status, {
-        Location: redirectUrl,
-        "Content-Type": "text/plain"
-      });
-      res.end(`Redirecting to ${redirectUrl}`);
-    },
-    rewrite(rewriteUrl) {
-      ctx._rewriteUrl = rewriteUrl;
-      const newUrl = new URL(rewriteUrl, `http://${req.headers.host || "localhost"}`);
-      ctx.url = newUrl;
-      ctx.pathname = newUrl.pathname;
-      ctx.searchParams = newUrl.searchParams;
-      req.url = rewriteUrl;
-    },
-    json(jsonData, status = 200) {
-      if (handled) {
-        console.warn("Response already sent, cannot send JSON");
-        return;
-      }
-      ctx._handled = true;
-      handled = true;
-      res.writeHead(status, {
-        "Content-Type": "application/json"
-      });
-      res.end(JSON.stringify(jsonData));
-    },
-    text(content, status = 200) {
-      if (handled) {
-        console.warn("Response already sent, cannot send text");
-        return;
-      }
-      ctx._handled = true;
-      handled = true;
-      res.writeHead(status, {
-        "Content-Type": "text/plain"
-      });
-      res.end(content);
-    },
-    html(content, status = 200) {
-      if (handled) {
-        console.warn("Response already sent, cannot send HTML");
-        return;
-      }
-      ctx._handled = true;
-      handled = true;
-      res.writeHead(status, {
-        "Content-Type": "text/html"
-      });
-      res.end(content);
-    }
-  };
-  return ctx;
-}
-__name(createContext, "createContext");
-
-// src/middleware/manager.ts
-import * as fs from "fs";
-import * as path from "path";
-function isMiddlewareResponse(value) {
-  return value instanceof Response;
-}
-__name(isMiddlewareResponse, "isMiddlewareResponse");
-var _MiddlewareManager = class _MiddlewareManager {
-  constructor(appDir, viteServer, config, i18n) {
-    this.middleware = [];
-    this.configMiddleware = [];
-    this.appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
-    this.viteServer = viteServer;
-    this.i18n = i18n;
-    this.configure(config);
-  }
-  configure(config) {
-    this.configMiddleware = [];
-    this.globalConfig = void 0;
-    if (!config) return;
-    const entries = Array.isArray(config) ? config : [config];
-    for (const [index, entry] of entries.entries()) {
-      const handlers = this.getConfigHandlers(entry);
-      const middlewareConfig = this.toMiddlewareConfig(entry);
-      if (handlers.length === 0) {
-        this.globalConfig = middlewareConfig;
-        continue;
-      }
-      this.configMiddleware.push({
-        path: "/",
-        filePath: `farm.config.ts#middleware-${index}`,
-        handlers,
-        config: middlewareConfig,
-        source: "config"
-      });
-    }
-  }
-  /**
-   * Discover all middleware.ts files
-   */
-  async discover() {
-    const middlewareByPath = /* @__PURE__ */ new Map();
-    for (const appDir of this.appDirs) {
-      const discovered = [];
-      await this.discoverInDirectory(appDir, "/", discovered);
-      for (const middleware of discovered) {
-        middlewareByPath.set(middleware.path, middleware);
-      }
-    }
-    this.middleware = Array.from(middlewareByPath.values());
-    this.middleware.sort((a, b) => {
-      const depthA = a.path.split("/").length;
-      const depthB = b.path.split("/").length;
-      return depthA - depthB;
-    });
-    if (process.env.FARM_VERBOSE && this.middleware.length > 0) {
-      logger.success(`Discovered ${this.middleware.length} middleware files`);
-      for (const mw of this.middleware) {
-        logger.info(`  ${mw.path} (${mw.handlers.length} handlers)`);
-      }
-    }
-  }
-  /**
-   * Recursively discover middleware files
-   */
-  async discoverInDirectory(dir, routePath, discovered) {
-    if (!fs.existsSync(dir)) {
-      return;
-    }
-    const middlewareFile = this.findMiddlewareFile(dir);
-    if (middlewareFile) {
-      const middleware = await this.loadMiddleware(middlewareFile, routePath);
-      if (middleware) {
-        discovered.push(middleware);
-      }
-    }
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
-        const subPath = path.join(dir, entry.name);
-        const subRoutePath = path.posix.join(routePath, entry.name);
-        await this.discoverInDirectory(subPath, subRoutePath, discovered);
-      }
-    }
-  }
-  /**
-   * Find middleware file in directory
-   */
-  findMiddlewareFile(dir) {
-    const extensions = [".ts", ".tsx", ".js", ".jsx"];
-    for (const ext of extensions) {
-      const filePath = path.join(dir, `middleware${ext}`);
-      if (fs.existsSync(filePath)) {
-        return filePath;
-      }
-    }
-    return null;
-  }
-  /**
-   * Load a middleware file
-   */
-  async loadMiddleware(filePath, routePath) {
-    try {
-      let module;
-      if (this.viteServer) {
-        module = await this.viteServer.ssrLoadModule(filePath);
-      } else {
-        const fileUrl = `file://${filePath}`;
-        module = await import(
-          /* @vite-ignore */
-          fileUrl
-        );
-      }
-      const normalized = normalizeMiddlewareModule(module, routePath);
-      if (!normalized) {
-        logger.warn(
-          `Middleware file ${filePath} must export a default handler or a named middleware handler`
-        );
-        return null;
-      }
-      return {
-        path: routePath,
-        filePath,
-        handlers: normalized.handlers,
-        config: normalized.config,
-        source: "file"
-      };
-    } catch (error) {
-      logger.error(`Failed to load middleware ${filePath}: ${error}`);
-      return null;
-    }
-  }
-  /**
-   * Execute middleware for a request
-   */
-  async execute(req, res) {
-    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
-    const pathname = url.pathname;
-    const routePathname = this.i18n?.enabled ? stripFarmLocaleFromPathname(pathname, this.i18n) : pathname;
-    const method = req.method || "GET";
-    const startTime = Date.now();
-    let parentData;
-    let ctx = createContext(req, res, this.viteServer);
-    if (this.globalConfig) {
-      const globalMatch = this.matchesConfig(routePathname, this.globalConfig, ctx);
-      if (!globalMatch.matched) {
-        return false;
-      }
-      if (globalMatch.params) {
-        ctx.params = { ...ctx.params, ...globalMatch.params };
-      }
-    }
-    const applicable = [
-      ...this.configMiddleware.map((mw) => ({ mw, routeMatch: { matched: true } })),
-      ...this.middleware.map((mw) => ({ mw, routeMatch: this.matchRoutePath(routePathname, mw.path) })).filter((entry) => entry.routeMatch.matched)
-    ];
-    if (applicable.length === 0) {
-      return false;
-    }
-    try {
-      const pc = __require("picocolors");
-      const middlewarePaths = applicable.map(({ mw }) => mw.path).join(", ");
-      const log = [
-        pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
-        pc.dim("[") + pc.bold(pc.magenta("MIDDLEWARE")) + pc.dim("]"),
-        pc.dim("[") + pc.bold(pc.white(method.padEnd(3))) + pc.dim("]"),
-        pc.gray("Executing middleware: "),
-        pc.gray(pathname),
-        pc.dim(` (${(Date.now() - startTime).toFixed(2)}ms)`)
-      ].join(" ");
-      console.log(log);
-    } catch {
-      console.log(
-        `[FARM] [MIDDLEWARE] [${method}] Executing ${pathname} (${applicable.length} middleware)`
-      );
-    }
-    for (const entry of applicable) {
-      const { mw, routeMatch } = entry;
-      const configMatch = mw.config ? this.matchesConfig(routePathname, mw.config, ctx) : { matched: true };
-      if (!configMatch.matched) {
-        continue;
-      }
-      if (routeMatch.params) {
-        ctx.params = { ...ctx.params, ...routeMatch.params };
-      }
-      if (configMatch.params) {
-        ctx.params = { ...ctx.params, ...configMatch.params };
-      }
-      if (parentData) {
-        ctx = createContext(req, res, this.viteServer, parentData);
-        if (routeMatch.params) {
-          ctx.params = { ...ctx.params, ...routeMatch.params };
-        }
-        if (configMatch.params) {
-          ctx.params = { ...ctx.params, ...configMatch.params };
-        }
-      }
-      const middlewareStartTime = Date.now();
-      const middlewareEvent = {
-        route: mw.path,
-        pathname,
-        name: mw.filePath
-      };
-      emitFarmEvent({ type: "middleware.start", ...middlewareEvent });
-      try {
-        let handlerIndex = 0;
-        let returnedResponse;
-        const executeNext = /* @__PURE__ */ __name(async () => {
-          if (handlerIndex < mw.handlers.length) {
-            const handler = mw.handlers[handlerIndex++];
-            const result2 = await handler(ctx, executeNext);
-            if (isMiddlewareResponse(result2)) {
-              returnedResponse = result2;
-              return result2;
-            }
-          }
-          return returnedResponse;
-        }, "executeNext");
-        const result = await executeNext();
-        const response = isMiddlewareResponse(result) ? result : returnedResponse;
-        if (response) {
-          if (!res.headersSent && !res.writableEnded) {
-            for (const [key, value] of ctx.headers) {
-              try {
-                res.setHeader(key, value);
-              } catch (error) {
-              }
-            }
-          }
-          emitFarmEvent({
-            type: "middleware.shortCircuit",
-            ...middlewareEvent,
-            status: response.status
-          });
-          await sendWebResponse(res, response);
-          return true;
-        }
-        if (ctx._handled || res.headersSent || res.writableEnded) {
-          emitFarmEvent({
-            type: "middleware.shortCircuit",
-            ...middlewareEvent,
-            status: res.statusCode
-          });
-          return true;
-        }
-        emitFarmEvent({
-          type: "middleware.complete",
-          ...middlewareEvent,
-          durationMs: Date.now() - middlewareStartTime
-        });
-      } catch (error) {
-        emitFarmEvent({
-          type: "middleware.error",
-          ...middlewareEvent,
-          error
-        });
-        throw error;
-      }
-      parentData = {
-        data: new Map(ctx.data),
-        locals: new Map(ctx.locals),
-        headers: Object.fromEntries(ctx.headers)
-      };
-    }
-    if (!res.headersSent && !res.writableEnded) {
-      for (const [key, value] of ctx.headers) {
-        try {
-          res.setHeader(key, value);
-        } catch (error) {
-        }
-      }
-    }
-    req.__FARM_MIDDLEWARE_DATA__ = new Map(ctx.data);
-    req.__FARM_MIDDLEWARE_CONTEXT__ = new Map(ctx.locals);
-    return false;
-  }
-  /**
-   * Check if pathname matches middleware config
-   */
-  matchesConfig(pathname, config, ctx) {
-    if (config.exclude) {
-      for (const pattern of config.exclude) {
-        if (this.matchPattern(pattern, pathname).matched) {
-          return { matched: false };
-        }
-      }
-    }
-    if (config.matcher) {
-      for (const matcher of this.toMatcherList(config.matcher)) {
-        if (typeof matcher === "string" || matcher instanceof RegExp) {
-          const result = this.matchPattern(matcher, pathname);
-          if (result.matched) {
-            return result;
-          }
-        } else if (typeof matcher === "function") {
-          return { matched: matcher(ctx) };
-        }
-      }
-      return { matched: false };
-    }
-    return { matched: true };
-  }
-  /**
-   * Match a pattern against pathname
-   */
-  matchPattern(pattern, pathname) {
-    if (pattern instanceof RegExp) {
-      pattern.lastIndex = 0;
-      const match2 = pattern.exec(pathname);
-      return {
-        matched: !!match2,
-        params: match2?.groups ? { ...match2.groups } : void 0
-      };
-    }
-    if (pattern === "*" || pattern === "/(.*)") {
-      return { matched: true };
-    }
-    if (pattern.endsWith("(.*)")) {
-      const prefix = pattern.slice(0, -4);
-      return { matched: pathname === prefix || pathname.startsWith(`${prefix}/`) };
-    }
-    const { regex, params } = this.compilePathPattern(pattern);
-    const match = regex.exec(pathname);
-    if (!match) {
-      return { matched: false };
-    }
-    const values = {};
-    params.forEach((param, index) => {
-      values[param] = decodeURIComponent(match[index + 1] || "");
-    });
-    return {
-      matched: true,
-      params: Object.keys(values).length > 0 ? values : void 0
-    };
-  }
-  /**
-   * Reload middleware (for HMR)
-   */
-  async reload() {
-    await this.discover();
-  }
-  getMiddlewares() {
-    return [...this.configMiddleware, ...this.middleware];
-  }
-  hasMiddleware() {
-    return this.configMiddleware.length > 0 || this.middleware.length > 0;
-  }
-  matchRoutePath(pathname, middlewarePath) {
-    if (middlewarePath === "/") return { matched: true };
-    const exactMatch = this.matchPattern(middlewarePath, pathname);
-    if (exactMatch.matched) {
-      return exactMatch;
-    }
-    const nestedMatch = this.matchPattern(`${middlewarePath}/:__farmRest*`, pathname);
-    if (!nestedMatch.matched) {
-      return { matched: false };
-    }
-    const params = { ...nestedMatch.params };
-    delete params.__farmRest;
-    return {
-      matched: true,
-      params: Object.keys(params).length > 0 ? params : void 0
-    };
-  }
-  toMatcherList(matcher) {
-    if (!matcher) return [];
-    return Array.isArray(matcher) ? matcher : [matcher];
-  }
-  getConfigHandlers(entry) {
-    const handlers = [];
-    if ("handler" in entry && typeof entry.handler === "function") {
-      handlers.push(entry.handler);
-    }
-    if ("handlers" in entry && Array.isArray(entry.handlers)) {
-      handlers.push(...entry.handlers.filter((handler) => typeof handler === "function"));
-    }
-    return handlers;
-  }
-  toMiddlewareConfig(entry) {
-    const { matcher, exclude, runtime } = entry;
-    return { matcher, exclude, runtime };
-  }
-  compilePathPattern(pattern) {
-    const params = [];
-    const segments = pattern.split("/").filter(Boolean);
-    if (segments.length === 0) {
-      return { regex: /^\/$/, params };
-    }
-    const parts = segments.map((segment) => {
-      if (segment === "**") {
-        return "(?:/.*)?";
-      }
-      if (segment === "*") {
-        return "/[^/]+";
-      }
-      if (segment.startsWith(":")) {
-        const { name, modifier } = this.parseColonParam(segment);
-        params.push(name);
-        if (modifier === "*") {
-          return "(?:/(.*))?";
-        }
-        if (modifier === "+") {
-          return "/(.+)";
-        }
-        return "/([^/]+)";
-      }
-      if (segment.startsWith("[...") && segment.endsWith("]")) {
-        params.push(segment.slice(4, -1));
-        return "(?:/(.*))?";
-      }
-      if (segment.startsWith("[") && segment.endsWith("]")) {
-        params.push(segment.slice(1, -1));
-        return "/([^/]+)";
-      }
-      return `/${this.escapeRegex(segment).replace(/\\\*/g, "[^/]*")}`;
-    });
-    return {
-      regex: new RegExp(`^${parts.join("")}$`),
-      params
-    };
-  }
-  parseColonParam(segment) {
-    const raw = segment.slice(1);
-    const last = raw[raw.length - 1];
-    const modifier = last === "*" || last === "+" || last === "?" ? last : void 0;
-    return {
-      name: modifier ? raw.slice(0, -1) : raw,
-      modifier
-    };
-  }
-  escapeRegex(value) {
-    return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
-  }
-};
-__name(_MiddlewareManager, "MiddlewareManager");
-var MiddlewareManager = _MiddlewareManager;
-
-export {
-  createContext,
-  MiddlewareManager
-};
-//# sourceMappingURL=chunk-MIUW47JX.mjs.map