@timber-js/app 0.2.0-alpha.16 → 0.2.0-alpha.161

package/src/cdn/headers.ts

@@ -0,0 +1,153 @@
+/**
+ * CDN header helpers — pure functions that build Cache-Control,
+ * CDN-Cache-Control, Surrogate-Control, and Surrogate-Key header values.
+ *
+ * These are developer-elected utilities for wiring CDN caching in
+ * proxy.ts / middleware.ts. The framework never sets these automatically.
+ * See design/25-production-deployments.md §Layer 2.
+ */
+
+export interface CacheControlOptions {
+  /** Mark the response as publicly cacheable (CDN, shared caches). */
+  public?: boolean;
+  /** Mark the response as private (browser cache only, not CDN). */
+  private?: boolean;
+  /** Max freshness in seconds for the browser/client. */
+  maxAge?: number;
+  /** Max freshness in seconds for shared caches (CDN, proxy). Overrides maxAge for CDNs. */
+  sMaxAge?: number;
+  /** Serve stale while revalidating in the background (seconds). */
+  staleWhileRevalidate?: number;
+  /** Serve stale on upstream error (seconds). */
+  staleIfError?: number;
+  /** Response must not be stored by any cache. */
+  noStore?: boolean;
+  /** Caches must revalidate before using a stored response. */
+  noCache?: boolean;
+  /** Caches must revalidate once stale — no serving stale without checking origin. */
+  mustRevalidate?: boolean;
+  /** Response will not change — allows aggressive caching. Pair with hashed URLs. */
+  immutable?: boolean;
+}
+
+/**
+ * Build a `Cache-Control` header value.
+ *
+ * ```ts
+ * ctx.headers.set('Cache-Control', cacheControl({
+ *   public: true,
+ *   maxAge: 300,
+ *   staleWhileRevalidate: 60,
+ * }));
+ * ```
+ */
+export function cacheControl(opts: CacheControlOptions): string {
+  if (opts.public && opts.private) {
+    throw new Error('cacheControl: public and private are mutually exclusive');
+  }
+  if (opts.noStore && opts.maxAge !== undefined) {
+    throw new Error('cacheControl: noStore makes maxAge meaningless — remove one');
+  }
+
+  const parts: string[] = [];
+
+  parts.push(opts.public ? 'public' : 'private');
+
+  if (opts.noStore) parts.push('no-store');
+  if (opts.noCache) parts.push('no-cache');
+  if (opts.maxAge !== undefined) parts.push(`max-age=${opts.maxAge}`);
+  if (opts.sMaxAge !== undefined) parts.push(`s-maxage=${opts.sMaxAge}`);
+  if (opts.staleWhileRevalidate !== undefined)
+    parts.push(`stale-while-revalidate=${opts.staleWhileRevalidate}`);
+  if (opts.staleIfError !== undefined) parts.push(`stale-if-error=${opts.staleIfError}`);
+  if (opts.mustRevalidate) parts.push('must-revalidate');
+  if (opts.immutable) parts.push('immutable');
+
+  return parts.join(', ');
+}
+
+export interface SurrogateControlOptions {
+  /** Max freshness in seconds for the surrogate (CDN). */
+  maxAge?: number;
+  /** Do not store in surrogate cache. */
+  noStore?: boolean;
+  /** Serve stale while revalidating (seconds). */
+  staleWhileRevalidate?: number;
+  /** Serve stale on error (seconds). */
+  staleIfError?: number;
+}
+
+/**
+ * Build a `Surrogate-Control` header value (Fastly, Akamai, Varnish).
+ *
+ * ```ts
+ * ctx.headers.set('Surrogate-Control', surrogateControl({ maxAge: 3600 }));
+ * ```
+ */
+export function surrogateControl(opts: SurrogateControlOptions): string {
+  const parts: string[] = [];
+  if (opts.noStore) parts.push('no-store');
+  if (opts.maxAge !== undefined) parts.push(`max-age=${opts.maxAge}`);
+  if (opts.staleWhileRevalidate !== undefined)
+    parts.push(`stale-while-revalidate=${opts.staleWhileRevalidate}`);
+  if (opts.staleIfError !== undefined) parts.push(`stale-if-error=${opts.staleIfError}`);
+  return parts.join(', ');
+}
+
+/**
+ * Build a `CDN-Cache-Control` header value (Cloudflare).
+ * Same directive syntax as Surrogate-Control but recognized by Cloudflare.
+ *
+ * ```ts
+ * ctx.headers.set('CDN-Cache-Control', cdnCacheControl({ maxAge: 3600 }));
+ * ```
+ */
+export function cdnCacheControl(opts: SurrogateControlOptions): string {
+  return surrogateControl(opts);
+}
+
+/**
+ * Build a `Surrogate-Key` header value — space-separated tags for CDN
+ * tag-based purging (Fastly, Cloudflare Enterprise, Akamai).
+ *
+ * Tags are deduplicated. Tags must not contain spaces or double quotes
+ * (these are separators/delimiters in the header format).
+ *
+ * ```ts
+ * ctx.headers.set('Surrogate-Key', surrogateKey(['products', `product:${id}`]));
+ * ```
+ */
+export function surrogateKey(tags: string[]): string {
+  for (const tag of tags) {
+    if (tag.includes(' ') || tag.includes('"')) {
+      throw new Error(`surrogateKey: tag "${tag}" must not contain spaces or double quotes`);
+    }
+  }
+  return [...new Set(tags)].join(' ');
+}
+
+/**
+ * Build a `Cache-Tag` header value — comma-separated tags for Cloudflare
+ * Workers Cache tag-based purging. Available on ALL Cloudflare plans.
+ *
+ * Tags are deduplicated. Tags must not contain commas (the delimiter).
+ * Maximum tag length is 1024 characters per Cloudflare's limits.
+ *
+ * Use this instead of `surrogateKey()` when using Cloudflare Workers Cache
+ * (ctx.cache.purge). Workers Cache reads `Cache-Tag`, not `Surrogate-Key`.
+ *
+ * ```ts
+ * ctx.headers.set('Cache-Tag', cacheTag(['products', `product:${id}`]));
+ * ```
+ */
+export function cacheTag(tags: string[]): string {
+  for (const tag of tags) {
+    if (tag.includes(',')) {
+      throw new Error(`cacheTag: tag "${tag}" must not contain commas`);
+    }
+    if (tag.length > 1024) {
+      throw new Error(`cacheTag: tag "${tag}" exceeds 1024-character limit`);
+    }
+  }
+  return [...new Set(tags)].join(',');
+}

