mcp-ts-template 2.2.4 → 2.2.5

package/dist/index.js

@@ -125174,9 +125174,25 @@ class StorageService2 {
     const tenantId = requireTenantId(context);
     return this.provider.delete(tenantId, key, context);
   }
-  list(prefix, context) {
+  list(prefix, context, options) {
     const tenantId = requireTenantId(context);
-    return this.provider.list(tenantId, prefix, context);
+    return this.provider.list(tenantId, prefix, context, options);
+  }
+  getMany(keys, context) {
+    const tenantId = requireTenantId(context);
+    return this.provider.getMany(tenantId, keys, context);
+  }
+  setMany(entries, context, options) {
+    const tenantId = requireTenantId(context);
+    return this.provider.setMany(tenantId, entries, context, options);
+  }
+  deleteMany(keys, context) {
+    const tenantId = requireTenantId(context);
+    return this.provider.deleteMany(tenantId, keys, context);
+  }
+  clear(context) {
+    const tenantId = requireTenantId(context);
+    return this.provider.clear(tenantId, context);
   }
 }
 StorageService2 = __legacyDecorateClassTS([
@@ -125194,6 +125210,7 @@ var import_tsyringe5 = __toESM(require_cjs3(), 1);
 import { existsSync, mkdirSync } from "fs";
 import { readFile, readdir, rm, writeFile } from "fs/promises";
 import path2 from "path";
+var DEFAULT_LIST_LIMIT = 1000;
 var FILE_ENVELOPE_VERSION = 1;
 
 class FileSystemProvider {
@@ -125321,7 +125338,7 @@ class FileSystemProvider {
     }
     return results;
   }
-  async list(tenantId, prefix, context) {
+  async list(tenantId, prefix, context, options) {
     return ErrorHandler.tryCatch(async () => {
       const tenantPath = this.getTenantPath(tenantId);
       const allKeys = await this.listFilesRecursively(tenantPath, tenantPath);
@@ -125339,16 +125356,93 @@ class FileSystemProvider {
           continue;
         }
       }
-      return validKeys;
+      validKeys.sort();
+      const limit2 = options?.limit ?? DEFAULT_LIST_LIMIT;
+      let startIndex = 0;
+      if (options?.cursor) {
+        const cursorIndex = validKeys.indexOf(options.cursor);
+        if (cursorIndex !== -1) {
+          startIndex = cursorIndex + 1;
+        }
+      }
+      const paginatedKeys = validKeys.slice(startIndex, startIndex + limit2);
+      const nextCursor = startIndex + limit2 < validKeys.length ? paginatedKeys[paginatedKeys.length - 1] : undefined;
+      return {
+        keys: paginatedKeys,
+        nextCursor
+      };
     }, {
       operation: "FileSystemProvider.list",
       context,
       input: { tenantId, prefix }
     });
   }
+  async getMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const results = new Map;
+      for (const key of keys) {
+        const value = await this.get(tenantId, key, context);
+        if (value !== null) {
+          results.set(key, value);
+        }
+      }
+      return results;
+    }, {
+      operation: "FileSystemProvider.getMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async setMany(tenantId, entries, context, options) {
+    return ErrorHandler.tryCatch(async () => {
+      for (const [key, value] of entries.entries()) {
+        await this.set(tenantId, key, value, context, options);
+      }
+    }, {
+      operation: "FileSystemProvider.setMany",
+      context,
+      input: { tenantId, entryCount: entries.size }
+    });
+  }
+  async deleteMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      let deletedCount = 0;
+      for (const key of keys) {
+        const deleted = await this.delete(tenantId, key, context);
+        if (deleted) {
+          deletedCount++;
+        }
+      }
+      return deletedCount;
+    }, {
+      operation: "FileSystemProvider.deleteMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async clear(tenantId, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const tenantPath = this.getTenantPath(tenantId);
+      const allKeys = await this.listFilesRecursively(tenantPath, tenantPath);
+      let deletedCount = 0;
+      for (const key of allKeys) {
+        const deleted = await this.delete(tenantId, key, context);
+        if (deleted) {
+          deletedCount++;
+        }
+      }
+      return deletedCount;
+    }, {
+      operation: "FileSystemProvider.clear",
+      context,
+      input: { tenantId }
+    });
+  }
 }
 
 // src/storage/providers/inMemory/inMemoryProvider.ts
