@edge-base/server 0.2.2 → 0.2.4

package/src/__tests__/functions-context.test.ts

@@ -1,6 +1,10 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { buildFunctionContext, getWorkerUrl } from '../lib/functions.js';
 
+function makeTaggedTemplateStrings(parts: string[]): TemplateStringsArray {
+  return Object.assign([...parts], { raw: [...parts] }) as unknown as TemplateStringsArray;
+}
+
 describe('buildFunctionContext admin.db', () => {
   afterEach(() => {
     vi.unstubAllGlobals();
@@ -48,6 +52,48 @@ describe('buildFunctionContext admin.db', () => {
     );
   });
 
+  it('preserves significant whitespace in dynamic admin.db instance ids', async () => {
+    const databaseFetch = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ items: [{ id: 'm1' }] }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      }),
+    );
+    const databaseNamespace = {
+      idFromName: vi.fn(() => 'workspace-id'),
+      get: vi.fn(() => ({ fetch: databaseFetch })),
+    } as unknown as DurableObjectNamespace;
+
+    const ctx = buildFunctionContext({
+      request: new Request('http://localhost/api/functions/feed-summary'),
+      auth: null,
+      databaseNamespace,
+      authNamespace: {} as DurableObjectNamespace,
+      d1Database: {} as D1Database,
+      config: {
+        databases: {
+          workspace: {
+            instance: true,
+            tables: {
+              members: { schema: { role: { type: 'string' } } },
+            },
+          },
+        },
+      },
+    });
+
+    await ctx.admin.db('workspace', ' ws-1 ').table('members').getList();
+
+    expect(databaseNamespace.idFromName).toHaveBeenCalledWith('workspace: ws-1 ');
+    expect(databaseFetch.mock.calls[0]?.[1]).toEqual(
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'X-DO-Name': 'workspace: ws-1 ',
+        }),
+      }),
+    );
+  });
+
   it('routes upsert calls through the worker with upsert query params', async () => {
     const fetchMock = vi.fn().mockResolvedValue(
       new Response(JSON.stringify({ id: 'p1', title: 'Upserted', action: 'inserted' }), {
@@ -97,16 +143,19 @@ describe('buildFunctionContext admin.db', () => {
     );
   });
 
-  it('normalizes admin.sqlWithDirectD1Access worker responses to row arrays', async () => {
+  it('normalizes admin.sqlProviderAware worker responses to row arrays', async () => {
     const fetchMock = vi.fn().mockResolvedValue(
-      new Response(JSON.stringify({
-        rows: [{ total: 2 }],
-        items: [{ total: 2 }],
-        results: [{ total: 2 }],
-      }), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      }),
+      new Response(
+        JSON.stringify({
+          rows: [{ total: 2 }],
+          items: [{ total: 2 }],
+          results: [{ total: 2 }],
+        }),
+        {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        },
+      ),
     );
     vi.stubGlobal('fetch', fetchMock);
 
@@ -129,7 +178,11 @@ describe('buildFunctionContext admin.db', () => {
       serviceKey: 'sk-test',
     });
 
-    const rows = await ctx.admin.sqlWithDirectD1Access('shared', undefined, 'SELECT COUNT(*) AS total FROM posts');
+    const rows = await ctx.admin.sqlProviderAware(
+      'shared',
+      undefined,
+      'SELECT COUNT(*) AS total FROM posts',
+    );
 
     expect(rows).toEqual([{ total: 2 }]);
     expect(fetchMock).toHaveBeenCalledWith(
@@ -144,31 +197,78 @@ describe('buildFunctionContext admin.db', () => {
     );
   });
 
+  it('rejects instance ids for single-instance admin.sqlProviderAware calls before touching direct backends', async () => {
+    const fetchMock = vi.fn();
+    vi.stubGlobal('fetch', fetchMock);
+
+    const databaseNamespace = {
+      idFromName: vi.fn(),
+      get: vi.fn(),
+    } as unknown as DurableObjectNamespace;
+
+    const ctx = buildFunctionContext({
+      request: new Request('http://localhost/api/functions/feed-summary'),
+      auth: null,
+      databaseNamespace,
+      authNamespace: {} as DurableObjectNamespace,
+      d1Database: {} as D1Database,
+      config: {
+        databases: {
+          shared: {
+            tables: {
+              posts: { schema: { title: { type: 'string' } } },
+            },
+          },
+        },
+      },
+      env: {
+        DB_D1_SHARED: {
+          prepare: vi.fn(),
+        },
+      } as never,
+    });
+
+    await expect(
+      ctx.admin.sqlProviderAware('shared', 'shadow', 'SELECT COUNT(*) AS total FROM posts'),
+    ).rejects.toThrow("instanceId is not allowed for single-instance namespace 'shared'");
+    expect(
+      (databaseNamespace as unknown as { get: ReturnType<typeof vi.fn> }).get,
+    ).not.toHaveBeenCalled();
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
   it('routes admin.sqlWithDirectD1Access through the database DO when env is available', async () => {
     const fetchMock = vi.fn();
     vi.stubGlobal('fetch', fetchMock);
 
     const stub = {
-      fetch: vi.fn()
+      fetch: vi
+        .fn()
         .mockResolvedValueOnce(
-          new Response(JSON.stringify({
-            needsCreate: true,
-            namespace: 'workspace',
-            id: 'ws-1',
-          }), {
-            status: 201,
-            headers: { 'Content-Type': 'application/json' },
-          }),
+          new Response(
+            JSON.stringify({
+              needsCreate: true,
+              namespace: 'workspace',
+              id: 'ws-1',
+            }),
+            {
+              status: 201,
+              headers: { 'Content-Type': 'application/json' },
+            },
+          ),
         )
         .mockResolvedValueOnce(
-        new Response(JSON.stringify({
-          rows: [{ total: 3 }],
-          items: [{ total: 3 }],
-          results: [{ total: 3 }],
-        }), {
-          status: 200,
-          headers: { 'Content-Type': 'application/json' },
-        }),
+          new Response(
+            JSON.stringify({
+              rows: [{ total: 3 }],
+              items: [{ total: 3 }],
+              results: [{ total: 3 }],
+            }),
+            {
+              status: 200,
+              headers: { 'Content-Type': 'application/json' },
+            },
+          ),
         ),
     };
     const databaseNamespace = {
@@ -185,6 +285,7 @@ describe('buildFunctionContext admin.db', () => {
       config: {
         databases: {
           workspace: {
+            instance: true,
             tables: {
               members: { schema: { userId: { type: 'string' } } },
             },
@@ -196,7 +297,12 @@ describe('buildFunctionContext admin.db', () => {
       serviceKey: 'sk-test',
     });
 
-    const rows = await ctx.admin.sqlWithDirectD1Access('workspace', 'ws-1', 'SELECT COUNT(*) AS total FROM members', []);
+    const rows = await ctx.admin.sqlWithDirectD1Access(
+      'workspace',
+      'ws-1',
+      'SELECT COUNT(*) AS total FROM members',
+      [],
+    );
 
     expect(rows).toEqual([{ total: 3 }]);
     expect(stub.fetch).toHaveBeenCalledTimes(2);
@@ -213,6 +319,531 @@ describe('buildFunctionContext admin.db', () => {
     expect(fetchMock).not.toHaveBeenCalled();
   });
 
+  it('falls back to /api/sql for admin.db(...).table(...).sql tagged templates when only workerUrl is available', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          rows: [{ total: 2 }],
+          items: [{ total: 2 }],
+          results: [{ total: 2 }],
+        }),
+        {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        },
+      ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+
+    const ctx = buildFunctionContext({
+      request: new Request('http://localhost/api/functions/feed-summary'),
+      auth: null,
+      databaseNamespace: {} as DurableObjectNamespace,
+      authNamespace: {} as DurableObjectNamespace,
+      d1Database: {} as D1Database,
+      config: {
+        databases: {
+          shared: {
+            tables: {
+              posts: { schema: { title: { type: 'string' } } },
+            },
+          },
+        },
+      },
+      workerUrl: 'http://localhost:8787',
+      serviceKey: 'sk-test',
+    });
+
+    const rows = await ctx.admin.db('shared').table('posts').sql`
+      SELECT COUNT(*) AS total FROM posts WHERE status = ${'published'}
+    `;
+
+    expect(rows).toEqual([{ total: 2 }]);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      'http://localhost:8787/api/sql',
+      expect.objectContaining({ method: 'POST' }),
+    );
+  });
+
+  it('routes admin.db(...).table(...).sql tagged templates through the direct SQL executor when env is available', async () => {
+    const fetchMock = vi.fn();
+    vi.stubGlobal('fetch', fetchMock);
+
+    const stub = {
+      fetch: vi
+        .fn()
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              needsCreate: true,
+              namespace: 'workspace',
+              id: 'ws-1',
+            }),
+            {
+              status: 201,
+              headers: { 'Content-Type': 'application/json' },
+            },
+          ),
+        )
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              rows: [{ total: 5 }],
+              items: [{ total: 5 }],
+              results: [{ total: 5 }],
+            }),
+            {
+              status: 200,
+              headers: { 'Content-Type': 'application/json' },
+            },
+          ),
+        ),
+    };
+    const databaseNamespace = {
+      idFromName: vi.fn().mockReturnValue('do-id'),
+      get: vi.fn().mockReturnValue(stub),
+    } as unknown as DurableObjectNamespace;
+
+    const ctx = buildFunctionContext({
+      request: new Request('http://localhost/api/functions/feed-summary'),
+      auth: null,
+      databaseNamespace,
+      authNamespace: {} as DurableObjectNamespace,
+      d1Database: {} as D1Database,
+      config: {
+        databases: {
+          workspace: {
+            instance: true,
+            tables: {
+              members: { schema: { userId: { type: 'string' } } },
+            },
+          },
+        },
+      },
+      env: {} as never,
+      workerUrl: 'http://localhost:8787',
+      serviceKey: 'sk-test',
+    });
+
+    const rows = await ctx.admin.db('workspace', 'ws-1').table('members').sql`
+      SELECT COUNT(*) AS total FROM members WHERE role = ${'owner'}
+    `;
+
+    expect(rows).toEqual([{ total: 5 }]);
+    expect(stub.fetch).toHaveBeenCalledTimes(2);
+    const firstRequest = stub.fetch.mock.calls[0]?.[0] as Request;
+    await expect(firstRequest.json()).resolves.toEqual({
+      query: 'SELECT COUNT(*) AS total FROM members WHERE role = ?',
+      params: ['owner'],
+    });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it.each(['postgres', 'neon'] as const)(
+    'routes admin.db(...).table(...).sql tagged templates through the provider-aware direct SQL executor for %s',
+    async (provider) => {
+      const fetchMock = vi
+        .fn()
+        .mockResolvedValueOnce(new Response(null, { status: 200 }))
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              columns: ['literal', 'total'],
+              rows: [{ literal: '?', total: 5 }],
+              rowCount: 1,
+            }),
+            {
+              status: 200,
+              headers: { 'Content-Type': 'application/json' },
+            },
+          ),
+        );
+      vi.stubGlobal('fetch', fetchMock);
+
+      const databaseNamespace = {
+        idFromName: vi.fn().mockReturnValue('do-id'),
+        get: vi.fn(() => ({ fetch: vi.fn() })),
+      } as unknown as DurableObjectNamespace;
+
+      const ctx = buildFunctionContext({
+        request: new Request('http://localhost/api/functions/feed-summary'),
+        auth: null,
+        databaseNamespace,
+        authNamespace: {} as DurableObjectNamespace,
+        d1Database: {} as D1Database,
+        config: {
+          databases: {
+            shared: {
+              provider,
+              tables: {
+                posts: { schema: { title: { type: 'string' } } },
+              },
+            },
+          },
+        },
+        env: {
+          EDGEBASE_DEV_SIDECAR_PORT: '8788',
+          JWT_ADMIN_SECRET: 'jwt-secret',
+          DB_POSTGRES_SHARED_URL: 'postgres://edgebase:test@localhost/shared',
+        } as never,
+        workerUrl: 'http://localhost:8787',
+        serviceKey: 'sk-test',
+      });
+
+      const rows = await ctx.admin.db('shared').table('posts').sql`
+        SELECT '?' AS literal, COUNT(*) AS total FROM posts WHERE title = ${'owner'}
+      `;
+
+      expect(rows).toEqual([{ literal: '?', total: 5 }]);
+      expect(fetchMock).toHaveBeenCalledTimes(2);
+      expect(fetchMock.mock.calls[1]?.[0]).toBe('http://127.0.0.1:8788/postgres/query');
+      expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body ?? '{}'))).toEqual({
+        namespace: 'shared',
+        sql: "SELECT '?' AS literal, COUNT(*) AS total FROM posts WHERE title = $1",
+        params: ['owner'],
+      });
+      expect(
+        (databaseNamespace as unknown as { get: ReturnType<typeof vi.fn> }).get,
+      ).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(['postgres', 'neon'] as const)(
+    'preserves PostgreSQL @? operators when admin.db(...).table(...).sql uses the provider-aware direct SQL executor for %s',
+    async (provider) => {
+      const fetchMock = vi
+        .fn()
+        .mockResolvedValueOnce(new Response(null, { status: 200 }))
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              columns: ['total'],
+              rows: [{ total: 4 }],
+              rowCount: 1,
+            }),
+            {
+              status: 200,
+              headers: { 'Content-Type': 'application/json' },
+            },
+          ),
+        );
+      vi.stubGlobal('fetch', fetchMock);
+
+      const databaseNamespace = {
+        idFromName: vi.fn().mockReturnValue('do-id'),
+        get: vi.fn(() => ({ fetch: vi.fn() })),
+      } as unknown as DurableObjectNamespace;
+
+      const ctx = buildFunctionContext({
+        request: new Request('http://localhost/api/functions/feed-summary'),
+        auth: null,
+        databaseNamespace,
+        authNamespace: {} as DurableObjectNamespace,
+        d1Database: {} as D1Database,
+        config: {
+          databases: {
+            shared: {
+              provider,
+              tables: {
+                posts: { schema: { title: { type: 'string' } } },
+              },
+            },
+          },
+        },
+        env: {
+          EDGEBASE_DEV_SIDECAR_PORT: '8788',
+          JWT_ADMIN_SECRET: 'jwt-secret',
+          DB_POSTGRES_SHARED_URL: 'postgres://edgebase:test@localhost/shared',
+        } as never,
+        workerUrl: 'http://localhost:8787',
+        serviceKey: 'sk-test',
+      });
+
+      const rows = await ctx.admin.db('shared').table('posts').sql`
+        SELECT COUNT(*) AS total
+        FROM posts
+        WHERE metadata @? '$.featured'
+          AND title = ${'owner'}
+      `;
+
+      expect(rows).toEqual([{ total: 4 }]);
+      expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body ?? '{}'))).toEqual({
+        namespace: 'shared',
+        sql: "SELECT COUNT(*) AS total\n        FROM posts\n        WHERE metadata @? '$.featured'\n          AND title = $1",
+        params: ['owner'],
+      });
+      expect(
+        (databaseNamespace as unknown as { get: ReturnType<typeof vi.fn> }).get,
+      ).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(['postgres', 'neon'] as const)(
+    'unescapes PostgreSQL @\\? operators when admin.db(...).table(...).sql uses tagged-template markers for %s',
+    async (provider) => {
+      const fetchMock = vi
+        .fn()
+        .mockResolvedValueOnce(new Response(null, { status: 200 }))
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              columns: ['total'],
+              rows: [{ total: 9 }],
+              rowCount: 1,
+            }),
+            {
+              status: 200,
+              headers: { 'Content-Type': 'application/json' },
+            },
+          ),
+        );
+      vi.stubGlobal('fetch', fetchMock);
+
+      const databaseNamespace = {
+        idFromName: vi.fn().mockReturnValue('do-id'),
+        get: vi.fn(() => ({ fetch: vi.fn() })),
+      } as unknown as DurableObjectNamespace;
+
+      const ctx = buildFunctionContext({
+        request: new Request('http://localhost/api/functions/feed-summary'),
+        auth: null,
+        databaseNamespace,
+        authNamespace: {} as DurableObjectNamespace,
+        d1Database: {} as D1Database,
+        config: {
+          databases: {
+            shared: {
+              provider,
+              tables: {
+                posts: { schema: { title: { type: 'string' } } },
+              },
+            },
+          },
+        },
+        env: {
+          EDGEBASE_DEV_SIDECAR_PORT: '8788',
+          JWT_ADMIN_SECRET: 'jwt-secret',
+          DB_POSTGRES_SHARED_URL: 'postgres://edgebase:test@localhost/shared',
+        } as never,
+        workerUrl: 'http://localhost:8787',
+        serviceKey: 'sk-test',
+      });
+
+      const rows = await ctx.admin.db('shared').table('posts').sql(
+        makeTaggedTemplateStrings([
+          "SELECT COUNT(*) AS total FROM posts WHERE metadata @\\? '$.featured' AND title = ",
+          '',
+        ]),
+        'owner',
+      );
+
+      expect(rows).toEqual([{ total: 9 }]);
+      expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body ?? '{}'))).toEqual({
+        namespace: 'shared',
+        sql: "SELECT COUNT(*) AS total FROM posts WHERE metadata @? '$.featured' AND title = $1",
+        params: ['owner'],
+      });
+      expect(
+        (databaseNamespace as unknown as { get: ReturnType<typeof vi.fn> }).get,
+      ).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(['postgres', 'neon'] as const)(
+    'rejects admin.db(...).table(...).sql tagged templates that mix interpolation with literal $n placeholders for %s',
+    async (provider) => {
+      const fetchMock = vi.fn();
+      vi.stubGlobal('fetch', fetchMock);
+
+      const databaseNamespace = {
+        idFromName: vi.fn().mockReturnValue('do-id'),
+        get: vi.fn(() => ({ fetch: vi.fn() })),
+      } as unknown as DurableObjectNamespace;
+
+      const ctx = buildFunctionContext({
+        request: new Request('http://localhost/api/functions/feed-summary'),
+        auth: null,
+        databaseNamespace,
+        authNamespace: {} as DurableObjectNamespace,
+        d1Database: {} as D1Database,
+        config: {
+          databases: {
+            shared: {
+              provider,
+              tables: {
+                posts: { schema: { title: { type: 'string' } } },
+              },
+            },
+          },
+        },
+        env: {
+          EDGEBASE_DEV_SIDECAR_PORT: '8788',
+          JWT_ADMIN_SECRET: 'jwt-secret',
+          DB_POSTGRES_SHARED_URL: 'postgres://edgebase:test@localhost/shared',
+        } as never,
+        workerUrl: 'http://localhost:8787',
+        serviceKey: 'sk-test',
+      });
+
+      await expect(
+        ctx.admin.db('shared').table('posts').sql(
+          makeTaggedTemplateStrings([
+            'SELECT COUNT(*) AS total FROM posts WHERE tenant_id = $1 AND title = ',
+            '',
+          ]),
+          'owner',
+        ),
+      ).rejects.toThrow(
+        'Cannot mix tagged template interpolation with PostgreSQL-style $n placeholders.',
+      );
+      expect(fetchMock).not.toHaveBeenCalled();
+      expect(
+        (databaseNamespace as unknown as { get: ReturnType<typeof vi.fn> }).get,
+      ).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(['postgres', 'neon'] as const)(
+    'routes admin.sqlProviderAware through the provider-aware direct SQL executor for %s',
+    async (provider) => {
+      const fetchMock = vi
+        .fn()
+        .mockResolvedValueOnce(new Response(null, { status: 200 }))
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              columns: ['total'],
+              rows: [{ total: 7 }],
+              rowCount: 1,
+            }),
+            {
+              status: 200,
+              headers: { 'Content-Type': 'application/json' },
+            },
+          ),
+        );
+      vi.stubGlobal('fetch', fetchMock);
+
+      const databaseNamespace = {
+        idFromName: vi.fn().mockReturnValue('do-id'),
+        get: vi.fn(() => ({ fetch: vi.fn() })),
+      } as unknown as DurableObjectNamespace;
+
+      const ctx = buildFunctionContext({
+        request: new Request('http://localhost/api/functions/feed-summary'),
+        auth: null,
+        databaseNamespace,
+        authNamespace: {} as DurableObjectNamespace,
+        d1Database: {} as D1Database,
+        config: {
+          databases: {
+            shared: {
+              provider,
+              tables: {
+                posts: { schema: { title: { type: 'string' } } },
+              },
+            },
+          },
+        },
+        env: {
+          EDGEBASE_DEV_SIDECAR_PORT: '8788',
+          JWT_ADMIN_SECRET: 'jwt-secret',
+          DB_POSTGRES_SHARED_URL: 'postgres://edgebase:test@localhost/shared',
+        } as never,
+        workerUrl: 'http://localhost:8787',
+        serviceKey: 'sk-test',
+      });
+
+      const rows = await ctx.admin.sqlProviderAware(
+        'shared',
+        undefined,
+        'SELECT COUNT(*) AS total FROM posts WHERE title = ?',
+        ['owner'],
+      );
+
+      expect(rows).toEqual([{ total: 7 }]);
+      expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body ?? '{}'))).toEqual({
+        namespace: 'shared',
+        sql: 'SELECT COUNT(*) AS total FROM posts WHERE title = $1',
+        params: ['owner'],
+      });
+      expect(
+        (databaseNamespace as unknown as { get: ReturnType<typeof vi.fn> }).get,
+      ).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(['postgres', 'neon'] as const)(
+    'preserves PostgreSQL @? operators when admin.sqlProviderAware uses the provider-aware direct SQL executor for %s',
+    async (provider) => {
+      const fetchMock = vi
+        .fn()
+        .mockResolvedValueOnce(new Response(null, { status: 200 }))
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              columns: ['total'],
+              rows: [{ total: 6 }],
+              rowCount: 1,
+            }),
+            {
+              status: 200,
+              headers: { 'Content-Type': 'application/json' },
+            },
+          ),
+        );
+      vi.stubGlobal('fetch', fetchMock);
+
+      const databaseNamespace = {
+        idFromName: vi.fn().mockReturnValue('do-id'),
+        get: vi.fn(() => ({ fetch: vi.fn() })),
+      } as unknown as DurableObjectNamespace;
+
+      const ctx = buildFunctionContext({
+        request: new Request('http://localhost/api/functions/feed-summary'),
+        auth: null,
+        databaseNamespace,
+        authNamespace: {} as DurableObjectNamespace,
+        d1Database: {} as D1Database,
+        config: {
+          databases: {
+            shared: {
+              provider,
+              tables: {
+                posts: { schema: { title: { type: 'string' } } },
+              },
+            },
+          },
+        },
+        env: {
+          EDGEBASE_DEV_SIDECAR_PORT: '8788',
+          JWT_ADMIN_SECRET: 'jwt-secret',
+          DB_POSTGRES_SHARED_URL: 'postgres://edgebase:test@localhost/shared',
+        } as never,
+        workerUrl: 'http://localhost:8787',
+        serviceKey: 'sk-test',
+      });
+
+      const rows = await ctx.admin.sqlProviderAware(
+        'shared',
+        undefined,
+        "SELECT COUNT(*) AS total FROM posts WHERE metadata @? '$.featured' AND title = ?",
+        ['owner'],
+      );
+
+      expect(rows).toEqual([{ total: 6 }]);
+      expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body ?? '{}'))).toEqual({
+        namespace: 'shared',
+        sql: "SELECT COUNT(*) AS total FROM posts WHERE metadata @? '$.featured' AND title = $1",
+        params: ['owner'],
+      });
+      expect(
+        (databaseNamespace as unknown as { get: ReturnType<typeof vi.fn> }).get,
+      ).not.toHaveBeenCalled();
+    },
+  );
+
   it('routes admin.kv through the configured KV binding when env is available', async () => {
     const fetchMock = vi.fn();
     vi.stubGlobal('fetch', fetchMock);
@@ -285,10 +916,14 @@ describe('buildFunctionContext admin.db', () => {
       serviceKey: 'sk-test',
     });
 
-    const rows = await ctx.admin.d1('analytics').exec('SELECT COUNT(*) AS total FROM rollups WHERE runId = ?', ['r1']);
+    const rows = await ctx.admin
+      .d1('analytics')
+      .exec('SELECT COUNT(*) AS total FROM rollups WHERE runId = ?', ['r1']);
 
     expect(rows).toEqual([{ total: 4 }]);
-    expect(d1Binding.prepare).toHaveBeenCalledWith('SELECT COUNT(*) AS total FROM rollups WHERE runId = ?');
+    expect(d1Binding.prepare).toHaveBeenCalledWith(
+      'SELECT COUNT(*) AS total FROM rollups WHERE runId = ?',
+    );
     expect(fetchMock).not.toHaveBeenCalled();
   });
 
