@vertz/cloudflare 0.2.0

package/.turbo/turbo-build.log

@@ -0,0 +1,15 @@
+$ bunup
+i Using bunup v0.16.26 and bun v1.3.9
+i Build started
+
+  src/index.ts
+
+  Output                Raw     Gzip
+
+  dist/index.js       676 B    349 B
+  dist/index.d.ts     327 B    225 B
+
+  2 files            1003 B    574 B
+
+
+✓ Build completed in 114ms

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { AppBuilder } from "@vertz/core";
+interface CloudflareHandlerOptions {
+	basePath?: string;
+}
+declare function createHandler(app: AppBuilder, options?: CloudflareHandlerOptions): {
+	fetch(request: Request, _env: unknown, _ctx: ExecutionContext): Promise<Response>;
+};
+export { createHandler, CloudflareHandlerOptions };

package/dist/index.js

@@ -0,0 +1,24 @@
+// src/handler.ts
+function createHandler(app, options) {
+  const handler = app.handler;
+  return {
+    async fetch(request, _env, _ctx) {
+      if (options?.basePath) {
+        const url = new URL(request.url);
+        if (url.pathname.startsWith(options.basePath)) {
+          url.pathname = url.pathname.slice(options.basePath.length) || "/";
+          request = new Request(url.toString(), request);
+        }
+      }
+      try {
+        return await handler(request);
+      } catch (error) {
+        console.error("Unhandled error in worker:", error);
+        return new Response("Internal Server Error", { status: 500 });
+      }
+    }
+  };
+}
+export {
+  createHandler
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@vertz/cloudflare",
+  "version": "0.2.0",
+  "description": "Cloudflare Workers adapter for vertz",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vertz-dev/vertz.git",
+    "directory": "packages/cloudflare"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bunup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@vertz/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20250214.0",
+    "bunup": "latest",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "@vertz/ui-server": "workspace:*"
+  },
+  "peerDependenciesMeta": {
+    "@vertz/ui-server": {
+      "optional": true
+    }
+  }
+}

package/src/handler.ts