+var DEFAULT_LIST_LIMIT2 = 1000;
+
 class InMemoryProvider {
   store = new Map;
   getTenantStore(tenantId) {
@@ -125388,21 +125482,71 @@ class InMemoryProvider {
     const tenantStore = this.getTenantStore(tenantId);
     return Promise.resolve(tenantStore.delete(key));
   }
-  list(tenantId, prefix, context) {
-    logger.debug(`[InMemoryProvider] Listing keys with prefix: ${prefix} for tenant: ${tenantId}`, context);
+  list(tenantId, prefix, context, options) {
+    logger.debug(`[InMemoryProvider] Listing keys with prefix: ${prefix} for tenant: ${tenantId}`, { ...context, options });
     const tenantStore = this.getTenantStore(tenantId);
     const now = Date.now();
-    const keys = [];
+    const allKeys = [];
     for (const [key, entry] of tenantStore.entries()) {
       if (key.startsWith(prefix)) {
         if (entry.expiresAt && now > entry.expiresAt) {
           tenantStore.delete(key);
         } else {
-          keys.push(key);
+          allKeys.push(key);
         }
       }
     }
-    return Promise.resolve(keys);
+    allKeys.sort();
+    const limit2 = options?.limit ?? DEFAULT_LIST_LIMIT2;
+    let startIndex = 0;
+    if (options?.cursor) {
+      const cursorIndex = allKeys.indexOf(options.cursor);
+      if (cursorIndex !== -1) {
+        startIndex = cursorIndex + 1;
+      }
+    }
+    const paginatedKeys = allKeys.slice(startIndex, startIndex + limit2);
+    const nextCursor = startIndex + limit2 < allKeys.length ? paginatedKeys[paginatedKeys.length - 1] : undefined;
+    return Promise.resolve({
+      keys: paginatedKeys,
+      nextCursor
+    });
+  }
+  async getMany(tenantId, keys, context) {
+    logger.debug(`[InMemoryProvider] Getting ${keys.length} keys for tenant: ${tenantId}`, context);
+    const results = new Map;
+    for (const key of keys) {
+      const value = await this.get(tenantId, key, context);
+      if (value !== null) {
+        results.set(key, value);
+      }
+    }
+    return results;
+  }
+  async setMany(tenantId, entries, context, options) {
+    logger.debug(`[InMemoryProvider] Setting ${entries.size} keys for tenant: ${tenantId}`, context);
+    for (const [key, value] of entries.entries()) {
+      await this.set(tenantId, key, value, context, options);
+    }
+  }
+  async deleteMany(tenantId, keys, context) {
+    logger.debug(`[InMemoryProvider] Deleting ${keys.length} keys for tenant: ${tenantId}`, context);
+    let deletedCount = 0;
+    for (const key of keys) {
+      const deleted = await this.delete(tenantId, key, context);
+      if (deleted) {
+        deletedCount++;
+      }
+    }
+    return deletedCount;
+  }
+  clear(tenantId, context) {
+    logger.debug(`[InMemoryProvider] Clearing all keys for tenant: ${tenantId}`, context);
+    const tenantStore = this.getTenantStore(tenantId);
+    const count = tenantStore.size;
+    tenantStore.clear();
+    logger.info(`[InMemoryProvider] Cleared ${count} keys for tenant: ${tenantId}`, context);
+    return Promise.resolve(count);
   }
 }
 
@@ -125410,6 +125554,7 @@ class InMemoryProvider {
 var import_tsyringe4 = __toESM(require_cjs3(), 1);
 var import_supabase_js = __toESM(require_main6(), 1);
 var TABLE_NAME = "kv_store";
+var DEFAULT_LIST_LIMIT3 = 1000;
 
 class SupabaseProvider {
   client;
@@ -125469,17 +125614,101 @@ class SupabaseProvider {
       input: { tenantId, key }
     });
   }
-  async list(tenantId, prefix, context) {
+  async list(tenantId, prefix, context, options) {
     return ErrorHandler.tryCatch(async () => {
       const now = new Date().toISOString();
-      const { data, error: error2 } = await this.getClient().from(TABLE_NAME).select("key").eq("tenant_id", tenantId).like("key", `${prefix}%`).or(`expires_at.is.null,expires_at.gt.${now}`);
+      const limit2 = options?.limit ?? DEFAULT_LIST_LIMIT3;
+      let query = this.getClient().from(TABLE_NAME).select("key").eq("tenant_id", tenantId).like("key", `${prefix}%`).or(`expires_at.is.null,expires_at.gt.${now}`).order("key", { ascending: true }).limit(limit2 + 1);
+      if (options?.cursor) {
+        query = query.gt("key", options.cursor);
+      }
+      const { data, error: error2 } = await query;
       if (error2)
         throw error2;
-      return data?.map((item) => item.key) ?? [];
+      const keys = data?.map((item) => item.key) ?? [];
+      const hasMore = keys.length > limit2;
+      const resultKeys = hasMore ? keys.slice(0, limit2) : keys;
+      const nextCursor = hasMore ? resultKeys[resultKeys.length - 1] : undefined;
+      return {
+        keys: resultKeys,
+        nextCursor
+      };
     }, {
       operation: "SupabaseProvider.list",
       context,
-      input: { tenantId, prefix }
+      input: { tenantId, prefix, options }
+    });
+  }
+  async getMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      if (keys.length === 0) {
+        return new Map;
+      }
+      const { data, error: error2 } = await this.getClient().from(TABLE_NAME).select("key, value, expires_at").eq("tenant_id", tenantId).in("key", keys);
+      if (error2)
+        throw error2;
+      const results = new Map;
+      for (const row of data ?? []) {
+        if (!row.expires_at || new Date(row.expires_at).getTime() >= Date.now()) {
+          results.set(row.key, row.value);
+        } else {
+          await this.delete(tenantId, row.key, context);
+        }
+      }
+      return results;
+    }, {
+      operation: "SupabaseProvider.getMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async setMany(tenantId, entries, context, options) {
+    return ErrorHandler.tryCatch(async () => {
+      if (entries.size === 0) {
+        return;
+      }
+      const expires_at = options?.ttl ? new Date(Date.now() + options.ttl * 1000).toISOString() : null;
+      const rows = Array.from(entries.entries()).map(([key, value]) => ({
+        tenant_id: tenantId,
+        key,
+        value,
+        expires_at
+      }));
+      const { error: error2 } = await this.getClient().from(TABLE_NAME).upsert(rows);
+      if (error2)
+        throw error2;
+    }, {
+      operation: "SupabaseProvider.setMany",
+      context,
+      input: { tenantId, entryCount: entries.size }
+    });
+  }
+  async deleteMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      if (keys.length === 0) {
+        return 0;
+      }
+      const { error: error2, count } = await this.getClient().from(TABLE_NAME).delete({ count: "exact" }).eq("tenant_id", tenantId).in("key", keys);
+      if (error2)
+        throw error2;
+      return count ?? 0;
+    }, {
+      operation: "SupabaseProvider.deleteMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async clear(tenantId, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const { error: error2, count } = await this.getClient().from(TABLE_NAME).delete({ count: "exact" }).eq("tenant_id", tenantId);
+      if (error2)
+        throw error2;
+      logger.info(`[SupabaseProvider] Cleared ${count ?? 0} keys for tenant: ${tenantId}`, context);
+      return count ?? 0;
+    }, {
+      operation: "SupabaseProvider.clear",
+      context,
+      input: { tenantId }
     });
   }
 }
