@gradial/aci 0.1.7 → 0.1.8

package/dist/content/cache.d.ts

@@ -0,0 +1,25 @@
+import type { ContentProvider, CompiledManifest } from './provider.js';
+export declare function getCacheStats(): {
+    manifest: {
+        hits: number;
+        misses: number;
+    };
+    siteConfig: {
+        hits: number;
+        misses: number;
+    };
+};
+export declare function resetCacheStats(): void;
+/**
+ * Get manifest with caching. Use this instead of calling provider.manifest() directly.
+ */
+export declare function getCachedManifest(provider: ContentProvider): Promise<CompiledManifest>;
+/**
+ * Get site config with caching. Use this instead of calling provider.getSiteConfig() directly.
+ */
+export declare function getCachedSiteConfig<T>(provider: ContentProvider): Promise<T>;
+/**
+ * Clear cached data for a specific provider.
+ * Useful for testing or manual cache invalidation.
+ */
+export declare function clearProviderCache(provider: ContentProvider): void;

package/dist/content/cache.js

@@ -0,0 +1,83 @@
+/**
+ * Framework-agnostic content caching layer.
+ *
+ * Caches shared resources (manifest, siteConfig) across requests
+ * to reduce S3 fetches on warm Lambda/serverless containers.
+ *
+ * Keyed by provider instance for automatic invalidation when
+ * provider config changes (e.g., new releaseId).
+ */
+// Cross-request cache - survives serverless warm starts
+const manifestCache = new WeakMap();
+const siteConfigCache = new WeakMap();
+// Cache hit/miss stats for observability
+let manifestHits = 0;
+let manifestMisses = 0;
+let siteConfigHits = 0;
+let siteConfigMisses = 0;
+export function getCacheStats() {
+    return {
+        manifest: { hits: manifestHits, misses: manifestMisses },
+        siteConfig: { hits: siteConfigHits, misses: siteConfigMisses },
+    };
+}
+export function resetCacheStats() {
+    manifestHits = 0;
+    manifestMisses = 0;
+    siteConfigHits = 0;
+    siteConfigMisses = 0;
+}
+/**
+ * Get manifest with caching. Use this instead of calling provider.manifest() directly.
+ */
+export function getCachedManifest(provider) {
+    const cached = manifestCache.get(provider);
+    if (cached) {
+        manifestHits++;
+        console.log('[ACI Cache] manifest HIT - serving from cache');
+        return cached;
+    }
+    manifestMisses++;
+    console.log('[ACI Cache] manifest MISS - fetching from provider');
+    // Only S3ContentProvider has manifest(), FileContentProvider doesn't
+    if (!('manifest' in provider) || typeof provider.manifest !== 'function') {
+        throw new Error('Provider does not support manifest()');
+    }
+    const promise = provider.manifest().catch((error) => {
+        console.error('[ACI Cache] manifest fetch FAILED:', error.message);
+        // Clear cache on error to allow retry on next request
+        manifestCache.delete(provider);
+        throw error;
+    });
+    manifestCache.set(provider, promise);
+    return promise;
+}
+/**
+ * Get site config with caching. Use this instead of calling provider.getSiteConfig() directly.
+ */
+export function getCachedSiteConfig(provider) {
+    const cached = siteConfigCache.get(provider);
+    if (cached) {
+        siteConfigHits++;
+        console.log('[ACI Cache] siteConfig HIT - serving from cache');
+        return cached;
+    }
+    siteConfigMisses++;
+    console.log('[ACI Cache] siteConfig MISS - fetching from provider');
+    const promise = provider.getSiteConfig().catch((error) => {
+        console.error('[ACI Cache] siteConfig fetch FAILED:', error.message);
+        // Clear cache on error to allow retry on next request
+        siteConfigCache.delete(provider);
+        throw error;
+    });
+    siteConfigCache.set(provider, promise);
+    return promise;
+}
+/**
+ * Clear cached data for a specific provider.
+ * Useful for testing or manual cache invalidation.
+ */
+export function clearProviderCache(provider) {
+    manifestCache.delete(provider);
+    siteConfigCache.delete(provider);
+}

