maintain backwards compatibility

Author: maxstevens-nl

src/create-zero.ts

@@ -3,7 +3,7 @@ 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 } from './query'
+import { useQueryWithZero } from './query'
 
 const zeroCleanups = new Set()
 
@@ -23,18 +23,18 @@ export function createZero<S extends Schema = Schema, MD extends CustomMutatorDe
     z.value = 'zero' in opts ? opts.zero : new Zero(opts)
   }, { deep: true })
 
-  function useQueryWrap<
+  function useQuery<
     TTable extends keyof S['tables'] & string,
     TReturn,
   >(
     query: MaybeRefOrGetter<Query<S, TTable, TReturn>>,
     options?: MaybeRefOrGetter<UseQueryOptions>,
   ): QueryResult<TReturn> {
-    return useQuery(z, query, options)
+    return useQueryWithZero(query, options, z)
   }
 
   return {
     useZero: () => z,
-    useQuery: useQueryWrap,
+    useQuery,
   }
 }

src/index.ts

@@ -1,2 +1,3 @@
 export { createZero } from './create-zero'
 export type { QueryResult, UseQueryOptions } from './query'
+export { useQuery } from './query'

src/query.test.ts

@@ -4,6 +4,7 @@ import { createBuilder, createSchema, number, string, syncedQuery, table } from
 import { describe, expect, it, vi } from 'vitest'
 import { ref, watchEffect } from 'vue'
 import { createZero } from './create-zero'
+import { useQuery } from './query'
 import { VueView, vueViewFactory } from './view'
 
 async function setupTestEnvironment() {
@@ -317,4 +318,25 @@ describe('useQuery', () => {
 
     z.value.close()
   })
+
+  it('can still be used without createZero', async () => {
+    const { z, tableQuery } = await setupTestEnvironment()
+
+    const { data: rows, status } = useQuery(() => tableQuery)
+    expect(rows.value).toMatchInlineSnapshot(`[
+  {
+    "a": 1,
+    "b": "a",
+    Symbol(rc): 1,
+  },
+  {
+    "a": 2,
+    "b": "b",
+    Symbol(rc): 1,
+  },
+]`)
+    expect(status.value).toEqual('unknown')
+
+    z.value.close()
+  })
 })

src/query.ts

@@ -25,15 +25,36 @@ export interface QueryResult<TReturn> {
   status: ComputedRef<ResultType>
 }
 
+/**
+ * @deprecated
+ *
+ * Use `useQuery` returned from `createZero` instead. This function doesn't
+ * support Synced Queries, and will be removed in a future version.
+ *
+ * @param query The query to execute.
+ * @param options Options for the query.
+ * @returns The result of the query.
+ */
 export function useQuery<
   TSchema extends Schema,
   TTable extends keyof TSchema['tables'] & string,
   TReturn,
+>(
+  query: MaybeRefOrGetter<Query<TSchema, TTable, TReturn>>,
+  options?: MaybeRefOrGetter<UseQueryOptions>,
+): QueryResult<TReturn> {
+  return useQueryWithZero(query, options)
+}
+
+export function useQueryWithZero<
+  TSchema extends Schema,
+  TTable extends keyof TSchema['tables'] & string,
+  TReturn,
   MD extends CustomMutatorDefs | undefined = undefined,
 >(
-  z: MaybeRefOrGetter<Zero<TSchema, MD>>,
   query: MaybeRefOrGetter<Query<TSchema, TTable, TReturn>>,
   options?: MaybeRefOrGetter<UseQueryOptions>,
+  z?: MaybeRefOrGetter<Zero<TSchema, MD>>,
 ): QueryResult<TReturn> {
   const ttl = computed(() => {
     return toValue(options)?.ttl ?? DEFAULT_TTL_MS