@farm.js/core 0.1.0-beta.0

package/dist/chunk-4PTK6KT4.mjs

@@ -0,0 +1,364 @@
+import {
+  notifyFarmCacheInvalidation
+} from "./chunk-TXCFGOHW.mjs";
+import {
+  getActiveFarmI18nSnapshot
+} from "./chunk-WZ5QFROO.mjs";
+import {
+  emitFarmEvent
+} from "./chunk-7ZY5AIJO.mjs";
+import {
+  __name
+} from "./chunk-CGILA3WO.mjs";
+
+// src/cache.ts
+var _FarmDataCache = class _FarmDataCache {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
+    this.version = 0;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get(key, options = {}) {
+    return this.getEntry(key, options)?.value;
+  }
+  getEntry(key, options = {}) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      emitFarmEvent({ type: "cache.miss", key });
+      return void 0;
+    }
+    const stale = this.isStale(entry, options.now);
+    if (stale) {
+      emitFarmEvent({
+        type: "cache.stale",
+        key,
+        tags: Array.from(entry.tags),
+        revalidate: entry.revalidate
+      });
+    }
+    if (!options.allowStale && stale) {
+      emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
+      return void 0;
+    }
+    emitFarmEvent({
+      type: "cache.hit",
+      key,
+      tags: Array.from(entry.tags),
+      revalidate: entry.revalidate,
+      stale
+    });
+    return this.toPublicEntry(entry);
+  }
+  set(key, value, options = {}) {
+    const tags = /* @__PURE__ */ new Set();
+    for (const tag of options.tags ?? []) {
+      tags.add(normalizeCacheTag(tag));
+    }
+    for (const routePath of options.paths ?? []) {
+      tags.add(createPathCacheTag(routePath));
+    }
+    const entry = {
+      key,
+      value,
+      tags,
+      createdAt: options.createdAt ?? Date.now(),
+      createdVersion: ++this.version,
+      revalidate: normalizeRevalidate(options.revalidate)
+    };
+    this.entries.set(key, entry);
+    emitFarmEvent({
+      type: "cache.set",
+      key,
+      tags: Array.from(tags),
+      revalidate: entry.revalidate
+    });
+    return this.toPublicEntry(entry);
+  }
+  delete(key) {
+    const deleted = this.entries.delete(key);
+    emitFarmEvent({ type: "cache.delete", key, deleted });
+    return deleted;
+  }
+  clear() {
+    const count = this.entries.size;
+    this.entries.clear();
+    this.inflight.clear();
+    this.invalidatedTagVersions.clear();
+    this.version = 0;
+    emitFarmEvent({ type: "cache.clear", count });
+  }
+  isStale(entry, now = Date.now()) {
+    if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
+      return true;
+    }
+    for (const tag of entry.tags) {
+      const invalidatedVersion = this.invalidatedTagVersions.get(normalizeCacheTag(tag));
+      if (typeof invalidatedVersion === "number" && typeof entry.createdVersion === "number" && invalidatedVersion > entry.createdVersion) {
+        return true;
+      }
+    }
+    return false;
+  }
+  revalidateTag(tag, options = {}) {
+    const normalized = normalizeCacheTag(tag);
+    const count = this.invalidateTag(normalized);
+    emitFarmEvent(
+      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
+    );
+    return count;
+  }
+  revalidatePath(routePath) {
+    const normalizedPath = normalizeRevalidatePath(routePath);
+    const pathTag = createPathCacheTag(normalizedPath);
+    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
+    const count = this.invalidateTag(pathTag);
+    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
+    if (pprCount > 0) {
+      emitFarmEvent({
+        type: "ppr.shell.invalidated",
+        route: normalizedPath,
+        reason: "revalidatePath",
+        count: pprCount
+      });
+    }
+    return count;
+  }
+  async getOrSet(key, producer, options = {}) {
+    const cached = this.getEntry(key);
+    if (cached) {
+      return cached.value;
+    }
+    const inflight = this.inflight.get(key);
+    if (inflight) {
+      emitFarmEvent({ type: "cache.dedupe", key });
+      return inflight;
+    }
+    const promise = Promise.resolve().then(producer).then((value) => {
+      this.set(key, value, options);
+      return value;
+    }).catch((error) => {
+      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
+      throw error;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  countEntriesForTag(tag) {
+    let count = 0;
+    for (const entry of this.entries.values()) {
+      if (entry.tags.has(tag)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  countEntriesForTags(tags) {
+    let count = 0;
+    for (const entry of this.entries.values()) {
+      if (tags.every((tag) => entry.tags.has(tag))) {
+        count++;
+      }
+    }
+    return count;
+  }
+  invalidateTag(normalizedTag) {
+    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
+    return this.countEntriesForTag(normalizedTag);
+  }
+  toPublicEntry(entry) {
+    return {
+      key: entry.key,
+      value: entry.value,
+      tags: Array.from(entry.tags),
+      createdAt: entry.createdAt,
+      createdVersion: entry.createdVersion,
+      revalidate: entry.revalidate
+    };
+  }
+};
+__name(_FarmDataCache, "FarmDataCache");
+var FarmDataCache = _FarmDataCache;
+var FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
+var farmDataCacheGlobal = globalThis;
+var sharedFarmDataCache = farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] ?? (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] = new FarmDataCache());
+var functionIds = /* @__PURE__ */ new WeakMap();
+var nextFunctionId = 0;
+function getFarmDataCache() {
+  return sharedFarmDataCache;
+}
+__name(getFarmDataCache, "getFarmDataCache");
+function unstable_cache(fn, keyParts = [], options = {}) {
+  return async (...args) => {
+    const locale = getActiveFarmI18nSnapshot()?.locale;
+    const key = createFarmCacheKey([
+      "unstable_cache",
+      getFunctionCacheIdentity(fn),
+      locale ? ["locale", locale] : null,
+      keyParts,
+      args
+    ]);
+    return getFarmDataCache().getOrSet(key, () => fn(...args), options);
+  };
+}
+__name(unstable_cache, "unstable_cache");
+function revalidateTag(_tag, _profile) {
+  getFarmDataCache().revalidateTag(_tag, {
+    source: "revalidateTag",
+    profile: _profile
+  });
+}
+__name(revalidateTag, "revalidateTag");
+function updateTag(tag) {
+  getFarmDataCache().revalidateTag(tag, { source: "updateTag" });
+}
+__name(updateTag, "updateTag");
+function revalidatePath(routePath) {
+  getFarmDataCache().revalidatePath(routePath);
+}
+__name(revalidatePath, "revalidatePath");
+function invalidate(key) {
+  const clientKey = createRouteDataCacheKey(key);
+  getFarmDataCache().revalidateTag(createRouteDataCacheTag(key), { source: "updateTag" });
+  notifyFarmCacheInvalidation(clientKey);
+}
+__name(invalidate, "invalidate");
+function invalidateRouteData(key) {
+  invalidate(key);
+}
+__name(invalidateRouteData, "invalidateRouteData");
+function createPathCacheTag(routePath) {
+  return `path:${normalizeRevalidatePath(routePath)}`;
+}
+__name(createPathCacheTag, "createPathCacheTag");
+function createRouteDataCacheTag(key) {
+  return `route-data:${createRouteDataCacheKey(key)}`;
+}
+__name(createRouteDataCacheTag, "createRouteDataCacheTag");
+function createRouteDataCacheKey(key) {
+  return createFarmCacheKey(Array.isArray(key) ? key : [key]);
+}
+__name(createRouteDataCacheKey, "createRouteDataCacheKey");
+function normalizeRevalidatePath(routePath) {
+  if (typeof routePath !== "string") {
+    throw new TypeError("revalidatePath expects a path string.");
+  }
+  let normalized = routePath.trim();
+  if (!normalized) {
+    throw new Error("revalidatePath expects a non-empty path.");
+  }
+  try {
+    if (/^https?:\/\//.test(normalized)) {
+      normalized = new URL(normalized).pathname;
+    }
+  } catch {
+  }
+  normalized = normalized.split("?")[0] ?? normalized;
+  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  normalized = normalized.replace(/\/{2,}/g, "/");
+  if (normalized.length > 1) {
+    normalized = normalized.replace(/\/+$/, "");
+  }
+  return normalized || "/";
+}
+__name(normalizeRevalidatePath, "normalizeRevalidatePath");
+function createFarmCacheKey(parts) {
+  return stableSerialize(parts);
+}
+__name(createFarmCacheKey, "createFarmCacheKey");
+function normalizeRevalidate(revalidate) {
+  if (revalidate === false || revalidate === void 0) {
+    return revalidate;
+  }
+  if (!Number.isFinite(revalidate) || revalidate <= 0) {
+    return void 0;
+  }
+  return revalidate;
+}
+__name(normalizeRevalidate, "normalizeRevalidate");
+function normalizeCacheTag(tag) {
+  if (typeof tag !== "string") {
+    throw new TypeError("Cache tags must be strings.");
+  }
+  const normalized = tag.trim();
+  if (!normalized) {
+    throw new Error("Cache tags cannot be empty.");
+  }
+  return normalized;
+}
+__name(normalizeCacheTag, "normalizeCacheTag");
+function getFunctionCacheIdentity(fn) {
+  if (fn.name) {
+    return `name:${fn.name}`;
+  }
+  let id = functionIds.get(fn);
+  if (!id) {
+    id = ++nextFunctionId;
+    functionIds.set(fn, id);
+  }
+  return `anonymous:${id}`;
+}
+__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
+function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const valueType = typeof value;
+  if (valueType === "string") return JSON.stringify(value);
+  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
+    return `${valueType}:${String(value)}`;
+  }
+  if (valueType === "symbol") {
+    return `symbol:${String(value)}`;
+  }
+  if (valueType === "function") {
+    return `function:${getFunctionCacheIdentity(value)}`;
+  }
+  if (value instanceof Date) {
+    return `date:${value.toISOString()}`;
+  }
+  if (value instanceof URL) {
+    return `url:${value.toString()}`;
+  }
+  if (value instanceof RegExp) {
+    return `regexp:${value.toString()}`;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableSerialize(item, seen)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
+    seen.delete(value);
+    return `{${serialized}}`;
+  }
+  return String(value);
+}
+__name(stableSerialize, "stableSerialize");
+
+export {
+  FarmDataCache,
+  getFarmDataCache,
+  unstable_cache,
+  revalidateTag,
+  updateTag,
+  revalidatePath,
+  invalidate,
+  invalidateRouteData,
+  createPathCacheTag,
+  createRouteDataCacheTag,
+  createRouteDataCacheKey,
+  normalizeRevalidatePath,
+  createFarmCacheKey
+};
+//# sourceMappingURL=chunk-4PTK6KT4.mjs.map

package/dist/chunk-4PTK6KT4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cache.ts"],"sourcesContent":["import { emitFarmEvent } from \"./observability\";\nimport { notifyFarmCacheInvalidation } from \"./cache-invalidation\";\nimport { getActiveFarmI18nSnapshot } from \"./i18n/bridge\";\n\nexport { applyFarmCacheInvalidations } from \"./cache-invalidation\";\n\nexport type RevalidateTagProfile =\n  | \"max\"\n  | \"default\"\n  | \"seconds\"\n  | \"minutes\"\n  | \"hours\"\n  | \"days\"\n  | \"weeks\"\n  | \"months\"\n  | { expire?: number };\n\nexport interface FarmCacheOptions {\n  /**\n   * Tag cached data so it can be invalidated with revalidateTag/updateTag.\n   */\n  tags?: readonly string[];\n  /**\n   * Path tags let revalidatePath invalidate data tied to a route.\n   */\n  paths?: readonly string[];\n  /**\n   * Time in seconds before the entry becomes stale. False means no TTL.\n   */\n  revalidate?: number | false;\n}\n\nexport interface FarmCacheSetOptions extends FarmCacheOptions {\n  createdAt?: number;\n}\n\nexport type RouteDataCacheKey = string | readonly unknown[];\n\nexport interface FarmCacheEntry<T = unknown> {\n  key: string;\n  value: T;\n  tags: readonly string[];\n  createdAt: number;\n  createdVersion?: number;\n  revalidate?: number | false;\n}\n\ninterface InternalFarmCacheEntry<T = unknown> {\n  key: string;\n  value: T;\n  tags: Set<string>;\n  createdAt: number;\n  createdVersion: number;\n  revalidate?: number | false;\n}\n\nexport interface GetFarmCacheEntryOptions {\n  allowStale?: boolean;\n  now?: number;\n}\n\ninterface FarmCacheStaleEntry {\n  tags: Iterable<string>;\n  createdAt: number;\n  createdVersion?: number;\n  revalidate?: number | false;\n}\n\nexport class FarmDataCache {\n  private entries = new Map<string, InternalFarmCacheEntry>();\n  private inflight = new Map<string, Promise<unknown>>();\n  private invalidatedTagVersions = new Map<string, number>();\n  private version = 0;\n\n  get size(): number {\n    return this.entries.size;\n  }\n\n  get<T>(key: string, options: GetFarmCacheEntryOptions = {}): T | undefined {\n    return this.getEntry<T>(key, options)?.value;\n  }\n\n  getEntry<T = unknown>(\n    key: string,\n    options: GetFarmCacheEntryOptions = {},\n  ): FarmCacheEntry<T> | undefined {\n    const entry = this.entries.get(key) as InternalFarmCacheEntry<T> | undefined;\n    if (!entry) {\n      emitFarmEvent({ type: \"cache.miss\", key });\n      return undefined;\n    }\n\n    const stale = this.isStale(entry, options.now);\n    if (stale) {\n      emitFarmEvent({\n        type: \"cache.stale\",\n        key,\n        tags: Array.from(entry.tags),\n        revalidate: entry.revalidate,\n      });\n    }\n\n    if (!options.allowStale && stale) {\n      emitFarmEvent({ type: \"cache.miss\", key, reason: \"stale\" });\n      return undefined;\n    }\n\n    emitFarmEvent({\n      type: \"cache.hit\",\n      key,\n      tags: Array.from(entry.tags),\n      revalidate: entry.revalidate,\n      stale,\n    });\n\n    return this.toPublicEntry(entry);\n  }\n\n  set<T>(key: string, value: T, options: FarmCacheSetOptions = {}): FarmCacheEntry<T> {\n    const tags = new Set<string>();\n    for (const tag of options.tags ?? []) {\n      tags.add(normalizeCacheTag(tag));\n    }\n    for (const routePath of options.paths ?? []) {\n      tags.add(createPathCacheTag(routePath));\n    }\n\n    const entry: InternalFarmCacheEntry<T> = {\n      key,\n      value,\n      tags,\n      createdAt: options.createdAt ?? Date.now(),\n      createdVersion: ++this.version,\n      revalidate: normalizeRevalidate(options.revalidate),\n    };\n\n    this.entries.set(key, entry);\n    emitFarmEvent({\n      type: \"cache.set\",\n      key,\n      tags: Array.from(tags),\n      revalidate: entry.revalidate,\n    });\n    return this.toPublicEntry(entry);\n  }\n\n  delete(key: string): boolean {\n    const deleted = this.entries.delete(key);\n    emitFarmEvent({ type: \"cache.delete\", key, deleted });\n    return deleted;\n  }\n\n  clear(): void {\n    const count = this.entries.size;\n    this.entries.clear();\n    this.inflight.clear();\n    this.invalidatedTagVersions.clear();\n    this.version = 0;\n    emitFarmEvent({ type: \"cache.clear\", count });\n  }\n\n  isStale(entry: FarmCacheStaleEntry, now = Date.now()): boolean {\n    if (\n      typeof entry.revalidate === \"number\" &&\n      entry.revalidate > 0 &&\n      now - entry.createdAt >= entry.revalidate * 1000\n    ) {\n      return true;\n    }\n\n    for (const tag of entry.tags) {\n      const invalidatedVersion = this.invalidatedTagVersions.get(normalizeCacheTag(tag));\n      if (\n        typeof invalidatedVersion === \"number\" &&\n        typeof entry.createdVersion === \"number\" &&\n        invalidatedVersion > entry.createdVersion\n      ) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  revalidateTag(\n    tag: string,\n    options: { source?: \"revalidateTag\" | \"updateTag\"; profile?: RevalidateTagProfile } = {},\n  ): number {\n    const normalized = normalizeCacheTag(tag);\n    const count = this.invalidateTag(normalized);\n    emitFarmEvent(\n      options.source === \"updateTag\"\n        ? { type: \"cache.updateTag\", tag: normalized, count }\n        : { type: \"cache.revalidateTag\", tag: normalized, profile: options.profile, count },\n    );\n    return count;\n  }\n\n  revalidatePath(routePath: string): number {\n    const normalizedPath = normalizeRevalidatePath(routePath);\n    const pathTag = createPathCacheTag(normalizedPath);\n    const pprCount = this.countEntriesForTags([pathTag, \"ppr\"]);\n    const count = this.invalidateTag(pathTag);\n    emitFarmEvent({ type: \"cache.revalidatePath\", path: normalizedPath, count });\n\n    if (pprCount > 0) {\n      emitFarmEvent({\n        type: \"ppr.shell.invalidated\",\n        route: normalizedPath,\n        reason: \"revalidatePath\",\n        count: pprCount,\n      });\n    }\n\n    return count;\n  }\n\n  async getOrSet<T>(\n    key: string,\n    producer: () => Promise<T> | T,\n    options: FarmCacheOptions = {},\n  ): Promise<T> {\n    const cached = this.getEntry<T>(key);\n    if (cached) {\n      return cached.value;\n    }\n\n    const inflight = this.inflight.get(key) as Promise<T> | undefined;\n    if (inflight) {\n      emitFarmEvent({ type: \"cache.dedupe\", key });\n      return inflight;\n    }\n\n    const promise = Promise.resolve()\n      .then(producer)\n      .then((value) => {\n        this.set(key, value, options);\n        return value;\n      })\n      .catch((error) => {\n        emitFarmEvent({ type: \"cache.error\", key, operation: \"set\", error });\n        throw error;\n      })\n      .finally(() => {\n        this.inflight.delete(key);\n      });\n\n    this.inflight.set(key, promise);\n    return promise;\n  }\n\n  private countEntriesForTag(tag: string): number {\n    let count = 0;\n    for (const entry of this.entries.values()) {\n      if (entry.tags.has(tag)) {\n        count++;\n      }\n    }\n    return count;\n  }\n\n  private countEntriesForTags(tags: readonly string[]): number {\n    let count = 0;\n    for (const entry of this.entries.values()) {\n      if (tags.every((tag) => entry.tags.has(tag))) {\n        count++;\n      }\n    }\n    return count;\n  }\n\n  private invalidateTag(normalizedTag: string): number {\n    this.invalidatedTagVersions.set(normalizedTag, ++this.version);\n    return this.countEntriesForTag(normalizedTag);\n  }\n\n  private toPublicEntry<T>(entry: InternalFarmCacheEntry<T>): FarmCacheEntry<T> {\n    return {\n      key: entry.key,\n      value: entry.value,\n      tags: Array.from(entry.tags),\n      createdAt: entry.createdAt,\n      createdVersion: entry.createdVersion,\n      revalidate: entry.revalidate,\n    };\n  }\n}\n\nconst FARM_DATA_CACHE_SYMBOL = Symbol.for(\"farm.dataCache\");\nconst farmDataCacheGlobal = globalThis as typeof globalThis & {\n  [FARM_DATA_CACHE_SYMBOL]?: FarmDataCache;\n};\nconst sharedFarmDataCache = (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] ??= new FarmDataCache());\nconst functionIds = new WeakMap<Function, number>();\nlet nextFunctionId = 0;\n\nexport function getFarmDataCache(): FarmDataCache {\n  return sharedFarmDataCache;\n}\n\nexport function unstable_cache<Args extends unknown[], Result>(\n  fn: (...args: Args) => Result | Promise<Result>,\n  keyParts: readonly unknown[] = [],\n  options: FarmCacheOptions = {},\n): (...args: Args) => Promise<Result> {\n  return async (...args: Args): Promise<Result> => {\n    const locale = getActiveFarmI18nSnapshot()?.locale;\n    const key = createFarmCacheKey([\n      \"unstable_cache\",\n      getFunctionCacheIdentity(fn),\n      locale ? [\"locale\", locale] : null,\n      keyParts,\n      args,\n    ]);\n    return getFarmDataCache().getOrSet<Result>(key, () => fn(...args), options);\n  };\n}\n\nexport function revalidateTag(_tag: string, _profile?: RevalidateTagProfile): void {\n  getFarmDataCache().revalidateTag(_tag, {\n    source: \"revalidateTag\",\n    profile: _profile,\n  });\n}\n\nexport function updateTag(tag: string): void {\n  getFarmDataCache().revalidateTag(tag, { source: \"updateTag\" });\n}\n\nexport function revalidatePath(routePath: string): void {\n  getFarmDataCache().revalidatePath(routePath);\n}\n\nexport function invalidate(key: RouteDataCacheKey): void {\n  const clientKey = createRouteDataCacheKey(key);\n  getFarmDataCache().revalidateTag(createRouteDataCacheTag(key), { source: \"updateTag\" });\n  notifyFarmCacheInvalidation(clientKey);\n}\n\nexport function invalidateRouteData(key: RouteDataCacheKey): void {\n  invalidate(key);\n}\n\nexport function createPathCacheTag(routePath: string): string {\n  return `path:${normalizeRevalidatePath(routePath)}`;\n}\n\nexport function createRouteDataCacheTag(key: RouteDataCacheKey): string {\n  return `route-data:${createRouteDataCacheKey(key)}`;\n}\n\nexport function createRouteDataCacheKey(key: RouteDataCacheKey): string {\n  return createFarmCacheKey(Array.isArray(key) ? key : [key]);\n}\n\nexport function normalizeRevalidatePath(routePath: string): string {\n  if (typeof routePath !== \"string\") {\n    throw new TypeError(\"revalidatePath expects a path string.\");\n  }\n\n  let normalized = routePath.trim();\n  if (!normalized) {\n    throw new Error(\"revalidatePath expects a non-empty path.\");\n  }\n\n  try {\n    if (/^https?:\\/\\//.test(normalized)) {\n      normalized = new URL(normalized).pathname;\n    }\n  } catch {\n    // Keep the original path if URL parsing fails.\n  }\n\n  normalized = normalized.split(\"?\")[0] ?? normalized;\n  normalized = normalized.startsWith(\"/\") ? normalized : `/${normalized}`;\n  normalized = normalized.replace(/\\/{2,}/g, \"/\");\n  if (normalized.length > 1) {\n    normalized = normalized.replace(/\\/+$/, \"\");\n  }\n  return normalized || \"/\";\n}\n\nexport function createFarmCacheKey(parts: readonly unknown[]): string {\n  return stableSerialize(parts);\n}\n\nfunction normalizeRevalidate(revalidate: number | false | undefined): number | false | undefined {\n  if (revalidate === false || revalidate === undefined) {\n    return revalidate;\n  }\n  if (!Number.isFinite(revalidate) || revalidate <= 0) {\n    return undefined;\n  }\n  return revalidate;\n}\n\nfunction normalizeCacheTag(tag: string): string {\n  if (typeof tag !== \"string\") {\n    throw new TypeError(\"Cache tags must be strings.\");\n  }\n  const normalized = tag.trim();\n  if (!normalized) {\n    throw new Error(\"Cache tags cannot be empty.\");\n  }\n  return normalized;\n}\n\nfunction getFunctionCacheIdentity(fn: Function): string {\n  if (fn.name) {\n    return `name:${fn.name}`;\n  }\n\n  let id = functionIds.get(fn);\n  if (!id) {\n    id = ++nextFunctionId;\n    functionIds.set(fn, id);\n  }\n  return `anonymous:${id}`;\n}\n\nfunction stableSerialize(value: unknown, seen = new WeakSet<object>()): string {\n  if (value === null) return \"null\";\n  if (value === undefined) return \"undefined\";\n\n  const valueType = typeof value;\n  if (valueType === \"string\") return JSON.stringify(value);\n  if (valueType === \"number\" || valueType === \"boolean\" || valueType === \"bigint\") {\n    return `${valueType}:${String(value)}`;\n  }\n  if (valueType === \"symbol\") {\n    return `symbol:${String(value)}`;\n  }\n  if (valueType === \"function\") {\n    return `function:${getFunctionCacheIdentity(value as Function)}`;\n  }\n\n  if (value instanceof Date) {\n    return `date:${value.toISOString()}`;\n  }\n  if (value instanceof URL) {\n    return `url:${value.toString()}`;\n  }\n  if (value instanceof RegExp) {\n    return `regexp:${value.toString()}`;\n  }\n\n  if (Array.isArray(value)) {\n    return `[${value.map((item) => stableSerialize(item, seen)).join(\",\")}]`;\n  }\n\n  if (value && typeof value === \"object\") {\n    if (seen.has(value)) {\n      return \"[Circular]\";\n    }\n    seen.add(value);\n\n    const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) =>\n      a.localeCompare(b),\n    );\n    const serialized = entries\n      .map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`)\n      .join(\",\");\n\n    seen.delete(value);\n    return `{${serialized}}`;\n  }\n\n  return String(value);\n}\n"],"mappings":";;;;;;;;;;;;;;AAoEO,IAAM,iBAAN,MAAM,eAAc;AAAA,EAApB;AACL,SAAQ,UAAU,oBAAI,IAAoC;AAC1D,SAAQ,WAAW,oBAAI,IAA8B;AACrD,SAAQ,yBAAyB,oBAAI,IAAoB;AACzD,SAAQ,UAAU;AAAA;AAAA,EAElB,IAAI,OAAe;AACjB,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA,EAEA,IAAO,KAAa,UAAoC,CAAC,GAAkB;AACzE,WAAO,KAAK,SAAY,KAAK,OAAO,GAAG;AAAA,EACzC;AAAA,EAEA,SACE,KACA,UAAoC,CAAC,GACN;AAC/B,UAAM,QAAQ,KAAK,QAAQ,IAAI,GAAG;AAClC,QAAI,CAAC,OAAO;AACV,oBAAc,EAAE,MAAM,cAAc,IAAI,CAAC;AACzC,aAAO;AAAA,IACT;AAEA,UAAM,QAAQ,KAAK,QAAQ,OAAO,QAAQ,GAAG;AAC7C,QAAI,OAAO;AACT,oBAAc;AAAA,QACZ,MAAM;AAAA,QACN;AAAA,QACA,MAAM,MAAM,KAAK,MAAM,IAAI;AAAA,QAC3B,YAAY,MAAM;AAAA,MACpB,CAAC;AAAA,IACH;AAEA,QAAI,CAAC,QAAQ,cAAc,OAAO;AAChC,oBAAc,EAAE,MAAM,cAAc,KAAK,QAAQ,QAAQ,CAAC;AAC1D,aAAO;AAAA,IACT;AAEA,kBAAc;AAAA,MACZ,MAAM;AAAA,MACN;AAAA,MACA,MAAM,MAAM,KAAK,MAAM,IAAI;AAAA,MAC3B,YAAY,MAAM;AAAA,MAClB;AAAA,IACF,CAAC;AAED,WAAO,KAAK,cAAc,KAAK;AAAA,EACjC;AAAA,EAEA,IAAO,KAAa,OAAU,UAA+B,CAAC,GAAsB;AAClF,UAAM,OAAO,oBAAI,IAAY;AAC7B,eAAW,OAAO,QAAQ,QAAQ,CAAC,GAAG;AACpC,WAAK,IAAI,kBAAkB,GAAG,CAAC;AAAA,IACjC;AACA,eAAW,aAAa,QAAQ,SAAS,CAAC,GAAG;AAC3C,WAAK,IAAI,mBAAmB,SAAS,CAAC;AAAA,IACxC;AAEA,UAAM,QAAmC;AAAA,MACvC;AAAA,MACA;AAAA,MACA;AAAA,MACA,WAAW,QAAQ,aAAa,KAAK,IAAI;AAAA,MACzC,gBAAgB,EAAE,KAAK;AAAA,MACvB,YAAY,oBAAoB,QAAQ,UAAU;AAAA,IACpD;AAEA,SAAK,QAAQ,IAAI,KAAK,KAAK;AAC3B,kBAAc;AAAA,MACZ,MAAM;AAAA,MACN;AAAA,MACA,MAAM,MAAM,KAAK,IAAI;AAAA,MACrB,YAAY,MAAM;AAAA,IACpB,CAAC;AACD,WAAO,KAAK,cAAc,KAAK;AAAA,EACjC;AAAA,EAEA,OAAO,KAAsB;AAC3B,UAAM,UAAU,KAAK,QAAQ,OAAO,GAAG;AACvC,kBAAc,EAAE,MAAM,gBAAgB,KAAK,QAAQ,CAAC;AACpD,WAAO;AAAA,EACT;AAAA,EAEA,QAAc;AACZ,UAAM,QAAQ,KAAK,QAAQ;AAC3B,SAAK,QAAQ,MAAM;AACnB,SAAK,SAAS,MAAM;AACpB,SAAK,uBAAuB,MAAM;AAClC,SAAK,UAAU;AACf,kBAAc,EAAE,MAAM,eAAe,MAAM,CAAC;AAAA,EAC9C;AAAA,EAEA,QAAQ,OAA4B,MAAM,KAAK,IAAI,GAAY;AAC7D,QACE,OAAO,MAAM,eAAe,YAC5B,MAAM,aAAa,KACnB,MAAM,MAAM,aAAa,MAAM,aAAa,KAC5C;AACA,aAAO;AAAA,IACT;AAEA,eAAW,OAAO,MAAM,MAAM;AAC5B,YAAM,qBAAqB,KAAK,uBAAuB,IAAI,kBAAkB,GAAG,CAAC;AACjF,UACE,OAAO,uBAAuB,YAC9B,OAAO,MAAM,mBAAmB,YAChC,qBAAqB,MAAM,gBAC3B;AACA,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,cACE,KACA,UAAsF,CAAC,GAC/E;AACR,UAAM,aAAa,kBAAkB,GAAG;AACxC,UAAM,QAAQ,KAAK,cAAc,UAAU;AAC3C;AAAA,MACE,QAAQ,WAAW,cACf,EAAE,MAAM,mBAAmB,KAAK,YAAY,MAAM,IAClD,EAAE,MAAM,uBAAuB,KAAK,YAAY,SAAS,QAAQ,SAAS,MAAM;AAAA,IACtF;AACA,WAAO;AAAA,EACT;AAAA,EAEA,eAAe,WAA2B;AACxC,UAAM,iBAAiB,wBAAwB,SAAS;AACxD,UAAM,UAAU,mBAAmB,cAAc;AACjD,UAAM,WAAW,KAAK,oBAAoB,CAAC,SAAS,KAAK,CAAC;AAC1D,UAAM,QAAQ,KAAK,cAAc,OAAO;AACxC,kBAAc,EAAE,MAAM,wBAAwB,MAAM,gBAAgB,MAAM,CAAC;AAE3E,QAAI,WAAW,GAAG;AAChB,oBAAc;AAAA,QACZ,MAAM;AAAA,QACN,OAAO;AAAA,QACP,QAAQ;AAAA,QACR,OAAO;AAAA,MACT,CAAC;AAAA,IACH;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,SACJ,KACA,UACA,UAA4B,CAAC,GACjB;AACZ,UAAM,SAAS,KAAK,SAAY,GAAG;AACnC,QAAI,QAAQ;AACV,aAAO,OAAO;AAAA,IAChB;AAEA,UAAM,WAAW,KAAK,SAAS,IAAI,GAAG;AACtC,QAAI,UAAU;AACZ,oBAAc,EAAE,MAAM,gBAAgB,IAAI,CAAC;AAC3C,aAAO;AAAA,IACT;AAEA,UAAM,UAAU,QAAQ,QAAQ,EAC7B,KAAK,QAAQ,EACb,KAAK,CAAC,UAAU;AACf,WAAK,IAAI,KAAK,OAAO,OAAO;AAC5B,aAAO;AAAA,IACT,CAAC,EACA,MAAM,CAAC,UAAU;AAChB,oBAAc,EAAE,MAAM,eAAe,KAAK,WAAW,OAAO,MAAM,CAAC;AACnE,YAAM;AAAA,IACR,CAAC,EACA,QAAQ,MAAM;AACb,WAAK,SAAS,OAAO,GAAG;AAAA,IAC1B,CAAC;AAEH,SAAK,SAAS,IAAI,KAAK,OAAO;AAC9B,WAAO;AAAA,EACT;AAAA,EAEQ,mBAAmB,KAAqB;AAC9C,QAAI,QAAQ;AACZ,eAAW,SAAS,KAAK,QAAQ,OAAO,GAAG;AACzC,UAAI,MAAM,KAAK,IAAI,GAAG,GAAG;AACvB;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EAEQ,oBAAoB,MAAiC;AAC3D,QAAI,QAAQ;AACZ,eAAW,SAAS,KAAK,QAAQ,OAAO,GAAG;AACzC,UAAI,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,IAAI,GAAG,CAAC,GAAG;AAC5C;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EAEQ,cAAc,eAA+B;AACnD,SAAK,uBAAuB,IAAI,eAAe,EAAE,KAAK,OAAO;AAC7D,WAAO,KAAK,mBAAmB,aAAa;AAAA,EAC9C;AAAA,EAEQ,cAAiB,OAAqD;AAC5E,WAAO;AAAA,MACL,KAAK,MAAM;AAAA,MACX,OAAO,MAAM;AAAA,MACb,MAAM,MAAM,KAAK,MAAM,IAAI;AAAA,MAC3B,WAAW,MAAM;AAAA,MACjB,gBAAgB,MAAM;AAAA,MACtB,YAAY,MAAM;AAAA,IACpB;AAAA,EACF;AACF;AA1N2B;AAApB,IAAM,gBAAN;AA4NP,IAAM,yBAAyB,uBAAO,IAAI,gBAAgB;AAC1D,IAAM,sBAAsB;AAG5B,IAAM,sBAAuB,8FAAgD,IAAI,cAAc;AAC/F,IAAM,cAAc,oBAAI,QAA0B;AAClD,IAAI,iBAAiB;AAEd,SAAS,mBAAkC;AAChD,SAAO;AACT;AAFgB;AAIT,SAAS,eACd,IACA,WAA+B,CAAC,GAChC,UAA4B,CAAC,GACO;AACpC,SAAO,UAAU,SAAgC;AAC/C,UAAM,SAAS,0BAA0B,GAAG;AAC5C,UAAM,MAAM,mBAAmB;AAAA,MAC7B;AAAA,MACA,yBAAyB,EAAE;AAAA,MAC3B,SAAS,CAAC,UAAU,MAAM,IAAI;AAAA,MAC9B;AAAA,MACA;AAAA,IACF,CAAC;AACD,WAAO,iBAAiB,EAAE,SAAiB,KAAK,MAAM,GAAG,GAAG,IAAI,GAAG,OAAO;AAAA,EAC5E;AACF;AAhBgB;AAkBT,SAAS,cAAc,MAAc,UAAuC;AACjF,mBAAiB,EAAE,cAAc,MAAM;AAAA,IACrC,QAAQ;AAAA,IACR,SAAS;AAAA,EACX,CAAC;AACH;AALgB;AAOT,SAAS,UAAU,KAAmB;AAC3C,mBAAiB,EAAE,cAAc,KAAK,EAAE,QAAQ,YAAY,CAAC;AAC/D;AAFgB;AAIT,SAAS,eAAe,WAAyB;AACtD,mBAAiB,EAAE,eAAe,SAAS;AAC7C;AAFgB;AAIT,SAAS,WAAW,KAA8B;AACvD,QAAM,YAAY,wBAAwB,GAAG;AAC7C,mBAAiB,EAAE,cAAc,wBAAwB,GAAG,GAAG,EAAE,QAAQ,YAAY,CAAC;AACtF,8BAA4B,SAAS;AACvC;AAJgB;AAMT,SAAS,oBAAoB,KAA8B;AAChE,aAAW,GAAG;AAChB;AAFgB;AAIT,SAAS,mBAAmB,WAA2B;AAC5D,SAAO,QAAQ,wBAAwB,SAAS,CAAC;AACnD;AAFgB;AAIT,SAAS,wBAAwB,KAAgC;AACtE,SAAO,cAAc,wBAAwB,GAAG,CAAC;AACnD;AAFgB;AAIT,SAAS,wBAAwB,KAAgC;AACtE,SAAO,mBAAmB,MAAM,QAAQ,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC;AAC5D;AAFgB;AAIT,SAAS,wBAAwB,WAA2B;AACjE,MAAI,OAAO,cAAc,UAAU;AACjC,UAAM,IAAI,UAAU,uCAAuC;AAAA,EAC7D;AAEA,MAAI,aAAa,UAAU,KAAK;AAChC,MAAI,CAAC,YAAY;AACf,UAAM,IAAI,MAAM,0CAA0C;AAAA,EAC5D;AAEA,MAAI;AACF,QAAI,eAAe,KAAK,UAAU,GAAG;AACnC,mBAAa,IAAI,IAAI,UAAU,EAAE;AAAA,IACnC;AAAA,EACF,QAAQ;AAAA,EAER;AAEA,eAAa,WAAW,MAAM,GAAG,EAAE,CAAC,KAAK;AACzC,eAAa,WAAW,WAAW,GAAG,IAAI,aAAa,IAAI,UAAU;AACrE,eAAa,WAAW,QAAQ,WAAW,GAAG;AAC9C,MAAI,WAAW,SAAS,GAAG;AACzB,iBAAa,WAAW,QAAQ,QAAQ,EAAE;AAAA,EAC5C;AACA,SAAO,cAAc;AACvB;AAzBgB;AA2BT,SAAS,mBAAmB,OAAmC;AACpE,SAAO,gBAAgB,KAAK;AAC9B;AAFgB;AAIhB,SAAS,oBAAoB,YAAoE;AAC/F,MAAI,eAAe,SAAS,eAAe,QAAW;AACpD,WAAO;AAAA,EACT;AACA,MAAI,CAAC,OAAO,SAAS,UAAU,KAAK,cAAc,GAAG;AACnD,WAAO;AAAA,EACT;AACA,SAAO;AACT;AARS;AAUT,SAAS,kBAAkB,KAAqB;AAC9C,MAAI,OAAO,QAAQ,UAAU;AAC3B,UAAM,IAAI,UAAU,6BAA6B;AAAA,EACnD;AACA,QAAM,aAAa,IAAI,KAAK;AAC5B,MAAI,CAAC,YAAY;AACf,UAAM,IAAI,MAAM,6BAA6B;AAAA,EAC/C;AACA,SAAO;AACT;AATS;AAWT,SAAS,yBAAyB,IAAsB;AACtD,MAAI,GAAG,MAAM;AACX,WAAO,QAAQ,GAAG,IAAI;AAAA,EACxB;AAEA,MAAI,KAAK,YAAY,IAAI,EAAE;AAC3B,MAAI,CAAC,IAAI;AACP,SAAK,EAAE;AACP,gBAAY,IAAI,IAAI,EAAE;AAAA,EACxB;AACA,SAAO,aAAa,EAAE;AACxB;AAXS;AAaT,SAAS,gBAAgB,OAAgB,OAAO,oBAAI,QAAgB,GAAW;AAC7E,MAAI,UAAU,KAAM,QAAO;AAC3B,MAAI,UAAU,OAAW,QAAO;AAEhC,QAAM,YAAY,OAAO;AACzB,MAAI,cAAc,SAAU,QAAO,KAAK,UAAU,KAAK;AACvD,MAAI,cAAc,YAAY,cAAc,aAAa,cAAc,UAAU;AAC/E,WAAO,GAAG,SAAS,IAAI,OAAO,KAAK,CAAC;AAAA,EACtC;AACA,MAAI,cAAc,UAAU;AAC1B,WAAO,UAAU,OAAO,KAAK,CAAC;AAAA,EAChC;AACA,MAAI,cAAc,YAAY;AAC5B,WAAO,YAAY,yBAAyB,KAAiB,CAAC;AAAA,EAChE;AAEA,MAAI,iBAAiB,MAAM;AACzB,WAAO,QAAQ,MAAM,YAAY,CAAC;AAAA,EACpC;AACA,MAAI,iBAAiB,KAAK;AACxB,WAAO,OAAO,MAAM,SAAS,CAAC;AAAA,EAChC;AACA,MAAI,iBAAiB,QAAQ;AAC3B,WAAO,UAAU,MAAM,SAAS,CAAC;AAAA,EACnC;AAEA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO,IAAI,MAAM,IAAI,CAAC,SAAS,gBAAgB,MAAM,IAAI,CAAC,EAAE,KAAK,GAAG,CAAC;AAAA,EACvE;AAEA,MAAI,SAAS,OAAO,UAAU,UAAU;AACtC,QAAI,KAAK,IAAI,KAAK,GAAG;AACnB,aAAO;AAAA,IACT;AACA,SAAK,IAAI,KAAK;AAEd,UAAM,UAAU,OAAO,QAAQ,KAAgC,EAAE;AAAA,MAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAC5E,EAAE,cAAc,CAAC;AAAA,IACnB;AACA,UAAM,aAAa,QAChB,IAAI,CAAC,CAAC,KAAK,IAAI,MAAM,GAAG,KAAK,UAAU,GAAG,CAAC,IAAI,gBAAgB,MAAM,IAAI,CAAC,EAAE,EAC5E,KAAK,GAAG;AAEX,SAAK,OAAO,KAAK;AACjB,WAAO,IAAI,UAAU;AAAA,EACvB;AAEA,SAAO,OAAO,KAAK;AACrB;AAhDS;","names":[]}