@@ -0,0 +1,28 @@
+import type { AppBuilder } from '@vertz/core';
+
+export interface CloudflareHandlerOptions {
+  basePath?: string;
+}
+
+export function createHandler(app: AppBuilder, options?: CloudflareHandlerOptions) {
+  const handler = app.handler;
+
+  return {
+    async fetch(request: Request, _env: unknown, _ctx: ExecutionContext): Promise<Response> {
+      // If basePath, strip it from the URL before routing
+      if (options?.basePath) {
+        const url = new URL(request.url);
+        if (url.pathname.startsWith(options.basePath)) {
+          url.pathname = url.pathname.slice(options.basePath.length) || '/';
+          request = new Request(url.toString(), request);
+        }
+      }
+      try {
+        return await handler(request);
+      } catch (error) {
+        console.error('Unhandled error in worker:', error);
+        return new Response('Internal Server Error', { status: 500 });
+      }
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export type { CloudflareHandlerOptions } from './handler.js';
+export { createHandler } from './handler.js';

package/tests/handler.test.ts

@@ -0,0 +1,178 @@
+import type { AppBuilder } from '@vertz/core';
+import { describe, expect, it, vi } from 'vitest';
+import { createHandler } from '../src/handler.js';
+
+describe('createHandler', () => {
+  it('returns proper Worker export with fetch method', () => {
+    const mockHandler = vi.fn().mockResolvedValue(new Response('OK'));
+    const mockApp = {
+      handler: mockHandler,
+    } as unknown as AppBuilder;
+
+    const worker = createHandler(mockApp);
+
+    expect(worker).toHaveProperty('fetch');
+    expect(typeof worker.fetch).toBe('function');
+  });
+
+  it('forwards requests to the vertz handler', async () => {
+    const mockResponse = new Response('Hello from handler');
+    const mockHandler = vi.fn().mockResolvedValue(mockResponse);
+    const mockApp = {
+      handler: mockHandler,
+    } as unknown as AppBuilder;
+
+    const worker = createHandler(mockApp);
+    const request = new Request('https://example.com/api/test');
+    const mockEnv = {};
+    const mockCtx = {} as ExecutionContext;
+
+    const response = await worker.fetch(request, mockEnv, mockCtx);
+
+    expect(mockHandler).toHaveBeenCalledWith(request);
+    expect(response).toBe(mockResponse);
+  });
+
+  it('strips basePath prefix from pathname', async () => {
+    const mockHandler = vi.fn().mockResolvedValue(new Response('OK'));
+    const mockApp = {
+      handler: mockHandler,
+    } as unknown as AppBuilder;
+
+    const worker = createHandler(mockApp, { basePath: '/api' });
+    const request = new Request('https://example.com/api/users');
+    const mockEnv = {};
+    const mockCtx = {} as ExecutionContext;
+
+    await worker.fetch(request, mockEnv, mockCtx);
+
+    expect(mockHandler).toHaveBeenCalledTimes(1);
+    const calledRequest = mockHandler.mock.calls[0][0] as Request;
+    const url = new URL(calledRequest.url);
+    expect(url.pathname).toBe('/users');
+  });
+
+  it('strips basePath with trailing slash correctly', async () => {
+    const mockHandler = vi.fn().mockResolvedValue(new Response('OK'));
+    const mockApp = {
+      handler: mockHandler,
+    } as unknown as AppBuilder;
+
+    const worker = createHandler(mockApp, { basePath: '/api' });
+    const request = new Request('https://example.com/api/');
+    const mockEnv = {};
+    const mockCtx = {} as ExecutionContext;
+
+    await worker.fetch(request, mockEnv, mockCtx);
+
+    const calledRequest = mockHandler.mock.calls[0][0] as Request;
+    const url = new URL(calledRequest.url);
+    expect(url.pathname).toBe('/');
+  });
+
+  it('handles basePath when pathname does not start with basePath', async () => {
+    const mockHandler = vi.fn().mockResolvedValue(new Response('OK'));
+    const mockApp = {
+      handler: mockHandler,
+    } as unknown as AppBuilder;
+
+    const worker = createHandler(mockApp, { basePath: '/api' });
+    const request = new Request('https://example.com/other/path');
+    const mockEnv = {};
+    const mockCtx = {} as ExecutionContext;
+
+    await worker.fetch(request, mockEnv, mockCtx);
+
+    const calledRequest = mockHandler.mock.calls[0][0] as Request;
+    const url = new URL(calledRequest.url);
+    expect(url.pathname).toBe('/other/path');
+  });
+
+  it('preserves query parameters when stripping basePath', async () => {
+    const mockHandler = vi.fn().mockResolvedValue(new Response('OK'));
+    const mockApp = {
+      handler: mockHandler,
+    } as unknown as AppBuilder;
+
+    const worker = createHandler(mockApp, { basePath: '/api' });
+    const request = new Request('https://example.com/api/users?page=1&limit=10');
+    const mockEnv = {};
+    const mockCtx = {} as ExecutionContext;
+
+    await worker.fetch(request, mockEnv, mockCtx);
+
+    const calledRequest = mockHandler.mock.calls[0][0] as Request;
+    const url = new URL(calledRequest.url);
+    expect(url.pathname).toBe('/users');
+    expect(url.searchParams.get('page')).toBe('1');
+    expect(url.searchParams.get('limit')).toBe('10');
+  });
+
+  it('preserves request headers and method', async () => {
+    const mockHandler = vi.fn().mockResolvedValue(new Response('OK'));
+    const mockApp = {
+      handler: mockHandler,
+    } as unknown as AppBuilder;
+
+    const worker = createHandler(mockApp, { basePath: '/api' });
+    const request = new Request('https://example.com/api/users', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: 'Bearer token123',
+      },
+    });
+    const mockEnv = {};
+    const mockCtx = {} as ExecutionContext;
+
+    await worker.fetch(request, mockEnv, mockCtx);
+
+    const calledRequest = mockHandler.mock.calls[0][0] as Request;
+    expect(calledRequest.method).toBe('POST');
+    expect(calledRequest.headers.get('Content-Type')).toBe('application/json');
+    expect(calledRequest.headers.get('Authorization')).toBe('Bearer token123');
+  });
+
+  it('works without basePath option', async () => {
+    const mockResponse = new Response('No basePath');
+    const mockHandler = vi.fn().mockResolvedValue(mockResponse);
+    const mockApp = {
+      handler: mockHandler,
+    } as unknown as AppBuilder;
+
+    const worker = createHandler(mockApp);
+    const request = new Request('https://example.com/api/test');
+    const mockEnv = {};
+    const mockCtx = {} as ExecutionContext;
+
+    const response = await worker.fetch(request, mockEnv, mockCtx);
+
+    expect(mockHandler).toHaveBeenCalledWith(request);
+    expect(response).toBe(mockResponse);
+    const calledRequest = mockHandler.mock.calls[0][0] as Request;
+    expect(new URL(calledRequest.url).pathname).toBe('/api/test');
+  });
+
+  it('returns 500 response when handler throws an error', async () => {
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const testError = new Error('Test error');
+    const mockHandler = vi.fn().mockRejectedValue(testError);
+    const mockApp = {
+      handler: mockHandler,
+    } as unknown as AppBuilder;
+
+    const worker = createHandler(mockApp);
+    const request = new Request('https://example.com/api/test');
+    const mockEnv = {};
+    const mockCtx = {} as ExecutionContext;
+
+    const response = await worker.fetch(request, mockEnv, mockCtx);
+
+    expect(mockHandler).toHaveBeenCalledWith(request);
+    expect(response.status).toBe(500);
+    expect(await response.text()).toBe('Internal Server Error');
+    expect(consoleErrorSpy).toHaveBeenCalledWith('Unhandled error in worker:', testError);
+
+    consoleErrorSpy.mockRestore();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["@cloudflare/workers-types"]
+  },
+  "extends": "../../tsconfig.json",
+  "include": ["src"]
+}

package/vitest.config.ts

@@ -0,0 +1,21 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { defineConfig } from 'vitest/config';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts', 'tests/**/*.test.ts'],
+    environment: 'node',
+    alias: {
+      '@': resolve(__dirname, './src'),
+    },
+    coverage: {
+      reporter: ['text', 'json-summary', 'json'],
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: ['src/**/*.test.ts', 'src/index.ts'],
+    },
+  },
+});