@uploadista/kv-store-cloudflare-kv 0.0.3

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+
+
+> @uploadista/kv-store-cloudflare-kv@0.0.2 build /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/kv-stores/cloudflare-kv
+> tsc -b
+

package/.turbo/turbo-check.log

@@ -0,0 +1,5 @@
+
+> @uploadista/kv-store-cloudflare-kv@ check /Users/denislaboureyras/Documents/uploadista/dev/uploadista/packages/uploadista/kv-stores/cloudflare-kv
+> biome check --write ./src
+
+Checked 2 files in 20ms. No fixes applied.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 uploadista
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,582 @@
+# @uploadista/kv-store-cloudflare-kv
+
+Cloudflare KV-backed key-value store for Uploadista. Deploy globally distributed storage on Cloudflare's edge network with zero-downtime updates.
+
+## Overview
+
+The Cloudflare KV store uses the `@cloudflare/workers-types` KVNamespace API for storing state on Cloudflare's edge network. Perfect for:
+
+- **Edge Deployment**: Store data globally at 300+ edge locations
+- **Serverless Uploads**: Run on Cloudflare Workers with no origin server
+- **Zero Cold Starts**: Pre-loaded KV namespaces at each edge
+- **Low Latency**: ~10ms read/write latency from any location
+- **Distributed by Default**: No replication config needed
+
+Ideal for Hono-based upload servers deployed to Cloudflare Workers.
+
+## Installation
+
+```bash
+npm install @uploadista/kv-store-cloudflare-kv
+# or
+pnpm add @uploadista/kv-store-cloudflare-kv
+```
+
+### Prerequisites
+
+- Cloudflare Workers project with `wrangler`
+- Cloudflare account with Workers enabled
+- KV namespace created via `wrangler kv:namespace`
+
+## Quick Start
+
+```typescript
+import { cloudflareKvStore } from "@uploadista/kv-store-cloudflare-kv";
+import { Effect } from "effect";
+
+// In Cloudflare Worker environment, KV is provided as a binding
+export default {
+  fetch(request: Request, env: { KV_STORE: KVNamespace }) {
+    const program = Effect.gen(function* () {
+      // The cloudflareKvStore is automatically available
+    });
+
+    return Effect.runPromise(
+      program.pipe(
+        Effect.provide(cloudflareKvStore({ kv: env.KV_STORE }))
+      )
+    );
+  },
+};
+```
+
+## Features
+
+- ✅ **Global Distribution**: Data replicated to 300+ edge locations
+- ✅ **Low Latency**: Sub-second read/write operations
+- ✅ **Serverless**: No origin server infrastructure needed
+- ✅ **Auto-Scaling**: Handles traffic spikes automatically
+- ✅ **Strong Consistency**: Atomic reads and writes
+- ✅ **No Cold Starts**: Workers start in ~1ms
+- ✅ **Type Safe**: Full TypeScript support
+
+## API Reference
+
+### Main Exports
+
+#### `cloudflareKvStore(config: CloudflareKvStoreConfig): Layer<BaseKvStoreService>`
+
+Creates an Effect layer providing the `BaseKvStoreService` backed by Cloudflare KV.
+
+```typescript
+import { cloudflareKvStore } from "@uploadista/kv-store-cloudflare-kv";
+
+export default {
+  fetch(request: Request, env: { KV_STORE: KVNamespace }) {
+    const layer = cloudflareKvStore({ kv: env.KV_STORE });
+  },
+};
+```
+
+**Configuration**:
+
+```typescript
+type CloudflareKvStoreConfig = {
+  kv: KVNamespace<string>; // Cloudflare KV namespace binding
+};
+```
+
+#### `makeCloudflareBaseKvStore(config: CloudflareKvStoreConfig): BaseKvStore`
+
+Factory function for creating a KV store with an existing KVNamespace.
+
+```typescript
+import { makeCloudflareBaseKvStore } from "@uploadista/kv-store-cloudflare-kv";
+
+const store = makeCloudflareBaseKvStore({ kv: env.KV_STORE });
+```
+
+### Available Operations
+
+The Cloudflare KV store implements the `BaseKvStore` interface:
+
+#### `get(key: string): Effect<string | null>`
+
+Retrieve a value by key.
+
+```typescript
+const program = Effect.gen(function* () {
+  const value = yield* store.get("upload:abc123");
+  // Returns immediately from nearest edge location
+});
+```
+
+#### `set(key: string, value: string): Effect<void>`
+
+Store a string value globally.
+
+```typescript
+const program = Effect.gen(function* () {
+  yield* store.set("upload:abc123", JSON.stringify(metadata));
+  // Replicated to all edge locations within seconds
+});
+```
+
+#### `delete(key: string): Effect<void>`
+
+Remove a key globally.
+
+```typescript
+const program = Effect.gen(function* () {
+  yield* store.delete("upload:abc123");
+});
+```
+
+#### `list(keyPrefix: string): Effect<string[]>`
+
+List keys matching a prefix.
+
+```typescript
+const program = Effect.gen(function* () {
+  const keys = yield* store.list("upload:");
+  // Returns matching keys
+});
+```
+
+## Configuration
+
+### Basic Setup in wrangler.toml
+
+```toml
+name = "uploadista-worker"
+type = "javascript"
+
+[env.production]
+kv_namespaces = [
+  { binding = "KV_STORE", id = "abc123def456", preview_id = "preview789" }
+]
+
+[env.staging]
+kv_namespaces = [
+  { binding = "KV_STORE", id = "staging-id", preview_id = "staging-preview" }
+]
+```
+
+### Worker Environment Setup
+
+```typescript
+export interface Env {
+  KV_STORE: KVNamespace<string>;
+  ENVIRONMENT: "production" | "staging" | "development";
+}
+
+export default {
+  async fetch(request: Request, env: Env) {
+    const program = Effect.gen(function* () {
+      // Use env.KV_STORE
+    });
+
+    return Effect.runPromise(
+      program.pipe(
+        Effect.provide(cloudflareKvStore({ kv: env.KV_STORE }))
+      )
+    );
+  },
+};
+```
+
+### Environment-Specific Configuration
+
+```typescript
+export default {
+  async fetch(request: Request, env: Env) {
+    const isProduction = env.ENVIRONMENT === "production";
+
+    const program = Effect.gen(function* () {
+      // Use KV with environment awareness
+      const cacheKey = isProduction ? "cache:prod" : "cache:dev";
+    });
+
+    return Effect.runPromise(
+      program.pipe(
+        Effect.provide(cloudflareKvStore({ kv: env.KV_STORE }))
+      )
+    );
+  },
+};
+```
+
+## Examples
+
+### Example 1: Cloudflare Workers Upload Server
+
+Complete serverless upload handler:
+
+```typescript
+import { cloudflareKvStore } from "@uploadista/kv-store-cloudflare-kv";
+import { uploadServer } from "@uploadista/server";
+import { Effect } from "effect";
+
+export interface Env {
+  KV_STORE: KVNamespace;
+  BUCKET: R2Bucket; // Cloudflare R2 for file storage
+}
+
+export default {
+  async fetch(request: Request, env: Env) {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/api/upload" && request.method === "POST") {
+      const program = Effect.gen(function* () {
+        const server = yield* uploadServer;
+
+        // Create upload session
+        const upload = yield* server.createUpload(
+          {
+            filename: "user-file.pdf",
+            size: 5242880,
+            mimeType: "application/pdf",
+          },
+          "client:123"
+        );
+
+        return new Response(
+          JSON.stringify({
+            uploadId: upload.id,
+            chunkSize: 1048576,
+          })
+        );
+      });
+
+      return Effect.runPromise(
+        program.pipe(
+          Effect.provide(cloudflareKvStore({ kv: env.KV_STORE }))
+        )
+      );
+    }
+
+    return new Response("Not found", { status: 404 });
+  },
+};
+```
+
+### Example 2: Request Deduplication
+
+Use KV to prevent duplicate uploads:
+
+```typescript
+import { cloudflareKvStore } from "@uploadista/kv-store-cloudflare-kv";
+import { Effect } from "effect";
+
+const dedupKey = (clientId: string, checksum: string) =>
+  `dedup:${clientId}:${checksum}`;
+
+const checkDedup = (kv: KVNamespace, clientId: string, checksum: string) =>
+  Effect.gen(function* () {
+    const key = dedupKey(clientId, checksum);
+    const existing = yield* Effect.tryPromise({
+      try: () => kv.get(key),
+      catch: () => null,
+    });
+
+    if (existing) {
+      return JSON.parse(existing); // Return existing upload
+    }
+
+    return null; // New upload
+  });
+
+const recordDedup = (
+  kv: KVNamespace,
+  clientId: string,
+  checksum: string,
+  uploadId: string
+) =>
+  Effect.gen(function* () {
+    const key = dedupKey(clientId, checksum);
+    yield* Effect.tryPromise({
+      try: () =>
+        kv.put(key, JSON.stringify({ uploadId }), {
+          expirationTtl: 86400, // 24 hours
+        }),
+      catch: () => null,
+    });
+  });
+
+// Usage in worker
+export default {
+  async fetch(request: Request, env: Env) {
+    const existing = yield* checkDedup(env.KV_STORE, clientId, checksum);
+
+    if (existing) {
+      return new Response(JSON.stringify(existing));
+    }
+
+    // Create new upload...
+    yield* recordDedup(env.KV_STORE, clientId, checksum, uploadId);
+  },
+};
+```
+
+### Example 3: Cache-Aside Pattern
+
+Use KV for upload metadata caching:
+
+```typescript
+import { cloudflareKvStore } from "@uploadista/kv-store-cloudflare-kv";
+import { Effect } from "effect";
+
+const getUploadMetadata = (
+  kv: KVNamespace,
+  uploadId: string
+) =>
+  Effect.gen(function* () {
+    // Check cache first
+    const cached = yield* Effect.tryPromise({
+      try: () => kv.get(`meta:${uploadId}`),
+      catch: () => null,
+    });
+
+    if (cached) {
+      return JSON.parse(cached);
+    }
+
+    // Fetch from source (e.g., database)
+    const metadata = yield* fetchFromDatabase(uploadId);
+
+    // Cache result
+    yield* Effect.tryPromise({
+      try: () =>
+        kv.put(`meta:${uploadId}`, JSON.stringify(metadata), {
+          expirationTtl: 3600, // 1 hour
+        }),
+      catch: () => null,
+    });
+
+    return metadata;
+  });
+```
+
+## Performance Characteristics
+
+| Operation | Latency | Global Sync |
+|-----------|---------|-------------|
+| get()     | ~10ms   | Immediate  |
+| set()     | ~50ms   | ~30 seconds |
+| delete()  | ~50ms   | ~30 seconds |
+| list()    | ~100ms  | N/A (edge) |
+
+All operations are served from the nearest edge location to the client.
+
+## Limits & Quotas
+
+| Limit | Value |
+|-------|-------|
+| Key Size | 512 bytes max |
+| Value Size | 25 MB max |
+| Namespace Storage | Unlimited (Capped at billing) |
+| Read/Write Rate | 10,000 ops/sec per namespace |
+| API Requests | Included in Workers plan |
+
+For most upload use cases, these limits are more than sufficient.
+
+## Best Practices
+
+### 1. Use Meaningful Key Prefixes
+
+```typescript
+// Good: Hierarchical, searchable
+"upload:abc123"
+"upload:abc123:chunk:0"
+"session:user:xyz"
+
+// Avoid: Unclear prefixes
+"data1", "tmp", "x"
+```
+
+### 2. Set Expiration on Temporary Data
+
+```typescript
+// Temporary upload sessions expire after 24 hours
+kv.put("session:user123", sessionData, {
+  expirationTtl: 86400, // seconds
+});
+```
+
+### 3. Handle Eventual Consistency
+
+```typescript
+// Wait for global replication
+const isReplicated = yield* Effect.gen(function* () {
+  const retries = 3;
+  for (let i = 0; i < retries; i++) {
+    const value = yield* store.get(key);
+    if (value === expectedValue) {
+      return true;
+    }
+    yield* Effect.sleep("100 millis");
+  }
+  return false;
+});
+```
+
+### 4. Batch Operations Efficiently
+
+```typescript
+// Instead of individual writes
+for (const item of items) {
+  yield* store.set(`item:${item.id}`, JSON.stringify(item));
+}
+
+// Better: Batch at application level
+// Or use metadata object
+const batch = items.reduce(
+  (acc, item) => ({ ...acc, [`item:${item.id}`]: item }),
+  {}
+);
+```
+
+## Deployment
+
+### Local Development
+
+```bash
+# Create local KV namespace
+wrangler kv:namespace create "KV_STORE" --preview
+
+# Run locally
+wrangler dev
+
+# Access KV from http://localhost:8787
+```
+
+### Production Deployment
+
+```bash
+# Create production KV namespace
+wrangler kv:namespace create "KV_STORE"
+
+# Deploy to Cloudflare
+wrangler publish
+
+# Deploy to specific environment
+wrangler publish --env production
+```
+
+### GitHub Actions
+
+```yaml
+name: Deploy
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "18"
+      - run: npm ci
+      - run: npm run build
+      - uses: cloudflare/wrangler-action@v3
+        with:
+          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+```
+
+## Integration with Other Services
+
+### Cloudflare R2 (File Storage)
+
+```typescript
+export interface Env {
+  KV_STORE: KVNamespace;
+  R2_BUCKET: R2Bucket;
+}
+
+export default {
+  async fetch(request: Request, env: Env) {
+    // Use KV for metadata, R2 for files
+    yield* store.set("file:abc", JSON.stringify({ bucket: "uploads", key: "abc.pdf" }));
+    await env.R2_BUCKET.put("uploads/abc.pdf", file);
+  },
+};
+```
+
+### Cloudflare D1 (Database)
+
+```typescript
+export interface Env {
+  KV_STORE: KVNamespace;
+  DB: D1Database;
+}
+
+// Use KV for cache, D1 for persistent queries
+const metadata = yield* getCachedMetadata(env.KV_STORE, id);
+if (!metadata) {
+  const result = await env.DB.prepare("SELECT * FROM uploads WHERE id = ?").bind(id).first();
+  yield* store.set(`meta:${id}`, JSON.stringify(result));
+}
+```
+
+## Related Packages
+
+- [@uploadista/core](../../core) - Core types
+- [@uploadista/adapters-hono](../../servers/adapters-hono) - Hono adapter for Cloudflare
+- [@uploadista/data-store-s3](../../data-stores/s3) - For file storage on R2
+- [@uploadista/server](../../servers/server) - Upload server
+- [@uploadista/kv-store-cloudflare-do](../cloudflare-do) - Durable Objects for real-time state
+
+## Troubleshooting
+
+### "KV_STORE not found" Error
+
+Ensure namespace is defined in `wrangler.toml`:
+
+```toml
+kv_namespaces = [
+  { binding = "KV_STORE", id = "your-namespace-id" }
+]
+```
+
+Then run `wrangler dev` to load bindings.
+
+### Data Not Visible Across Regions
+
+KV replication takes 30-60 seconds globally. For immediate consistency:
+
+```typescript
+// Read from same origin temporarily
+const data = await kv.get(key, { cacheTtl: 0 });
+```
+
+### Memory/Size Limits
+
+If hitting 25MB limit for single key:
+
+1. Split data: `"upload:123:part:0"`, `"upload:123:part:1"`
+2. Use R2 for actual files, KV only for metadata
+3. Implement cleanup: set `expirationTtl` on temporary data
+
+### Rate Limiting (10k ops/sec)
+
+If hitting rate limit:
+
+1. Implement batching on client
+2. Use longer cache TTL
+3. Request quota increase from Cloudflare
+
+## License
+
+See [LICENSE](../../../LICENSE) in the main repository.
+
+## See Also
+
+- [KV Stores Comparison Guide](../KV_STORES_COMPARISON.md) - Compare with other stores
+- [Cloudflare Workers Documentation](https://developers.cloudflare.com/workers/) - Official docs
+- [Cloudflare KV API Reference](https://developers.cloudflare.com/workers/runtime-apis/kv/) - KV API
+- [Server Setup with Cloudflare](../../../SERVER_SETUP.md#cloudflare-workers) - Server deployment
+- [@uploadista/adapters-hono](../../servers/adapters-hono) - Hono integration example

package/dist/cloudflare-kv-store.d.ts

@@ -0,0 +1,9 @@
+import type { KVNamespace } from "@cloudflare/workers-types";
+import { type BaseKvStore, BaseKvStoreService } from "@uploadista/core/types";
+import { Layer } from "effect";
+export type CloudflareKvStoreConfig = {
+    kv: KVNamespace<string>;
+};
+export declare function makeCloudflareBaseKvStore({ kv, }: CloudflareKvStoreConfig): BaseKvStore;
+export declare const cloudflareKvStore: (config: CloudflareKvStoreConfig) => Layer.Layer<BaseKvStoreService, never, never>;
+//# sourceMappingURL=cloudflare-kv-store.d.ts.map

package/dist/cloudflare-kv-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-kv-store.d.ts","sourceRoot":"","sources":["../src/cloudflare-kv-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EAEZ,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAAE,KAAK,WAAW,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AAEvC,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACzB,CAAC;AAGF,wBAAgB,yBAAyB,CAAC,EACxC,EAAE,GACH,EAAE,uBAAuB,GAAG,WAAW,CAiDvC;AAGD,eAAO,MAAM,iBAAiB,GAAI,QAAQ,uBAAuB,kDACK,CAAC"}

package/dist/cloudflare-kv-store.js

@@ -0,0 +1,42 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { BaseKvStoreService } from "@uploadista/core/types";
+import { Effect, Layer } from "effect";
+// Base CloudFlare KV store that stores raw strings
+export function makeCloudflareBaseKvStore({ kv, }) {
+    return {
+        get: (key) => Effect.tryPromise({
+            try: () => kv.get(key),
+            catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+        }),
+        set: (key, value) => Effect.tryPromise({
+            try: () => kv.put(key, value),
+            catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+        }).pipe(Effect.asVoid),
+        delete: (key) => Effect.tryPromise({
+            try: () => kv.delete(key),
+            catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+        }).pipe(Effect.asVoid),
+        list: (keyPrefix) => Effect.gen(function* (_) {
+            const keys = new Set();
+            let cursor = null;
+            do {
+                const result = yield* _(Effect.tryPromise({
+                    try: () => kv.list({
+                        prefix: keyPrefix,
+                        limit: 20,
+                        cursor,
+                    }),
+                    catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+                }));
+                cursor = result.list_complete ? null : result.cursor;
+                for (const key of result.keys) {
+                    const unprefixedKey = key.name.replace(keyPrefix, "");
+                    keys.add(unprefixedKey);
+                }
+            } while (cursor);
+            return Array.from(keys);
+        }),
+    };
+}
+// Base store layer
+export const cloudflareKvStore = (config) => Layer.succeed(BaseKvStoreService, makeCloudflareBaseKvStore(config));

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./cloudflare-kv-store";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./cloudflare-kv-store";

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@uploadista/kv-store-cloudflare-kv",
+  "type": "module",
+  "version": "0.0.3",
+  "description": "Cloudflare KV store for Uploadista",
+  "license": "MIT",
+  "author": "Uploadista",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@cloudflare/workers-types": "4.20251011.0",
+    "effect": "3.18.4",
+    "@uploadista/core": "0.0.3"
+  },
+  "devDependencies": {
+    "@uploadista/typescript-config": "0.0.3"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "format": "biome format --write ./src",
+    "lint": "biome lint --write ./src",
+    "check": "biome check --write ./src"
+  }
+}

package/src/cloudflare-kv-store.ts

@@ -0,0 +1,70 @@
+import type {
+  KVNamespace,
+  KVNamespaceListResult,
+} from "@cloudflare/workers-types";
+import { UploadistaError } from "@uploadista/core/errors";
+
+import { type BaseKvStore, BaseKvStoreService } from "@uploadista/core/types";
+import { Effect, Layer } from "effect";
+
+export type CloudflareKvStoreConfig = {
+  kv: KVNamespace<string>;
+};
+
+// Base CloudFlare KV store that stores raw strings
+export function makeCloudflareBaseKvStore({
+  kv,
+}: CloudflareKvStoreConfig): BaseKvStore {
+  return {
+    get: (key: string) =>
+      Effect.tryPromise({
+        try: () => kv.get(key),
+        catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+      }),
+
+    set: (key: string, value: string) =>
+      Effect.tryPromise({
+        try: () => kv.put(key, value),
+        catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+      }).pipe(Effect.asVoid),
+
+    delete: (key: string) =>
+      Effect.tryPromise({
+        try: () => kv.delete(key),
+        catch: (cause) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+      }).pipe(Effect.asVoid),
+
+    list: (keyPrefix: string) =>
+      Effect.gen(function* (_) {
+        const keys = new Set<string>();
+        let cursor: string | null = null;
+
+        do {
+          const result: KVNamespaceListResult<unknown, string> = yield* _(
+            Effect.tryPromise({
+              try: () =>
+                kv.list({
+                  prefix: keyPrefix,
+                  limit: 20,
+                  cursor,
+                }),
+              catch: (cause) =>
+                UploadistaError.fromCode("UNKNOWN_ERROR", { cause }),
+            }),
+          );
+
+          cursor = result.list_complete ? null : result.cursor;
+          for (const key of result.keys) {
+            const unprefixedKey = key.name.replace(keyPrefix, "");
+            keys.add(unprefixedKey);
+          }
+        } while (cursor);
+
+        return Array.from(keys);
+      }),
+  };
+}
+
+// Base store layer
+export const cloudflareKvStore = (config: CloudflareKvStoreConfig) =>
+  Layer.succeed(BaseKvStoreService, makeCloudflareBaseKvStore(config));

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./cloudflare-kv-store";

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@uploadista/typescript-config/server.json",
+  "compilerOptions": {
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "typeRoots": ["../../../../node_modules/@types"]
+  },
+  "include": ["src"]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/cloudflare-kv-store.ts","./src/index.ts"],"version":"5.9.3"}