@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-2DA7CLY7.mjs

@@ -0,0 +1,560 @@
+// src/tracing.ts
+import {
+  context,
+  createContextKey,
+  isSpanContextValid,
+  propagation,
+  SpanKind,
+  SpanStatusCode,
+  trace
+} from "@opentelemetry/api";
+var FARM_TRACER_NAME = "@farm.js/core";
+var ALL_SPAN_KINDS = [
+  "request",
+  "render",
+  "middleware",
+  "api",
+  "integration",
+  "storage",
+  "ppr",
+  "build",
+  "plugin"
+];
+var DEFAULT_IGNORED_PATHS = [
+  "/@vite/",
+  "/@fs/",
+  "/@id/",
+  "/@react-refresh",
+  "/node_modules/",
+  "/__vite",
+  "/.well-known/appspecific/"
+];
+var FARM_REQUEST_METHOD_CONTEXT_KEY = createContextKey("@farm.js/core/request-method");
+var TRACING_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/tracing-runtime/v1");
+var runtime = globalThis;
+var tracingState = runtime[TRACING_RUNTIME] ?? (runtime[TRACING_RUNTIME] = normalizeFarmTracingConfig(false));
+function normalizeFarmTracingConfig(config) {
+  if (!config) {
+    return {
+      enabled: false,
+      spans: new Set(ALL_SPAN_KINDS),
+      recordEvents: true,
+      attributes: {},
+      ignorePaths: DEFAULT_IGNORED_PATHS
+    };
+  }
+  if (config === true) {
+    return {
+      enabled: true,
+      spans: new Set(ALL_SPAN_KINDS),
+      recordEvents: true,
+      attributes: {},
+      ignorePaths: DEFAULT_IGNORED_PATHS
+    };
+  }
+  return {
+    enabled: config.enabled ?? true,
+    spans: new Set(config.spans ?? ALL_SPAN_KINDS),
+    recordEvents: config.recordEvents ?? true,
+    attributes: { ...config.attributes },
+    ignorePaths: [...DEFAULT_IGNORED_PATHS, ...config.ignorePaths ?? []]
+  };
+}
+function configureFarmTracing(config) {
+  if (isResolvedFarmTracingConfig(config)) {
+    Object.assign(tracingState, {
+      ...config,
+      spans: new Set(config.spans),
+      attributes: { ...config.attributes },
+      ignorePaths: [...config.ignorePaths]
+    });
+    return;
+  }
+  Object.assign(
+    tracingState,
+    normalizeFarmTracingConfig(config)
+  );
+}
+function isResolvedFarmTracingConfig(config) {
+  return !!config && typeof config === "object" && typeof config.enabled === "boolean" && config.spans instanceof Set && typeof config.recordEvents === "boolean" && Array.isArray(config.ignorePaths);
+}
+function resetFarmTracing() {
+  Object.assign(tracingState, normalizeFarmTracingConfig(false));
+}
+function getFarmTraceContext() {
+  return getSpanTraceContext(trace.getSpan(context.active()));
+}
+async function runWithFarmSpan(name, handler, options = {}) {
+  const spanFamily = options.kind;
+  if (!tracingState.enabled || spanFamily !== void 0 && !tracingState.spans.has(spanFamily)) {
+    return await handler();
+  }
+  const tracer = trace.getTracer(FARM_TRACER_NAME);
+  return await tracer.startActiveSpan(
+    name,
+    {
+      kind: options.spanKind ?? SpanKind.INTERNAL,
+      attributes: {
+        ...tracingState.attributes,
+        ...options.attributes
+      }
+    },
+    async (span) => {
+      try {
+        return await handler();
+      } catch (error) {
+        recordSpanError(span, error);
+        throw error;
+      } finally {
+        span.end();
+      }
+    }
+  );
+}
+async function _runWithFarmRequestSpan(request, handler, options = {}) {
+  const startedAt = Date.now();
+  const url = tracingState.enabled && tracingState.spans.has("request") ? new URL(request.url) : void 0;
+  const shouldTrace = url && !tracingState.ignorePaths.some((prefix) => url.pathname.startsWith(prefix));
+  if (!shouldTrace) {
+    options.onStart?.();
+    try {
+      const result = await handler();
+      options.onComplete?.(resolveResultStatus(result, options), Date.now() - startedAt);
+      return result;
+    } catch (error) {
+      options.onError?.(error, Date.now() - startedAt);
+      throw error;
+    }
+  }
+  const extractedContext = propagation.extract(context.active(), request.headers, {
+    keys(carrier) {
+      return Array.from(carrier.keys());
+    },
+    get(carrier, key) {
+      return carrier.get(key) ?? void 0;
+    }
+  });
+  const requestContext = extractedContext.setValue(FARM_REQUEST_METHOD_CONTEXT_KEY, request.method);
+  const tracer = trace.getTracer(FARM_TRACER_NAME);
+  const attributes = {
+    ...tracingState.attributes,
+    "http.request.method": request.method,
+    "url.path": url.pathname,
+    "url.scheme": url.protocol.replace(/:$/, ""),
+    "server.address": url.hostname
+  };
+  if (url.port) attributes["server.port"] = Number(url.port);
+  return await tracer.startActiveSpan(
+    `${request.method} ${url.pathname}`,
+    { kind: SpanKind.SERVER, attributes },
+    requestContext,
+    async (span) => {
+      options.onStart?.();
+      try {
+        const result = await handler();
+        const status = resolveResultStatus(result, options);
+        setResponseStatus(span, status);
+        options.onComplete?.(status, Date.now() - startedAt);
+        return result;
+      } catch (error) {
+        recordSpanError(span, error);
+        options.onError?.(error, Date.now() - startedAt);
+        throw error;
+      } finally {
+        span.end();
+      }
+    }
+  );
+}
+function recordFarmEventTrace(event) {
+  if (!tracingState.enabled) return void 0;
+  const activeContext = context.active();
+  const activeSpan = trace.getSpan(activeContext);
+  const traceContext = getSpanTraceContext(activeSpan);
+  if (activeSpan && traceContext) {
+    if (event.type === "route.matched") {
+      const method = activeContext.getValue(FARM_REQUEST_METHOD_CONTEXT_KEY) ?? "HTTP";
+      activeSpan.updateName(`${method} ${event.route}`);
+      activeSpan.setAttribute("http.route", event.route);
+      activeSpan.setAttribute("farm.route", event.route);
+    }
+    if (tracingState.recordEvents) {
+      activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
+    }
+    const error = event.type === "request.error" ? void 0 : getEventError(event);
+    if (error !== void 0) {
+      if (event.type === "render.error") {
+        recordSpanException(activeSpan, error);
+      } else {
+        recordSpanError(activeSpan, error);
+      }
+    }
+  }
+  const completedTraceContext = recordCompletedEventSpan(event, activeContext);
+  return traceContext ?? completedTraceContext;
+}
+function recordCompletedEventSpan(event, parentContext) {
+  const descriptor = getCompletedSpanDescriptor(event);
+  if (!descriptor || !tracingState.spans.has(descriptor.kind)) return void 0;
+  const tracer = trace.getTracer(FARM_TRACER_NAME);
+  const span = tracer.startSpan(
+    descriptor.name,
+    {
+      kind: SpanKind.INTERNAL,
+      startTime: event.timestamp - descriptor.durationMs,
+      attributes: {
+        ...tracingState.attributes,
+        ...toEventAttributes(event),
+        "farm.event.type": event.type
+      }
+    },
+    parentContext
+  );
+  const status = "status" in event && typeof event.status === "number" ? event.status : void 0;
+  if (status !== void 0) setResponseStatus(span, status);
+  const error = getEventError(event);
+  if (error !== void 0) recordSpanError(span, error);
+  const traceContext = getSpanTraceContext(span);
+  span.end(event.timestamp);
+  return traceContext;
+}
+function getCompletedSpanDescriptor(event) {
+  if (!("durationMs" in event) || typeof event.durationMs !== "number") return void 0;
+  switch (event.type) {
+    case "render.complete":
+      return { kind: "render", name: `farm.render ${event.route}`, durationMs: event.durationMs };
+    case "render.stream.shellReady":
+      return {
+        kind: "render",
+        name: `farm.render.shell ${event.route}`,
+        durationMs: event.durationMs
+      };
+    case "render.stream.complete":
+      return {
+        kind: "render",
+        name: `farm.render.stream ${event.route}`,
+        durationMs: event.durationMs
+      };
+    case "middleware.complete":
+      return {
+        kind: "middleware",
+        name: `farm.middleware ${event.name ?? event.route ?? "anonymous"}`,
+        durationMs: event.durationMs
+      };
+    case "api.request.complete":
+    case "api.error":
+      return {
+        kind: "api",
+        name: `farm.api ${event.method} ${event.route}`,
+        durationMs: event.durationMs
+      };
+    case "integration.api.call.complete":
+      return {
+        kind: "integration",
+        name: `farm.integration ${event.integration}.${event.operation}`,
+        durationMs: event.durationMs
+      };
+    case "storage.query.complete":
+      return {
+        kind: "storage",
+        name: `farm.storage ${event.operation}`,
+        durationMs: event.durationMs
+      };
+    case "ppr.refresh.complete":
+      return {
+        kind: "ppr",
+        name: `farm.ppr.refresh ${event.route}`,
+        durationMs: event.durationMs
+      };
+    case "build.complete":
+      return {
+        kind: "build",
+        name: `farm.build${event.target ? ` ${event.target}` : ""}`,
+        durationMs: event.durationMs
+      };
+    case "plugin.hook.complete":
+      return {
+        kind: "plugin",
+        name: `farm.plugin ${event.plugin}.${event.hook}`,
+        durationMs: event.durationMs
+      };
+    default:
+      return void 0;
+  }
+}
+function hashFarmCacheKey(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function toEventAttributes(event) {
+  const attributes = {};
+  for (const [key, value] of Object.entries(event)) {
+    if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
+      continue;
+    }
+    if (key === "key" && typeof value === "string") {
+      attributes["farm.key_hash"] = hashFarmCacheKey(value);
+      continue;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      attributes[`farm.${key}`] = value;
+    } else if (Array.isArray(value)) {
+      if (value.every((entry) => typeof entry === "string")) {
+        attributes[`farm.${key}`] = value;
+      } else if (value.every((entry) => typeof entry === "number")) {
+        attributes[`farm.${key}`] = value;
+      } else if (value.every((entry) => typeof entry === "boolean")) {
+        attributes[`farm.${key}`] = value;
+      }
+    }
+  }
+  return attributes;
+}
+function getEventError(event) {
+  return "error" in event ? event.error : void 0;
+}
+function recordSpanException(span, error) {
+  const normalized = error instanceof Error ? error : new Error(String(error));
+  span.recordException(normalized);
+  return normalized;
+}
+function recordSpanError(span, error) {
+  const normalized = recordSpanException(span, error);
+  span.setStatus({ code: SpanStatusCode.ERROR, message: normalized.message });
+}
+function setResponseStatus(span, status) {
+  span.setAttribute("http.response.status_code", status);
+  if (status >= 500) {
+    span.setStatus({ code: SpanStatusCode.ERROR });
+  }
+}
+function resolveResultStatus(result, options) {
+  if (result instanceof Response) return result.status;
+  return options.getStatusCode?.() ?? 200;
+}
+function getSpanTraceContext(span) {
+  if (!span) return void 0;
+  const spanContext = span.spanContext();
+  if (!isSpanContextValid(spanContext)) return void 0;
+  return {
+    traceId: spanContext.traceId,
+    spanId: spanContext.spanId,
+    traceSampled: (spanContext.traceFlags & 1) === 1
+  };
+}
+
+// src/observability.ts
+var OBSERVABILITY_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/observability-runtime/v1");
+var runtime2 = globalThis;
+var shared = runtime2[OBSERVABILITY_RUNTIME] ?? (runtime2[OBSERVABILITY_RUNTIME] = {
+  handlers: /* @__PURE__ */ new Set(),
+  unfilteredHandlers: /* @__PURE__ */ new Set(),
+  config: { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) }
+});
+var runtimeHandlers = shared.handlers;
+var unfilteredRuntimeHandlers = shared.unfilteredHandlers;
+var observabilityState = shared.config;
+function configureFarmObservability(config) {
+  Object.assign(
+    observabilityState,
+    { events: void 0 },
+    normalizeFarmObservabilityConfig(config)
+  );
+  configureFarmTracing(observabilityState.tracing);
+}
+function normalizeFarmObservabilityConfig(config) {
+  if (config === void 0 || config === false) {
+    return { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) };
+  }
+  if (config === true) {
+    return { logs: true, handlers: [], tracing: normalizeFarmTracingConfig(false) };
+  }
+  const handlers = config.onEvent ? Array.isArray(config.onEvent) ? [...config.onEvent] : [config.onEvent] : [];
+  return {
+    logs: config.logs ?? false,
+    handlers,
+    events: config.events ? new Set(config.events) : void 0,
+    tracing: normalizeFarmTracingConfig(config.tracing)
+  };
+}
+function onFarmEvent(handler, options = {}) {
+  const handlers = options.unfiltered ? unfilteredRuntimeHandlers : runtimeHandlers;
+  handlers.add(handler);
+  return () => {
+    handlers.delete(handler);
+  };
+}
+function resetFarmObservability() {
+  runtimeHandlers.clear();
+  unfilteredRuntimeHandlers.clear();
+  Object.assign(observabilityState, {
+    logs: false,
+    handlers: [],
+    events: void 0,
+    tracing: normalizeFarmTracingConfig(false)
+  });
+  resetFarmTracing();
+}
+function emitFarmEvent(input) {
+  const event = {
+    timestamp: Date.now(),
+    level: inferFarmEventLevel(input.type),
+    ...input
+  };
+  if (event.type === "route.redirect") event.to = event.to.replace(/[?#][\s\S]*$/, "");
+  const traceContext = recordFarmEventTrace(event);
+  if (traceContext) {
+    event.traceId = traceContext.traceId;
+    event.spanId = traceContext.spanId;
+    event.traceSampled = traceContext.traceSampled;
+  }
+  notifyFarmEventHandlers(event, unfilteredRuntimeHandlers);
+  if (!shouldEmitFarmEvent(event)) return event;
+  if (observabilityState.logs) {
+    logFarmEvent(event);
+  }
+  notifyFarmEventHandlers(event, [...observabilityState.handlers, ...runtimeHandlers]);
+  return event;
+}
+function notifyFarmEventHandlers(event, handlers) {
+  for (const handler of handlers) {
+    try {
+      Promise.resolve(handler(event)).catch((error) => {
+        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+      });
+    } catch (error) {
+      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+    }
+  }
+}
+async function runWithFarmRequestSpan(request, handler, options = {}) {
+  const url = new URL(request.url);
+  const method = request.method || "GET";
+  return await _runWithFarmRequestSpan(request, handler, {
+    ...options,
+    onStart() {
+      emitFarmEvent({ type: "request.start", method, pathname: url.pathname });
+      options.onStart?.();
+    },
+    onComplete(status, durationMs) {
+      emitFarmEvent({
+        type: "request.complete",
+        method,
+        pathname: url.pathname,
+        status,
+        durationMs
+      });
+      options.onComplete?.(status, durationMs);
+    },
+    onError(error, durationMs) {
+      emitFarmEvent({
+        type: "request.error",
+        method,
+        pathname: url.pathname,
+        durationMs,
+        error
+      });
+      options.onError?.(error, durationMs);
+    }
+  });
+}
+function shouldEmitFarmEvent(event) {
+  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
+    return false;
+  }
+  if (observabilityState.events && !observabilityState.events.has(event.type)) {
+    return false;
+  }
+  return true;
+}
+function inferFarmEventLevel(type) {
+  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
+    return "error";
+  }
+  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
+    return "warn";
+  }
+  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
+    return "debug";
+  }
+  return "info";
+}
+function logFarmEvent(event) {
+  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
+  switch (event.level) {
+    case "error":
+      console.error(message);
+      break;
+    case "warn":
+      console.warn(message);
+      break;
+    default:
+      console.log(message);
+      break;
+  }
+}
+function formatFarmEventDetails(event) {
+  const details = [];
+  const record = event;
+  for (const key of [
+    "route",
+    "pathname",
+    "method",
+    "status",
+    "key",
+    "tag",
+    "path",
+    "reason",
+    "durationMs",
+    "integration",
+    "server",
+    "tool",
+    "outcome",
+    "operation",
+    "plugin",
+    "hook",
+    "target",
+    "count"
+  ]) {
+    const value = record[key];
+    if (key === "key" && typeof value === "string") {
+      details.push(`key_hash=${hashFarmCacheKey(value)}`);
+    } else if (value !== void 0) {
+      details.push(`${key}=${formatDetailValue(value)}`);
+    }
+  }
+  return details.length > 0 ? ` ${details.join(" ")}` : "";
+}
+function formatDetailValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export {
+  normalizeFarmTracingConfig,
+  configureFarmTracing,
+  getFarmTraceContext,
+  runWithFarmSpan,
+  configureFarmObservability,
+  normalizeFarmObservabilityConfig,
+  onFarmEvent,
+  resetFarmObservability,
+  emitFarmEvent,
+  runWithFarmRequestSpan
+};

