fix query tests

Author: maxstevens-nl

src/create-zero-composables.ts

@@ -1,21 +1,22 @@
-import type { CustomMutatorDefs, Query, Schema, ZeroOptions } from '@rocicorp/zero'
+import type { CustomMutatorDefs, DefaultContext, DefaultSchema, PullRow, QueryOrQueryRequest, ReadonlyJSONValue, Schema, ZeroOptions } from '@rocicorp/zero'
 import type { MaybeRefOrGetter, ShallowRef } from 'vue'
 import type { QueryResult, UseQueryOptions } from './query'
 import { Zero } from '@rocicorp/zero'
 import { shallowRef, toValue, watch } from 'vue'
 import { useQuery as _useQuery } from './query'
 
 export function createZeroComposables<
-  S extends Schema = Schema,
+  TSchema extends Schema = DefaultSchema,
   MD extends CustomMutatorDefs | undefined = undefined,
+  TContext = DefaultContext,
 >(
-  optsOrZero: MaybeRefOrGetter<ZeroOptions<S, MD> | { zero: Zero<S, MD> }>,
+  optsOrZero: MaybeRefOrGetter<ZeroOptions<TSchema, MD, TContext> | { zero: Zero<TSchema, MD, TContext> }>,
 ) {
-  let z: ShallowRef<Zero<S, MD>>
+  let z: ShallowRef<Zero<TSchema, MD, TContext>>
 
-  function useZero(): ShallowRef<Zero<S, MD>> {
+  function useZero(): ShallowRef<Zero<TSchema, MD, TContext>> {
     if (!z) {
-      z = shallowRef() as ShallowRef<Zero<S, MD>>
+      z = shallowRef() as ShallowRef<Zero<TSchema, MD, TContext>>
     }
 
     if (z.value) {
@@ -34,10 +35,12 @@ export function createZeroComposables<
   }
 
   function useQuery<
-    TTable extends keyof S['tables'] & string,
-    TReturn,
+    TTable extends keyof TSchema['tables'] & string,
+    TInput extends ReadonlyJSONValue | undefined,
+    TOutput extends ReadonlyJSONValue | undefined,
+    TReturn = PullRow<TTable, TSchema>,
   >(
-    query: MaybeRefOrGetter<Query<S, TTable, TReturn>>,
+    query: MaybeRefOrGetter<QueryOrQueryRequest<TTable, TInput, TOutput, TSchema, TReturn, TContext>>,
     options?: MaybeRefOrGetter<UseQueryOptions>,
   ): QueryResult<TReturn> {
     const zero = useZero()

src/query.test.ts

@@ -1,7 +1,8 @@
 import type { TTL } from '@rocicorp/zero'
-import { createBuilder, createSchema, number, string, syncedQuery, table, Zero } from '@rocicorp/zero'
+import { createBuilder, createCRUDBuilder, createSchema, defineMutator, defineMutators, defineQueries, defineQuery, number, string, table, Zero } from '@rocicorp/zero'
 import { describe, expect, it, onTestFinished, vi } from 'vitest'
 import { nextTick, ref, watchEffect } from 'vue'
+import z from 'zod'
 import { createZeroComposables } from './create-zero-composables'
 import { useQuery } from './query'
 import { VueView, vueViewFactory } from './view'
@@ -20,44 +21,58 @@ const schema = createSchema({
 async function setupTestEnvironment() {
   const userID = ref('asdf')
 
+  const crud = createCRUDBuilder(schema)
+  const mutators = defineMutators({
+    table: {
+      insert: defineMutator(
+        z.object({ a: z.number(), b: z.string() }),
+        async ({ tx, args: { a, b } }) => {
+          return tx.mutate(crud.table.insert({ a, b }))
+        },
+      ),
+      update: defineMutator(
+        z.object({ a: z.number(), b: z.string() }),
+        async ({ tx, args: { a, b } }) => {
+          return tx.mutate(crud.table.update({ a, b }))
+        },
+      ),
+    },
+  })
+
   const { useZero, useQuery } = createZeroComposables(() => ({
     userID: userID.value,
     server: null,
     schema,
+    mutators,
     kvStore: 'mem',
   }))
 
   const zero = useZero()
-  await zero.value.mutate.table.insert({ a: 1, b: 'a' })
-  await zero.value.mutate.table.insert({ a: 2, b: 'b' })
-
-  const builder = createBuilder(schema)
-  const byIdQuery = syncedQuery(
-    'byId',
-    ([id]) => {
-      if (typeof id !== 'number') {
-        throw new TypeError('id must be a number')
-      }
-      return [id] as const
-    },
-    (id: number) => {
-      return builder.table.where('a', id)
-    },
-  )
-
-  const tableQuery = zero!.value.query.table
+  await zero.value.mutate(mutators.table.insert({ a: 1, b: 'a' })).client
+  await zero.value.mutate(mutators.table.insert({ a: 2, b: 'b' })).client
+
+  const zql = createBuilder(schema)
+  const queries = defineQueries({
+    byId: defineQuery(
+      z.number(),
+      ({ args: a }) => zql.table.where('a', a),
+    ),
+    table: defineQuery(
+      () => zql.table,
+    ),
+  })
 
-  onTestFinished(() => {
-    zero.value.close()
+  onTestFinished(async () => {
+    await zero.value.close()
   })
 
-  return { z: zero, tableQuery, useQuery, byIdQuery, userID }
+  return { zero, queries, useQuery, mutators, userID }
 }
 
 describe('useQuery', () => {
   it('useQuery', async () => {
-    const { z, tableQuery, useQuery } = await setupTestEnvironment()
-    const { data: rows, status } = useQuery(() => tableQuery)
+    const { zero, mutators, queries, useQuery } = await setupTestEnvironment()
+    const { data: rows, status } = useQuery(() => queries.table())
     expect(rows.value).toMatchInlineSnapshot(`[
   {
     "a": 1,
@@ -72,7 +87,7 @@ describe('useQuery', () => {
 ]`)
     expect(status.value).toEqual('unknown')
 
-    await z.value.mutate.table.insert({ a: 3, b: 'c' })
+    await zero.value.mutate(mutators.table.insert({ a: 3, b: 'c' })).client
     await nextTick()
 
     expect(rows.value).toMatchInlineSnapshot(`[
@@ -98,24 +113,45 @@ describe('useQuery', () => {
   })
 
   it('useQuery with ttl', async () => {
-    const { z, tableQuery, useQuery } = await setupTestEnvironment()
+    const { zero, queries, useQuery } = await setupTestEnvironment()
 
     const ttl = ref<TTL>('1m')
 
-    const materializeSpy = vi.spyOn(z.value, 'materialize')
-    const queryGetter = vi.fn(() => tableQuery)
+    const materializeSpy = vi.spyOn(zero.value, 'materialize')
+    const queryGetter = vi.fn(() => queries.table())
 
     useQuery(queryGetter, () => ({ ttl: ttl.value }))
     expect(queryGetter).toHaveBeenCalledTimes(1)
 
     expect(materializeSpy).toHaveLastReturnedWith(expect.any(VueView))
     expect(materializeSpy).toHaveBeenCalledExactlyOnceWith(
-      tableQuery,
+      expect.any(Object),
       vueViewFactory,
       { ttl: '1m' },
     )
+    expect(materializeSpy.mock.calls[0]![0]).toMatchInlineSnapshot(`
+      QueryImpl {
+        "_exists": [Function],
+        "customQueryID": {
+          "args": [],
+          "name": "table",
+        },
+        "format": {
+          "relationships": {},
+          "singular": false,
+        },
+        "limit": [Function],
+        "one": [Function],
+        "orderBy": [Function],
+        "related": [Function],
+        "start": [Function],
+        "where": [Function],
+        "whereExists": [Function],
+        Symbol(): true,
+      }
+    `)
 
-    const view: VueView<unknown> = materializeSpy.mock.results[0]!.value
+    const view: VueView = materializeSpy.mock.results[0]!.value
     const updateTTLSpy = vi.spyOn(view, 'updateTTL')
 
     materializeSpy.mockClear()
@@ -128,12 +164,12 @@ describe('useQuery', () => {
   })
 
   it('useQuery deps change', async () => {
-    const { tableQuery, useQuery } = await setupTestEnvironment()
+    const { queries, useQuery } = await setupTestEnvironment()
 
     const a = ref(1)
 
     const { data: rows, status } = useQuery(() =>
-      tableQuery.where('a', a.value),
+      queries.byId(a.value),
     )
 
     const rowLog: unknown[] = []
@@ -187,9 +223,9 @@ describe('useQuery', () => {
   })
 
   it('useQuery deps change watchEffect', async () => {
-    const { z, tableQuery, useQuery } = await setupTestEnvironment()
+    const { zero, queries, mutators, useQuery } = await setupTestEnvironment()
     const a = ref(1)
-    const { data: rows } = useQuery(() => tableQuery.where('a', a.value))
+    const { data: rows } = useQuery(() => queries.byId(a.value))
 
     let run = 0
 
@@ -205,7 +241,7 @@ describe('useQuery', () => {
   },
 ]`,
           )
-          z.value.mutate.table.update({ a: 1, b: 'a2' })
+          zero.value.mutate(mutators.table.update({ a: 1, b: 'a2' }))
         }
         else if (run === 1) {
           expect(rows.value).toMatchInlineSnapshot(
@@ -236,37 +272,36 @@ describe('useQuery', () => {
     })
   })
 
-  it('useQuery with syncedQuery', async () => {
-    const { byIdQuery, useQuery } = await setupTestEnvironment()
-    if (!byIdQuery) {
-      return
-    }
-
-    const a = ref(1)
-    const { data: rows, status } = useQuery(() => byIdQuery(a.value))
-
-    expect(rows.value).toMatchInlineSnapshot(`
-[
-  {
-    "a": 1,
-    "b": "a",
-    Symbol(rc): 1,
-  },
-]`)
-    expect(status.value).toEqual('unknown')
-  })
-
   it('can still be used without createZero', async () => {
+    const crud = createCRUDBuilder(schema)
+    const mutators = defineMutators({
+      table: {
+        insert: defineMutator(
+          z.object({ a: z.number(), b: z.string() }),
+          async ({ tx, args: { a, b } }) => {
+            return tx.mutate(crud.table.insert({ a, b }))
+          },
+        ),
+      },
+    })
     const zero = new Zero({
       userID: 'test-user',
       server: null,
       schema,
+      mutators,
       kvStore: 'mem' as const,
     })
-    await zero.mutate.table.insert({ a: 1, b: 'a' })
-    await zero.mutate.table.insert({ a: 2, b: 'b' })
+    await zero.mutate(mutators.table.insert({ a: 1, b: 'a' })).client
+    await zero.mutate(mutators.table.insert({ a: 2, b: 'b' })).client
+
+    const zql = createBuilder(schema)
+    const queries = defineQueries({
+      table: defineQuery(
+        () => zql.table,
+      ),
+    })
 
-    const { data: rows, status } = useQuery(zero, () => zero.query.table)
+    const { data: rows, status } = useQuery(zero, () => queries.table())
     expect(rows.value).toMatchInlineSnapshot(`[
   {
     "a": 1,
@@ -281,6 +316,6 @@ describe('useQuery', () => {
 ]`)
     expect(status.value).toEqual('unknown')
 
-    zero.close()
+    await zero.close()
   })
 })

src/query.ts

@@ -1,6 +1,6 @@
 // based on https://github.com/rocicorp/mono/tree/main/packages/zero-solid
 
-import type { CustomMutatorDefs, HumanReadable, Query, Schema, TTL, Zero } from '@rocicorp/zero'
+import type { CustomMutatorDefs, DefaultContext, DefaultSchema, HumanReadable, PullRow, Query, QueryOrQueryRequest, ReadonlyJSONValue, Schema, TTL, Zero } from '@rocicorp/zero'
 import type { ComputedRef, MaybeRefOrGetter } from 'vue'
 import type { QueryError, QueryStatus, VueView } from './view'
 
@@ -26,24 +26,57 @@ export interface QueryResult<TReturn> {
   error: ComputedRef<QueryError & { retry: () => void } | undefined>
 }
 
-export function useQuery<
-  TSchema extends Schema,
+export function addContextToQuery<
   TTable extends keyof TSchema['tables'] & string,
+  TInput extends ReadonlyJSONValue | undefined,
+  TOutput extends ReadonlyJSONValue | undefined,
+  TSchema extends Schema,
+  TReturn,
+  TContext,
+>(query: QueryOrQueryRequest<
+  TTable,
+  TInput,
+  TOutput,
+  TSchema,
   TReturn,
+  TContext
+>, context: TContext): Query<TTable, TSchema, TReturn> {
+  return 'query' in query ? query.query.fn({ ctx: context, args: query.args }) : query
+}
+
+export function useQuery<
+  TTable extends keyof TSchema['tables'] & string,
+  TInput extends ReadonlyJSONValue | undefined,
+  TOutput extends ReadonlyJSONValue | undefined,
+  TSchema extends Schema = DefaultSchema,
+  TReturn = PullRow<TTable, TSchema>,
+  TContext = DefaultContext,
   MD extends CustomMutatorDefs | undefined = undefined,
 >(
-  z: MaybeRefOrGetter<Zero<TSchema, MD>>,
-  query: MaybeRefOrGetter<Query<TSchema, TTable, TReturn>>,
+  z: MaybeRefOrGetter<Zero<TSchema, MD, TContext>>,
+  query: MaybeRefOrGetter<QueryOrQueryRequest<TTable, TInput, TOutput, TSchema, TReturn, TContext>>,
   options?: MaybeRefOrGetter<UseQueryOptions>,
 ): QueryResult<TReturn> {
   const ttl = computed(() => toValue(options)?.ttl ?? DEFAULT_TTL_MS)
-  const view = shallowRef<VueView<HumanReadable<TReturn>> | null>(null)
+  const view = shallowRef<VueView | null>(null)
   const refetchKey = shallowRef(0)
 
+  const q = shallowRef()
   watch(
     [
       () => toValue(query),
       () => toValue(z),
+    ],
+    ([query, z]) => {
+      q.value = addContextToQuery(toValue(query), toValue(z).context)
+    },
+    { immediate: true },
+  )
+
+  watch(
+    [
+      () => toValue(q),
+      () => toValue(z),
       refetchKey,
     ],
     ([q, z]) => {