payment-kit 1.29.1 → 1.29.2

package/cloudflare/shims/did-space-js.ts

@@ -1,17 +0,0 @@
-// noop shim for @blocklet/did-space-js in CF Workers
-const noop = (..._args: any[]) => {};
-
-export class SpaceClient {
-  constructor(..._args: any[]) {}
-  send = noop;
-}
-
-export class GetObjectCommand {
-  constructor(..._args: any[]) {}
-}
-
-export class PutObjectCommand {
-  constructor(..._args: any[]) {}
-}
-
-export default { SpaceClient, GetObjectCommand, PutObjectCommand };

package/cloudflare/shims/did-space.ts

@@ -1,11 +0,0 @@
-// @blocklet/did-space-js shim
-export class SpaceClient {
-  constructor(_opts?: any) {}
-  async send(_cmd: any) { return {}; }
-}
-export class GetObjectCommand {
-  constructor(_opts?: any) {}
-}
-export class PutObjectCommand {
-  constructor(_opts?: any) {}
-}

package/cloudflare/shims/express-compat/index.ts

@@ -1,80 +0,0 @@
-// Express compatibility shim for CF Workers
-// Allows existing Express route handlers to work with Hono
-
-export type RouteEntry = { method: string; path: string; handlers: Function[] };
-
-export function Router() {
-  const routes: RouteEntry[] = [];
-  const middlewares: Function[] = [];
-
-  const router: any = function () {};
-
-  for (const method of ['get', 'post', 'put', 'patch', 'delete']) {
-    router[method] = (path: string, ...handlers: Function[]) => {
-      routes.push({ method: method.toUpperCase(), path, handlers: [...middlewares, ...handlers] });
-      return router;
-    };
-  }
-
-  router.use = (...args: any[]) => {
-    if (typeof args[0] === 'string') {
-      // router.use('/path', ...middlewaresOrSubRouter)
-      const path = args[0];
-      const rest = args.slice(1);
-
-      // Find the sub-router (has _routes) — it's typically the last arg
-      const subRouterIdx = rest.findIndex((a: any) => a?._routes);
-      if (subRouterIdx >= 0) {
-        const subRouter = rest[subRouterIdx];
-        // Middlewares are everything before the sub-router
-        const pathMiddlewares = rest.slice(0, subRouterIdx).filter((a: any) => typeof a === 'function');
-
-        for (const route of subRouter._routes) {
-          routes.push({
-            method: route.method,
-            path: path + route.path,
-            // Chain: parent middlewares -> path-level middlewares -> sub-router middlewares from route
-            handlers: [...middlewares, ...pathMiddlewares, ...route.handlers],
-          });
-        }
-      } else {
-        // All args are middlewares for this path — treat as path-scoped middleware
-        for (const fn of rest) {
-          if (typeof fn === 'function') {
-            // We store path-scoped middlewares as a special route entry
-            // They'll match any method and sub-path
-            middlewares.push(fn);
-          }
-        }
-      }
-    } else {
-      // router.use(middleware1, middleware2, ...)
-      for (const fn of args) {
-        if (typeof fn === 'function') {
-          middlewares.push(fn);
-        }
-      }
-    }
-    return router;
-  };
-
-  router._routes = routes;
-  router._middlewares = middlewares;
-
-  return router;
-}
-
-// Express app stub
-export function express() {
-  return Router();
-}
-
-// Static middleware stubs
-express.json = (_opts?: any) => (_req: any, _res: any, next: any) => next();
-express.urlencoded = (_opts?: any) => (_req: any, _res: any, next: any) => next();
-express.static = (_path: string, _opts?: any) => (_req: any, _res: any, next: any) => next();
-express.Router = Router;
-express.raw = (_opts?: any) => (_req: any, _res: any, next: any) => next();
-
-export default express;
-export type { Request, Response, NextFunction, ErrorRequestHandler } from './types';

package/cloudflare/shims/express-compat/types.ts

@@ -1,41 +0,0 @@
-// Express type stubs
-export interface Request {
-  method: string;
-  path: string;
-  url: string;
-  originalUrl: string;
-  query: Record<string, any>;
-  params: Record<string, any>;
-  body: any;
-  headers: Record<string, string>;
-  user?: any;
-  customer?: any;
-  livemode?: boolean;
-  baseCurrency?: any;
-  doc?: any;
-  stripeEvent?: any;
-  stripeClient?: any;
-  get(name: string): string | undefined;
-  header(name: string): string | undefined;
-  [key: string]: any;
-}
-
-export interface Response {
-  json(data: any): any;
-  status(code: number): Response;
-  send(data: any): any;
-  redirect(url: string): any;
-  set(key: string, value: string): Response;
-  setHeader(key: string, value: string): Response;
-  cookie(name: string, value: string, options?: any): Response;
-  end(): void;
-  headersSent: boolean;
-  statusCode: number;
-  _statusCode?: number;
-  _headers?: Record<string, string>;
-  _body?: any;
-  _sent?: boolean;
-}
-
-export type NextFunction = (err?: any) => void;
-export type ErrorRequestHandler = (err: any, req: Request, res: Response, next: NextFunction) => void;