@@ -306,7 +941,9 @@ describe('buildFunctionContext admin.db', () => {
     };
 
     const ctx = buildFunctionContext({
-      request: new Request('http://localhost/api/functions/mock/email/inbox/user@test.edgebase.fun'),
+      request: new Request(
+        'http://localhost/api/functions/mock/email/inbox/user@test.edgebase.fun',
+      ),
       auth: null,
       databaseNamespace: {} as DurableObjectNamespace,
       authNamespace: {} as DurableObjectNamespace,
@@ -317,10 +954,14 @@ describe('buildFunctionContext admin.db', () => {
       serviceKey: 'sk-test',
     });
 
-    const rows = await ctx.admin.d1('auth').exec('SELECT token FROM _email_tokens WHERE userId = ?', ['u1']);
+    const rows = await ctx.admin
+      .d1('auth')
+      .exec('SELECT token FROM _email_tokens WHERE userId = ?', ['u1']);
 
     expect(rows).toEqual([{ token: 'tok-1' }]);
-    expect(authBinding.prepare).toHaveBeenCalledWith('SELECT token FROM _email_tokens WHERE userId = ?');
+    expect(authBinding.prepare).toHaveBeenCalledWith(
+      'SELECT token FROM _email_tokens WHERE userId = ?',
+    );
     expect(fetchMock).not.toHaveBeenCalled();
   });