test: benchmark test bun

Author: nichenqin

.github/workflows/v2-benchmark-tests.yml

@@ -40,3 +40,35 @@ jobs:
       - name: 🧪 Run v2 benchmarks
         run: |
           pnpm -C packages/v2/benchmark-node bench
+
+  bench-bun:
+    if: github.ref == 'refs/heads/refactor/core' || github.head_ref == 'refactor/core'
+    runs-on: ubuntu-latest
+    name: V2 Benchmarks (Bun)
+    env:
+      CI: 1
+      TESTCONTAINERS_REUSE_ENABLE: 'false'
+
+    strategy:
+      matrix:
+        node-version: [22.18.0]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Use Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: 'latest'
+
+      - name: 📥 Monorepo install
+        uses: ./.github/actions/pnpm-install
+
+      - name: 🧪 Run v2 bun benchmarks
+        run: |
+          pnpm -C packages/v2/benchmark-bun bench

packages/v2/benchmark-bun/.eslintrc.cjs

@@ -0,0 +1,27 @@
+/**
+ * Specific eslint rules for this workspace, learn how to compose
+ * @link https://github.com/teableio/teable/tree/main/packages/eslint-config-bases
+ */
+require('@teable/eslint-config-bases/patch/modern-module-resolution');
+
+const { getDefaultIgnorePatterns } = require('@teable/eslint-config-bases/helpers');
+
+module.exports = {
+  root: true,
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    tsconfigRootDir: __dirname,
+    project: 'tsconfig.eslint.json',
+  },
+  ignorePatterns: [...getDefaultIgnorePatterns()],
+  extends: [
+    '@teable/eslint-config-bases/typescript',
+    '@teable/eslint-config-bases/sonar',
+    '@teable/eslint-config-bases/regexp',
+    '@teable/eslint-config-bases/jest',
+    // Apply prettier and disable incompatible rules
+    '@teable/eslint-config-bases/prettier-plugin',
+  ],
+  rules: {},
+  overrides: [],
+};

packages/v2/benchmark-bun/.gitignore

@@ -0,0 +1,13 @@
+# build
+/dist
+
+# dependencies
+node_modules
+
+# testing
+/coverage
+
+# misc
+.DS_Store
+*.pem
+

packages/v2/benchmark-bun/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@teable/v2-benchmark-bun",
+  "version": "0.0.0",
+  "private": true,
+  "license": "MIT",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown --tsconfig tsconfig.build.json",
+    "dev": "tsdown --tsconfig tsconfig.build.json --watch",
+    "clean": "rimraf ./dist ./coverage ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo ./.eslintcache",
+    "lint": "eslint . --ext .ts,.js,.mjs,.cjs,.mts,.cts --cache --cache-location ../../../.cache/eslint/v2-benchmark-bun.eslintcache",
+    "typecheck": "tsc --project ./tsconfig.json --noEmit",
+    "bench": "bun run --bun src/run.ts",
+    "fix-all-files": "eslint . --ext .ts,.js,.mjs,.cjs,.mts,.cts --fix"
+  },
+  "dependencies": {
+    "@orpc/client": "1.13.0",
+    "@orpc/contract": "1.13.0",
+    "@orpc/server": "1.13.0",
+    "@teable/v2-container-bun-test": "workspace:*",
+    "@teable/v2-contract-http-implementation": "workspace:*",
+    "@teable/v2-contract-http": "workspace:*",
+    "@teable/v2-core": "workspace:*",
+    "@teable/v2-db-postgres": "workspace:*",
+    "@teable/v2-di": "workspace:*",
+    "@teable/v2-postgres-schema": "workspace:*",
+    "kysely": "0.28.9",
+    "tinybench": "2.9.0"
+  },
+  "devDependencies": {
+    "@teable/v2-tsdown-config": "workspace:*",
+    "@teable/eslint-config-bases": "workspace:^",
+    "@types/node": "22.18.0",
+    "eslint": "8.57.0",
+    "prettier": "3.2.5",
+    "rimraf": "5.0.5",
+    "tsdown": "0.18.1",
+    "typescript": "5.4.3",
+    "vite-tsconfig-paths": "4.3.2"
+  }
+}

packages/v2/benchmark-bun/src/bench-context.ts