package/src/cdn/index.ts

@@ -0,0 +1,17 @@
+// @timber-js/app/cdn — CDN integration helpers
+//
+// Header utilities and purge handler for CDN caching. Developer-elected,
+// never automatic. See design/25-production-deployments.md §Layer 2.
+
+export { cacheControl, surrogateKey, surrogateControl, cdnCacheControl, cacheTag } from './headers';
+export type { CacheControlOptions, SurrogateControlOptions } from './headers';
+
+export { setCdnPurgeHandler, getCdnPurgeHandler } from './purge-store';
+export type { CdnPurgeHandler } from './purge-store';
+
+// Platform-specific purge handlers are at their own entry points:
+//   @timber-js/app/cdn/cloudflare         → CloudflarePurge (REST API, Enterprise)
+//   @timber-js/app/cdn/cloudflare-workers → WorkersCachePurge (ctx.cache, all plans)
+//   @timber-js/app/cdn/fastly             → FastlyPurge
+// Same pattern as @timber-js/app/cache/stores/* — keeps platform
+// dependencies out of the main CDN import.

package/src/cdn/purge-store.ts

@@ -0,0 +1,34 @@
+/**
+ * CDN purge handler singleton — same pattern as cache/handler-store.ts.
+ *
+ * Set via timber.config.ts or setCdnPurgeHandler() at boot. When set,
+ * cache.invalidate({ tag }) also triggers CDN purge for the invalidated
+ * tags, so revalidateTag() composes with CDN caching out of the box.
+ *
+ * See design/25-production-deployments.md §Layer 2.
+ */
+
+export interface CdnPurgeHandler {
+  /**
+   * Purge the given cache tags from the CDN.
+   * Called by cache.invalidate when a tag is invalidated.
+   */
+  purgeTags(tags: string[]): Promise<void>;
+}
+
+let handler: CdnPurgeHandler | undefined;
+
+/** Install a CDN purge handler. Called by the framework at boot from timber.config.ts. */
+export function setCdnPurgeHandler(h: CdnPurgeHandler): void {
+  handler = h;
+}
+
+/** Get the current CDN purge handler, if configured. */
+export function getCdnPurgeHandler(): CdnPurgeHandler | undefined {
+  return handler;
+}
+
+/** @internal — reset for tests only. */
+export function _resetCdnPurgeHandler(): void {
+  handler = undefined;
+}