package/dist/content/cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/content/cache.test.js

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { getCachedSiteConfig, getCachedManifest, clearProviderCache, getCacheStats, resetCacheStats } from './cache.js';
+describe('Content Cache', () => {
+    let mockProvider;
+    let getSiteConfigCallCount = 0;
+    let manifestCallCount = 0;
+    beforeEach(() => {
+        getSiteConfigCallCount = 0;
+        manifestCallCount = 0;
+        resetCacheStats();
+        mockProvider = {
+            getSiteConfig: async () => {
+                getSiteConfigCallCount++;
+                return { title: 'Test Site' };
+            },
+            manifest: async () => {
+                manifestCallCount++;
+                return {
+                    routes: {},
+                    fragments: {},
+                    siteConfigRef: 'site.json'
+                };
+            },
+            getPage: async () => ({}),
+            getFragment: async () => ({}),
+            listRoutes: async () => []
+        };
+    });
+    it('should cache siteConfig across multiple calls', async () => {
+        const result1 = await getCachedSiteConfig(mockProvider);
+        const result2 = await getCachedSiteConfig(mockProvider);
+        expect(getSiteConfigCallCount).toBe(1); // Only called once
+        expect(result1).toEqual(result2);
+        const stats = getCacheStats();
+        expect(stats.siteConfig.hits).toBe(1);
+        expect(stats.siteConfig.misses).toBe(1);
+    });
+    it('should cache manifest across multiple calls', async () => {
+        const result1 = await getCachedManifest(mockProvider);
+        const result2 = await getCachedManifest(mockProvider);
+        expect(manifestCallCount).toBe(1); // Only called once
+        expect(result1).toEqual(result2);
+        const stats = getCacheStats();
+        expect(stats.manifest.hits).toBe(1);
+        expect(stats.manifest.misses).toBe(1);
+    });
+    it('should clear cache for a provider', async () => {
+        await getCachedSiteConfig(mockProvider);
+        expect(getSiteConfigCallCount).toBe(1);
+        clearProviderCache(mockProvider);
+        await getCachedSiteConfig(mockProvider);
+        expect(getSiteConfigCallCount).toBe(2); // Called again after clear
+        const stats = getCacheStats();
+        expect(stats.siteConfig.misses).toBe(2);
+    });
+    it('should not cache rejected promises', async () => {
+        const errorProvider = {
+            getSiteConfig: async () => {
+                getSiteConfigCallCount++;
+                throw new Error('S3 timeout');
+            },
+            getPage: async () => ({}),
+            getFragment: async () => ({}),
+            listRoutes: async () => []
+        };
+        await expect(getCachedSiteConfig(errorProvider)).rejects.toThrow('S3 timeout');
+        expect(getSiteConfigCallCount).toBe(1);
+        // Second call should retry (not cached)
+        await expect(getCachedSiteConfig(errorProvider)).rejects.toThrow('S3 timeout');
+        expect(getSiteConfigCallCount).toBe(2);
+    });
+    it('should cache separately per provider instance', async () => {
+        const provider2 = {
+            getSiteConfig: async () => ({ title: 'Site 2' }),
+            getPage: async () => ({}),
+            getFragment: async () => ({}),
+            listRoutes: async () => []
+        };
+        const result1 = await getCachedSiteConfig(mockProvider);
+        const result2 = await getCachedSiteConfig(provider2);
+        expect(result1).toEqual({ title: 'Test Site' });
+        expect(result2).toEqual({ title: 'Site 2' });
+        const stats = getCacheStats();
+        expect(stats.siteConfig.misses).toBe(2); // Both are cache misses
+    });
+});

package/dist/content/index.d.ts

@@ -1,3 +1,4 @@
 export * from './provider.js';
 export * from './routes.js';
 export * from './types.js';
+export * from './cache.js';

package/dist/content/index.js

@@ -1,3 +1,4 @@
 export * from './provider.js';
 export * from './routes.js';
 export * from './types.js';
+export * from './cache.js';

package/dist/content/provider.js

@@ -16,10 +16,11 @@ export class FragmentNotFoundError extends Error {
         this.cause = cause;
     }
 }