package/dist/chunk-4S3ORGFA.mjs

@@ -0,0 +1,44 @@
+import {
+  __name
+} from "./chunk-CGILA3WO.mjs";
+
+// src/build/production-node-env.ts
+var productionNodeEnvStateKey = /* @__PURE__ */ Symbol.for("@farm.js/core/production-node-env-state");
+function getProductionNodeEnvState() {
+  return Reflect.get(globalThis, productionNodeEnvStateKey);
+}
+__name(getProductionNodeEnvState, "getProductionNodeEnvState");
+async function withProductionNodeEnv(operation) {
+  let state = getProductionNodeEnvState();
+  if (state) {
+    state.depth += 1;
+  } else {
+    state = {
+      depth: 1,
+      original: process.env.NODE_ENV
+    };
+    Reflect.set(globalThis, productionNodeEnvStateKey, state);
+  }
+  process.env.NODE_ENV = "production";
+  try {
+    return await operation();
+  } finally {
+    state.depth -= 1;
+    if (state.depth > 0) {
+      process.env.NODE_ENV = "production";
+    } else {
+      Reflect.deleteProperty(globalThis, productionNodeEnvStateKey);
+      if (state.original === void 0) {
+        delete process.env.NODE_ENV;
+      } else {
+        process.env.NODE_ENV = state.original;
+      }
+    }
+  }
+}
+__name(withProductionNodeEnv, "withProductionNodeEnv");
+
+export {
+  withProductionNodeEnv
+};
+//# sourceMappingURL=chunk-4S3ORGFA.mjs.map

