@japikey/cloudflare 0.1.0 → 0.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 susu-dot-dev
+
+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/dist/d1.d.ts

@@ -0,0 +1,22 @@
+import type { ApiKeyRow, DatabaseDriver } from '@japikey/shared';
+import { TRUNCATE_TABLE_ONLY_USE_FOR_UNIT_TESTS } from '@japikey/shared';
+import type { D1Database } from '@cloudflare/workers-types';
+export default class D1Driver implements DatabaseDriver {
+    private db;
+    private _queries?;
+    private tableName;
+    constructor(db: D1Database, tableName?: string);
+    private getQuery;
+    private prepareStatements;
+    ensureTable(): Promise<void>;
+    insertApiKey(apiKey: ApiKeyRow): Promise<void>;
+    getApiKey(kid: string): Promise<ApiKeyRow | null>;
+    findApiKeys(user_id: string, limit?: number, offset?: number): Promise<ApiKeyRow[]>;
+    revokeApiKey(filter: {
+        user_id: string;
+        kid: string;
+    }): Promise<void>;
+    close(): Promise<void>;
+    [TRUNCATE_TABLE_ONLY_USE_FOR_UNIT_TESTS](): Promise<void>;
+}
+//# sourceMappingURL=d1.d.ts.map

package/dist/d1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d1.d.ts","sourceRoot":"","sources":["../src/d1.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAIL,sCAAsC,EACvC,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EACV,UAAU,EAGX,MAAM,2BAA2B,CAAC;AAyCnC,MAAM,CAAC,OAAO,OAAO,QAAS,YAAW,cAAc;IAKnD,OAAO,CAAC,EAAE;IAJZ,OAAO,CAAC,QAAQ,CAAC,CAAU;IAC3B,OAAO,CAAC,SAAS,CAAS;gBAGhB,EAAE,EAAE,UAAU,EACtB,SAAS,GAAE,MAAmB;IAQhC,OAAO,CAAC,QAAQ;IAShB,OAAO,CAAC,iBAAiB;IAqBnB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB5B,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB9C,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAgBjD,WAAW,CACf,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,EAAE,CAAC;IAajB,YAAY,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAWrE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAEtB,CAAC,sCAAsC,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhE"}

package/dist/d1.js

