sailfork / t3code-github / .repos/ alchemy-effect/ packages/ frontend-frameworks/ src/ vinext/ cache/ seed.ts

/**
 * Seed a persistent vinext data-cache store from `dist/server` prerender
 * artifacts.
 *
 * One write path for every platform: load pairs, then `sink.putText`.
 *
 * - Cloudflare: `Website.Vinext` build calls {@link seedPrerenderTo} with
 *   {@link kvHttpSink} (distilled KV HTTP, deploy machine).
 * - Node / Lambda: the Redis / S3 runtime calls
 *   {@link seedStoreFromPrerenderLogged} on first cache op (artifacts
 *   ship in the image).
 */
import { existsSync } from "node:fs";
import { createRequire } from "node:module";
import * as nodePath from "node:path";
import * as Effect from "effect/Effect";
import { buildVinextPrerenderKVPairs, type VinextPrerenderKVPair } from "../PrerenderCache.ts";
import type { DataCacheStore } from "./handler.ts";

export interface SeedSink<E = never, R = never> {
  readonly putText: (key: string, value: string, ttlMs?: number) => Effect.Effect<unknown, E, R>;
}

export type LoadedPrerenderPairs = {
  readonly pairs: ReadonlyArray<VinextPrerenderKVPair>;
  readonly routeCount: number;
  readonly warnings: ReadonlyArray<string>;
};

const resolveVinextRoot = (cwd: string): string | undefined => {
  const projectRequire = createRequire(nodePath.join(cwd, "package.json"));
  // vinext does not export package.json; use Node's package search directories.
  for (const directory of projectRequire.resolve.paths("vinext") ?? []) {
    const root = nodePath.join(directory, "vinext");
    if (existsSync(nodePath.join(root, "package.json"))) return root;
  }
  return undefined;
};

const resolveServerDir = (cwd: string): string | undefined => {
  const fromEnv = process.env.VINEXT_SERVER_DIR;
  if (typeof fromEnv === "string" && fromEnv.length > 0) return fromEnv;
  const candidates = [nodePath.join(cwd, "dist", "server"), nodePath.join(cwd, "server"), cwd];
  for (const dir of candidates) {
    if (existsSync(nodePath.join(dir, "vinext-prerender.json"))) return dir;
  }
  return undefined;
};

const ttlMsOf = (pair: VinextPrerenderKVPair): number | undefined =>
  pair.expirationTtl !== undefined && pair.expirationTtl > 0
    ? pair.expirationTtl * 1000
    : undefined;

export const loadPrerenderPairs = async (cwd: string): Promise<LoadedPrerenderPairs> => {
  const vinextRoot = resolveVinextRoot(cwd);
  const serverDir = resolveServerDir(cwd);
  if (vinextRoot === undefined || serverDir === undefined) {
    return { pairs: [], routeCount: 0, warnings: [] };
  }
  return buildVinextPrerenderKVPairs(vinextRoot, serverDir);
};

/** Platform-agnostic seed: pairs → `sink.putText`. */
export const seedPrerenderTo = <E, R>(
  sink: SeedSink<E, R>,
  options: { readonly rootDir: string; readonly label: string },
): Effect.Effect<{ readonly count: number; readonly routeCount: number }, E, R> =>
  Effect.gen(function* () {
    const loaded = yield* Effect.promise(() => loadPrerenderPairs(options.rootDir));
    for (const warning of loaded.warnings) yield* Effect.logWarning(warning);
    if (loaded.pairs.length === 0) {
      return { count: 0, routeCount: loaded.routeCount };
    }
    yield* Effect.forEach(
      loaded.pairs,
      (pair) => sink.putText(pair.key, pair.value, ttlMsOf(pair)),
      { concurrency: 8 },
    );
    yield* Effect.logInfo(
      `[vinext] seeded ${loaded.pairs.length} prerender cache ${
        loaded.pairs.length === 1 ? "entry" : "entries"
      } into ${options.label} (${loaded.routeCount} route${loaded.routeCount === 1 ? "" : "s"})`,
    );
    return { count: loaded.pairs.length, routeCount: loaded.routeCount };
  });

const promiseSink = (store: DataCacheStore): SeedSink => ({
  putText: (key, value, ttlMs) =>
    Effect.promise(() => store.getText(key)).pipe(
      Effect.flatMap((existing) =>
        existing === undefined
          ? Effect.promise(() => store.putText(key, value, ttlMs))
          : Effect.void,
      ),
    ),
});

export const seedStoreFromPrerender = async (
  store: DataCacheStore,
  cwd = process.cwd(),
): Promise<number> => {
  const { count } = await Effect.runPromise(
    seedPrerenderTo(promiseSink(store), { rootDir: cwd, label: "store" }),
  );
  return count;
};

/** Await seed and log how many entries landed. Never throws. */
export const seedStoreFromPrerenderLogged = async (
  store: DataCacheStore,
  label: string,
  cwd = process.cwd(),
): Promise<number> => {
  try {
    const { count } = await Effect.runPromise(
      seedPrerenderTo(promiseSink(store), { rootDir: cwd, label }),
    );
    return count;
  } catch {
    return 0;
  }
};

export const _resolveForTests = { resolveVinextRoot, resolveServerDir };