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

package/dist/chunk-C3DLZMBU.mjs

@@ -1,597 +0,0 @@
-import {
-  getResolvedEnv
-} from "./chunk-RSKVYESE.mjs";
-import {
-  clearRequestContext,
-  deleteRequestContext,
-  getRequestContext,
-  getRequestContextSnapshot,
-  hasRequestContext,
-  setRequestContext
-} from "./chunk-K4667E2Q.mjs";
-import {
-  __name
-} from "./chunk-CGILA3WO.mjs";
-
-// src/plugin.ts
-var _PluginManager = class _PluginManager {
-  constructor(context) {
-    this.plugins = [];
-    this.hookPresence = /* @__PURE__ */ new Map();
-    this.runtimeHookPresence = /* @__PURE__ */ new Map();
-    this.pluginStates = /* @__PURE__ */ new Map();
-    this.setupComplete = false;
-    this.initialized = false;
-    this.runtimeReady = false;
-    this.runtimeClosed = false;
-    this.runtimeRequestContexts = /* @__PURE__ */ new WeakMap();
-    this.failedRuntimeSessions = /* @__PURE__ */ new WeakSet();
-    this.context = {
-      ...context,
-      requestContext: {
-        set(target, key, value, options) {
-          setRequestContext(target, key, value, options);
-        },
-        get(target, key) {
-          return getRequestContext(target, key);
-        },
-        has(target, key) {
-          return hasRequestContext(target, key);
-        },
-        delete(target, key) {
-          return deleteRequestContext(target, key);
-        },
-        clear(target) {
-          clearRequestContext(target);
-        },
-        getAll(target, options) {
-          return getRequestContextSnapshot(target, options);
-        }
-      }
-    };
-  }
-  createRequestHookContext(target) {
-    const requestContext = this.context.requestContext;
-    return {
-      ...this.context,
-      req: {
-        set(key, value, options) {
-          requestContext.set(target, key, value, options);
-        },
-        get(key) {
-          return requestContext.get(target, key);
-        },
-        has(key) {
-          return requestContext.has(target, key);
-        },
-        delete(key) {
-          return requestContext.delete(target, key);
-        },
-        clear() {
-          requestContext.clear(target);
-        },
-        snapshot(options) {
-          return requestContext.getAll(target, options);
-        }
-      }
-    };
-  }
-  copyRequestStore(source, target) {
-    const requestContext = this.context.requestContext;
-    const values = requestContext.getAll(source);
-    const exposed = requestContext.getAll(source, { exposedOnly: true });
-    for (const [key, value] of values) {
-      requestContext.set(target, key, value, {
-        exposeToPage: exposed.has(key)
-      });
-    }
-  }
-  copyRuntimeRequestContext(source, target) {
-    const runtimeContext = this.runtimeRequestContexts.get(source);
-    if (runtimeContext) {
-      this.runtimeRequestContexts.set(target, runtimeContext);
-    }
-  }
-  createRuntimeBaseEvent(plugin, request, options, waitUntil) {
-    return {
-      ...this.createStateHookContext(plugin),
-      request,
-      req: this.createRequestHookContext(request).req,
-      kind: options.kind ?? "request",
-      route: options.route,
-      signal: request.signal,
-      waitUntil
-    };
-  }
-  async createRuntimeRequestContext(request, options, waitUntil) {
-    const values = {};
-    const owners = /* @__PURE__ */ new Map();
-    for (const plugin of this.getSortedPlugins()) {
-      const createContext = plugin.runtime?.context;
-      if (!createContext) continue;
-      const result = await createContext(
-        this.createRuntimeBaseEvent(plugin, request, options, waitUntil)
-      );
-      if (result === void 0) continue;
-      if (!result || typeof result !== "object" || Array.isArray(result)) {
-        throw new TypeError(`Farm plugin "${plugin.name}" runtime.context must return an object`);
-      }
-      for (const [key, value] of Object.entries(result)) {
-        const owner = owners.get(key);
-        if (owner) {
-          throw new Error(
-            `Farm plugin context key "${key}" from "${plugin.name}" conflicts with "${owner}"`
-          );
-        }
-        owners.set(key, plugin.name);
-        values[key] = value;
-      }
-    }
-    const runtimeContext = Object.freeze(values);
-    this.runtimeRequestContexts.set(request, runtimeContext);
-    return runtimeContext;
-  }
-  async runRuntimeErrorHooks(request, error, ctx, durationMs, options, waitUntil) {
-    for (const plugin of this.getSortedPlugins()) {
-      const onError = plugin.runtime?.error;
-      if (!onError) continue;
-      try {
-        await onError({
-          ...this.createRuntimeBaseEvent(plugin, request, options, waitUntil),
-          ctx,
-          error,
-          durationMs
-        });
-      } catch (hookError) {
-        console.error(`Farm plugin "${plugin.name}" runtime.error failed:`, hookError);
-      }
-    }
-    try {
-      await this.runHookParallel("onError", {
-        phase: "runtime",
-        error,
-        meta: {
-          kind: options.kind ?? "request",
-          pathname: new URL(request.url).pathname,
-          durationMs
-        }
-      });
-    } catch (hookError) {
-      console.error("Farm plugin onError hook failed:", hookError);
-    }
-  }
-  createStateHookContext(plugin, context = this.context) {
-    return {
-      ...context,
-      state: this.pluginStates.get(plugin)
-    };
-  }
-  getPluginHooks(plugin, hookName) {
-    const hooks = [];
-    const legacyHook = plugin[hookName];
-    if (typeof legacyHook === "function") {
-      hooks.push(legacyHook);
-    }
-    const withState = /* @__PURE__ */ __name((context) => this.createStateHookContext(plugin, context), "withState");
-    switch (hookName) {
-      case "config":
-        if (plugin.configure) {
-          hooks.push(
-            (config, context) => plugin.configure?.(config, context)
-          );
-        }
-        break;
-      case "ready":
-        if (plugin.runtime?.start) {
-          hooks.push((context) => plugin.runtime?.start?.(withState(context)));
-        }
-        break;
-      case "shutdown":
-        if (plugin.runtime?.close) {
-          hooks.push(
-            (payload, context) => plugin.runtime?.close?.({
-              ...withState(context),
-              reason: payload.reason
-            })
-          );
-        }
-        break;
-      case "routeDiscovered":
-        if (plugin.router?.discovered) {
-          hooks.push(
-            (route, context) => plugin.router?.discovered?.(route, withState(context))
-          );
-        }
-        break;
-      case "middlewareDiscovered":
-        if (plugin.router?.discovered) {
-          hooks.push(
-            (route, context) => plugin.router?.discovered?.({ kind: "middleware", ...route }, withState(context))
-          );
-        }
-        break;
-      case "apiRouteDiscovered":
-        if (plugin.router?.discovered) {
-          hooks.push(
-            (route, context) => plugin.router?.discovered?.({ kind: "api", ...route }, withState(context))
-          );
-        }
-        break;
-      case "routesGenerated":
-        if (plugin.router?.generated) {
-          hooks.push(
-            (routes, context) => plugin.router?.generated?.(routes, withState(context))
-          );
-        }
-        break;
-      case "beforeRouteMatch":
-        if (plugin.router?.before) {
-          hooks.push(
-            (route, context) => plugin.router?.before?.(route, withState(context))
-          );
-        }
-        break;
-      case "afterRouteMatch":
-        if (plugin.router?.after) {
-          hooks.push(
-            (result, context) => plugin.router?.after?.(result, withState(context))
-          );
-        }
-        break;
-      case "beforeRender":
-        if (plugin.render?.before) {
-          hooks.push(
-            (render, context) => plugin.render?.before?.(render, withState(context))
-          );
-        }
-        break;
-      case "afterRender":
-        if (plugin.render?.html) {
-          hooks.push(
-            (html, render, context) => plugin.render?.html?.(html, render, withState(context))
-          );
-        }
-        break;
-      case "beforeBundle":
-        if (plugin.build?.before) {
-          hooks.push(
-            (bundle, context) => plugin.build?.before?.(bundle, withState(context))
-          );
-        }
-        break;
-      case "beforeNitroBuild":
-        if (plugin.build?.configure) {
-          hooks.push(
-            (buildConfig, context) => plugin.build?.configure?.(buildConfig, withState(context))
-          );
-        }
-        break;
-      case "afterBundle":
-        if (plugin.build?.after) {
-          hooks.push(
-            (result, context) => plugin.build?.after?.(result, withState(context))
-          );
-        }
-        break;
-      case "devServerCreated":
-        if (plugin.dev?.server) {
-          hooks.push(
-            (server, context) => plugin.dev?.server?.(server, withState(context))
-          );
-        }
-        break;
-      case "hmrUpdate":
-        if (plugin.dev?.update) {
-          hooks.push(
-            (update, context) => plugin.dev?.update?.(update, withState(context))
-          );
-        }
-        break;
-    }
-    return hooks;
-  }
-  getHookContext(hookName, args) {
-    if (hookName === "beforeRequest" || hookName === "afterResponse" || hookName === "beforeApiHandler") {
-      const target = args[0];
-      if (target && typeof target === "object") {
-        return this.createRequestHookContext(target);
-      }
-    }
-    return this.context;
-  }
-  addPlugin(plugin) {
-    this.plugins.push(plugin);
-    this.hookPresence.clear();
-    this.runtimeHookPresence.clear();
-  }
-  addPlugins(plugins) {
-    for (const plugin of plugins) {
-      this.addPlugin(plugin);
-    }
-  }
-  getPlugins() {
-    return [...this.plugins];
-  }
-  getSortedPlugins() {
-    const pre = this.plugins.filter((p) => p.enforce === "pre");
-    const normal = this.plugins.filter((p) => !p.enforce);
-    const post = this.plugins.filter((p) => p.enforce === "post");
-    return [...pre, ...normal, ...post];
-  }
-  hasHook(hookName) {
-    const cached = this.hookPresence.get(hookName);
-    if (cached !== void 0) return cached;
-    const present = this.plugins.some((plugin) => this.getPluginHooks(plugin, hookName).length > 0);
-    this.hookPresence.set(hookName, present);
-    return present;
-  }
-  hasRuntimeHook(hookName) {
-    const cached = this.runtimeHookPresence.get(hookName);
-    if (cached !== void 0) return cached;
-    const present = this.plugins.some((plugin) => typeof plugin.runtime?.[hookName] === "function");
-    this.runtimeHookPresence.set(hookName, present);
-    return present;
-  }
-  hasRuntimeRequestHooks() {
-    return this.hasRuntimeHook("context") || this.hasRuntimeHook("before") || this.hasRuntimeHook("after") || this.hasRuntimeHook("error");
-  }
-  copyRequestContext(source, target) {
-    this.copyRequestStore(source, target);
-    if (source instanceof Request && target instanceof Request) {
-      this.copyRuntimeRequestContext(source, target);
-    }
-  }
-  async setupPlugins() {
-    if (this.setupComplete) return;
-    for (const plugin of this.getSortedPlugins()) {
-      if (!plugin.setup) continue;
-      const state = await plugin.setup({
-        ...this.context,
-        env: getResolvedEnv()
-      });
-      this.pluginStates.set(plugin, state);
-    }
-    this.setupComplete = true;
-  }
-  async startRuntime() {
-    if (this.runtimeReady) return;
-    if (this.runtimeStartPromise) return this.runtimeStartPromise;
-    this.runtimeStartPromise = (async () => {
-      if (!this.initialized) {
-        await this.runHookParallel("init");
-      }
-      await this.setupPlugins();
-      if (!this.runtimeReady) {
-        await this.runHookParallel("ready");
-      }
-    })();
-    try {
-      await this.runtimeStartPromise;
-    } catch (error) {
-      this.runtimeStartPromise = void 0;
-      throw error;
-    }
-  }
-  async closeRuntime(reason = "runtime-closed") {
-    if (this.runtimeClosed) return;
-    if (this.runtimeClosePromise) return this.runtimeClosePromise;
-    this.runtimeClosePromise = this.runHookParallel("shutdown", {
-      reason
-    }).then(() => void 0);
-    try {
-      await this.runtimeClosePromise;
-    } catch (error) {
-      this.runtimeClosePromise = void 0;
-      throw error;
-    }
-  }
-  async beginRuntimeRequest(request, options = {}) {
-    await this.startRuntime();
-    const startedAt = Date.now();
-    const waitUntil = options.waitUntil ? (promise) => options.waitUntil?.(Promise.resolve(promise)) : (promise) => {
-      void Promise.resolve(promise).catch(() => {
-      });
-    };
-    let activeRequest = request;
-    let runtimeContext = Object.freeze({});
-    try {
-      runtimeContext = await this.createRuntimeRequestContext(activeRequest, options, waitUntil);
-      let response;
-      for (const plugin of this.getSortedPlugins()) {
-        const before = plugin.runtime?.before;
-        if (!before) continue;
-        const result = await before({
-          ...this.createRuntimeBaseEvent(plugin, activeRequest, options, waitUntil),
-          ctx: runtimeContext
-        });
-        if (result instanceof Request) {
-          this.copyRequestStore(activeRequest, result);
-          this.copyRuntimeRequestContext(activeRequest, result);
-          activeRequest = result;
-          continue;
-        }
-        if (result instanceof Response) {
-          response = result;
-          break;
-        }
-        if (result !== void 0) {
-          throw new TypeError(
-            `Farm plugin "${plugin.name}" runtime.before must return a Request, Response, or undefined`
-          );
-        }
-      }
-      return {
-        request: activeRequest,
-        response,
-        ctx: runtimeContext,
-        startedAt,
-        options,
-        waitUntil
-      };
-    } catch (error) {
-      await this.runRuntimeErrorHooks(
-        activeRequest,
-        error,
-        runtimeContext,
-        Date.now() - startedAt,
-        options,
-        waitUntil
-      );
-      throw error;
-    }
-  }
-  async endRuntimeRequest(session, initialResponse) {
-    let response = initialResponse;
-    try {
-      for (const plugin of this.getSortedPlugins()) {
-        const after = plugin.runtime?.after;
-        if (!after) continue;
-        const result = await after({
-          ...this.createRuntimeBaseEvent(
-            plugin,
-            session.request,
-            session.options,
-            session.waitUntil
-          ),
-          ctx: session.ctx,
-          response,
-          durationMs: Date.now() - session.startedAt
-        });
-        if (result !== void 0) {
-          if (!(result instanceof Response)) {
-            throw new TypeError(
-              `Farm plugin "${plugin.name}" runtime.after must return a Response or undefined`
-            );
-          }
-          response = result;
-        }
-      }
-      return response;
-    } catch (error) {
-      await this.failRuntimeRequest(session, error);
-      throw error;
-    }
-  }
-  async failRuntimeRequest(session, error) {
-    if (this.failedRuntimeSessions.has(session)) return;
-    this.failedRuntimeSessions.add(session);
-    await this.runRuntimeErrorHooks(
-      session.request,
-      error,
-      session.ctx,
-      Date.now() - session.startedAt,
-      session.options,
-      session.waitUntil
-    );
-  }
-  async runRuntimeRequest(request, handler, options = {}) {
-    const session = await this.beginRuntimeRequest(request, options);
-    try {
-      const response = session.response ?? await handler(session.request);
-      if (!(response instanceof Response)) {
-        throw new TypeError("Farm plugin runtime handlers must return a Response");
-      }
-      return await this.endRuntimeRequest(session, response);
-    } catch (error) {
-      await this.failRuntimeRequest(session, error);
-      throw error;
-    }
-  }
-  async runHook(hookName, ...args) {
-    const plugins = this.getSortedPlugins();
-    for (const plugin of plugins) {
-      for (const hook of this.getPluginHooks(plugin, hookName)) {
-        const hookContext = this.getHookContext(hookName, args);
-        const result = await hook.apply(plugin, [...args, hookContext]);
-        if (result !== void 0) {
-          return result;
-        }
-      }
-    }
-  }
-  async runHookSerial(hookName, initialValue, ...args) {
-    const plugins = this.getSortedPlugins();
-    let value = initialValue;
-    for (const plugin of plugins) {
-      for (const hook of this.getPluginHooks(plugin, hookName)) {
-        const hookArgs = [value, ...args];
-        const hookContext = this.getHookContext(hookName, hookArgs);
-        const result = await hook.apply(plugin, [...hookArgs, hookContext]);
-        if (result !== void 0) {
-          if (hookName === "beforeApiHandler" && result !== value && value && result && typeof value === "object" && typeof result === "object") {
-            this.copyRequestStore(value, result);
-          }
-          value = result;
-        }
-      }
-    }
-    return value;
-  }
-  async runHookParallel(hookName, ...args) {
-    const plugins = this.getSortedPlugins();
-    const sequentialHooks = /* @__PURE__ */ new Set([
-      "ready",
-      "shutdown",
-      "beforeRequest",
-      "afterResponse",
-      "beforeApiHandler",
-      "afterApiHandler",
-      "beforeRouteMatch",
-      "afterRouteMatch",
-      "beforeRender",
-      "afterRender"
-    ]);
-    if (sequentialHooks.has(hookName)) {
-      for (const plugin of plugins) {
-        for (const hook of this.getPluginHooks(plugin, hookName)) {
-          if (hookName === "beforeRequest") {
-            const res = args[1];
-            if (res && res.writableEnded) {
-              return true;
-            }
-          }
-          const hookContext = this.getHookContext(hookName, args);
-          await hook.apply(plugin, [...args, hookContext]);
-          if (hookName === "beforeRequest") {
-            const res = args[1];
-            if (res && res.writableEnded) {
-              return true;
-            }
-          }
-        }
-      }
-    } else {
-      const promises = [];
-      for (const plugin of plugins) {
-        for (const hook of this.getPluginHooks(plugin, hookName)) {
-          const hookContext = this.getHookContext(hookName, args);
-          promises.push(hook.apply(plugin, [...args, hookContext]));
-        }
-      }
-      await Promise.all(promises);
-    }
-    if (hookName === "init") this.initialized = true;
-    if (hookName === "ready") this.runtimeReady = true;
-    if (hookName === "shutdown") this.runtimeClosed = true;
-    return false;
-  }
-  updateContext(updates) {
-    this.context = {
-      ...this.context,
-      ...updates,
-      requestContext: this.context.requestContext
-    };
-  }
-};
-__name(_PluginManager, "PluginManager");
-var PluginManager = _PluginManager;
-function definePlugin(plugin) {
-  return plugin;
-}
-__name(definePlugin, "definePlugin");
-
-export {
-  PluginManager,
-  definePlugin
-};
-//# sourceMappingURL=chunk-C3DLZMBU.mjs.map