package/dist/chunk-2DLGV2ZG.mjs

@@ -0,0 +1,71 @@
+import {
+  resolveSchemaModels
+} from "./chunk-F3N52U7S.mjs";
+
+// src/schema-extend.ts
+function collectSchemaExtensions(owner, schema, models) {
+  if (!schema.extend) return [];
+  const resolved = resolveSchemaModels(owner, schema);
+  const extensions = [];
+  for (const [modelKey, extension] of Object.entries(schema.extend)) {
+    const model = resolved[modelKey];
+    if (!model || !model.external && (!models || models.includes(modelKey))) continue;
+    const fields = Object.keys(extension.fields ?? {}).map((fieldKey) => {
+      const field = model.fields[fieldKey];
+      assertAddableColumn(owner, modelKey, fieldKey, field);
+      return { fieldKey, field };
+    });
+    if (fields.length > 0) {
+      extensions.push({ owner, modelKey, table: model.name, fields });
+    }
+  }
+  return extensions;
+}
+function assertAddableColumn(owner, modelKey, fieldKey, field) {
+  const where = `${owner} adds "${modelKey}.${fieldKey}" to a table it does not own`;
+  if (field.primaryKey || field.unique || field.index || field.list) {
+    const what = field.primaryKey ? "a primary key" : field.unique ? "unique" : field.index ? "indexed" : "a list";
+    throw new Error(`${where}, which cannot be ${what}. Remove it from the extension.`);
+  }
+  if (field.nullable !== true && field.required !== false && field.default === void 0) {
+    throw new Error(
+      `${where}. The table may already have rows, so the column needs a \`default\` or \`nullable: true\`.`
+    );
+  }
+}
+function isSchemaExtensionAllowed(allowExtend, extension) {
+  if (!allowExtend || !Object.prototype.hasOwnProperty.call(allowExtend, extension.owner)) {
+    return false;
+  }
+  const allowed = allowExtend[extension.owner] ?? [];
+  return allowed.includes(extension.modelKey) || allowed.includes(extension.table);
+}
+function describeSchemaExtensionApproval(extension) {
+  return `schema: { allowExtend: { ${JSON.stringify(extension.owner)}: [${JSON.stringify(extension.modelKey)}] } }`;
+}
+
+// src/schema-owner.ts
+var FARM_SCHEMA_TABLES = /* @__PURE__ */ Symbol.for("farm.schema-tables");
+function declareSchemaTables(target, declaration) {
+  Object.defineProperty(target, FARM_SCHEMA_TABLES, {
+    value: declaration,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+}
+function readSchemaTables(candidate) {
+  if (!candidate || typeof candidate !== "object" && typeof candidate !== "function") {
+    return void 0;
+  }
+  return candidate[FARM_SCHEMA_TABLES];
+}
+
+export {
+  collectSchemaExtensions,
+  isSchemaExtensionAllowed,
+  describeSchemaExtensionApproval,
+  FARM_SCHEMA_TABLES,
+  declareSchemaTables,
+  readSchemaTables
+};

package/dist/chunk-2H3FJYY6.mjs

@@ -0,0 +1,78 @@
+import {
+  PROGRAMMATIC_ROUTE_FILE_NAMES,
+  scanProgrammaticPagePaths
+} from "./chunk-6YFC3ZFX.mjs";
+
+// src/routes.server.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+async function loadProgrammaticRouteManifests(options) {
+  const manifests = [];
+  const routeFiles = findProgrammaticRouteFiles(options.root, options.srcDir);
+  if (routeFiles.length === 0) return manifests;
+  const { getProgrammaticRouteManifest } = await import("./routes.mjs");
+  for (const filePath of routeFiles) {
+    const mod = await options.loadModule(filePath);
+    const manifest = getProgrammaticRouteManifest(mod);
+    if (manifest) {
+      manifests.push({ filePath, manifest });
+    }
+  }
+  return manifests;
+}
+function findProgrammaticRouteFiles(root, srcDir = "src") {
+  return findProgrammaticRouteFilesInDir(join(root, srcDir));
+}
+function findProgrammaticRouteFilesInDir(srcRoot) {
+  const files = [];
+  for (const fileName of PROGRAMMATIC_ROUTE_FILE_NAMES) {
+    const filePath = join(srcRoot, fileName);
+    if (existsSync(filePath)) {
+      files.push(filePath);
+    }
+  }
+  return files;
+}
+async function discoverProgrammaticRoutePaths(root, srcDir = "src") {
+  const paths = /* @__PURE__ */ new Set();
+  const files = /* @__PURE__ */ new Set([
+    ...findProgrammaticRouteFiles(root, srcDir),
+    ...await findProgrammaticRouteSourceFiles(join(root, srcDir))
+  ]);
+  for (const filePath of files) {
+    const source = readFileSync(filePath, "utf8");
+    for (const routePath of scanProgrammaticPagePaths(source)) {
+      paths.add(routePath);
+    }
+  }
+  return Array.from(paths).sort();
+}
+async function findProgrammaticRouteSourceFiles(srcRoot) {
+  if (!existsSync(srcRoot)) {
+    return [];
+  }
+  try {
+    const glob = await import("fast-glob");
+    return await glob.default("**/*.{ts,tsx,js,jsx}", {
+      cwd: srcRoot,
+      absolute: true,
+      ignore: [
+        "**/*.d.ts",
+        "**/node_modules/**",
+        "**/.*/**",
+        "farm-routes.d.ts",
+        "farm-env.d.ts",
+        "lib/api.generated.ts"
+      ]
+    });
+  } catch {
+    return [];
+  }
+}
+
+export {
+  loadProgrammaticRouteManifests,
+  findProgrammaticRouteFiles,
+  findProgrammaticRouteFilesInDir,
+  discoverProgrammaticRoutePaths
+};