package/dist/chunk-4S3ORGFA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/build/production-node-env.ts"],"sourcesContent":["const productionNodeEnvStateKey = Symbol.for(\"@farm.js/core/production-node-env-state\");\n\ninterface ProductionNodeEnvState {\n  depth: number;\n  original: string | undefined;\n}\n\nfunction getProductionNodeEnvState(): ProductionNodeEnvState | undefined {\n  return Reflect.get(globalThis, productionNodeEnvStateKey) as ProductionNodeEnvState | undefined;\n}\n\n/**\n * Keep overlapping production operations on the production condition.\n *\n * The state lives on `globalThis` so independently loaded CJS/ESM copies of\n * Farm share one refcount. The first entrant captures the caller's value and\n * only the last operation to settle restores it.\n *\n * @internal\n */\nexport async function withProductionNodeEnv<T>(operation: () => T | PromiseLike<T>): Promise<T> {\n  let state = getProductionNodeEnvState();\n\n  if (state) {\n    state.depth += 1;\n  } else {\n    state = {\n      depth: 1,\n      original: process.env.NODE_ENV,\n    };\n    Reflect.set(globalThis, productionNodeEnvStateKey, state);\n  }\n\n  process.env.NODE_ENV = \"production\";\n\n  try {\n    return await operation();\n  } finally {\n    state.depth -= 1;\n\n    if (state.depth > 0) {\n      // A nested operation may have changed NODE_ENV. Keep the remaining\n      // production scopes pinned until the final scope settles.\n      process.env.NODE_ENV = \"production\";\n    } else {\n      Reflect.deleteProperty(globalThis, productionNodeEnvStateKey);\n      if (state.original === undefined) {\n        delete process.env.NODE_ENV;\n      } else {\n        process.env.NODE_ENV = state.original;\n      }\n    }\n  }\n}\n"],"mappings":";;;;;AAAA,IAAM,4BAA4B,uBAAO,IAAI,yCAAyC;AAOtF,SAAS,4BAAgE;AACvE,SAAO,QAAQ,IAAI,YAAY,yBAAyB;AAC1D;AAFS;AAaT,eAAsB,sBAAyB,WAAiD;AAC9F,MAAI,QAAQ,0BAA0B;AAEtC,MAAI,OAAO;AACT,UAAM,SAAS;AAAA,EACjB,OAAO;AACL,YAAQ;AAAA,MACN,OAAO;AAAA,MACP,UAAU,QAAQ,IAAI;AAAA,IACxB;AACA,YAAQ,IAAI,YAAY,2BAA2B,KAAK;AAAA,EAC1D;AAEA,UAAQ,IAAI,WAAW;AAEvB,MAAI;AACF,WAAO,MAAM,UAAU;AAAA,EACzB,UAAE;AACA,UAAM,SAAS;AAEf,QAAI,MAAM,QAAQ,GAAG;AAGnB,cAAQ,IAAI,WAAW;AAAA,IACzB,OAAO;AACL,cAAQ,eAAe,YAAY,yBAAyB;AAC5D,UAAI,MAAM,aAAa,QAAW;AAChC,eAAO,QAAQ,IAAI;AAAA,MACrB,OAAO;AACL,gBAAQ,IAAI,WAAW,MAAM;AAAA,MAC/B;AAAA,IACF;AAAA,EACF;AACF;AAjCsB;","names":[]}

