covara 0.0.1 → 0.6.0

package/dist/resource/track-mutations.js

@@ -0,0 +1,721 @@
+import { getTableName } from "drizzle-orm";
+import { changelog, recordCreate, recordUpdate, recordDelete } from "./changelog.js";
+import { getGlobalKV, hasGlobalKV } from "../kv/index.js";
+import { createHash } from "node:crypto";
+import { pushInsertsToSubscriptions, pushUpdatesToSubscriptions, pushDeletesToSubscriptions, invalidateResourceSubscriptions, } from "./subscription.js";
+import { createResourceFilter } from "./filter.js";
+async function runOrDefer(context, thunk) {
+    if (context.pendingEvents) {
+        context.pendingEvents.push(thunk);
+    }
+    else {
+        await thunk();
+    }
+}
+const CACHE_KEY_PREFIX = "covara:cache:";
+const CACHE_KEYS_SET_PREFIX = "covara:cache:keys:";
+function generateCacheKey(tableName, sql, params, prefix) {
+    const hash = createHash("sha256")
+        .update(sql)
+        .update(JSON.stringify(params))
+        .digest("hex")
+        .slice(0, 16);
+    return `${prefix}${tableName}:${hash}`;
+}
+async function invalidateTableCache(tableName) {
+    if (!hasGlobalKV())
+        return;
+    const kv = getGlobalKV();
+    const keysSetKey = `${CACHE_KEYS_SET_PREFIX}${tableName}`;
+    const keys = await kv.smembers(keysSetKey);
+    if (keys.length > 0) {
+        await kv.del(...keys);
+        await kv.del(keysSetKey);
+    }
+}
+async function storeCacheKey(tableName, cacheKey) {
+    if (!hasGlobalKV())
+        return;
+    const kv = getGlobalKV();
+    const keysSetKey = `${CACHE_KEYS_SET_PREFIX}${tableName}`;
+    await kv.sadd(keysSetKey, cacheKey);
+}
+function detectMutation(sql) {
+    const normalized = sql.trim();
+    const insertMatch = normalized.match(/^INSERT\s+INTO\s+["'`]?(\w+)["'`]?/i);
+    if (insertMatch)
+        return { type: "create", tableName: insertMatch[1].toLowerCase() };
+    const updateMatch = normalized.match(/^UPDATE\s+["'`]?(\w+)["'`]?/i);
+    if (updateMatch)
+        return { type: "update", tableName: updateMatch[1].toLowerCase() };
+    const deleteMatch = normalized.match(/^DELETE\s+FROM\s+["'`]?(\w+)["'`]?/i);
+    if (deleteMatch)
+        return { type: "delete", tableName: deleteMatch[1].toLowerCase() };
+    return null;
+}
+function wrapInsertBuilder(builder, tableInfo, context) {
+    return new Proxy(builder, {
+        get(target, prop) {
+            if (prop === "values") {
+                return (data) => {
+                    const base = target.values(data);
+                    return wrapInsertBase(base, tableInfo, context, data);
+                };
+            }
+            const value = Reflect.get(target, prop, target);
+            if (typeof value === "function") {
+                return value.bind(target);
+            }
+            return value;
+        },
+    });
+}
+function wrapInsertBase(base, tableInfo, context, insertValues, state = { hasReturning: false, hasConflictHandler: false }) {
+    return new Proxy(base, {
+        get(target, prop) {
+            if (prop === "returning") {
+                return (fields) => {
+                    const result = fields ? target.returning(fields) : target.returning();
+                    return wrapInsertBase(result, tableInfo, context, insertValues, {
+                        ...state,
+                        hasReturning: true,
+                    });
+                };
+            }
+            if (prop === "onConflictDoNothing" || prop === "onConflictDoUpdate") {
+                return (...args) => {
+                    const result = target[prop](...args);
+                    return wrapInsertBase(result, tableInfo, context, insertValues, {
+                        ...state,
+                        hasConflictHandler: true,
+                    });
+                };
+            }
+            if (prop === "then") {
+                return async (resolve, reject) => {
+                    try {
+                        const result = await target;
+                        if (context.trackingEnabled) {
+                            const items = Array.isArray(result) ? result : (result ? [result] : []);
+                            await runOrDefer(context, async () => {
+                                // Only record mutations if we got results or if there's no conflict handler
+                                // With a conflict handler and no results, the insert was a no-op
+                                if (items.length === 0 && state.hasReturning === false && !state.hasConflictHandler) {
+                                    const insertArray = Array.isArray(insertValues) ? insertValues : [insertValues];
+                                    for (const item of insertArray) {
+                                        const id = item[tableInfo.idColumnName];
+                                        if (id !== undefined) {
+                                            const entry = await recordCreate(tableInfo.resourceName, String(id), item);
+                                            if (context.config.onMutation) {
+                                                await context.config.onMutation(entry);
+                                            }
+                                        }
+                                    }
+                                }
+                                else if (items.length > 0) {
+                                    for (const item of items) {
+                                        const id = String(item[tableInfo.idColumnName]);
+                                        const entry = await recordCreate(tableInfo.resourceName, id, item);
+                                        if (context.config.onMutation) {
+                                            await context.config.onMutation(entry);
+                                        }
+                                    }
+                                    if (context.config.pushToSubscriptions !== false) {
+                                        await pushInsertsToSubscriptions(tableInfo.resourceName, tableInfo.filter, items, tableInfo.idColumnName);
+                                    }
+                                }
+                                if (context.config.cache?.enabled && items.length > 0) {
+                                    await invalidateTableCache(tableInfo.resourceName);
+                                }
+                            });
+                        }
+                        return resolve ? resolve(result) : result;
+                    }
+                    catch (error) {
+                        if (reject)
+                            return reject(error);
+                        throw error;
+                    }
+                };
+            }
+            const value = Reflect.get(target, prop, target);
+            if (typeof value === "function") {
+                return value.bind(target);
+            }
+            return value;
+        },
+    });
+}
+function wrapUpdateBuilder(builder, tableInfo, context) {
+    return new Proxy(builder, {
+        get(target, prop) {
+            if (prop === "set") {
+                return (data) => {
+                    const base = target.set(data);
+                    return wrapUpdateBase(base, tableInfo, context, data);
+                };
+            }
+            const value = Reflect.get(target, prop, target);
+            if (typeof value === "function") {
+                return value.bind(target);
+            }
+            return value;
+        },
+    });
+}
+function wrapUpdateBase(base, tableInfo, context, updateValues, state = { hasReturning: false }) {
+    return new Proxy(base, {
+        get(target, prop) {
+            if (prop === "where") {
+                return (condition) => {
+                    const result = target.where(condition);
+                    return wrapUpdateBase(result, tableInfo, context, updateValues, {
+                        ...state,
+                        whereClause: condition,
+                    });
+                };
+            }
+            if (prop === "returning") {
+                return (fields) => {
+                    const result = fields ? target.returning(fields) : target.returning();
+                    return wrapUpdateBase(result, tableInfo, context, updateValues, {
+                        ...state,
+                        hasReturning: true,
+                    });
+                };
+            }
+            if (prop === "then") {
+                return async (resolve, reject) => {
+                    try {
+                        let previousItems = [];
+                        if (context.trackingEnabled && state.whereClause && context.config.capturePreviousState !== false) {
+                            previousItems = await context.db.select().from(tableInfo.table).where(state.whereClause);
+                        }
+                        const previousMap = new Map(previousItems.map((i) => [String(i[tableInfo.idColumnName]), i]));
+                        const result = await target;
+                        if (context.trackingEnabled) {
+                            const items = Array.isArray(result) ? result : (result ? [result] : []);
+                            await runOrDefer(context, async () => {
+                                for (const item of items) {
+                                    const id = String(item[tableInfo.idColumnName]);
+                                    const previousItem = previousMap.get(id);
+                                    const entry = await recordUpdate(tableInfo.resourceName, id, item, previousItem);
+                                    if (context.config.onMutation) {
+                                        await context.config.onMutation(entry);
+                                    }
+                                }
+                                if (context.config.pushToSubscriptions !== false && items.length > 0) {
+                                    await pushUpdatesToSubscriptions(tableInfo.resourceName, tableInfo.filter, items, tableInfo.idColumnName, previousMap);
+                                }
+                                if (context.config.cache?.enabled) {
+                                    await invalidateTableCache(tableInfo.resourceName);
+                                }
+                            });
+                        }
+                        return resolve ? resolve(result) : result;
+                    }
+                    catch (error) {
+                        if (reject)
+                            return reject(error);
+                        throw error;
+                    }
+                };
+            }
+            const value = Reflect.get(target, prop, target);
+            if (typeof value === "function") {
+                return value.bind(target);
+            }
+            return value;
+        },
+    });
+}
+function wrapDeleteBuilder(builder, tableInfo, context, state = { hasReturning: false }) {
+    return new Proxy(builder, {
+        get(target, prop) {
+            if (prop === "where") {
+                return (condition) => {
+                    const result = target.where(condition);
+                    return wrapDeleteBuilder(result, tableInfo, context, {
+                        ...state,
+                        whereClause: condition,
+                    });
+                };
+            }
+            if (prop === "returning") {
+                return (fields) => {
+                    const result = fields ? target.returning(fields) : target.returning();
+                    return wrapDeleteBuilder(result, tableInfo, context, {
+                        ...state,
+                        hasReturning: true,
+                    });
+                };
+            }
+            if (prop === "then") {
+                return async (resolve, reject) => {
+                    try {
+                        let itemsToDelete = [];
+                        if (context.trackingEnabled && state.whereClause) {
+                            itemsToDelete = await context.db.select().from(tableInfo.table).where(state.whereClause);
+                        }
+                        const result = await target;
+                        if (context.trackingEnabled) {
+                            await runOrDefer(context, async () => {
+                                const deletedIds = [];
+                                for (const item of itemsToDelete) {
+                                    const id = String(item[tableInfo.idColumnName]);
+                                    deletedIds.push(id);
+                                    const entry = await recordDelete(tableInfo.resourceName, id, item);
+                                    if (context.config.onMutation) {
+                                        await context.config.onMutation(entry);
+                                    }
+                                }
+                                if (context.config.pushToSubscriptions !== false && deletedIds.length > 0) {
+                                    await pushDeletesToSubscriptions(tableInfo.resourceName, deletedIds);
+                                }
+                                if (context.config.cache?.enabled) {
+                                    await invalidateTableCache(tableInfo.resourceName);
+                                }
+                            });
+                        }
+                        return resolve ? resolve(result) : result;
+                    }
+                    catch (error) {
+                        if (reject)
+                            return reject(error);
+                        throw error;
+                    }
+                };
+            }
+            const value = Reflect.get(target, prop, target);
+            if (typeof value === "function") {
+                return value.bind(target);
+            }
+            return value;
+        },
+    });
+}
+const JOIN_METHODS = ["leftJoin", "rightJoin", "innerJoin", "fullJoin"];
+const CHAIN_METHODS = ["where", "orderBy", "limit", "offset", "groupBy", "having"];
+function resolveResourceName(table, context) {
+    const name = getTableName(table);
+    return context.registryByName.get(name)?.resourceName ?? name;
+}
+function wrapSelectBuilder(builder, context, tableName = null, referencedTables = new Set()) {
+    let currentTableName = tableName;
+    return new Proxy(builder, {
+        get(target, prop) {
+            if (prop === "from") {
+                return (table) => {
+                    currentTableName = resolveResourceName(table, context);
+                    referencedTables.add(currentTableName);
+                    const result = target.from(table);
+                    return wrapSelectBuilder(result, context, currentTableName, referencedTables);
+                };
+            }
+            if (prop === "then") {
+                return async (resolve, reject) => {
+                    try {
+                        const cacheConfig = context.config.cache;
+                        const shouldCache = cacheConfig?.enabled && currentTableName && hasGlobalKV();
+                        if (shouldCache && currentTableName) {
+                            const tableCache = cacheConfig?.tables?.[currentTableName];
+                            if (tableCache?.enabled === false) {
+                                const result = await target;
+                                return resolve ? resolve(result) : result;
+                            }
+                            const kv = getGlobalKV();
+                            const keyPrefix = cacheConfig?.keyPrefix ?? CACHE_KEY_PREFIX;
+                            const queryObj = target.toSQL?.();
+                            if (queryObj) {
+                                const { sql, params } = queryObj;
+                                const cacheKey = generateCacheKey(currentTableName, sql, params, keyPrefix);
+                                const cached = await kv.get(cacheKey);
+                                if (cached) {
+                                    const result = JSON.parse(cached);
+                                    return resolve ? resolve(result) : result;
+                                }
+                                const result = await target;
+                                const ttl = tableCache?.ttl ?? cacheConfig?.ttl;
+                                if (ttl) {
+                                    await kv.set(cacheKey, JSON.stringify(result), { ex: Math.ceil(ttl / 1000) });
+                                }
+                                else {
+                                    await kv.set(cacheKey, JSON.stringify(result));
+                                }
+                                // Register the cache key under EVERY table the query touches
+                                // (including joined tables), so a mutation to any of them
+                                // invalidates this cached result — not just the FROM table.
+                                const tablesToTag = referencedTables.size > 0
+                                    ? referencedTables
+                                    : new Set([currentTableName]);
+                                for (const table of tablesToTag) {
+                                    await storeCacheKey(table, cacheKey);
+                                }
+                                return resolve ? resolve(result) : result;
+                            }
+                        }
+                        const result = await target;
+                        return resolve ? resolve(result) : result;
+                    }
+                    catch (error) {
+                        if (reject)
+                            return reject(error);
+                        throw error;
+                    }
+                };
+            }
+            const value = Reflect.get(target, prop, target);
+            if (typeof value === "function") {
+                const result = value.bind(target);
+                if (JOIN_METHODS.includes(prop)) {
+                    return (...args) => {
+                        const joinedTable = args[0];
+                        if (joinedTable && typeof joinedTable === "object") {
+                            try {
+                                referencedTables.add(resolveResourceName(joinedTable, context));
+                            }
+                            catch {
+                                // not a table (e.g. a subquery) — nothing to tag
+                            }
+                        }
+                        return wrapSelectBuilder(result(...args), context, currentTableName, referencedTables);
+                    };
+                }
+                if (CHAIN_METHODS.includes(prop)) {
+                    return (...args) => wrapSelectBuilder(result(...args), context, currentTableName, referencedTables);
+                }
+                return result;
+            }
+            return value;
+        },
+    });
+}
+function extractSqlString(query) {
+    if (typeof query === "string") {
+        return query;
+    }
+    const sqlObj = query;
+    if (sqlObj.queryChunks && Array.isArray(sqlObj.queryChunks)) {
+        return sqlObj.queryChunks
+            .flatMap((chunk) => {
+            if (typeof chunk === "string")
+                return [chunk];
+            if (chunk && Array.isArray(chunk.value))
+                return chunk.value;
+            if (chunk && chunk.encoder)
+                return ["?"];
+            return [""];
+        })
+            .join("");
+    }
+    return "";
+}
+function recordDetectedMutation(sqlString, context) {
+    const mutationInfo = detectMutation(sqlString);
+    if (!mutationInfo)
+        return;
+    const tableInfo = context.registryByName.get(mutationInfo.tableName);
+    if (!tableInfo)
+        return;
+    return runOrDefer(context, async () => {
+        await changelog.append({
+            resource: tableInfo.resourceName,
+            type: mutationInfo.type,
+            objectId: "*",
+            object: undefined,
+            previousObject: undefined,
+            timestamp: Date.now(),
+        });
+        if (context.config.onRawSqlMutation) {
+            await context.config.onRawSqlMutation(tableInfo.resourceName, mutationInfo.type);
+        }
+        if (context.config.cache?.enabled) {
+            await invalidateTableCache(tableInfo.resourceName);
+        }
+        // Row-level details are unknown for raw SQL, so notify subscribers to
+        // refetch rather than sending a precise added/changed/removed event.
+        if (context.config.pushToSubscriptions !== false) {
+            await invalidateResourceSubscriptions(tableInfo.resourceName, "raw-sql-mutation");
+        }
+    });
+}
+// Public entry point for writers OUTSIDE this process / outside trackMutations
+// (cron jobs, other services, manual DB edits). Records a changelog entry,
+// invalidates the query cache, and tells live subscribers to refetch. This is
+// the portable alternative to database-specific CDC.
+export async function recordExternalMutation(resource, type, options = {}) {
+    await changelog.append({
+        resource,
+        type,
+        objectId: options.objectId ?? "*",
+        object: undefined,
+        previousObject: undefined,
+        timestamp: Date.now(),
+    });
+    await invalidateTableCache(resource);
+    await invalidateResourceSubscriptions(resource, "external-mutation");
+}
+// drizzle's db.batch([...]) runs an array of query builders atomically without
+// awaiting them individually, so the per-builder `.then()` tracking never
+// fires. We extract each statement's SQL, detect the mutation, and record a
+// coarse `invalidate` (objectId "*") — the same contract as raw SQL — so
+// subscribers/caches stay correct even though we can't see individual rows.
+function wrapBatch(target, context) {
+    return async (statements) => {
+        const result = await target.batch(statements);
+        if (context.trackingEnabled && Array.isArray(statements)) {
+            for (const stmt of statements) {
+                try {
+                    const compiled = stmt?.toSQL?.();
+                    const sqlString = compiled?.sql ?? "";
+                    if (sqlString) {
+                        await recordDetectedMutation(sqlString, context);
+                    }
+                }
+                catch {
+                    // a statement we can't introspect just isn't tracked
+                }
+            }
+        }
+        return result;
+    };
+}
+function wrapRawSql(method, target, context) {
+    return async (query) => {
+        const result = await target[method](query);
+        if (context.trackingEnabled) {
+            const sqlString = extractSqlString(query);
+            const mutationInfo = detectMutation(sqlString);
+            if (mutationInfo) {
+                const tableInfo = context.registryByName.get(mutationInfo.tableName);
+                if (tableInfo) {
+                    await runOrDefer(context, async () => {
+                        await changelog.append({
+                            resource: tableInfo.resourceName,
+                            type: mutationInfo.type,
+                            objectId: "*",
+                            object: undefined,
+                            previousObject: undefined,
+                            timestamp: Date.now(),
+                        });
+                        if (context.config.onRawSqlMutation) {
+                            await context.config.onRawSqlMutation(tableInfo.resourceName, mutationInfo.type);
+                        }
+                        if (context.config.cache?.enabled) {
+                            await invalidateTableCache(tableInfo.resourceName);
+                        }
+                    });
+                }
+            }
+        }
+        return result;
+    };
+}
+function wrapTransaction(tx, registry, registryByName, config, pendingEvents) {
+    const txContext = {
+        db: tx,
+        registry,
+        registryByName,
+        config,
+        trackingEnabled: true,
+        pendingEvents,
+    };
+    return new Proxy(tx, {
+        get(target, prop) {
+            if (prop === "transaction" && config.trackTransactions !== false) {
+                return async (fn, txConfig) => {
+                    return target.transaction(async (nestedTx) => {
+                        const wrappedNested = wrapTransaction(nestedTx, registry, registryByName, config, pendingEvents);
+                        return fn(wrappedNested);
+                    }, txConfig);
+                };
+            }
+            if (prop === "insert") {
+                return (table) => {
+                    const tableInfo = registry.get(table);
+                    if (!tableInfo || config.skipTables?.includes(tableInfo.resourceName)) {
+                        return target.insert(table);
+                    }
+                    return wrapInsertBuilder(target.insert(table), tableInfo, txContext);
+                };
+            }
+            if (prop === "update") {
+                return (table) => {
+                    const tableInfo = registry.get(table);
+                    if (!tableInfo || config.skipTables?.includes(tableInfo.resourceName)) {
+                        return target.update(table);
+                    }
+                    return wrapUpdateBuilder(target.update(table), tableInfo, txContext);
+                };
+            }
+            if (prop === "delete") {
+                return (table) => {
+                    const tableInfo = registry.get(table);
+                    if (!tableInfo || config.skipTables?.includes(tableInfo.resourceName)) {
+                        return target.delete(table);
+                    }
+                    return wrapDeleteBuilder(target.delete(table), tableInfo, txContext);
+                };
+            }
+            if (prop === "select") {
+                return (fields) => {
+                    const selectBuilder = fields ? target.select(fields) : target.select();
+                    if (config.cache?.enabled) {
+                        return wrapSelectBuilder(selectBuilder, txContext);
+                    }
+                    return selectBuilder;
+                };
+            }
+            if (prop === "run" || prop === "execute") {
+                return wrapRawSql(prop, target, txContext);
+            }
+            if (prop === "batch") {
+                return wrapBatch(target, txContext);
+            }
+            const value = Reflect.get(target, prop, target);
+            if (typeof value === "function") {
+                return value.bind(target);
+            }
+            return value;
+        },
+    });
+}
+export function isTrackedDb(db) {
+    if (db === null || typeof db !== "object") {
+        return false;
+    }
+    // Access properties directly since proxies may not have `has` trap
+    const maybeTracked = db;
+    return (maybeTracked._trackingContext !== undefined &&
+        maybeTracked._originalDb !== undefined);
+}
+export function trackMutations(db, tables, config = {}) {
+    const registry = new Map();
+    const registryByName = new Map();
+    for (const registration of Object.values(tables)) {
+        const tableName = getTableName(registration.table);
+        const resourceName = registration.resourceName ?? tableName;
+        const filter = createResourceFilter(registration.table, {});
+        const tableInfo = {
+            table: registration.table,
+            resourceName,
+            idColumn: registration.id,
+            idColumnName: registration.id.name,
+            filter,
+        };
+        registry.set(registration.table, tableInfo);
+        registryByName.set(tableName, tableInfo);
+        registryByName.set(resourceName, tableInfo);
+    }
+    const context = {
+        db,
+        registry,
+        registryByName,
+        config,
+        trackingEnabled: true,
+    };
+    const proxy = new Proxy(db, {
+        get(target, prop) {
+            if (prop === "_trackingContext") {
+                return context;
+            }
+            if (prop === "_originalDb") {
+                return db;
+            }
+            if (prop === "withoutTracking") {
+                return async (fn) => {
+                    const prevEnabled = context.trackingEnabled;
+                    context.trackingEnabled = false;
+                    try {
+                        return await fn(db);
+                    }
+                    finally {
+                        context.trackingEnabled = prevEnabled;
+                    }
+                };
+            }
+            if (prop === "insert") {
+                return (table) => {
+                    const tableInfo = registry.get(table);
+                    if (!tableInfo || config.skipTables?.includes(tableInfo.resourceName)) {
+                        return target.insert(table);
+                    }
+                    return wrapInsertBuilder(target.insert(table), tableInfo, context);
+                };
+            }
+            if (prop === "update") {
+                return (table) => {
+                    const tableInfo = registry.get(table);
+                    if (!tableInfo || config.skipTables?.includes(tableInfo.resourceName)) {
+                        return target.update(table);
+                    }
+                    return wrapUpdateBuilder(target.update(table), tableInfo, context);
+                };
+            }
+            if (prop === "delete") {
+                return (table) => {
+                    const tableInfo = registry.get(table);
+                    if (!tableInfo || config.skipTables?.includes(tableInfo.resourceName)) {
+                        return target.delete(table);
+                    }
+                    return wrapDeleteBuilder(target.delete(table), tableInfo, context);
+                };
+            }
+            if (prop === "select") {
+                return (fields) => {
+                    const selectBuilder = fields ? target.select(fields) : target.select();
+                    if (config.cache?.enabled) {
+                        return wrapSelectBuilder(selectBuilder, context);
+                    }
+                    return selectBuilder;
+                };
+            }
+            if (prop === "run" || prop === "execute") {
+                return wrapRawSql(prop, target, context);
+            }
+            if (prop === "batch") {
+                return wrapBatch(target, context);
+            }
+            if (prop === "transaction" && config.trackTransactions !== false) {
+                return async (fn, txConfig) => {
+                    const pendingEvents = [];
+                    const result = await target.transaction(async (tx) => {
+                        const wrappedTx = wrapTransaction(tx, registry, registryByName, config, pendingEvents);
+                        return fn(wrappedTx);
+                    }, txConfig);
+                    // The transaction committed successfully — only now emit changelog
+                    // entries, subscription pushes, and cache invalidations. If the
+                    // transaction had rolled back, `target.transaction` would have thrown
+                    // and these buffered side effects would be discarded.
+                    for (const emit of pendingEvents) {
+                        await emit();
+                    }
+                    return result;
+                };
+            }
+            const value = Reflect.get(target, prop, target);
+            if (typeof value === "function") {
+                return value.bind(target);
+            }
+            return value;
+        },
+    });
+    return proxy;
+}
+export async function invalidateCache(resourceName) {
+    await invalidateTableCache(resourceName);
+}
+export async function invalidateAllCache() {
+    if (!hasGlobalKV())
+        return;
+    const kv = getGlobalKV();
+    const keys = await kv.keys(`${CACHE_KEYS_SET_PREFIX}*`);
+    for (const keysSetKey of keys) {
+        const cacheKeys = await kv.smembers(keysSetKey);
+        if (cacheKeys.length > 0) {
+            await kv.del(...cacheKeys);
+        }
+        await kv.del(keysSetKey);
+    }
+}
+//# sourceMappingURL=track-mutations.js.map