@@ -125493,10 +125722,14 @@ SupabaseProvider = __legacyDecorateClassTS([
 
 // src/storage/providers/cloudflare/r2Provider.ts
 var R2_ENVELOPE_VERSION = 1;
+var DEFAULT_LIST_LIMIT4 = 1000;
 
 class R2Provider {
   bucket;
   constructor(bucket) {
+    if (!bucket) {
+      throw new McpError(-32008 /* ConfigurationError */, "R2Provider requires a valid R2Bucket instance.");
+    }
     this.bucket = bucket;
   }
   getR2Key(tenantId, key) {
@@ -125581,27 +125814,115 @@ class R2Provider {
       input: { tenantId, key }
     });
   }
-  async list(tenantId, prefix, context) {
+  async list(tenantId, prefix, context, options) {
     const r2Prefix = this.getR2Key(tenantId, prefix);
     return ErrorHandler.tryCatch(async () => {
-      logger.debug(`[R2Provider] Listing keys with prefix: ${r2Prefix}`, context);
-      const listed = await this.bucket.list({ prefix: r2Prefix });
+      logger.debug(`[R2Provider] Listing keys with prefix: ${r2Prefix}`, {
+        ...context,
+        options
+      });
+      const limit2 = options?.limit ?? DEFAULT_LIST_LIMIT4;
+      const listOptions = {
+        prefix: r2Prefix,
+        limit: limit2 + 1
+      };
+      if (options?.cursor) {
+        listOptions.cursor = options.cursor;
+      }
+      const listed = await this.bucket.list(listOptions);
       const tenantPrefix = `${tenantId}:`;
       const keys = listed.objects.map((obj) => obj.key.startsWith(tenantPrefix) ? obj.key.substring(tenantPrefix.length) : obj.key);
-      logger.debug(`[R2Provider] Found ${keys.length} keys with prefix: ${r2Prefix}`, context);
-      return keys;
+      const hasMore = keys.length > limit2;
+      const resultKeys = hasMore ? keys.slice(0, limit2) : keys;
+      const nextCursor = "cursor" in listed && listed.truncated ? listed.cursor : undefined;
+      logger.debug(`[R2Provider] Found ${resultKeys.length} keys with prefix: ${r2Prefix}`, context);
+      return {
+        keys: resultKeys,
+        nextCursor
+      };
     }, {
       operation: "R2Provider.list",
       context,
-      input: { tenantId, prefix }
+      input: { tenantId, prefix, options }
+    });
+  }
+  async getMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const results = new Map;
+      for (const key of keys) {
+        const value = await this.get(tenantId, key, context);
+        if (value !== null) {
+          results.set(key, value);
+        }
+      }
+      return results;
+    }, {
+      operation: "R2Provider.getMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async setMany(tenantId, entries, context, options) {
+    return ErrorHandler.tryCatch(async () => {
+      const promises = Array.from(entries.entries()).map(([key, value]) => this.set(tenantId, key, value, context, options));
+      await Promise.all(promises);
+    }, {
+      operation: "R2Provider.setMany",
+      context,
+      input: { tenantId, entryCount: entries.size }
+    });
+  }
+  async deleteMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const promises = keys.map((key) => this.delete(tenantId, key, context));
+      const results = await Promise.all(promises);
+      return results.filter((deleted) => deleted).length;
+    }, {
+      operation: "R2Provider.deleteMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async clear(tenantId, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const r2Prefix = `${tenantId}:`;
+      let deletedCount = 0;
+      let cursor;
+      let hasMore = true;
+      while (hasMore) {
+        const listOpts = {
+          prefix: r2Prefix,
+          limit: 1000
+        };
+        if (cursor) {
+          listOpts.cursor = cursor;
+        }
+        const listed = await this.bucket.list(listOpts);
+        const deletePromises = listed.objects.map((obj) => this.bucket.delete(obj.key));
+        await Promise.all(deletePromises);
+        deletedCount += listed.objects.length;
+        hasMore = listed.truncated;
+        cursor = "cursor" in listed ? listed.cursor : undefined;
+      }
+      logger.info(`[R2Provider] Cleared ${deletedCount} keys for tenant: ${tenantId}`, context);
+      return deletedCount;
+    }, {
+      operation: "R2Provider.clear",
+      context,
+      input: { tenantId }
     });
   }
 }
 
 // src/storage/providers/cloudflare/kvProvider.ts
