@gradial/aci 0.1.7 → 0.1.9

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/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';
@@ -25,7 +26,6 @@ export async function getFragment(name, config = {}) {
         const fragments = runtimeInput.fragments || {};
         if (name in fragments)
             return fragments[name];
-        throw new FragmentNotFoundError(name);
     }
     const provider = await resolveProviderWithFallback(config);
     return await provider.getFragment(name);
@@ -36,15 +36,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 +154,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 +163,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 +264,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.9",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",