@epic-web/workshop-utils 6.84.3 → 6.84.4

package/dist/cache.server.d.ts

@@ -407,6 +407,14 @@ export declare function getGlobalCaches(): Promise<{
         }>;
     }>;
 }[]>;
+export declare function readWorkshopCacheMetadata(workshopId: string): Promise<{
+    schemaVersion: 1;
+    workshopId: string;
+    displayName: string;
+    createdAt: number;
+    repoName?: string | undefined;
+    subtitle?: string | undefined;
+} | null>;
 export declare function getWorkshopFileCaches(): Promise<Record<string, any>>;
 export declare function readEntryByPath(cacheFilePath: string): Promise<any>;
 export declare function deleteCache(): Promise<null | undefined>;

package/dist/cache.server.js

@@ -11,11 +11,13 @@ import { resolveCacheDir } from "./data-storage.server.js";
 import { logger } from "./logger.js";
 import { cachifiedTimingReporter } from "./timing.server.js";
 import { checkConnection } from "./utils.server.js";
+import { ensureWorkshopCacheMetadataFile, getWorkshopCacheMetadataFilePath, readWorkshopCacheMetadataFile, } from "./workshop-cache-metadata.server.js";
 const MAX_CACHE_FILE_SIZE = 3 * 1024 * 1024; // 3MB in bytes
 const cacheDir = resolveCacheDir();
 const log = logger('epic:cache');
 // Throttle repeated Sentry reports for corrupted cache files to reduce noise
 const corruptedReportThrottle = remember('epic:cache:corruption-throttle', () => new LRUCache({ max: 2000, ttl: 60_000 }));