+import { getCachedSiteConfig } from './cache.js';
 export async function loadRenderInput(provider, route = '/', options = {}) {
     const normalized = normalizeRoute(route);
     const [siteConfig, page] = await Promise.all([
-        provider.getSiteConfig(),
+        getCachedSiteConfig(provider),
         provider.getPage(normalized).catch((error) => {
             if (error instanceof PageNotFoundError)
                 return null;

package/dist/next/server.js

@@ -1,5 +1,6 @@
 import { headers } from 'next/headers.js';
 import { FragmentNotFoundError, PageNotFoundError, } from '../content/provider.js';
+import { getCachedManifest, getCachedSiteConfig } from '../content/cache.js';
 import { S3ContentProvider } from '../providers/s3.js';
 import { GRADIAL_RENDER_INPUT_HEADER, getPendingRenderInput } from '../runtime/page.js';
 import { getUncachedEdgeConfigValue } from './edge-config.js';
@@ -36,15 +37,23 @@ export async function getRoutes(config = {}) {
     return routes.map((route) => route.path).sort();
 }
 export async function getRenderInput(route = '/', config = {}) {
+    const startTime = Date.now();
     const runtimeInput = await getPageRuntimeRenderInput();
     if (runtimeInput) {
         return runtimeInput;
     }
+    const providerStart = Date.now();
     const provider = await resolveProviderWithFallback(config);
+    console.log(`[ACI SSR] Provider resolved in ${Date.now() - providerStart}ms`);
+    // Cache shared resources (manifest, siteConfig) but not per-page content
+    // Page-level caching is handled by CDN
+    const fetchStart = Date.now();
     const [page, siteConfig] = await Promise.all([
         provider.getPage(route),
-        provider.getSiteConfig(),
+        getCachedSiteConfig(provider),
     ]);
+    console.log(`[ACI SSR] Content fetched in ${Date.now() - fetchStart}ms`);
+    console.log(`[ACI SSR] Total getRenderInput for ${route}: ${Date.now() - startTime}ms`);
     return {
         route,
         domain: siteConfig.domain || 'www.aci.local',
@@ -146,7 +155,7 @@ export async function resolveReleaseId(config = {}) {
 }
 async function resolveProvider(config) {
     const releaseId = await resolveReleaseId(config);
-    return new S3ContentProvider({
+    const provider = new S3ContentProvider({
         bucket: config.bucket,
         keyPrefix: releaseKey(config, releaseId),
         region: config.region,
@@ -155,6 +164,9 @@ async function resolveProvider(config) {
         sessionToken: config.sessionToken,
         endpoint: config.endpoint,
     });
+    // Pre-warm the manifest with cached version
+    await getCachedManifest(provider);
+    return provider;
 }
 async function resolveProviderWithFallback(config) {
     if (process.env.ACI_CONTENT_PROVIDER === 'file') {
@@ -253,3 +265,5 @@ function joinKey(...parts) {
         .filter(Boolean)
         .join('/');
 }
+// Note: React cache() would be redundant here since getCachedSiteConfig already
+// returns the same Promise for the same provider instance within a request

package/dist/providers/file.js

@@ -36,23 +36,14 @@ export class FileContentProvider {
     async getFragment(id) {
         const manifest = await this.manifest();
         const entry = manifest.fragments[id];
-        if (entry) {
-            try {
-                return await this.readJSON(entry.payloadRef);
-            }
-            catch (error) {
-                throw new FragmentNotFoundError(id, error);
-            }
+        if (!entry) {
+            throw new FragmentNotFoundError(id);
         }
-        // Raw content directory stores fragments as flat files
-        const contentRoot = process.env.ACI_CONTENT_DIR || path.join(path.resolve(process.cwd()), '.content');
-        const rawPath = path.join(contentRoot, 'fragments', `${id}.json`);
         try {
-            const raw = await fs.readFile(rawPath, 'utf8');
-            return JSON.parse(raw);
+            return await this.readJSON(entry.payloadRef);
         }
-        catch {
-            throw new FragmentNotFoundError(id);
+        catch (error) {
+            throw new FragmentNotFoundError(id, error);
         }
     }
     async manifest() {

package/dist/providers/s3.js

@@ -60,6 +60,7 @@ export class S3ContentProvider {
 // S3 fetch with AWS SigV4 signing
 // ---------------------------------------------------------------------------
 export async function getS3JSON(key, config) {
+    const startTime = Date.now();
     const url = s3ObjectURL(config, key);
     const signedHeaders = signedS3Headers('GET', url, config);
     const res = await fetch(url, {
@@ -67,6 +68,8 @@ export async function getS3JSON(key, config) {
         headers: signedHeaders,
         cache: 'no-store'
     });
+    const duration = Date.now() - startTime;
+    console.log(`[ACI S3] GET ${key} - ${res.status} in ${duration}ms`);
     if (!res.ok) {
         throw new Error(`S3 GET ${key} failed with status ${res.status}: ${await res.text()}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gradial/aci",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -106,12 +106,6 @@
     "./cli/validate-content": "./src/cli/validate-content.mjs",
     "./cli/verify-renderer": "./src/cli/verify-renderer.mjs"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "build:cli": "cd ../.. && ./scripts/build-cli.sh",
-    "compile-registry": "tsx src/cli/compile-registry.mjs",
-    "prepack": "npm run build"
-  },
   "overrides": {
     "postcss": "^8.5.10"
   },
@@ -141,5 +135,10 @@
     "tsx": "^4.20.0",
     "typescript": "^5.9.3",
     "zod": "^4.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build:cli": "cd ../.. && ./scripts/build-cli.sh",
+    "compile-registry": "tsx src/cli/compile-registry.mjs"
   }
-}
+}