@farm.js/core 0.1.0-beta.14 → 0.1.0-beta.17

package/dist/cache.d.ts

@@ -0,0 +1,192 @@
+declare function applyFarmCacheInvalidations(keys: unknown): void;
+
+type RevalidateTagProfile = "max" | "default" | "seconds" | "minutes" | "hours" | "days" | "weeks" | "months" | {
+    expire?: number;
+};
+interface FarmCacheOptions {
+    /**
+     * Tag cached data so it can be invalidated with revalidateTag/updateTag.
+     */
+    tags?: readonly string[];
+    /**
+     * Path tags let revalidatePath invalidate data tied to a route.
+     */
+    paths?: readonly string[];
+    /**
+     * Time in seconds before the entry becomes stale. False means no TTL.
+     */
+    revalidate?: number | false;
+}
+interface FarmCacheSetOptions extends FarmCacheOptions {
+    createdAt?: number;
+}
+type RouteDataCacheKey = string | readonly unknown[];
+type FarmCacheInvalidationTarget = {
+    key: RouteDataCacheKey;
+} | {
+    path: string;
+} | {
+    tag: string;
+};
+declare const FARM_DEFINED_CACHE_KEY_DATA: unique symbol;
+/**
+ * A regular Farm cache key carrying the data shape stored under that key.
+ *
+ * The brand exists only in TypeScript. At runtime the value remains the
+ * original string or structured array, so all existing cache APIs continue to
+ * accept untyped keys.
+ */
+type DefinedCacheKey<TData, TKey extends RouteDataCacheKey = RouteDataCacheKey> = TKey & {
+    readonly [FARM_DEFINED_CACHE_KEY_DATA]: TData;
+};
+type CacheKeyFactory<TData, TArguments extends readonly unknown[], TKey extends RouteDataCacheKey = RouteDataCacheKey> = (...args: TArguments) => DefinedCacheKey<TData, TKey>;
+type InferCacheKeyData<TKey> = TKey extends DefinedCacheKey<infer TData, RouteDataCacheKey> ? TData : unknown;
+/**
+ * Optionally add a data type to an existing string/array cache-key factory.
+ *
+ * This helper does not introduce a new runtime key representation. Calling the
+ * returned factory produces the exact key returned by `factory`.
+ */
+declare function defineCacheKey<TData>(): <const TArguments extends readonly unknown[], const TKey extends RouteDataCacheKey>(factory: (...args: TArguments) => TKey) => CacheKeyFactory<TData, TArguments, TKey>;
+interface FarmCacheEntry<T = unknown> {
+    key: string;
+    value: T;
+    tags: readonly string[];
+    /**
+     * Adapter tag versions captured before the cached value was produced.
+     * A later version makes the entry stale across every server instance.
+     */
+    tagVersions?: Readonly<Record<string, number>>;
+    createdAt: number;
+    createdVersion?: number;
+    revalidate?: number | false;
+}
+/**
+ * Asynchronous persistence contract used by distributed Farm caches.
+ *
+ * Implementations are responsible for serializing cache entries and making
+ * tag version updates atomic when the backing service supports it.
+ */
+interface FarmCacheAdapter {
+    readonly name?: string;
+    get<T = unknown>(key: string): Promise<FarmCacheEntry<T> | null | undefined>;
+    set<T = unknown>(key: string, entry: FarmCacheEntry<T>): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear?(): Promise<void>;
+    getTagVersions?(tags: readonly string[]): Promise<Readonly<Record<string, number>>>;
+    invalidateTags?(tags: readonly string[]): Promise<void>;
+    /** Atomically acquire a short-lived regeneration lease. */
+    acquireLease?(key: string, ttlMs: number): Promise<string | null | undefined>;
+    /** Release the lease only when the supplied ownership token still matches. */
+    releaseLease?(key: string, token: string): Promise<void>;
+}
+interface FarmCacheUserConfig {
+    /** Shared cache implementation, for example a Redis-backed adapter. */
+    adapter?: FarmCacheAdapter;
+    /** Prefix isolating applications and deployments sharing one adapter. */
+    namespace?: string;
+    /**
+     * Coordinate cache fills across processes when the adapter implements
+     * acquireLease/releaseLease. Set false to disable.
+     */
+    lease?: false | {
+        ttlMs?: number;
+        waitTimeoutMs?: number;
+        pollIntervalMs?: number;
+    };
+}
+interface FarmCacheStorage {
+    getItem<T = unknown>(key: string): Promise<T | null>;
+    setItem<T = unknown>(key: string, value: T): Promise<unknown>;
+    removeItem(key: string): Promise<unknown>;
+    clear?(base?: string): Promise<unknown>;
+}
+interface StorageFarmCacheAdapterOptions {
+    /** Prefix used inside the supplied storage client. */
+    base?: string;
+}
+/**
+ * Adapt a Farm/unstorage-compatible key-value client to the cache contract.
+ *
+ * This is a portable baseline adapter. Provider-specific adapters should use
+ * their atomic increment/transaction primitives for tag invalidation.
+ */
+declare function storageCacheAdapter(storage: FarmCacheStorage, options?: StorageFarmCacheAdapterOptions): FarmCacheAdapter;
+interface GetFarmCacheEntryOptions {
+    allowStale?: boolean;
+    now?: number;
+}
+interface FarmCacheStaleEntry {
+    tags: Iterable<string>;
+    createdAt: number;
+    createdVersion?: number;
+    revalidate?: number | false;
+}
+declare class FarmDataCache {
+    private entries;
+    private inflight;
+    private invalidatedTagVersions;
+    private version;
+    private adapter?;
+    private namespace;
+    private local;
+    private lease;
+    constructor(config?: FarmCacheUserConfig);
+    configure(config?: FarmCacheUserConfig): void;
+    get adapterName(): string;
+    get hasAdapter(): boolean;
+    get size(): number;
+    get<T>(key: string, options?: GetFarmCacheEntryOptions): T | undefined;
+    getEntry<T = unknown>(key: string, options?: GetFarmCacheEntryOptions): FarmCacheEntry<T> | undefined;
+    getEntryAsync<T = unknown>(key: string, options?: GetFarmCacheEntryOptions): Promise<FarmCacheEntry<T> | undefined>;
+    set<T>(key: string, value: T, options?: FarmCacheSetOptions): FarmCacheEntry<T>;
+    setAsync<T>(key: string, value: T, options?: FarmCacheSetOptions, tagVersions?: Readonly<Record<string, number>>): Promise<FarmCacheEntry<T>>;
+    delete(key: string): boolean;
+    deleteAsync(key: string): Promise<boolean>;
+    clear(): void;
+    clearAsync(): Promise<void>;
+    isStale(entry: FarmCacheStaleEntry, now?: number): boolean;
+    isStaleAsync(entry: FarmCacheEntry, now?: number): Promise<boolean>;
+    revalidateTag(tag: string, options?: {
+        source?: "revalidateTag" | "updateTag";
+        profile?: RevalidateTagProfile;
+    }): number;
+    revalidateTagAsync(tag: string, options?: {
+        source?: "revalidateTag" | "updateTag";
+        profile?: RevalidateTagProfile;
+    }): Promise<number>;
+    revalidatePath(routePath: string): number;
+    revalidatePathAsync(routePath: string): Promise<number>;
+    getOrSet<T>(key: string, producer: () => Promise<T> | T, options?: FarmCacheOptions): Promise<T>;
+    private fillCacheEntry;
+    private waitForAdapterEntry;
+    private countEntriesForTag;
+    private countEntriesForTags;
+    private invalidateTag;
+    private toPublicEntry;
+    private hydrateLocalEntry;
+    private createAdapterKey;
+    private createAdapterTag;
+    private getAdapterTagVersions;
+    private isAdapterEntryStale;
+}
+declare function getFarmDataCache(): FarmDataCache;
+declare function configureFarmCache(config: FarmCacheUserConfig | undefined): void;
+declare function unstable_cache<Args extends unknown[], Result>(fn: (...args: Args) => Result | Promise<Result>, keyParts?: readonly unknown[], options?: FarmCacheOptions): (...args: Args) => Promise<Result>;
+declare function revalidateTag(_tag: string, _profile?: RevalidateTagProfile): void | Promise<void>;
+declare function updateTag(tag: string): void | Promise<void>;
+declare function revalidatePath(routePath: string): void | Promise<void>;
+declare function invalidate(key: RouteDataCacheKey): void | Promise<void>;
+declare function invalidateRouteData(key: RouteDataCacheKey): void | Promise<void>;
+/**
+ * Apply a normalized set of invalidation targets and return browser cache keys
+ * that should be carried with an action/endpoint response.
+ */
+declare function applyFarmCacheInvalidationTargets(targets: readonly FarmCacheInvalidationTarget[]): Promise<readonly string[]>;
+declare function createPathCacheTag(routePath: string): string;
+declare function createRouteDataCacheTag(key: RouteDataCacheKey): string;
+declare function createRouteDataCacheKey(key: RouteDataCacheKey): string;
+declare function normalizeRevalidatePath(routePath: string): string;
+declare function createFarmCacheKey(parts: readonly unknown[]): string;
+
+export { type CacheKeyFactory, type DefinedCacheKey, type FarmCacheAdapter, type FarmCacheEntry, type FarmCacheInvalidationTarget, type FarmCacheOptions, type FarmCacheSetOptions, type FarmCacheStorage, type FarmCacheUserConfig, FarmDataCache, type GetFarmCacheEntryOptions, type InferCacheKeyData, type RevalidateTagProfile, type RouteDataCacheKey, type StorageFarmCacheAdapterOptions, applyFarmCacheInvalidationTargets, applyFarmCacheInvalidations, configureFarmCache, createFarmCacheKey, createPathCacheTag, createRouteDataCacheKey, createRouteDataCacheTag, defineCacheKey, getFarmDataCache, invalidate, invalidateRouteData, normalizeRevalidatePath, revalidatePath, revalidateTag, storageCacheAdapter, unstable_cache, updateTag };