package/dist/chunk-5BY76U2M.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-5BY76U2M.mjs.map

package/dist/chunk-5BY76U2M.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-5ZGPRGWV.mjs

@@ -0,0 +1,136 @@
+import {
+  resolveStorageRuntimeClient
+} from "./chunk-T4QJQK76.mjs";
+import {
+  __name
+} from "./chunk-CGILA3WO.mjs";
+
+// src/integration-orm.ts
+async function createIntegrationOrm(options) {
+  const [schema, client] = await Promise.all([
+    farmIntegrationSchemaToOrmSchema(options.schema),
+    resolveIntegrationOrmRuntimeClient(options)
+  ]);
+  if (!client) {
+    throw new Error(
+      "Schema-backed integration storage requires a runtime client at farm.config storage.client."
+    );
+  }
+  const { createOrmFromRuntime } = await import("@farming-labs/orm-runtime");
+  return createOrmFromRuntime({
+    schema,
+    client
+  });
+}
+__name(createIntegrationOrm, "createIntegrationOrm");
+async function resolveIntegrationOrmRuntimeClient(options) {
+  if (options.client !== void 0) {
+    return typeof options.client === "function" ? await options.client() : options.client;
+  }
+  return resolveStorageRuntimeClient(options.storage ?? options.config?.storage);
+}
+__name(resolveIntegrationOrmRuntimeClient, "resolveIntegrationOrmRuntimeClient");
+async function farmIntegrationSchemaToOrmSchema(schema) {
+  const orm = await import("@farming-labs/orm");
+  const models = {};
+  for (const [modelKey, modelSchema] of Object.entries(schema.models)) {
+    models[modelKey] = orm.model({
+      table: modelSchema.name ?? modelKey,
+      fields: createOrmModelFields(orm, modelSchema),
+      constraints: createOrmModelConstraints(modelSchema),
+      description: modelSchema.description
+    });
+  }
+  return orm.defineSchema(models);
+}
+__name(farmIntegrationSchemaToOrmSchema, "farmIntegrationSchemaToOrmSchema");
+function createOrmModelFields(orm, modelSchema) {
+  return Object.fromEntries(
+    Object.entries(modelSchema.fields).map(([fieldKey, fieldSchema]) => [
+      fieldKey,
+      createOrmField(orm, fieldKey, fieldSchema)
+    ])
+  );
+}
+__name(createOrmModelFields, "createOrmModelFields");
+function createOrmField(orm, fieldKey, field) {
+  let builder = createOrmFieldBuilder(orm, fieldKey, field);
+  if (field.unique) {
+    builder = builder.unique();
+  }
+  if (field.nullable || field.required === false) {
+    builder = builder.nullable();
+  }
+  if (field.default !== void 0) {
+    builder = field.type === "datetime" && field.default === "now" ? builder.defaultNow() : builder.default(field.default);
+  }
+  if (field.reference) {
+    builder = builder.references(`${field.reference.model}.${field.reference.field}`);
+  }
+  if (field.name && field.name !== fieldKey) {
+    builder = builder.map(field.name);
+  }
+  if (field.description) {
+    builder = builder.describe(field.description);
+  }
+  return builder;
+}
+__name(createOrmField, "createOrmField");
+function createOrmFieldBuilder(orm, fieldKey, field) {
+  switch (field.type) {
+    case "id":
+    case "uuid":
+      return orm.id();
+    case "string":
+    case "text":
+      return orm.string();
+    case "boolean":
+      return orm.boolean();
+    case "integer":
+      return orm.integer();
+    case "number":
+      return orm.decimal();
+    case "datetime":
+      return orm.datetime();
+    case "json":
+      return orm.json();
+    case "enum": {
+      if (!field.values?.length) {
+        throw new Error(`Integration schema enum field "${fieldKey}" must define values.`);
+      }
+      return orm.enumeration(field.values);
+    }
+    default:
+      throw new Error(
+        `Unsupported integration schema field type "${field.type}" for "${fieldKey}".`
+      );
+  }
+}
+__name(createOrmFieldBuilder, "createOrmFieldBuilder");
+function createOrmModelConstraints(modelSchema) {
+  const unique = [];
+  const indexes = [];
+  for (const constraint of modelSchema.constraints ?? []) {
+    if (!constraint.fields.length) {
+      continue;
+    }
+    const fields = constraint.fields;
+    if (constraint.type === "unique") {
+      unique.push(fields);
+    } else {
+      indexes.push(fields);
+    }
+  }
+  return {
+    unique,
+    indexes
+  };
+}
+__name(createOrmModelConstraints, "createOrmModelConstraints");
+
+export {
+  createIntegrationOrm,
+  resolveIntegrationOrmRuntimeClient,
+  farmIntegrationSchemaToOrmSchema
+};
+//# sourceMappingURL=chunk-5ZGPRGWV.mjs.map

