@farm.js/core 0.1.61 → 0.1.62

package/dist/devtools-NUVXYG7I.mjs

@@ -0,0 +1,463 @@
+import {
+  getDeployTargetForPreset
+} from "./chunk-VWW4Q3BJ.mjs";
+import "./chunk-VISQDC6W.mjs";
+import "./chunk-PAKCHVUS.mjs";
+import "./chunk-X3XUZWRB.mjs";
+import "./chunk-XR2ZIBQK.mjs";
+import "./chunk-CU5SYTJG.mjs";
+import "./chunk-ES2LD2YD.mjs";
+import "./chunk-T4TBK5NY.mjs";
+import "./chunk-22W4FNTG.mjs";
+import "./chunk-2WZTGPK6.mjs";
+import "./chunk-KVW2M6PI.mjs";
+import "./chunk-52Y3C3HG.mjs";
+import "./chunk-2NGZFOKG.mjs";
+import "./chunk-N33DLJBC.mjs";
+import "./chunk-UIJOLBUL.mjs";
+import "./chunk-YSXTNSXS.mjs";
+import "./chunk-VFXE6NWR.mjs";
+import "./chunk-TZVUF5JJ.mjs";
+import {
+  resolveCronConfig
+} from "./chunk-DQF3QLOH.mjs";
+import "./chunk-WXFY5JIY.mjs";
+import "./chunk-E46NXBNJ.mjs";
+import "./chunk-YP7YO3S3.mjs";
+import "./chunk-YWPNIYUP.mjs";
+import "./chunk-TGULJSHD.mjs";
+import "./chunk-H4WUWLQR.mjs";
+import "./chunk-M53MIIXY.mjs";
+import "./chunk-46P5KNTE.mjs";
+import "./chunk-EDPENAVO.mjs";
+import "./chunk-C7GJDVN4.mjs";
+import {
+  mergeFarmRouteRuntimeConfigs,
+  resolveFarmRouteRuleRuntimeConfig,
+  resolveFarmRouteRuntimeConfig
+} from "./chunk-EVMXPJCB.mjs";
+import "./chunk-TGSEVBPO.mjs";
+import "./chunk-QSTRBKHZ.mjs";
+import "./chunk-MU5V7XHL.mjs";
+import "./chunk-JSDV2NUN.mjs";
+import "./chunk-H3ASZDT7.mjs";
+import "./chunk-2DA7CLY7.mjs";
+import "./chunk-CO6UYM2D.mjs";
+import "./chunk-2I6PUKWJ.mjs";
+import "./chunk-QDWMCFTH.mjs";
+import "./chunk-D2LCAV6L.mjs";
+import "./chunk-GYMGK467.mjs";
+import "./chunk-GUZC226X.mjs";
+import "./chunk-W6QLRQ3V.mjs";
+import "./chunk-WCLLPR6H.mjs";
+import "./chunk-UAQD67HM.mjs";
+import "./chunk-AZQXXXDX.mjs";
+import "./chunk-ONG4RDW3.mjs";
+import "./chunk-LM55GS4R.mjs";
+import "./chunk-JNYFXL7X.mjs";
+import "./chunk-OHWM2VI4.mjs";
+import "./chunk-VIXTAVEA.mjs";
+import "./chunk-7S7AAK2D.mjs";
+import "./chunk-SF3JB56B.mjs";
+import "./chunk-AYP2YFVN.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+
+// src/devtools.ts
+import path from "path";
+function collectPlugins(plugins) {
+  const valueAt = (value, key) => value && (typeof value === "object" || typeof value === "function") ? Object.getOwnPropertyDescriptor(value, key)?.value : void 0;
+  const hooks = (value, names, prefix = "") => names.filter((key) => typeof valueAt(value, key) === "function").map((key) => prefix + key);
+  return plugins.map((plugin, index) => {
+    const serverHooks = hooks(plugin, [
+      "configure",
+      "setup",
+      "init",
+      "ready",
+      "devServerCreated",
+      "config",
+      "configResolved",
+      "buildStart",
+      "buildEnd",
+      "routeDiscovered",
+      "routesGenerated",
+      "middlewareDiscovered",
+      "apiRouteDiscovered",
+      "beforeRouteMatch",
+      "afterRouteMatch",
+      "beforeRender",
+      "afterRender",
+      "beforeApiHandler",
+      "afterApiHandler",
+      "onError",
+      "hmrUpdate",
+      "beforeBundle",
+      "afterBundle",
+      "beforeNitroBuild",
+      "afterNitroBuild",
+      "shutdown",
+      "beforeRequest",
+      "afterResponse",
+      "transformHTML",
+      "transformPage"
+    ]);
+    for (const [group, names] of [
+      ["runtime", ["start", "context", "before", "after", "error", "close"]],
+      ["router", ["discovered", "generated", "before", "after"]],
+      ["render", ["before", "html"]],
+      ["build", ["before", "configure", "after"]],
+      ["dev", ["server", "update"]]
+    ])
+      serverHooks.push(...hooks(valueAt(plugin, group), names, `${group}.`));
+    const client = valueAt(plugin, "client");
+    const clientHooks = hooks(client, ["setup", "error", "performance", "close"], "client.");
+    clientHooks.push(
+      ...hooks(valueAt(client, "hydration"), ["before", "after"], "client.hydration.")
+    );
+    clientHooks.push(
+      ...hooks(
+        valueAt(client, "navigation"),
+        ["before", "loaded", "resolved", "rendered", "error"],
+        "client.navigation."
+      )
+    );
+    const name = valueAt(plugin, "name");
+    const version = valueAt(plugin, "version");
+    const enforce = valueAt(plugin, "enforce");
+    return {
+      name: typeof name === "string" ? name : "Unnamed plugin",
+      ...typeof version === "string" ? { version } : {},
+      order: index + 1,
+      enforce: enforce === "pre" || enforce === "post" ? enforce : "normal",
+      serverHooks,
+      clientHooks,
+      routes: valueAt(plugin, "routes") !== void 0
+    };
+  });
+}
+function normalizePath(value) {
+  return value.replace(/\\/g, "/");
+}
+function toProjectPath(root, filePath) {
+  const normalizedRoot = normalizePath(root).replace(/\/$/, "");
+  const normalizedFile = normalizePath(filePath);
+  if (normalizedFile.startsWith(normalizedRoot + "/")) {
+    return normalizedFile.slice(normalizedRoot.length + 1);
+  }
+  return normalizedFile;
+}
+function sortByPath(items) {
+  return [...items].sort(
+    (a, b) => (a.path || a.pattern || "").localeCompare(b.path || b.pattern || "")
+  );
+}
+function toRuntime(value) {
+  return {
+    runtime: value.runtime,
+    ...value.regions ? { regions: [...value.regions] } : {},
+    ...value.maxDuration ? { maxDuration: value.maxDuration } : {}
+  };
+}
+async function collectRoutes(root, kind, routes, routeManager, diagnostics) {
+  return Promise.all(
+    Array.from(routes.values()).map(async (route) => {
+      let runtime;
+      if (kind === "page" && routeManager.resolveRouteRuntimeConfig) {
+        try {
+          runtime = toRuntime(await routeManager.resolveRouteRuntimeConfig(route.pattern));
+        } catch (error) {
+          diagnostics.push({
+            severity: "warning",
+            code: "ROUTE_RUNTIME_UNRESOLVED",
+            title: `Could not inspect ${route.pattern}`,
+            message: error instanceof Error ? error.message : String(error),
+            action: "Check the route and inherited layout runtime exports."
+          });
+        }
+      }
+      return {
+        kind,
+        pattern: route.pattern,
+        filePath: toProjectPath(root, route.modulePath),
+        ...runtime ? { runtime } : {}
+      };
+    })
+  );
+}
+function collectIntegrations(integrations) {
+  if (!integrations || typeof integrations !== "object") return [];
+  return Object.entries(integrations).filter((entry) => Boolean(entry[1])).map(([key, value]) => {
+    const integration = value;
+    const routes = (integration.routes || []).map((route) => ({
+      path: route.path,
+      methods: [...route.methods || (route.method ? [route.method] : ["ALL"])].map((method) => method.toUpperCase()).sort()
+    }));
+    return {
+      key,
+      type: integration.type || key,
+      category: integration.category || "custom",
+      serverRuntime: integration.serverRuntime !== false,
+      routes: sortByPath(routes),
+      middlewareCount: integration.middleware?.length || 0,
+      providerCount: integration.providers?.length || 0,
+      schemaModelCount: Object.keys(integration.schema?.models || {}).length
+    };
+  }).sort((a, b) => a.key.localeCompare(b.key));
+}
+function collectStorage(storage) {
+  if (!storage || typeof storage !== "object") {
+    return {
+      entries: [{ mount: "root", driver: "memory", default: true }],
+      configured: false
+    };
+  }
+  const value = storage;
+  if (value.kind === "farm-storage-client") {
+    return {
+      entries: [{ mount: "root", driver: "storage client", default: false }],
+      configured: true
+    };
+  }
+  const configured = Object.keys(value).length > 0;
+  const rootDriver = value.client ? describeStorageDriver(value.client) : describeStorageDriver(value.driver);
+  const entries = [
+    {
+      mount: "root",
+      driver: rootDriver,
+      default: !configured
+    }
+  ];
+  if (value.mounts && typeof value.mounts === "object") {
+    for (const [mount, mountConfig] of Object.entries(value.mounts)) {
+      entries.push({
+        mount,
+        driver: describeStorageDriver(mountConfig),
+        default: false
+      });
+    }
+  }
+  return {
+    entries: entries.sort((a, b) => {
+      if (a.mount === "root") return -1;
+      if (b.mount === "root") return 1;
+      return a.mount.localeCompare(b.mount);
+    }),
+    configured
+  };
+}
+function describeStorageDriver(value) {
+  if (!value) return "memory";
+  if (typeof value === "string") return value;
+  if (typeof value === "function") return "custom";
+  if (typeof value !== "object") return "custom";
+  const record = value;
+  if (record.kind === "farm-storage-client") return "storage client";
+  if (typeof record.driver === "string") return record.driver;
+  if (typeof record.driver === "function") return "custom";
+  return "custom";
+}
+function featureEnabled(value) {
+  if (!value) return false;
+  if (typeof value === "object" && "enabled" in value) {
+    return value.enabled !== false;
+  }
+  return value !== false;
+}
+function collectEnvironmentKeys(config) {
+  const env = config?.env;
+  return {
+    server: Object.keys(env?.server || {}).sort(),
+    public: Object.keys(env?.public || {}).sort()
+  };
+}
+function resolveHealth(diagnostics) {
+  if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) return "error";
+  if (diagnostics.some((diagnostic) => diagnostic.severity === "warning")) return "attention";
+  return "ready";
+}
+async function createFarmDevtoolsSnapshot(input) {
+  const config = input.config || {};
+  const diagnostics = [];
+  const pageRoutes = await collectRoutes(
+    input.root,
+    "page",
+    input.routeManager.getRoutes(),
+    input.routeManager,
+    diagnostics
+  );
+  const layoutRoutes = await collectRoutes(
+    input.root,
+    "layout",
+    input.routeManager.getLayouts(),
+    input.routeManager,
+    diagnostics
+  );
+  const loadingRoutes = await collectRoutes(
+    input.root,
+    "loading",
+    input.routeManager.getLoadings(),
+    input.routeManager,
+    diagnostics
+  );
+  const errorRoutes = await collectRoutes(
+    input.root,
+    "error",
+    input.routeManager.getErrors(),
+    input.routeManager,
+    diagnostics
+  );
+  const apiRoutes = sortByPath(
+    Array.from(input.apiRouteManager.getRoutes().values()).map((route) => {
+      const runtime = resolveFarmRouteRuntimeConfig(
+        mergeFarmRouteRuntimeConfigs(
+          resolveFarmRouteRuleRuntimeConfig(route.path, config.routeRules),
+          route
+        ),
+        `API route "${route.path}"`
+      );
+      return {
+        path: route.path,
+        methods: [...route.methods].sort(),
+        filePath: toProjectPath(input.root, route.filePath),
+        runtime: toRuntime(runtime)
+      };
+    })
+  );
+  const middleware = sortByPath(
+    input.middlewareManager.getMiddlewares().map((entry) => ({
+      path: entry.path,
+      source: entry.source || "file",
+      filePath: toProjectPath(input.root, entry.filePath),
+      handlerCount: entry.handlers.length
+    }))
+  );
+  const integrations = collectIntegrations(config.integrations);
+  const storage = collectStorage(config.storage);
+  const cron = resolveCronConfig(config.cron);
+  const workflows = (input.workflows || []).map((workflow) => ({
+    id: workflow.id,
+    filePath: toProjectPath(input.root, workflow.filePath),
+    routePath: workflow.routePath,
+    schedule: [...workflow.schedule],
+    ...workflow.timezone ? { timezone: workflow.timezone } : {}
+  })).sort((a, b) => a.id.localeCompare(b.id));
+  const layers = (config.layers || []).map((layer) => ({
+    name: layer.name,
+    source: layer.source,
+    srcDir: layer.srcDir
+  }));
+  const deploymentPreset = String(config.deploy?.preset || config.preset || "node-server");
+  const deploymentTarget = String(
+    config.deploy?.target || getDeployTargetForPreset(deploymentPreset) || "node"
+  );
+  const env = input.env || process.env;
+  if (pageRoutes.length === 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "NO_PAGE_ROUTES",
+      title: "No page routes found",
+      message: `Farm did not discover a page under ${input.srcDir}/app.`,
+      action: `Add ${input.srcDir}/app/page.tsx or a programmatic page route.`
+    });
+  }
+  if (layoutRoutes.length === 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "ROOT_LAYOUT_MISSING",
+      title: "Root layout is missing",
+      message: "The application has no shared root layout.",
+      action: `Add ${input.srcDir}/app/layout.tsx for shared metadata and application chrome.`
+    });
+  }
+  const apiPaths = new Set(apiRoutes.map((route) => route.path));
+  for (const job of cron.jobs) {
+    if (!apiPaths.has(job.path)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "CRON_ROUTE_MISSING",
+        title: `Cron route ${job.path} was not found`,
+        message: `${job.name} is scheduled, but its GET API route is not registered.`,
+        action: "Add the target API route or update the cron path in farm.config.ts."
+      });
+    }
+  }
+  if (cron.jobs.length > 0 && !env[cron.secretEnv]) {
+    diagnostics.push({
+      severity: "info",
+      code: "CRON_SECRET_NOT_SET",
+      title: `${cron.secretEnv} is not set`,
+      message: "Local manual runs remain available, but production cron routes fail closed.",
+      action: `Set ${cron.secretEnv} in the deployment environment before production.`
+    });
+  }
+  if (storage.configured && storage.entries[0]?.driver === "memory" && ["vercel", "cloudflare", "netlify"].includes(deploymentTarget)) {
+    diagnostics.push({
+      severity: "warning",
+      code: "EPHEMERAL_PRODUCTION_STORAGE",
+      title: "Production storage is in memory",
+      message: `${deploymentTarget} instances do not preserve in-memory data across executions.`,
+      action: "Configure a durable storage driver or mount for production state."
+    });
+  }
+  const environment = collectEnvironmentKeys(config);
+  const docs = config.docs;
+  const docsEnabled = featureEnabled(docs);
+  const allRoutes = sortByPath([...pageRoutes, ...layoutRoutes, ...loadingRoutes, ...errorRoutes]);
+  const plugins = collectPlugins(input.plugins ?? []);
+  return {
+    generatedAt: (input.now?.() || /* @__PURE__ */ new Date()).toISOString(),
+    health: resolveHealth(diagnostics),
+    project: {
+      name: path.basename(path.resolve(input.root)),
+      root: input.root,
+      srcDir: input.srcDir,
+      basePath: config.basePath || "/",
+      deploymentId: config.deploymentId || "development"
+    },
+    deployment: {
+      target: deploymentTarget,
+      preset: deploymentPreset,
+      ...config.deploy?.outputDir ? { outputDir: config.deploy.outputDir } : {}
+    },
+    counts: {
+      pages: pageRoutes.length,
+      layouts: layoutRoutes.length,
+      loadingBoundaries: loadingRoutes.length,
+      errorBoundaries: errorRoutes.length,
+      apiRoutes: apiRoutes.length,
+      middleware: middleware.length,
+      integrations: integrations.length,
+      plugins: plugins.length,
+      storageMounts: storage.entries.length,
+      cronJobs: cron.jobs.length,
+      workflows: workflows.length,
+      layers: layers.length,
+      diagnostics: diagnostics.length
+    },
+    routes: allRoutes,
+    apiRoutes,
+    middleware,
+    integrations,
+    plugins,
+    storage: storage.entries,
+    cron: cron.jobs,
+    workflows,
+    layers,
+    environment,
+    docs: {
+      enabled: docsEnabled,
+      entry: docsEnabled && docs && typeof docs === "object" && "entry" in docs ? String(docs.entry) : void 0
+    },
+    features: {
+      openapi: Boolean(config.openapi?.enabled),
+      markdown: featureEnabled(config.md),
+      serverComponents: Boolean(config.experimental?.serverComponents),
+      serverActions: Boolean(config.experimental?.serverActions),
+      optimizedBoundary: Boolean(config.experimental?.optimizedBoundary),
+      observability: featureEnabled(config.observability)
+    },
+    diagnostics
+  };
+}
+export {
+  createFarmDevtoolsSnapshot
+};