@@ -0,0 +1,96 @@
+import { onError } from '@orpc/server';
+import { RPCHandler } from '@orpc/server/fetch';
+import { CORSPlugin } from '@orpc/server/plugins';
+import { createV2BunTestContainer } from '@teable/v2-container-bun-test';
+import { createV2OrpcRouter } from '@teable/v2-contract-http-implementation';
+import { NoopLogger, v2CoreTokens } from '@teable/v2-core';
+import type { DependencyContainer } from '@teable/v2-di';
+
+import { createV2RpcClient } from './rpc-client';
+
+type IBunServer = {
+  port: number;
+  stop: (closeConnections?: boolean) => void;
+};
+
+type IBunServeOptions = {
+  port?: number;
+  hostname?: string;
+  fetch: (request: Request) => Response | Promise<Response>;
+};
+
+type IBunRuntime = {
+  serve: (options: IBunServeOptions) => IBunServer;
+};
+
+const getBunRuntime = (): IBunRuntime => {
+  const bun = (globalThis as Record<string, unknown>)['Bun'] as IBunRuntime | undefined;
+  if (!bun) {
+    throw new Error('Bun runtime is required for v2 bun benchmarks.');
+  }
+  return bun;
+};
+
+const startBunServer = (container: DependencyContainer): IBunServer => {
+  const orpcRouter = createV2OrpcRouter({
+    createContainer: () => container,
+  });
+  const handler = new RPCHandler(orpcRouter, {
+    plugins: [new CORSPlugin()],
+    interceptors: [
+      onError((error) => {
+        console.error(error);
+      }),
+    ],
+  });
+
+  const bun = getBunRuntime();
+
+  return bun.serve({
+    port: 0,
+    hostname: '127.0.0.1',
+    async fetch(request: Request) {
+      const { matched, response } = await handler.handle(request, {
+        prefix: '/rpc',
+        context: {},
+      });
+
+      if (matched) {
+        return response;
+      }
+
+      return new Response('Not found', { status: 404 });
+    },
+  });
+};
+
+export type IBunBenchContext = {
+  client: ReturnType<typeof createV2RpcClient>;
+  baseId: string;
+  dispose: () => Promise<void>;
+};
+
+export const createBunBenchContext = async (): Promise<IBunBenchContext> => {
+  console.log('[bun-bench] starting test container');
+  const testContainer = await createV2BunTestContainer();
+  testContainer.container.registerInstance(v2CoreTokens.logger, new NoopLogger());
+
+  console.log('[bun-bench] test container ready');
+  const server = startBunServer(testContainer.container);
+  const baseUrl = `http://127.0.0.1:${server.port}/rpc`;
+  const client = createV2RpcClient({ baseUrl });
+  console.log(`[bun-bench] bun server ready at ${baseUrl}`);
+
+  return {
+    client,
+    baseId: testContainer.baseId.toString(),
+    dispose: async () => {
+      console.log('[bun-bench] shutting down');
+      try {
+        server.stop();
+      } finally {
+        await testContainer.dispose();
+      }
+    },
+  };
+};

packages/v2/benchmark-bun/src/create-table.bench.ts

@@ -0,0 +1,92 @@
+import type { ICreateTableRequestDto } from '@teable/v2-contract-http';
+import { Bench } from 'tinybench';
+
+import { createBunBenchContext } from './bench-context';
+
+const benchOptions = {
+  iterations: 0,
+  warmupIterations: 0,
+  time: 5000,
+  warmupTime: 1000,
+  throws: true,
+};
+
+const createTableName = (scenario: string): string => {
+  const random = Math.random().toString(36).slice(2, 8);
+  return `Bench_Bun_${scenario}_${Date.now()}_${random}`;
+};
+
+const createSimpleFields = (): ICreateTableRequestDto['fields'] => [
+  { type: 'singleLineText', name: 'Name' },
+  { type: 'number', name: 'Amount', options: { defaultValue: 1 } },
+  { type: 'checkbox', name: 'Done', options: { defaultValue: false } },
+];
+
+const createAllBaseFields = (): ICreateTableRequestDto['fields'] => [
+  { type: 'singleLineText', name: 'Name' },
+  { type: 'longText', name: 'Description', options: { defaultValue: 'Notes' } },
+  { type: 'number', name: 'Amount', options: { defaultValue: 10 } },
+  { type: 'rating', name: 'Priority', max: 5, options: { icon: 'star', color: 'yellowBright' } },
+  { type: 'singleSelect', name: 'Status', options: ['Todo', 'Done'] },
+  { type: 'multipleSelect', name: 'Tags', options: ['Frontend', 'Backend'] },
+  { type: 'checkbox', name: 'Done', options: { defaultValue: true } },
+  { type: 'attachment', name: 'Files' },
+  { type: 'date', name: 'Due Date' },
+  { type: 'user', name: 'Owner', options: { isMultiple: false } },
+  { type: 'button', name: 'Action', options: { label: 'Run' } },
+];
+
+const createTextColumns = (count: number): ICreateTableRequestDto['fields'] =>
+  Array.from({ length: count }, (_, index) => ({
+    type: 'singleLineText',
+    name: `Column ${index + 1}`,
+  }));
+
+export const runCreateTableBench = async (): Promise<void> => {
+  const context = await createBunBenchContext();
+
+  try {
+    const bench = new Bench(benchOptions);
+    const simpleFields = createSimpleFields();
+    const baseFields = createAllBaseFields();
+    const fields200 = createTextColumns(200);
+    const fields1000 = createTextColumns(1000);
+
+    const runCreateTable = async (scenario: string, fields: ICreateTableRequestDto['fields']) => {
+      const input = {
+        baseId: context.baseId,
+        name: createTableName(scenario),
+        fields,
+      };
+
+      const response = await context.client.tables.create(input);
+      if (!response.ok) {
+        throw new Error('Create table failed');
+      }
+    };
+
+    bench.add('bun: create table: 3 columns', async () => {
+      await runCreateTable('simple', simpleFields);
+    });
+
+    bench.add('bun: create table: all base fields', async () => {
+      await runCreateTable('base', baseFields);
+    });
+
+    bench.add('bun: create table: 200 columns', async () => {
+      await runCreateTable('200', fields200);
+    });
+
+    bench.add('bun: create table: 1000 columns', async () => {
+      await runCreateTable('1000', fields1000);
+    });
+
+    console.log('[bun-bench] running create table benchmarks');
+    await bench.run();
+
+    console.log('CreateTable benchmarks (bun)');
+    console.table(bench.table());
+  } finally {
+    await context.dispose();
+  }
+};