@@ -0,0 +1,143 @@
+import { IncorrectUsageError, DatabaseError, InvalidInputError, TRUNCATE_TABLE_ONLY_USE_FOR_UNIT_TESTS, } from '@japikey/shared';
+function toSqlite(apiKey) {
+    try {
+        return {
+            kid: apiKey.kid,
+            user_id: apiKey.user_id,
+            revoked: apiKey.revoked ? 1 : 0,
+            jwk: JSON.stringify(apiKey.jwk),
+            metadata: JSON.stringify(apiKey.metadata),
+        };
+    }
+    catch (err) {
+        throw new InvalidInputError('Failed to serialize the metadata', {
+            cause: err,
+        });
+    }
+}
+function fromSqlite(result) {
+    try {
+        return {
+            kid: result.kid,
+            user_id: result.user_id,
+            revoked: result.revoked === 1,
+            jwk: JSON.parse(result.jwk),
+            metadata: JSON.parse(result.metadata),
+        };
+    }
+    catch (err) {
+        throw new DatabaseError('Failed to deserialize an ApiKeyRow', {
+            cause: err,
+        });
+    }
+}
+export default class D1Driver {
+    db;
+    _queries;
+    tableName;
+    constructor(db, tableName = 'japikeys') {
+        this.db = db;
+        if (!/^[a-zA-Z0-9_]+$/.test(tableName)) {
+            throw new IncorrectUsageError('Invalid table name');
+        }
+        this.tableName = tableName;
+    }
+    getQuery(name) {
+        if (!this._queries) {
+            throw new IncorrectUsageError('Database not initialized. Call ensureTable() first.');
+        }
+        return this._queries[name];
+    }
+    prepareStatements() {
+        try {
+            this._queries = {
+                insert: this.db.prepare(`INSERT INTO ${this.tableName} (kid, user_id, revoked, jwk, metadata) VALUES (?1, ?2, ?3, ?4, ?5)`),
+                get: this.db.prepare(`SELECT * FROM ${this.tableName} WHERE kid = ?1`),
+                find: this.db.prepare(`SELECT * FROM ${this.tableName} WHERE user_id = ?1 LIMIT ?2 OFFSET ?3`),
+                revoke: this.db.prepare(`UPDATE ${this.tableName} SET revoked = 1 WHERE user_id = ?1 AND kid = ?2`),
+            };
+        }
+        catch (err) {
+            throw new DatabaseError('Failed to generate sql prepared statements', {
+                cause: err,
+            });
+        }
+    }
+    async ensureTable() {
+        try {
+            await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        kid TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        revoked INTEGER NOT NULL,
+        jwk TEXT NOT NULL,
+        metadata TEXT NOT NULL
+      )
+    `);
+        }
+        catch (err) {
+            throw new DatabaseError('Failed to create the table', {
+                cause: err,
+            });
+        }
+        this.prepareStatements();
+    }
+    async insertApiKey(apiKey) {
+        const params = toSqlite(apiKey);
+        const query = this.getQuery('insert');
+        try {
+            await query
+                .bind(params.kid, params.user_id, params.revoked, params.jwk, params.metadata)
+                .run();
+        }
+        catch (err) {
+            throw new DatabaseError('Failed to insert api key', {
+                cause: err,
+            });
+        }
+    }
+    async getApiKey(kid) {
+        let result;
+        const query = this.getQuery('get');
+        try {
+            result = await query.bind(kid).first();
+        }
+        catch (err) {
+            throw new DatabaseError('Failed to query for the api key', {
+                cause: err,
+            });
+        }
+        if (!result) {
+            return null;
+        }
+        return fromSqlite(result);
+    }
+    async findApiKeys(user_id, limit, offset) {
+        let response;
+        const query = this.getQuery('find');
+        try {
+            response = await query.bind(user_id, limit ?? -1, offset ?? 0).all();
+        }
+        catch (err) {
+            throw new DatabaseError('Failed to query for the api keys', {
+                cause: err,
+            });
+        }
+        return response.results.map(row => fromSqlite(row));
+    }
+    async revokeApiKey(filter) {
+        const query = this.getQuery('revoke');
+        try {
+            await query.bind(filter.user_id, filter.kid).run();
+        }
+        catch (err) {
+            throw new DatabaseError('Failed to revoke the api key', {
+                cause: err,
+            });
+        }
+    }
+    async close() { }
+    async [TRUNCATE_TABLE_ONLY_USE_FOR_UNIT_TESTS]() {
+        await this.db.exec(`DELETE FROM ${this.tableName}`);
+    }
+}

package/{src/index.ts → dist/index.d.ts}

@@ -1,12 +1,5 @@
 import type { CreateApiKeyRouterOptions, CreateApiKeyData } from './router.ts';
 import { createApiKeyRouter, createJWKSRouter, isJWKSPath } from './router.ts';
 import D1Driver from './d1.ts';
-
-export {
-  createApiKeyRouter,
-  createJWKSRouter,
-  isJWKSPath,
-  D1Driver,
-  type CreateApiKeyRouterOptions,
-  type CreateApiKeyData,
-};
+export { createApiKeyRouter, createJWKSRouter, isJWKSPath, D1Driver, type CreateApiKeyRouterOptions, type CreateApiKeyData, };
+//# 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,OAAO,KAAK,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,QAAQ,MAAM,SAAS,CAAC;AAE/B,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,UAAU,EACV,QAAQ,EACR,KAAK,yBAAyB,EAC9B,KAAK,gBAAgB,GACtB,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+import { createApiKeyRouter, createJWKSRouter, isJWKSPath } from "./router.js";
+import D1Driver from "./d1.js";
+export { createApiKeyRouter, createJWKSRouter, isJWKSPath, D1Driver, };

package/dist/router.d.ts

@@ -0,0 +1,19 @@
+import type { DatabaseDriver } from '@japikey/japikey';
+import type { ExportedHandler } from '@cloudflare/workers-types';
+export type CreateApiKeyData = {
+    expiresAt: Date;
+    claims: Record<string, unknown>;
+    databaseMetadata: Record<string, unknown>;
+};
+export type CreateApiKeyRouterOptions<Env> = {
+    getUserId: (request: Request, env: Env) => Promise<string>;
+    parseCreateApiKeyRequest: (request: Request, env: Env) => Promise<CreateApiKeyData>;
+    issuer: URL;
+    aud: string;
+    db: DatabaseDriver;
+    routePrefix: string;
+};
+export declare function createJWKSRouter<Env>(baseIssuer: URL, db: DatabaseDriver): ExportedHandler<Env>;
+export declare function isJWKSPath(request: Request, baseIssuer: URL): boolean;
+export declare function createApiKeyRouter<Env>(options: CreateApiKeyRouterOptions<Env>): ExportedHandler<Env>;
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,kBAAkB,CAAC;AAGtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAGjE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE,IAAI,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC3C,CAAC;AAEF,MAAM,MAAM,yBAAyB,CAAC,GAAG,IAAI;IAC3C,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3D,wBAAwB,EAAE,CACxB,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,GAAG,KACL,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC/B,MAAM,EAAE,GAAG,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,cAAc,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAwEF,wBAAgB,gBAAgB,CAAC,GAAG,EAClC,UAAU,EAAE,GAAG,EACf,EAAE,EAAE,cAAc,GACjB,eAAe,CAAC,GAAG,CAAC,CAUtB;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,GAAG,OAAO,CAOrE;AA6HD,wBAAgB,kBAAkB,CAAC,GAAG,EACpC,OAAO,EAAE,yBAAyB,CAAC,GAAG,CAAC,GACtC,eAAe,CAAC,GAAG,CAAC,CAmCtB"}

package/dist/router.js

@@ -0,0 +1,195 @@
+import { NotFoundError, JapikeyError } from '@japikey/shared';
+import { createApiKey } from '@japikey/japikey';
+import { validate as validateUuid } from 'uuid';
+import { pathToRegexp } from 'path-to-regexp';
+function wrapError(fn) {
+    return async (...args) => {
+        try {
+            return await fn(...args);
+        }
+        catch (err) {
+            if (err instanceof JapikeyError) {
+                return new Response(JSON.stringify({
+                    error: {
+                        type: err.errorType,
+                        message: err.message,
+                    },
+                }), {
+                    status: err.code,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                });
+            }
+            throw err;
+        }
+    };
+}
+async function handleJWKSRequest(kid, db) {
+    const row = await db.getApiKey(kid);
+    if (!row || row.revoked) {
+        throw new NotFoundError('API key not found');
+    }
+    const jwks = {
+        keys: [row.jwk],
+    };
+    return new Response(JSON.stringify(jwks), {
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+}
+function getWellKnownKid(request, baseIssuer) {
+    if (!request.url.startsWith(baseIssuer.toString())) {
+        throw new NotFoundError('Invalid JWKS request');
+    }
+    let partialPath = request.url.slice(baseIssuer.toString().length);
+    if (!partialPath.startsWith('/')) {
+        partialPath = `/${partialPath}`;
+    }
+    const parts = partialPath.split('/');
+    if (parts.length !== 4 ||
+        parts[0] !== '' ||
+        parts[2] !== '.well-known' ||
+        parts[3] !== 'jwks.json') {
+        throw new NotFoundError('Invalid JWKS request');
+    }
+    const kid = parts[1];
+    if (!kid || !validateUuid(kid)) {
+        throw new NotFoundError('Invalid JWKS request');
+    }
+    return kid;
+}
+export function createJWKSRouter(baseIssuer, db) {
+    return {
+        fetch: wrapError(async function fetch(request, env) {
+            const kid = getWellKnownKid(request, baseIssuer);
+            return handleJWKSRequest(kid, db);
+        }),
+    };
+}
+export function isJWKSPath(request, baseIssuer) {
+    try {
+        getWellKnownKid(request, baseIssuer);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+function matchPath(request, method, routePrefix, pattern) {
+    if (request.method !== method) {
+        return { valid: false, params: {} };
+    }
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    const normalizedPrefix = routePrefix === ''
+        ? ''
+        : routePrefix.startsWith('/')
+            ? routePrefix
+            : `/${routePrefix}`;
+    const fullPattern = `${normalizedPrefix}${pattern}`;
+    const regexp = pathToRegexp(fullPattern);
+    const match = regexp.regexp.exec(pathname);
+    if (!match) {
+        return { valid: false, params: {} };
+    }
+    const params = {};
+    regexp.keys.forEach((key, index) => {
+        params[key.name] = match[index + 1];
+    });
+    return { valid: true, params };
+}
+function ensureKid(params) {
+    const kid = params.kid ?? params.id;
+    if (!kid || typeof kid !== 'string' || !validateUuid(kid)) {
+        throw new NotFoundError('Invalid API key ID');
+    }
+    return kid;
+}
+async function handleCreateApiKeyRequest(request, env, options) {
+    const userId = await options.getUserId(request, env);
+    const { expiresAt, claims, databaseMetadata } = await options.parseCreateApiKeyRequest(request, env);
+    const { jwt, jwk } = await createApiKey(claims, {
+        sub: userId,
+        iss: options.issuer,
+        aud: options.aud,
+        expiresAt,
+    });
+    const kid = jwk.kid;
+    await options.db.insertApiKey({
+        kid,
+        user_id: userId,
+        revoked: false,
+        jwk,
+        metadata: databaseMetadata,
+    });
+    return new Response(JSON.stringify({ api_key: jwt, kid }), {
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+}
+async function handleListApiKeysRequest(request, env, options) {
+    const userId = await options.getUserId(request, env);
+    const apiKeys = await options.db.findApiKeys(userId);
+    return new Response(JSON.stringify(apiKeys), {
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+}
+async function handleGetApiKeyRequest(request, env, options, keyId) {
+    const userId = await options.getUserId(request, env);
+    const apiKey = await options.db.getApiKey(keyId);
+    if (!apiKey || apiKey.user_id !== userId) {
+        throw new NotFoundError('API key not found');
+    }
+    return new Response(JSON.stringify(apiKey), {
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+}
+async function handleRevokeApiKeyRequest(request, env, options, keyId) {
+    const userId = await options.getUserId(request, env);
+    const apiKey = await options.db.getApiKey(keyId);
+    if (!apiKey || apiKey.user_id !== userId) {
+        throw new NotFoundError('API key not found');
+    }
+    await options.db.revokeApiKey({ user_id: userId, kid: keyId });
+    return new Response(JSON.stringify({}), {
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+}
+export function createApiKeyRouter(options) {
+    return {
+        fetch: wrapError(async function fetch(request, env) {
+            // POST /api-keys - Create API key
+            let matchResult = matchPath(request, 'POST', options.routePrefix, '');
+            if (matchResult.valid) {
+                return handleCreateApiKeyRequest(request, env, options);
+            }
+            // GET /api-keys/my - List user's API keys
+            matchResult = matchPath(request, 'GET', options.routePrefix, '/my');
+            if (matchResult.valid) {
+                return handleListApiKeysRequest(request, env, options);
+            }
+            // GET /api-keys/:id - Get specific API key
+            matchResult = matchPath(request, 'GET', options.routePrefix, '/:id');
+            if (matchResult.valid) {
+                const keyId = ensureKid(matchResult.params);
+                return handleGetApiKeyRequest(request, env, options, keyId);
+            }
+            // DELETE /api-keys/:id - Revoke API key
+            matchResult = matchPath(request, 'DELETE', options.routePrefix, '/:id');
+            if (matchResult.valid) {
+                const keyId = ensureKid(matchResult.params);
+                return handleRevokeApiKeyRequest(request, env, options, keyId);
+            }
+            throw new NotFoundError('Route not found');
+        }),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@japikey/cloudflare",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "Cloudflare worker-based endpoints for japikey",
   "engines": {
     "node": ">=22.5.0"
@@ -28,6 +28,11 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "test": "vitest",
     "test:coverage": "vitest --coverage",
@@ -39,7 +44,7 @@
     "format:check": "prettier --check src/**/*.ts"
   },
   "dependencies": {
-    "@japikey/japikey": "0.1.0",
+    "@japikey/japikey": "0.2.2",
     "path-to-regexp": "^8.2.0"
   },
   "devDependencies": {

package/eslint.config.js

@@ -1,3 +0,0 @@
-import { browserConfig } from '../../eslint.config.js';
-
-export default browserConfig;

package/src/d1.ts

@@ -1,185 +0,0 @@
-import type { ApiKeyRow, DatabaseDriver } from '@japikey/shared';
-import {
-  IncorrectUsageError,
-  DatabaseError,
-  InvalidInputError,
-  TRUNCATE_TABLE_ONLY_USE_FOR_UNIT_TESTS,
-} from '@japikey/shared';
-import type {
-  D1Database,
-  D1PreparedStatement,
-  D1Result,
-} from '@cloudflare/workers-types';
-
-type Queries = {
-  insert: D1PreparedStatement;
-  get: D1PreparedStatement;
-  find: D1PreparedStatement;
-  revoke: D1PreparedStatement;
-};
-
-function toSqlite(apiKey: ApiKeyRow): Record<keyof ApiKeyRow, unknown> {
-  try {
-    return {
-      kid: apiKey.kid,
-      user_id: apiKey.user_id,
-      revoked: apiKey.revoked ? 1 : 0,
-      jwk: JSON.stringify(apiKey.jwk),
-      metadata: JSON.stringify(apiKey.metadata),
-    };
-  } catch (err) {
-    throw new InvalidInputError('Failed to serialize the metadata', {
-      cause: err,
-    });
-  }
-}
-
-function fromSqlite(result: Record<keyof ApiKeyRow, unknown>): ApiKeyRow {
-  try {
-    return {
-      kid: result.kid as string,
-      user_id: result.user_id as string,
-      revoked: result.revoked === 1,
-      jwk: JSON.parse(result.jwk as string),
-      metadata: JSON.parse(result.metadata as string),
-    };
-  } catch (err) {
-    throw new DatabaseError('Failed to deserialize an ApiKeyRow', {
-      cause: err,
-    });
-  }
-}
-
-export default class D1Driver implements DatabaseDriver {
-  private _queries?: Queries;
-  private tableName: string;
-
-  constructor(
-    private db: D1Database,
-    tableName: string = 'japikeys'
-  ) {
-    if (!/^[a-zA-Z0-9_]+$/.test(tableName)) {
-      throw new IncorrectUsageError('Invalid table name');
-    }
-    this.tableName = tableName;
-  }
-
-  private getQuery(name: keyof Queries): D1PreparedStatement {
-    if (!this._queries) {
-      throw new IncorrectUsageError(
-        'Database not initialized. Call ensureTable() first.'
-      );
-    }
-    return this._queries[name];
-  }
-
-  private prepareStatements(): void {
-    try {
-      this._queries = {
-        insert: this.db.prepare(
-          `INSERT INTO ${this.tableName} (kid, user_id, revoked, jwk, metadata) VALUES (?1, ?2, ?3, ?4, ?5)`
-        ),
-        get: this.db.prepare(`SELECT * FROM ${this.tableName} WHERE kid = ?1`),
-        find: this.db.prepare(
-          `SELECT * FROM ${this.tableName} WHERE user_id = ?1 LIMIT ?2 OFFSET ?3`
-        ),
-        revoke: this.db.prepare(
-          `UPDATE ${this.tableName} SET revoked = 1 WHERE user_id = ?1 AND kid = ?2`
-        ),
-      };
-    } catch (err) {
-      throw new DatabaseError('Failed to generate sql prepared statements', {
-        cause: err,
-      });
-    }
-  }
-
-  async ensureTable(): Promise<void> {
-    try {
-      await this.db.exec(`
-      CREATE TABLE IF NOT EXISTS ${this.tableName} (
-        kid TEXT PRIMARY KEY,
-        user_id TEXT NOT NULL,
-        revoked INTEGER NOT NULL,
-        jwk TEXT NOT NULL,
-        metadata TEXT NOT NULL
-      )
-    `);
-    } catch (err) {
-      throw new DatabaseError('Failed to create the table', {
-        cause: err,
-      });
-    }
-    this.prepareStatements();
-  }
-
-  async insertApiKey(apiKey: ApiKeyRow): Promise<void> {
-    const params = toSqlite(apiKey);
-    const query = this.getQuery('insert');
-    try {
-      await query
-        .bind(
-          params.kid,
-          params.user_id,
-          params.revoked,
-          params.jwk,
-          params.metadata
-        )
-        .run();
-    } catch (err) {
-      throw new DatabaseError('Failed to insert api key', {
-        cause: err,
-      });
-    }
-  }
-
-  async getApiKey(kid: string): Promise<ApiKeyRow | null> {
-    let result: Record<string, unknown> | undefined | null;
-    const query = this.getQuery('get');
-    try {
-      result = await query.bind(kid).first();
-    } catch (err) {
-      throw new DatabaseError('Failed to query for the api key', {
-        cause: err,
-      });
-    }
-    if (!result) {
-      return null;
-    }
-    return fromSqlite(result);
-  }
-
-  async findApiKeys(
-    user_id: string,
-    limit?: number,
-    offset?: number
-  ): Promise<ApiKeyRow[]> {
-    let response: D1Result<Record<string, unknown>>;
-    const query = this.getQuery('find');
-    try {
-      response = await query.bind(user_id, limit ?? -1, offset ?? 0).all();
-    } catch (err) {
-      throw new DatabaseError('Failed to query for the api keys', {
-        cause: err,
-      });
-    }
-    return response.results.map(row => fromSqlite(row));
-  }
-
-  async revokeApiKey(filter: { user_id: string; kid: string }): Promise<void> {
-    const query = this.getQuery('revoke');
-    try {
-      await query.bind(filter.user_id, filter.kid).run();
-    } catch (err) {
-      throw new DatabaseError('Failed to revoke the api key', {
-        cause: err,
-      });
-    }
-  }
-
-  async close(): Promise<void> {}
-
-  async [TRUNCATE_TABLE_ONLY_USE_FOR_UNIT_TESTS](): Promise<void> {
-    await this.db.exec(`DELETE FROM ${this.tableName}`);
-  }
-}