Airtable Phase A–C + Server Sync Web MVP

[kooksee]

Summary

• Database / Airtable alignment (Phase A–C MVP): CSV import/export, lookup/autonumber, bidirectional relations, bulk edit, form view, rollup enhancements, scheduled-task automations, and related UI/tests.
• Server Sync Web MVP: self-hosted sync server (apps/server) with op-log push/pull, file blobs, workspace join/list/delete, WebSocket realtime + polling fallback, protocol versioning, Docker Compose deployment, and web client integration.
• CI / release hardening: faster web Docker builds (buildx GHA cache), reliable latest image tagging (workflow_run + retry + manual dispatch), Cloudflare deploy skip when secrets are missing.
• Merge prep: ignore/untrack apps/server/.data, client lint fixes, Page meta type dedup fix after cloud sync import.

Test plan

• npm run test -w @colanode/server (9 tests)
• npm run test -w @colanode/client (133 tests)
• npm run lint -w @colanode/client
• Manual: database Airtable test plan (docs/database-airtable-test-plan.md)
• Manual: server sync smoke test — dual-device realtime, Join flow, docker compose up (docs/server-sync-release-notes.md)
• After merge: verify GitHub Actions workflow_run mark-latest on main

Made with Cursor

[gemini-code-assist]

Code Review

This pull request introduces a self-hosted sync server (apps/server) and integrates it with the web client to enable realtime, multi-device synchronization, alongside several database enhancements like autonumber fields, lookup fields, bidirectional relations, bulk operations, and a new Form view. The review feedback focuses on critical performance optimizations for the sync server, including avoiding recursive directory scans in memory, indexing the sync_records table for faster workspace listing, grouping WebSocket subscribers by workspace ID to optimize notifications, and deleting file objects in parallel to prevent request timeouts.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

The listObjects method reads the entire directory tree recursively into memory via listFilesRecursively before filtering by prefix and slicing for pagination. As the number of files and workspaces grows, this will cause severe performance degradation, high CPU usage, and potential Out-Of-Memory (OOM) crashes. Consider optimizing this by resolving the base directory from the prefix and starting the recursive scan from there if it exists.

  public async listObjects(input: ListObjectsInput): Promise<ListObjectsOutput> {
    const limit = input.limit ?? DEFAULT_LIST_LIMIT;
    let scanDir = this.rootDir;
    const prefixDir = input.prefix.includes('/')
      ? input.prefix.substring(0, input.prefix.lastIndexOf('/'))
      : '';

    if (prefixDir) {
      const absolutePrefixDir = toAbsoluteStoragePath(this.rootDir, prefixDir);
      try {
        await fs.access(absolutePrefixDir);
        scanDir = absolutePrefixDir;
      } catch {
        // Fallback to rootDir if prefix directory doesn't exist yet
      }
    }

    const allItems = await listFilesRecursively(this.rootDir, scanDir);
    const filtered = allItems
      .filter((item) => item.key.startsWith(input.prefix))
      .sort((a, b) => a.key.localeCompare(b.key));

    const start = input.cursor ? Number(input.cursor) : 0;
    const page = filtered.slice(start, start + limit);
    const nextIndex = start + page.length;

    return {
      items: page,
      nextCursor: nextIndex >= filtered.length ? null : String(nextIndex),
    };
  }

[gemini-code-assist]

The workspace listing query in listWorkspaces performs a full table scan and aggregation (COUNT(*), MAX(happened_at)) on the sync_records table grouped by workspace_id. As the op-log grows, this query will become extremely slow. Adding an index on (workspace_id, happened_at) will significantly speed up this aggregation.

  `,
  `
  CREATE INDEX IF NOT EXISTS idx_sync_records_ws_seq
    ON sync_records(workspace_id, server_seq);
  `,
  `
  CREATE INDEX IF NOT EXISTS idx_sync_records_ws_happened
    ON sync_records(workspace_id, happened_at);
  `,

[gemini-code-assist]

The notify method iterates over all active subscribers in the entire hub to find those matching the workspaceId. If there are many connected clients across different workspaces, this O(N) scan will become a performance bottleneck. Grouping subscribers by workspaceId using a Map<string, Set<Subscriber>> optimizes this lookup to O(M) where M is only the subscribers in the active workspace.

export class SyncRealtimeHub {
  private readonly subscribers = new Map<string, Set<Subscriber>>();

  public subscribe(
    socket: WebSocket,
    workspaceId: string,
    deviceId: string
  ): void {
    const subscriber: Subscriber = { socket, workspaceId, deviceId };
    if (!this.subscribers.has(workspaceId)) {
      this.subscribers.set(workspaceId, new Set());
    }
    this.subscribers.get(workspaceId)!.add(subscriber);

    const cleanup = () => {
      const set = this.subscribers.get(workspaceId);
      if (set) {
        set.delete(subscriber);
        if (set.size === 0) {
          this.subscribers.delete(workspaceId);
        }
      }
    };

    socket.on('close', cleanup);
    socket.on('error', cleanup);

    socket.send(JSON.stringify({ type: 'connected', workspaceId, deviceId }));
  }

  public notify(input: {
    workspaceId: string;
    fromDeviceId: string;
    watermarkSeq: number;
  }): void {
    if (input.watermarkSeq <= 0) {
      return;
    }

    const message: SyncUpdatedMessage = {
      type: 'sync.updated',
      workspaceId: input.workspaceId,
      fromDeviceId: input.fromDeviceId,
      watermarkSeq: input.watermarkSeq,
    };
    const payload = JSON.stringify(message);

    const workspaceSubscribers = this.subscribers.get(input.workspaceId);
    if (!workspaceSubscribers) {
      return;
    }

    for (const subscriber of workspaceSubscribers) {
      if (subscriber.deviceId === input.fromDeviceId) {
        continue;
      }
      if (subscriber.socket.readyState !== 1) {
        continue;
      }

      subscriber.socket.send(payload);
    }
  }
}

[gemini-code-assist]

Deleting file objects sequentially in a for loop using await storage.deleteObject(key) can be extremely slow if a workspace has many files, potentially causing the HTTP request to time out. Consider deleting them in parallel using Promise.allSettled to avoid blocking the request.

    const objectKeys = repository.listFileObjectKeys(params.data.workspaceId);
    if (storage && objectKeys.length > 0) {
      await Promise.allSettled(
        objectKeys.map((key) => storage.deleteObject(key))
      );
    }