package/src/cdn/workers-cache-purge.ts

@@ -0,0 +1,30 @@
+/**
+ * Cloudflare Workers Cache purge handler — purges by cache tag via
+ * ctx.cache.purge() on the ExecutionContext.
+ *
+ * Available on ALL Cloudflare plans (no Enterprise requirement).
+ * No API token needed — uses the Workers runtime's built-in cache API.
+ *
+ * Auto-wired by the Cloudflare adapter when no user-configured CDN
+ * purge handler is set. Uses the Workers Cache ALS bridge to access
+ * ctx.cache from within the request context.
+ */
+
+import type { CdnPurgeHandler } from './purge-store';
+import { getWorkersCachePurgeCtx } from '../server/workers-cache-bridge.js';
+
+export class WorkersCachePurge implements CdnPurgeHandler {
+  async purgeTags(tags: string[]): Promise<void> {
+    if (tags.length === 0) return;
+
+    const ctx = getWorkersCachePurgeCtx();
+    if (!ctx) {
+      throw new Error(
+        'WorkersCachePurge: no Workers Cache context available. ' +
+          'This handler can only be used within a Cloudflare Workers request context.'
+      );
+    }
+
+    await ctx.purge({ tags });
+  }
+}

package/src/cli-schema-sync.ts

@@ -0,0 +1,388 @@
+/**
+ * `timber schema sync` — scan filesystem for dynamic segments, append
+ * missing entries with `codec.string` defaults, and remove stale entries
+ * whose segments no longer exist in the filesystem.
+ *
+ * Design doc: design/41-global-params.md §Auto-Scaffolding
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { scanRoutes } from './routing/scanner.js';
+import type { SegmentNode } from './routing/types.js';
+import { resolveAppDir } from './plugin-context.js';
+
+/**
+ * Collect all unique bracket-keyed dynamic segment names from the route tree.
+ * Returns entries like '[artistSlug]', '[...slug]', '[[...topic]]'.
+ */
+export function collectDynamicSegments(appDir: string): string[] {
+  const tree = scanRoutes(appDir);
+  const segments = new Set<string>();
+  walkSegments(tree.root, segments);
+  return [...segments].sort();
+}
+
+function walkSegments(node: SegmentNode, segments: Set<string>): void {
+  if (node.paramName) {
+    // Reconstruct bracket key from segmentName (already has brackets)
+    segments.add(node.segmentName);
+  }
+  for (const child of node.children) {
+    walkSegments(child, segments);
+  }
+  for (const slot of Object.values(node.slots)) {
+    walkSegments(slot, segments);
+  }
+}
+
+/**
+ * Replace comment bodies (and optionally string contents) with spaces,
+ * preserving length and newlines so every index maps 1:1 to the original.
+ * Lets the structural scanning below ignore `segmentParams` mentions and
+ * braces inside comments/strings without a TS parser (fine pre-alpha,
+ * see TIM-1066).
+ *
+ * With `maskStrings`, string contents are blanked too — except literal
+ * 'segmentParams' strings, kept so a quoted property key stays findable.
+ */
+function maskSource(content: string, maskStrings: boolean): string {
+  const out = content.split('');
+  const n = content.length;
+  let i = 0;
+
+  const blank = (from: number, to: number): void => {
+    for (let j = from; j < to; j++) {
+      if (content[j] !== '\n') out[j] = ' ';
+    }
+  };
+
+  while (i < n) {
+    const ch = content[i];
+    const next = content[i + 1];
+    if (ch === '/' && next === '/') {
+      const start = i;
+      while (i < n && content[i] !== '\n') i++;
+      blank(start, i);
+    } else if (ch === '/' && next === '*') {
+      const start = i;
+      i += 2;
+      while (i < n && !(content[i] === '*' && content[i + 1] === '/')) i++;
+      i = Math.min(i + 2, n);
+      blank(start, i);
+    } else if (ch === '"' || ch === "'" || ch === '`') {
+      const start = i;
+      i++;
+      while (i < n && content[i] !== ch) {
+        if (content[i] === '\\') i++;
+        i++;
+      }
+      const end = i; // at closing quote (or n if unterminated)
+      if (maskStrings && content.slice(start + 1, end) !== 'segmentParams') {
+        blank(start + 1, end);
+      }
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return out.join('');
+}
+
+/**
+ * Locate the `segmentParams: { ... }` block in a schema file.
+ * Returns the indices of the opening and matching closing brace, or null
+ * if no segmentParams property is found. Comments and strings are masked
+ * first, so a JSDoc example mentioning `segmentParams: { ... }` above the
+ * real defineSchema call is not mistaken for the block, and braces inside
+ * comments/strings don't skew the depth count. The search is anchored to
+ * the `defineSchema(` call when present, so helper objects with their own
+ * segmentParams property earlier in the file are skipped.
+ */
+export function findSegmentParamsBlock(
+  content: string
+): { openBrace: number; closeBrace: number } | null {
+  const masked = maskSource(content, true);
+
+  const defineCall = /\bdefineSchema\s*\(/.exec(masked);
+  const keyRe = /(['"]?)segmentParams\1\s*:\s*\{/g;
+  keyRe.lastIndex = defineCall ? defineCall.index + defineCall[0].length : 0;
+  const keyMatch = keyRe.exec(masked);
+  if (!keyMatch) return null;
+
+  const openBrace = keyMatch.index + keyMatch[0].length - 1;
+  let depth = 1;
+  let i = openBrace + 1;
+  while (i < masked.length && depth > 0) {
+    if (masked[i] === '{') depth++;
+    else if (masked[i] === '}') depth--;
+    i++;
+  }
+  if (depth > 0) return null;
+  // i now points to just after the closing brace
+  return { openBrace, closeBrace: i - 1 };
+}
+
+/**
+ * Parse existing bracket keys from an app/schema.ts file.
+ * Scoped to the segmentParams: { ... } block — bracket keys elsewhere in
+ * the file (unrelated objects, comments above defineSchema) are ignored.
+ * Comments inside the block are masked, so a commented-out entry does not
+ * count as registered.
+ *
+ * The key charset matches the route classifier (segment-classify.ts):
+ * any character except `]`, so hyphenated params like '[my-param]' parse.
+ */
+export function parseExistingSchemaKeys(content: string): string[] {
+  const block = findSegmentParamsBlock(content);
+  if (!block) return [];
+
+  const blockContent = maskSource(content, false).slice(block.openBrace, block.closeBrace);
+  const keys: string[] = [];
+  // Match quoted bracket keys like '[artistSlug]', '[...slug]', '[[...topic]]'
+  const re = /['"](\[{1,2}(?:\.{3})?[^\]]+\]{1,2})['"]\s*:/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(blockContent)) !== null) {
+    keys.push(m[1]);
+  }
+  return keys;
+}
+
+/** Schema file extensions to check. */
+const SCHEMA_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+
+/**
+ * Find the schema file path if it exists.
+ */
+export function findSchemaFile(appDir: string): string | undefined {
+  for (const ext of SCHEMA_EXTENSIONS) {
+    const p = join(appDir, `schema${ext}`);
+    if (existsSync(p)) return p;
+  }
+  return undefined;
+}
+
+export function defaultCodecForSegment(seg: string): string {
+  if (seg.startsWith('[[...')) return 'codec.optionalCatchAll(codec.string)';
+  if (seg.startsWith('[...')) return 'codec.stringArray';
+  return 'codec.string';
+}
+
+/**
+ * Generate the content for a new app/schema.ts with the given segment keys.
+ */
+function generateNewSchema(segments: string[]): string {
+  const lines: string[] = [];
+  lines.push("import { defineSchema } from '@timber-js/app/params';");
+  lines.push("import { codec } from '@timber-js/app/codec';");
+  lines.push('');
+  lines.push('export default defineSchema({');
+  lines.push('  segmentParams: {');
+  for (const seg of segments) {
+    lines.push(`    '${seg}': ${defaultCodecForSegment(seg)},`);
+  }
+  lines.push('  },');
+  lines.push('});');
+  lines.push('');
+  return lines.join('\n');
+}
+
+/**
+ * Append missing segment entries to an existing schema file.
+ * Inserts new entries before the closing `}` of segmentParams.
+ */
+const CODEC_IMPORT = "import { codec } from '@timber-js/app/codec';";
+
+function hasCodecImport(content: string): boolean {
+  return /import\s+\{[^}]*\bcodec\b[^}]*\}\s+from\s+['"]@timber-js\/app\/codec['"]/.test(content);
+}
+
+function ensureCodecImport(content: string): string {
+  if (hasCodecImport(content)) return content;
+
+  // Insert after the last existing import statement
+  const lines = content.split('\n');
+  let lastImportIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^\s*import\s/.test(lines[i])) lastImportIndex = i;
+  }
+
+  if (lastImportIndex === -1) {
+    return CODEC_IMPORT + '\n' + content;
+  }
+
+  lines.splice(lastImportIndex + 1, 0, CODEC_IMPORT);
+  return lines.join('\n');
+}
+
+function appendToSchema(content: string, newSegments: string[]): string {
+  content = ensureCodecImport(content);
+
+  const block = findSegmentParamsBlock(content);
+  if (!block) {
+    throw new Error(
+      '[timber] Could not find segmentParams in schema file. ' +
+        'Expected a defineSchema({ segmentParams: { ... } }) call.'
+    );
+  }
+  const { openBrace, closeBrace } = block;
+
+  // Detect indentation from existing entries
+  const existingLine = content.slice(openBrace, closeBrace).match(/^(\s+)['"]\[/m);
+  const indent = existingLine ? existingLine[1] : '    ';
+
+  // Build insertion text
+  const insertion = newSegments
+    .map((seg) => `${indent}'${seg}': ${defaultCodecForSegment(seg)},`)
+    .join('\n');
+
+  // Insert before the closing brace
+  const before = content.slice(0, closeBrace);
+  const after = content.slice(closeBrace);
+
+  // Add newline if the content before doesn't end with one
+  const separator = before.trimEnd().endsWith(',') ? '\n' : '\n';
+
+  return before + separator + insertion + '\n' + after;
+}
+
+/**
+ * Remove entries from the segmentParams block whose keys match `staleSegments`.
+ * Removes the entire entry including trailing comma/whitespace. Scoped to
+ * the segmentParams block — identical keys in unrelated objects elsewhere
+ * in the file are left untouched.
+ */
+function removeFromSchema(content: string, staleSegments: string[]): string {
+  const block = findSegmentParamsBlock(content);
+  if (!block) return content;
+
+  let blockContent = content.slice(block.openBrace, block.closeBrace);
+  // Key matching and the entry walk run on a comment-masked copy (same
+  // length, indices align) so commented-out entries are never removed.
+  // Both copies are spliced in sync to keep indices valid.
+  let blockMasked = maskSource(blockContent, false);
+
+  for (const seg of staleSegments) {
+    const escaped = seg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const keyRe = new RegExp(`^[ \t]*['"]${escaped}['"][ \t]*:`, 'gm');
+    let m: RegExpExecArray | null;
+    while ((m = keyRe.exec(blockMasked)) !== null) {
+      const start = m.index;
+      let i = m.index + m[0].length;
+      let depth = 0;
+      let inString: string | null = null;
+
+      while (i < blockMasked.length) {
+        const ch = blockMasked[i];
+        if (inString) {
+          if (ch === '\\') {
+            i++;
+          } else if (ch === inString) {
+            inString = null;
+          }
+        } else if (ch === '"' || ch === "'" || ch === '`') {
+          inString = ch;
+        } else if (ch === '(' || ch === '{' || ch === '[') {
+          depth++;
+        } else if (ch === ')' || ch === '}' || ch === ']') {
+          depth--;
+        } else if (depth === 0 && ch === ',') {
+          i++;
+          break;
+        } else if (depth === 0 && (ch === '\n' || ch === '}')) {
+          break;
+        }
+        i++;
+      }
+
+      // Consume trailing newline
+      if (i < blockMasked.length && blockMasked[i] === '\n') i++;
+
+      blockContent = blockContent.slice(0, start) + blockContent.slice(i);
+      blockMasked = blockMasked.slice(0, start) + blockMasked.slice(i);
+      keyRe.lastIndex = start;
+    }
+  }
+
+  return content.slice(0, block.openBrace) + blockContent + content.slice(block.closeBrace);
+}
+
+export interface SchemaSyncResult {
+  /** Segments found in the filesystem. */
+  filesystemSegments: string[];
+  /** Segments already defined in app/schema.ts. */
+  existingSegments: string[];
+  /** Segments that were added. */
+  addedSegments: string[];
+  /** Segments that were removed (no longer in filesystem). */
+  removedSegments: string[];
+  /** Whether a new schema file was created. */
+  created: boolean;
+}
+
+/**
+ * Run the schema sync: scan filesystem, diff against schema, append missing.
+ */
+export function runSchemaSync(projectRoot: string): SchemaSyncResult {
+  const appDir = resolveAppDir(projectRoot);
+
+  const filesystemSegments = collectDynamicSegments(appDir);
+
+  const schemaPath = findSchemaFile(appDir);
+
+  if (filesystemSegments.length === 0 && !schemaPath) {
+    return {
+      filesystemSegments: [],
+      existingSegments: [],
+      addedSegments: [],
+      removedSegments: [],
+      created: false,
+    };
+  }
+
+  if (!schemaPath) {
+    // Create new schema file
+    const newPath = join(appDir, 'schema.ts');
+    writeFileSync(newPath, generateNewSchema(filesystemSegments), 'utf-8');
+    return {
+      filesystemSegments,
+      existingSegments: [],
+      addedSegments: filesystemSegments,
+      removedSegments: [],
+      created: true,
+    };
+  }
+
+  // Read existing schema and diff
+  const content = readFileSync(schemaPath, 'utf-8');
+  const existingSegments = parseExistingSchemaKeys(content);
+  const missing = filesystemSegments.filter((seg) => !existingSegments.includes(seg));
+  const stale = existingSegments.filter((seg) => !filesystemSegments.includes(seg));
+
+  if (missing.length === 0 && stale.length === 0) {
+    return {
+      filesystemSegments,
+      existingSegments,
+      addedSegments: [],
+      removedSegments: [],
+      created: false,
+    };
+  }
+
+  let updated = content;
+  if (stale.length > 0) {
+    updated = removeFromSchema(updated, stale);
+  }
+  if (missing.length > 0) {
+    updated = appendToSchema(updated, missing);
+  }
+  writeFileSync(schemaPath, updated, 'utf-8');
+
+  return {
+    filesystemSegments,
+    existingSegments,
+    addedSegments: missing,
+    removedSegments: stale,
+    created: false,
+  };
+}