+const ensuredWorkshopCacheMetadata = remember('epic:cache:ensured-workshop-cache-metadata', () => new Set());
 // Format cache time helper function (copied from @epic-web/cachified for consistency)
 function formatCacheTime(metadata, formatDuration) {
     const ttl = metadata?.ttl;
@@ -180,6 +182,51 @@ export const notificationsCache = makeSingletonCache('NotificationsCache');
 export const directoryEmptyCache = makeSingletonCache('DirectoryEmptyCache');
 export const discordCache = makeSingletonFsCache('DiscordCache');
 export const epicApiCache = makeSingletonFsCache('EpicApiCache');
+async function getCurrentWorkshopDisplayInfo() {
+    const env = getEnv();
+    const contextCwd = env.EPICSHOP_CONTEXT_CWD;
+    const repoName = contextCwd
+        ? path.basename(contextCwd) || undefined
+        : undefined;
+    let displayName = repoName || env.EPICSHOP_WORKSHOP_INSTANCE_ID || 'Unknown';
+    let subtitle;
+    try {
+        const { getWorkshopConfig } = await import("./config.server.js");
+        const config = getWorkshopConfig();
+        displayName = config.title || displayName;
+        subtitle = config.subtitle;
+    }
+    catch {
+        // Best-effort only: cache metadata should never break caching.
+    }
+    return { displayName, repoName, subtitle };
+}
+async function ensureWorkshopCacheMetadata(workshopId) {
+    if (!workshopId)
+        return;
+    if (ensuredWorkshopCacheMetadata.has(workshopId)) {
+        try {
+            const filePath = getWorkshopCacheMetadataFilePath({ cacheDir, workshopId });
+            if (await fsExtra.pathExists(filePath))
+                return;
+        }
+        catch {
+            // Treat errors as "missing" and attempt to re-create.
+        }
+        ensuredWorkshopCacheMetadata.delete(workshopId);
+    }
+    const { displayName, repoName, subtitle } = await getCurrentWorkshopDisplayInfo();
+    const metadata = await ensureWorkshopCacheMetadataFile({
+        cacheDir,
+        workshopId,
+        displayName,
+        repoName,
+        subtitle,
+    });
+    if (metadata) {
+        ensuredWorkshopCacheMetadata.add(workshopId);
+    }
+}
 export function makeGlobalFsCache(name) {
     return remember(`global-${name}`, () => {
         const cacheInstanceDir = path.join(cacheDir, 'global', name);
@@ -419,6 +466,9 @@ export async function getGlobalCaches() {
         workshopId: 'global',
     }));
 }
+export async function readWorkshopCacheMetadata(workshopId) {
+    return readWorkshopCacheMetadataFile({ cacheDir, workshopId });
+}
 export async function getWorkshopFileCaches() {
     const workshopCacheDir = path.join(cacheDir, getEnv().EPICSHOP_WORKSHOP_INSTANCE_ID);
     const caches = readJsonFilesInDirectory(workshopCacheDir);
@@ -436,6 +486,7 @@ export async function deleteCache() {
         if (await fsExtra.exists(cacheDir)) {
             await fsExtra.remove(cacheDir);
         }
+        ensuredWorkshopCacheMetadata.clear();
     }
     catch (error) {
         console.error(`Error deleting the cache in ${cacheDir}`, error);
@@ -469,6 +520,7 @@ export async function deleteWorkshopCache(workshopId, cacheName) {
             if (await fsExtra.exists(workshopCachePath)) {
                 await fsExtra.remove(workshopCachePath);
             }
+            ensuredWorkshopCacheMetadata.delete(workshopId);
         }
     }
     catch (error) {
@@ -526,7 +578,8 @@ export function makeSingletonCache(name) {
 }
 export function makeSingletonFsCache(name) {
     return remember(name, () => {
-        const cacheInstanceDir = path.join(cacheDir, getEnv().EPICSHOP_WORKSHOP_INSTANCE_ID, name);
+        const workshopId = getEnv().EPICSHOP_WORKSHOP_INSTANCE_ID;
+        const cacheInstanceDir = path.join(cacheDir, workshopId, name);
         const fsCache = {
             name: `Filesystem cache (${name})`,
             async get(key) {
@@ -558,6 +611,12 @@ export function makeSingletonFsCache(name) {
                 return null;
             },
             async set(key, entry) {
+                try {
+                    await ensureWorkshopCacheMetadata(workshopId);
+                }
+                catch {
+                    // Ignore: this is optional metadata only.
+                }
                 const filePath = path.join(cacheInstanceDir, md5(key));
                 const tempPath = `${filePath}.tmp`;
                 await fsExtra.ensureDir(path.dirname(filePath));

package/dist/workshop-cache-metadata.server.d.ts

@@ -0,0 +1,27 @@
+import z from 'zod';
+export declare const WORKSHOP_CACHE_METADATA_FILE_NAME: ".workshop-cache-metadata.json";
+declare const WorkshopCacheMetadataSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    workshopId: z.ZodString;
+    displayName: z.ZodString;
+    repoName: z.ZodOptional<z.ZodString>;
+    subtitle: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+}, z.core.$strip>;
+export type WorkshopCacheMetadata = z.infer<typeof WorkshopCacheMetadataSchema>;
+export declare function getWorkshopCacheMetadataFilePath({ cacheDir, workshopId, }: {
+    cacheDir: string;
+    workshopId: string;
+}): string;
+export declare function readWorkshopCacheMetadataFile({ cacheDir, workshopId, }: {
+    cacheDir: string;
+    workshopId: string;
+}): Promise<WorkshopCacheMetadata | null>;
+export declare function ensureWorkshopCacheMetadataFile({ cacheDir, workshopId, displayName, repoName, subtitle, }: {
+    cacheDir: string;
+    workshopId: string;
+    displayName: string;
+    repoName?: string;
+    subtitle?: string;
+}): Promise<WorkshopCacheMetadata | null>;
+export {};

package/dist/workshop-cache-metadata.server.js

@@ -0,0 +1,59 @@
+import path from 'path';
+import fsExtra from 'fs-extra';
+import z from 'zod';
+export const WORKSHOP_CACHE_METADATA_FILE_NAME = '.workshop-cache-metadata.json';
+const WorkshopCacheMetadataSchema = z.object({
+    schemaVersion: z.literal(1),
+    workshopId: z.string().min(1),
+    displayName: z.string().min(1),
+    repoName: z.string().optional(),
+    subtitle: z.string().optional(),
+    createdAt: z.number(),
+});
+export function getWorkshopCacheMetadataFilePath({ cacheDir, workshopId, }) {
+    return path.join(cacheDir, workshopId, WORKSHOP_CACHE_METADATA_FILE_NAME);
+}
+async function writeWorkshopCacheMetadataAtomic({ filePath, metadata, }) {
+    const tmpPath = `${filePath}.tmp`;
+    await fsExtra.ensureDir(path.dirname(filePath));
+    await fsExtra.writeJSON(tmpPath, metadata, { spaces: 2 });
+    await fsExtra.move(tmpPath, filePath, { overwrite: true });
+}
+export async function readWorkshopCacheMetadataFile({ cacheDir, workshopId, }) {
+    const filePath = getWorkshopCacheMetadataFilePath({ cacheDir, workshopId });
+    try {
+        const raw = await fsExtra.readJSON(filePath);
+        const parsed = WorkshopCacheMetadataSchema.safeParse(raw);
+        return parsed.success ? parsed.data : null;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return null;
+        }
+        return null;
+    }
+}
+export async function ensureWorkshopCacheMetadataFile({ cacheDir, workshopId, displayName, repoName, subtitle, }) {
+    const filePath = getWorkshopCacheMetadataFilePath({ cacheDir, workshopId });
+    // Fast path: already exists and parses.
+    const existing = await readWorkshopCacheMetadataFile({ cacheDir, workshopId });
+    if (existing)
+        return existing;
+    const metadata = {
+        schemaVersion: 1,
+        workshopId,
+        displayName,
+        repoName,
+        subtitle,
+        createdAt: Date.now(),
+    };
+    try {
+        await writeWorkshopCacheMetadataAtomic({ filePath, metadata });
+        return metadata;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epic-web/workshop-utils",
-  "version": "6.84.3",
+  "version": "6.84.4",
   "publishConfig": {
     "access": "public"
   },