@farm.js/core 0.1.60 → 0.1.61

package/dist/devtools-ERIKFEXX.mjs

@@ -0,0 +1,472 @@
+import {
+  getDeployTargetForPreset
+} from "./chunk-OHLSEQ57.mjs";
+import "./chunk-XZNTNMHT.mjs";
+import "./chunk-RSOJ7DRT.mjs";
+import "./chunk-JBSVKMC5.mjs";
+import "./chunk-GHFS7RUB.mjs";
+import "./chunk-BUGNQIHC.mjs";
+import "./chunk-DAATZTKJ.mjs";
+import "./chunk-4E5WBPEG.mjs";
+import "./chunk-DTSROJ5J.mjs";
+import "./chunk-G2KY33I6.mjs";
+import {
+  resolveCronConfig
+} from "./chunk-YHOCRI4H.mjs";
+import "./chunk-4WVJLURN.mjs";
+import "./chunk-4OOBRCJX.mjs";
+import "./chunk-FA2W42OV.mjs";
+import "./chunk-WWIKMBRN.mjs";
+import "./chunk-MVL2RAJW.mjs";
+import "./chunk-SFGWNC43.mjs";
+import "./chunk-Q2KB32T4.mjs";
+import "./chunk-2UC36WAC.mjs";
+import "./chunk-ONUEYC6N.mjs";
+import "./chunk-AELACLOB.mjs";
+import "./chunk-MKYBIIAQ.mjs";
+import "./chunk-44SYJEG3.mjs";
+import "./chunk-JG6DJF5A.mjs";
+import "./chunk-ZLAT2CWY.mjs";
+import {
+  mergeFarmRouteRuntimeConfigs,
+  resolveFarmRouteRuleRuntimeConfig,
+  resolveFarmRouteRuntimeConfig
+} from "./chunk-2J7W2WND.mjs";
+import "./chunk-FZ6YYU2W.mjs";
+import "./chunk-FP2INE7H.mjs";
+import "./chunk-ZMMBIVQM.mjs";
+import "./chunk-BCMSYSN2.mjs";
+import "./chunk-KI3MESHB.mjs";
+import "./chunk-QVKYGNVM.mjs";
+import "./chunk-FUZEBRP3.mjs";
+import "./chunk-Z2RZJZIZ.mjs";
+import "./chunk-BTHHUD7Q.mjs";
+import "./chunk-JPLUGGRV.mjs";
+import "./chunk-O7BH5O46.mjs";
+import "./chunk-7LTCDQRS.mjs";
+import "./chunk-SKNL7VA2.mjs";
+import "./chunk-2A3EQHXX.mjs";
+import "./chunk-4SIYUGRY.mjs";
+import "./chunk-SAXPH6G5.mjs";
+import "./chunk-Z3HATSKO.mjs";
+import "./chunk-CBBLJMR5.mjs";
+import "./chunk-CQ6OSQ3K.mjs";
+import "./chunk-L3KT7IXV.mjs";
+import "./chunk-4RB44K6Z.mjs";
+import "./chunk-55YI3RRB.mjs";
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/devtools.ts
+import path from "path";
+function collectPlugins(plugins) {
+  const valueAt = /* @__PURE__ */ __name((value, key) => value && (typeof value === "object" || typeof value === "function") ? Object.getOwnPropertyDescriptor(value, key)?.value : void 0, "valueAt");
+  const hooks = /* @__PURE__ */ __name((value, names, prefix = "") => names.filter((key) => typeof valueAt(value, key) === "function").map((key) => prefix + key), "hooks");
+  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
+    };
+  });
+}
+__name(collectPlugins, "collectPlugins");
+function normalizePath(value) {
+  return value.replace(/\\/g, "/");
+}
+__name(normalizePath, "normalizePath");
+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;
+}
+__name(toProjectPath, "toProjectPath");
+function sortByPath(items) {
+  return [...items].sort(
+    (a, b) => (a.path || a.pattern || "").localeCompare(b.path || b.pattern || "")
+  );
+}
+__name(sortByPath, "sortByPath");
+function toRuntime(value) {
+  return {
+    runtime: value.runtime,
+    ...value.regions ? { regions: [...value.regions] } : {},
+    ...value.maxDuration ? { maxDuration: value.maxDuration } : {}
+  };
+}
+__name(toRuntime, "toRuntime");
+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 } : {}
+      };
+    })
+  );
+}
+__name(collectRoutes, "collectRoutes");
+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));
+}
+__name(collectIntegrations, "collectIntegrations");
+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
+  };
+}
+__name(collectStorage, "collectStorage");
+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";
+}
+__name(describeStorageDriver, "describeStorageDriver");
+function featureEnabled(value) {
+  if (!value) return false;
+  if (typeof value === "object" && "enabled" in value) {
+    return value.enabled !== false;
+  }
+  return value !== false;
+}
+__name(featureEnabled, "featureEnabled");
+function collectEnvironmentKeys(config) {
+  const env = config?.env;
+  return {
+    server: Object.keys(env?.server || {}).sort(),
+    public: Object.keys(env?.public || {}).sort()
+  };
+}
+__name(collectEnvironmentKeys, "collectEnvironmentKeys");
+function resolveHealth(diagnostics) {
+  if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) return "error";
+  if (diagnostics.some((diagnostic) => diagnostic.severity === "warning")) return "attention";
+  return "ready";
+}
+__name(resolveHealth, "resolveHealth");
+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
+  };
+}
+__name(createFarmDevtoolsSnapshot, "createFarmDevtoolsSnapshot");
+export {
+  createFarmDevtoolsSnapshot
+};