package/dist/chunk-5ZGPRGWV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/integration-orm.ts"],"sourcesContent":["import type {\n  AnyFieldBuilder,\n  AnyModelDefinition,\n  FieldBuilder,\n  JsonValue,\n  ModelDefinition,\n  OrmClient,\n  SchemaDefinition,\n  SchemaModels,\n} from \"@farming-labs/orm\";\nimport type {\n  FarmIntegrationSchema,\n  FarmIntegrationSchemaField,\n  FarmIntegrationSchemaModel,\n} from \"./integrations\";\nimport { resolveStorageRuntimeClient } from \"./storage\";\nimport type { FarmStorageUserConfig } from \"./storage/types\";\nimport type { FarmConfig } from \"./types\";\n\ntype RuntimeClientFactory<TClient> = () => TClient | Promise<TClient>;\n\nexport type FarmIntegrationOrmSchema = SchemaDefinition<Record<string, AnyModelDefinition>>;\n\nexport type FarmIntegrationOrmClient<TSchema extends FarmIntegrationOrmSchema> = OrmClient<TSchema>;\n\ntype FarmIntegrationOrmFieldKind<TField extends FarmIntegrationSchemaField> = TField[\"type\"] extends\n  | \"id\"\n  | \"uuid\"\n  ? \"id\"\n  : TField[\"type\"] extends \"text\"\n    ? \"string\"\n    : TField[\"type\"] extends \"number\"\n      ? \"decimal\"\n      : Extract<TField[\"type\"], \"string\" | \"boolean\" | \"integer\" | \"datetime\" | \"json\" | \"enum\">;\n\ntype FarmIntegrationOrmFieldNullable<TField extends FarmIntegrationSchemaField> = TField extends {\n  nullable: true;\n}\n  ? true\n  : TField extends { required: false }\n    ? true\n    : false;\n\ntype FarmIntegrationOrmEnumValue<TField extends FarmIntegrationSchemaField> = TField extends {\n  values: readonly (infer TValue extends string)[];\n}\n  ? TValue\n  : string;\n\ntype FarmIntegrationOrmFieldValue<TField extends FarmIntegrationSchemaField> =\n  TField[\"type\"] extends \"id\" | \"uuid\" | \"string\" | \"text\"\n    ? string\n    : TField[\"type\"] extends \"boolean\"\n      ? boolean\n      : TField[\"type\"] extends \"integer\"\n        ? number\n        : TField[\"type\"] extends \"number\"\n          ? string\n          : TField[\"type\"] extends \"datetime\"\n            ? Date\n            : TField[\"type\"] extends \"json\"\n              ? JsonValue\n              : TField[\"type\"] extends \"enum\"\n                ? FarmIntegrationOrmEnumValue<TField>\n                : never;\n\nexport type InferFarmIntegrationOrmField<TField extends FarmIntegrationSchemaField> = FieldBuilder<\n  FarmIntegrationOrmFieldKind<TField>,\n  FarmIntegrationOrmFieldNullable<TField>,\n  FarmIntegrationOrmFieldValue<TField>\n>;\n\nexport type InferFarmIntegrationOrmFields<TModel extends FarmIntegrationSchemaModel> = {\n  [TFieldKey in keyof TModel[\"fields\"] & string]: InferFarmIntegrationOrmField<\n    Extract<TModel[\"fields\"][TFieldKey], FarmIntegrationSchemaField>\n  >;\n};\n\nexport type InferFarmIntegrationOrmSchema<TSchema extends FarmIntegrationSchema> =\n  SchemaDefinition<{\n    [TModelKey in keyof TSchema[\"models\"] & string]: ModelDefinition<\n      InferFarmIntegrationOrmFields<\n        Extract<TSchema[\"models\"][TModelKey], FarmIntegrationSchemaModel>\n      >,\n      {}\n    >;\n  }>;\n\nexport type InferFarmIntegrationOrmClient<TSchema extends FarmIntegrationSchema | undefined> =\n  TSchema extends FarmIntegrationSchema ? OrmClient<InferFarmIntegrationOrmSchema<TSchema>> : never;\n\nexport interface CreateIntegrationOrmOptions<\n  TClient = unknown,\n  TSchema extends FarmIntegrationSchema = FarmIntegrationSchema,\n> {\n  schema: TSchema;\n  config?: Pick<FarmConfig, \"storage\">;\n  storage?: FarmStorageUserConfig;\n  client?: TClient | RuntimeClientFactory<TClient>;\n}\n\nexport async function createIntegrationOrm<\n  TClient = unknown,\n  TSchema extends FarmIntegrationSchema = FarmIntegrationSchema,\n>(\n  options: CreateIntegrationOrmOptions<TClient, TSchema>,\n): Promise<InferFarmIntegrationOrmClient<TSchema>> {\n  const [schema, client] = await Promise.all([\n    farmIntegrationSchemaToOrmSchema(options.schema),\n    resolveIntegrationOrmRuntimeClient(options),\n  ]);\n\n  if (!client) {\n    throw new Error(\n      \"Schema-backed integration storage requires a runtime client at farm.config storage.client.\",\n    );\n  }\n\n  const { createOrmFromRuntime } = await import(\"@farming-labs/orm-runtime\");\n  return createOrmFromRuntime({\n    schema,\n    client,\n  }) as Promise<InferFarmIntegrationOrmClient<TSchema>>;\n}\n\nexport async function resolveIntegrationOrmRuntimeClient<TClient = unknown>(\n  options: Omit<CreateIntegrationOrmOptions<TClient>, \"schema\">,\n): Promise<TClient | unknown | undefined> {\n  if (options.client !== undefined) {\n    return typeof options.client === \"function\"\n      ? await (options.client as RuntimeClientFactory<TClient>)()\n      : options.client;\n  }\n\n  return resolveStorageRuntimeClient(options.storage ?? options.config?.storage);\n}\n\nexport async function farmIntegrationSchemaToOrmSchema(\n  schema: FarmIntegrationSchema,\n): Promise<FarmIntegrationOrmSchema> {\n  const orm = await import(\"@farming-labs/orm\");\n  const models: Record<string, AnyModelDefinition> = {};\n\n  for (const [modelKey, modelSchema] of Object.entries(schema.models)) {\n    models[modelKey] = orm.model({\n      table: modelSchema.name ?? modelKey,\n      fields: createOrmModelFields(orm, modelSchema),\n      constraints: createOrmModelConstraints(modelSchema),\n      description: modelSchema.description,\n    }) as AnyModelDefinition;\n  }\n\n  return orm.defineSchema(models) as FarmIntegrationOrmSchema;\n}\n\nfunction createOrmModelFields(\n  orm: typeof import(\"@farming-labs/orm\"),\n  modelSchema: FarmIntegrationSchemaModel,\n): Record<string, AnyFieldBuilder> {\n  return Object.fromEntries(\n    Object.entries(modelSchema.fields).map(([fieldKey, fieldSchema]) => [\n      fieldKey,\n      createOrmField(orm, fieldKey, fieldSchema),\n    ]),\n  );\n}\n\nfunction createOrmField(\n  orm: typeof import(\"@farming-labs/orm\"),\n  fieldKey: string,\n  field: FarmIntegrationSchemaField,\n): AnyFieldBuilder {\n  let builder = createOrmFieldBuilder(orm, fieldKey, field) as AnyFieldBuilder;\n\n  if (field.unique) {\n    builder = builder.unique();\n  }\n\n  if (field.nullable || field.required === false) {\n    builder = builder.nullable();\n  }\n\n  if (field.default !== undefined) {\n    builder =\n      field.type === \"datetime\" && field.default === \"now\"\n        ? builder.defaultNow()\n        : builder.default(field.default as never);\n  }\n\n  if (field.reference) {\n    builder = builder.references(`${field.reference.model}.${field.reference.field}`);\n  }\n\n  if (field.name && field.name !== fieldKey) {\n    builder = builder.map(field.name);\n  }\n\n  if (field.description) {\n    builder = builder.describe(field.description);\n  }\n\n  return builder;\n}\n\nfunction createOrmFieldBuilder(\n  orm: typeof import(\"@farming-labs/orm\"),\n  fieldKey: string,\n  field: FarmIntegrationSchemaField,\n): AnyFieldBuilder {\n  switch (field.type) {\n    case \"id\":\n    case \"uuid\":\n      return orm.id();\n    case \"string\":\n    case \"text\":\n      return orm.string();\n    case \"boolean\":\n      return orm.boolean();\n    case \"integer\":\n      return orm.integer();\n    case \"number\":\n      return orm.decimal();\n    case \"datetime\":\n      return orm.datetime();\n    case \"json\":\n      return orm.json();\n    case \"enum\": {\n      if (!field.values?.length) {\n        throw new Error(`Integration schema enum field \"${fieldKey}\" must define values.`);\n      }\n\n      return orm.enumeration(field.values as readonly [string, ...string[]]);\n    }\n    default:\n      throw new Error(\n        `Unsupported integration schema field type \"${field.type}\" for \"${fieldKey}\".`,\n      );\n  }\n}\n\nfunction createOrmModelConstraints(modelSchema: FarmIntegrationSchemaModel) {\n  const unique: Array<readonly [string, ...string[]]> = [];\n  const indexes: Array<readonly [string, ...string[]]> = [];\n\n  for (const constraint of modelSchema.constraints ?? []) {\n    if (!constraint.fields.length) {\n      continue;\n    }\n\n    const fields = constraint.fields as readonly [string, ...string[]];\n    if (constraint.type === \"unique\") {\n      unique.push(fields);\n    } else {\n      indexes.push(fields);\n    }\n  }\n\n  return {\n    unique,\n    indexes,\n  };\n}\n\nexport type IntegrationOrmModelNames<TSchema extends FarmIntegrationOrmSchema> =\n  keyof SchemaModels<TSchema> & string;\n"],"mappings":"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","names":[]}