package/dist/{chunk-VUL55IAX.mjs → chunk-2FLBZFPG.mjs}

@@ -9,7 +9,7 @@ import {
   FARM_DOCS_LAST_MODIFIED_MANIFEST,
   createFarmDocsLastModifiedManifest,
   getFarmDocsRouteTypeEntries
-} from "./chunk-OPHK6OJN.mjs";
+} from "./chunk-JAEAE27K.mjs";
 import {
   generateFarmDocsSearchClientRuntime,
   isFarmDocsSearchEnabled,
@@ -18,12 +18,13 @@ import {
 import {
   hasCustomFarmRouteContext,
   resolveDeployOutputPath
-} from "./chunk-L2PE36GQ.mjs";
+} from "./chunk-PZXBQKCH.mjs";
 import {
   PluginManager
 } from "./chunk-DJSGLHCN.mjs";
 import {
   createFarmApp,
+  createFarmSourceAlias,
   farmFontImportsPlugin,
   generateFarmClientPluginEntryCode,
   generateFarmTypeArtifacts,
@@ -31,7 +32,7 @@ import {
   mergeFarmFontCss,
   mergeFarmViteConfig,
   resolveRouteRenderingConfigFromFile
-} from "./chunk-PNFQQSRA.mjs";
+} from "./chunk-T2M5QANG.mjs";
 import {
   farmEnvironmentFunctionsPlugin
 } from "./chunk-V6WE6JSZ.mjs";
@@ -63,7 +64,7 @@ import {
 } from "./chunk-K4667E2Q.mjs";
 import {
   APIRouteManager
-} from "./chunk-Z5CQMP54.mjs";
+} from "./chunk-ARRYKOI5.mjs";
 import {
   readFarmI18nCatalogs
 } from "./chunk-2ED5Q2GH.mjs";