package/cloudflare/shims/lock.ts

@@ -1,115 +0,0 @@
-// CF Workers lock shim — replaces libs/lock.ts
-//
-// In Blocklet Server (single-process Node.js), the original in-memory lock works fine.
-// In CF Workers, each HTTP request runs in a separate isolate, so in-memory locks
-// are useless for cross-request mutual exclusion.
-//
-// This shim uses D1 (SQLite) as the coordination layer:
-// - INSERT OR IGNORE with PRIMARY KEY constraint provides atomic lock acquisition
-// - owner token prevents accidental release by other isolates
-// - TTL-based expiry prevents deadlocks from crashed isolates
-// - Exponential backoff with jitter avoids D1 write hotspots
-
-import { getDB } from './sequelize-d1/model';
-
-let _nanoidCounter = 0;
-function simpleId(): string {
-  // Lightweight unique ID — no need for crypto-strength randomness for lock owners
-  return `${Date.now().toString(36)}-${(++_nanoidCounter).toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
-}
-
-export class Lock {
-  name: string;
-  owner: string;
-  locked: boolean;
-  ttl: number;
-
-  // EventEmitter stub for API compatibility — original Lock extends EventEmitter
-  events: { on: () => void; removeListener: () => void; emit: () => void };
-
-  constructor(name: string, options?: { ttl?: number }) {
-    this.name = name;
-    this.owner = simpleId();
-    this.locked = false;
-    this.ttl = options?.ttl || 5000; // default 5s TTL for short critical sections
-    this.events = { on: () => {}, removeListener: () => {}, emit: () => {} };
-  }
-
-  async acquire(maxWaitMs = 10000): Promise<true> {
-    const db = getDB();
-    const deadline = Date.now() + maxWaitMs;
-    let delay = 30; // start at 30ms
-
-    while (Date.now() < deadline) {
-      const now = Date.now();
-
-      try {
-        // Atomically: clean expired locks + try to insert ours + verify ownership
-        // All 3 statements in a single D1 batch (1 round-trip instead of 2)
-        const batchResult = await db.batch([
-          db.prepare('DELETE FROM _locks WHERE name = ? AND expires_at < ?').bind(this.name, now),
-          db.prepare('INSERT OR IGNORE INTO _locks (name, owner, expires_at) VALUES (?, ?, ?)')
-            .bind(this.name, this.owner, now + this.ttl),
-          db.prepare('SELECT owner FROM _locks WHERE name = ?').bind(this.name),
-        ]);
-
-        const row = batchResult[2]?.results?.[0] as { owner: string } | undefined;
-        if (row?.owner === this.owner) {
-          this.locked = true;
-          return true;
-        }
-      } catch (err: any) {
-        // D1 errors (e.g. table not found on first deploy) — log and retry
-        console.error(`[D1Lock] acquire error for "${this.name}":`, err?.message || err);
-      }
-
-      // Exponential backoff with jitter to avoid D1 write hotspots
-      const jitter = Math.random() * delay * 0.3;
-      await new Promise(r => setTimeout(r, delay + jitter));
-      delay = Math.min(delay * 2, 500); // cap at 500ms
-    }
-
-    // Timeout — throw to match original behavior where acquire() always resolves
-    // All callers use try/catch or don't check the return value
-    console.warn(`[D1Lock] acquire timeout: "${this.name}" after ${maxWaitMs}ms`);
-    throw new Error(`[D1Lock] Failed to acquire lock "${this.name}" within ${maxWaitMs}ms`);
-  }
-
-  release(): void {
-    if (!this.locked) return;
-    this.locked = false;
-
-    // Fire-and-forget: 8 out of 10 call sites do NOT await release().
-    // We register the promise with __cfPendingJobs__ so flushPendingJobs()
-    // in worker.ts ensures it completes before the response is sent.
-    try {
-      const db = getDB();
-      const promise = db.prepare('DELETE FROM _locks WHERE name = ? AND owner = ?')
-        .bind(this.name, this.owner)
-        .run()
-        .catch((err: any) => console.error(`[D1Lock] release error for "${this.name}":`, err?.message || err));
-
-      // For HTTP context, use waitUntil (non-blocking) instead of pendingJobs (blocking)
-      const isHttp = (globalThis as any).__cfHttpContext__;
-      if (isHttp) {
-        const waitUntil = (globalThis as any).__cfWaitUntil__;
-        if (typeof waitUntil === 'function') {
-          waitUntil(promise);
-        }
-      } else {
-        const pending = (globalThis as any).__cfPendingJobs__;
-        if (Array.isArray(pending)) {
-          pending.push(promise);
-        }
-      }
-    } catch (err: any) {
-      console.error(`[D1Lock] release setup error for "${this.name}":`, err?.message || err);
-    }
-  }
-}
-
-// In CF Workers, don't cache Lock instances across requests — each request is isolated.
-// The original code caches by name, but that's only useful within a single process.
-export function getLock(name: string, options?: { ttl?: number }): Lock {
-  return new Lock(name, options);
-}