+var DEFAULT_LIST_LIMIT5 = 1000;
+
 class KvProvider {
   kv;
   constructor(kv) {
+    if (!kv) {
+      throw new McpError(-32008 /* ConfigurationError */, "KvProvider requires a valid KVNamespace instance.");
+    }
     this.kv = kv;
   }
   getKvKey(tenantId, key) {
@@ -125661,19 +125982,100 @@ class KvProvider {
       input: { tenantId, key }
     });
   }
-  async list(tenantId, prefix, context) {
+  async list(tenantId, prefix, context, options) {
     const kvPrefix = this.getKvKey(tenantId, prefix);
     return ErrorHandler.tryCatch(async () => {
-      logger.debug(`[KvProvider] Listing keys with prefix: ${kvPrefix}`, context);
-      const listed = await this.kv.list({ prefix: kvPrefix });
+      logger.debug(`[KvProvider] Listing keys with prefix: ${kvPrefix}`, {
+        ...context,
+        options
+      });
+      const limit2 = options?.limit ?? DEFAULT_LIST_LIMIT5;
+      const listOptions = {
+        prefix: kvPrefix,
+        limit: limit2
+      };
+      if (options?.cursor) {
+        listOptions.cursor = options.cursor;
+      }
+      const listed = await this.kv.list(listOptions);
       const tenantPrefix = `${tenantId}:`;
       const keys = listed.keys.map((keyInfo) => keyInfo.name.startsWith(tenantPrefix) ? keyInfo.name.substring(tenantPrefix.length) : keyInfo.name);
+      const nextCursor = "cursor" in listed && !listed.list_complete ? listed.cursor : undefined;
       logger.debug(`[KvProvider] Found ${keys.length} keys with prefix: ${kvPrefix}`, context);
-      return keys;
+      return {
+        keys,
+        nextCursor
+      };
     }, {
       operation: "KvProvider.list",
       context,
-      input: { tenantId, prefix }
+      input: { tenantId, prefix, options }
+    });
+  }
+  async getMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const results = new Map;
+      for (const key of keys) {
+        const value = await this.get(tenantId, key, context);
+        if (value !== null) {
+          results.set(key, value);
+        }
+      }
+      return results;
+    }, {
+      operation: "KvProvider.getMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async setMany(tenantId, entries, context, options) {
+    return ErrorHandler.tryCatch(async () => {
+      const promises = Array.from(entries.entries()).map(([key, value]) => this.set(tenantId, key, value, context, options));
+      await Promise.all(promises);
+    }, {
+      operation: "KvProvider.setMany",
+      context,
+      input: { tenantId, entryCount: entries.size }
+    });
+  }
+  async deleteMany(tenantId, keys, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const promises = keys.map((key) => this.delete(tenantId, key, context));
+      const results = await Promise.all(promises);
+      return results.filter((deleted) => deleted).length;
+    }, {
+      operation: "KvProvider.deleteMany",
+      context,
+      input: { tenantId, keyCount: keys.length }
+    });
+  }
+  async clear(tenantId, context) {
+    return ErrorHandler.tryCatch(async () => {
+      const kvPrefix = `${tenantId}:`;
+      let deletedCount = 0;
+      let cursor;
+      let listComplete = false;
+      while (!listComplete) {
+        const listOpts = {
+          prefix: kvPrefix,
+          limit: 1000
+        };
+        if (cursor) {
+          listOpts.cursor = cursor;
+        }
+        const listed = await this.kv.list(listOpts);
+        const deletePromises = listed.keys.map((keyInfo) => this.kv.delete(keyInfo.name));
+        await Promise.all(deletePromises);
+        deletedCount += listed.keys.length;
+        listComplete = listed.list_complete;
+        cursor = "cursor" in listed ? listed.cursor : undefined;
+      }
+      logger.info(`[KvProvider] Cleared ${deletedCount} keys for tenant: ${tenantId}`, context);
+      return deletedCount;
+    }, {
+      operation: "KvProvider.clear",
+      context,
+      input: { tenantId }
     });
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-ts-template",
-  "version": "2.2.4",
+  "version": "2.2.5",
   "mcpName": "io.github.cyanheads/mcp-ts-template",
   "description": "The definitive, production-grade template for building powerful and scalable Model Context Protocol (MCP) servers with TypeScript, featuring built-in observability (OpenTelemetry), declarative tooling, robust error handling, and a modular, DI-driven architecture.",
   "main": "dist/index.js",