@@ -79,6 +80,9 @@ import {
 import {
   logger
 } from "./chunk-J4FNJ5IU.mjs";
+import {
+  getFarmPresetRuntime
+} from "./chunk-3HIVDX7J.mjs";
 import {
   __name
 } from "./chunk-CGILA3WO.mjs";
@@ -154,10 +158,15 @@ async function writeFarmRouteRuntimeManifest(directory, manifest) {
 }
 __name(writeFarmRouteRuntimeManifest, "writeFarmRouteRuntimeManifest");
 function validateFarmRouteRuntimeDeployment(manifest, preset) {
-  const runtime = getPresetRuntime(preset);
+  const runtime = getFarmPresetRuntime(preset);
   const warnings = /* @__PURE__ */ new Set();
   for (const route of manifest.routes) {
     if (route.rendering === "static") continue;
+    if (runtime === "unknown" && route.runtime !== "auto") {
+      warnings.add(
+        `Preset "${preset}" has an unknown runtime, so Farm could not verify routes that explicitly require node or edge.`
+      );
+    }
     if (runtime !== "unknown" && route.runtime !== "auto" && route.runtime !== runtime) {
       throw new Error(
         `Route "${route.pattern}" requires the ${route.runtime} runtime, but preset "${preset}" emits ${runtime} functions. Choose a compatible preset or change the route runtime.`
@@ -177,16 +186,6 @@ function validateFarmRouteRuntimeDeployment(manifest, preset) {
   return { runtime, warnings: Array.from(warnings) };
 }
 __name(validateFarmRouteRuntimeDeployment, "validateFarmRouteRuntimeDeployment");
-function getPresetRuntime(preset) {
-  if (preset === "cloudflare" || preset === "cloudflare-pages" || preset === "cloudflare-module" || preset === "netlify-edge" || preset === "vercel-edge" || preset === "deno") {
-    return "edge";
-  }
-  if (preset === "node-server" || preset === "vercel" || preset === "netlify" || preset === "aws-lambda" || preset === "azure" || preset === "firebase" || preset === "bun") {
-    return "node";
-  }
-  return "unknown";
-}
-__name(getPresetRuntime, "getPresetRuntime");
 function normalizeManifestSource(root, modulePath) {
   const queryIndex = modulePath.indexOf("?");
   const filePath = queryIndex === -1 ? modulePath : modulePath.slice(0, queryIndex);
@@ -2785,9 +2784,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
         postcss: postcssConfigDir
       } : void 0,
       resolve: {
-        alias: {
-          "@": path3.resolve(root, "src")
-        },
+        alias: createFarmSourceAlias(root, config.srcDir),
         // Programmatic route wrappers are created inside @farm.js/core. Resolve
         // their React imports from the application so React 18/19 elements and
         // the selected server renderer always share the same runtime instance.
@@ -6401,6 +6398,9 @@ async function createProjectModuleServer(createViteServer, config, root) {
         middlewareMode: true,
         hmr: false
       },
+      resolve: {
+        alias: createFarmSourceAlias(root, config.srcDir)
+      },
       optimizeDeps: {
         noDiscovery: true
       },
@@ -6585,4 +6585,4 @@ __name(buildNitro, "buildNitro");
 export {
   build
 };
-//# sourceMappingURL=chunk-VUL55IAX.mjs.map
+//# sourceMappingURL=chunk-2FLBZFPG.mjs.map