over-zero 0.0.35 → 0.0.37

package/readme.md

@@ -212,7 +212,7 @@ generates all files needed to connect your models and queries:
 - `models.ts` - aggregates all model files into a single import
 - `types.ts` - generates TypeScript types from table schemas
 - `tables.ts` - exports table schemas (separate to avoid circular types)
-- `queries.ts` - generates synced query definitions with valibot validators
+- `syncedQueries.ts` - generates synced query definitions with valibot validators
 
 **options:**
 
@@ -283,7 +283,7 @@ export { schema as channel } from '~/data/models/channel'
 export { schema as message } from '~/data/models/message'
 ```
 
-**queries.ts:**
+**syncedQueries.ts:**
 
 ```ts
 import * as v from 'valibot'
@@ -329,12 +329,14 @@ client:
 
 ```tsx
 import { createZeroClient } from 'over-zero'
-import { schema } from './data/schema'
-import { models } from './data/models'
+import { schema } from '~/data/schema'
+import { models } from '~/data/generated/models'
+import * as groupedQueries from '~/data/generated/groupedQueries'
 
-export const { ProvideZero, useQuery, zero } = createZeroClient({
+export const { ProvideZero, useQuery, zero, usePermission } = createZeroClient({
   schema,
   models,
+  groupedQueries,
 })
 
 // in your app root
@@ -352,17 +354,19 @@ server:
 
 ```ts
 import { createZeroServer } from 'over-zero/server'
+import { syncedQueries } from '~/data/generated/syncedQueries'
 
 export const zeroServer = createZeroServer({
   schema,
   models,
   database: process.env.DATABASE_URL,
+  queries: syncedQueries, // required for synced queries / pull endpoint
   createServerActions: () => ({
     sendEmail: async (to, subject, body) => { ... }
   })
 })
 
-// in your api endpoint
+// push endpoint for mutations
 app.post('/api/zero/push', async (req) => {
   const authData = await getAuthFromRequest(req)
   const { response } = await zeroServer.handleMutationRequest({
@@ -371,6 +375,16 @@ app.post('/api/zero/push', async (req) => {
   })
   return response
 })
+
+// pull endpoint for synced queries
+app.post('/api/zero/pull', async (req) => {
+  const authData = await getAuthFromRequest(req)
+  const { response } = await zeroServer.handleQueryRequest({
+    authData,
+    request: req
+  })
+  return response
+})
 ```
 
 type augmentation:

package/src/cli.ts

@@ -453,14 +453,14 @@ function generateSyncedQueriesFile(
   const sortedFiles = Array.from(queryByFile.keys()).sort()
 
   const imports = `// auto-generated by: over-zero generate
-// server-side syncedQuery wrappers with validators
-import { syncedQuery } from '@rocicorp/zero'
+// server-side query definitions with validators
+import { defineQuery, defineQueries } from '@rocicorp/zero'
 import * as v from 'valibot'
 import * as Queries from './groupedQueries'
 `
 
-  // generate grouped exports by namespace
-  const namespaceExports = sortedFiles
+  // generate grouped definitions by namespace
+  const namespaceDefs = sortedFiles
     .map((file) => {
       const fileQueries = queryByFile
         .get(file)!
@@ -474,7 +474,7 @@ import * as Queries from './groupedQueries'
             l.startsWith('export const QueryParams')
           )
 
-          let validatorDef = 'v.void()'
+          let validatorDef = ''
           if (schemaLineIndex !== -1) {
             const schemaLines: string[] = []
             let openBraces = 0
@@ -500,31 +500,32 @@ import * as Queries from './groupedQueries'
             validatorDef = schemaLines.join('\n')
           }
 
-          // wrap validator in v.parser(v.tuple([...]))
-          const wrappedValidator =
-            validatorDef === 'v.void()'
-              ? 'v.parser(v.tuple([]))'
-              : `v.parser(v.tuple([${validatorDef}]))`
-
-          // namespaced query name: file.queryName
-          const namespacedName = `${q.sourceFile}.${q.name}`
-
-          // for void queries, no arg parameter
-          const queryFn =
-            validatorDef === 'v.void()'
-              ? `() => Queries.${file}.${q.name}()`
-              : `(arg) => Queries.${file}.${q.name}(arg)`
+          // for void queries, no validator and no args
+          if (!validatorDef) {
+            return `  ${q.name}: defineQuery(() => Queries.${file}.${q.name}()),`
+          }
 
-          return `  ${q.name}: syncedQuery('${namespacedName}', ${wrappedValidator}, ${queryFn}),`
+          // defineQuery with validator and args
+          return `  ${q.name}: defineQuery(
+    ${validatorDef},
+    ({ args }) => Queries.${file}.${q.name}(args),
+  ),`
         })
         .join('\n')
 
-      return `export const ${file} = {\n${queryDefs}\n}`
+      return `const ${file} = {\n${queryDefs}\n}`
     })
     .join('\n\n')
 
+  // build the defineQueries call with all namespaces
+  const queriesObject = sortedFiles.map((file) => `  ${file},`).join('\n')
+
   return `${imports}
-${namespaceExports}
+${namespaceDefs}
+
+export const queries = defineQueries({
+${queriesObject}
+})
 `
 }
 

package/src/createPermissions.ts

@@ -1,8 +1,9 @@
-import { ensure, EnsureError } from '@vxrn/helpers'
+import { ensure, EnsureError } from '@take-out/helpers'
 
 import { setDidRunPermissionCheck } from './helpers/didRunPermissionCheck'
 import { mutatorContext } from './helpers/mutatorContext'
 import { prettyFormatZeroQuery } from './helpers/prettyFormatZeroQuery'
+import { getZQL } from './state'
 import { getWhereTableName } from './where'
 
 import type { AuthData, Can, TableName, Transaction, Where } from './types'
@@ -96,7 +97,8 @@ export function createPermissions<Schema extends ZeroSchema>({
       return
     }
 
-    const queryBase = tx.query[tableName] as Query<any, any>
+    const zqlBuilder = getZQL() as any
+    const queryBase = zqlBuilder[tableName] as Query<any, any>
     let query: Query<any, any, any> | null = null
 
     try {
@@ -106,9 +108,9 @@ export function createPermissions<Schema extends ZeroSchema>({
         })
         .one()
 
-      ensure(await query)
+      ensure(await tx.run(query))
     } catch (err) {
-      const errorTitle = `${name} with auth id: ${authData?.id}`
+      const errorTitle = `${tableName} with auth id: ${authData?.id}`
 
       if (err instanceof EnsureError) {
         let msg = `[permission] 🚫 Not Allowed: ${errorTitle}`

package/src/createUseQuery.tsx

@@ -1,4 +1,3 @@
-import { syncedQuery } from '@rocicorp/zero'
 import { useQuery as zeroUseQuery } from '@rocicorp/zero/react'
 import { use, useMemo, type Context } from 'react'
 
@@ -6,10 +5,9 @@ import { useZeroDebug } from './helpers/useZeroDebug'
 import { getQueryName } from './queryRegistry'
 
 import type {
+  AnyQueryRegistry,
   HumanReadable,
   Query,
-  ReadonlyJSONValue,
-  SyncedQuery,
   Schema as ZeroSchema,
 } from '@rocicorp/zero'
 
@@ -26,77 +24,43 @@ export type PlainQueryFn<
   TReturn extends Query<any, any, any> = Query<any, any, any>,
 > = (args: TArg) => TReturn
 
-// inline query type - only available when DisableInline is false
-type InlineQuery<
-  Schema extends ZeroSchema,
-  TTable extends keyof Schema['tables'] & string,
-  TReturn,
-> =
-  | Query<Schema, TTable, TReturn>
-  | SyncedQuery<any, any, any, any, Query<Schema, TTable, TReturn>>
-
-// the useQuery hook type with conditional inline overload
-export type UseQueryHook<
-  Schema extends ZeroSchema,
-  DisableInline extends boolean = false,
-> = {
-  // overload 1: inline query (only when DisableInline is false)
-  <TTable extends keyof Schema['tables'] & string, TReturn>(
-    query: DisableInline extends true ? never : InlineQuery<Schema, TTable, TReturn>,
-    options?: UseQueryOptions | boolean
-  ): QueryResult<TReturn>;
-
-  // overload 2: plain function with params
+export type UseQueryHook<Schema extends ZeroSchema> = {
+  // overload 1: plain function with params
   <TArg, TTable extends keyof Schema['tables'] & string, TReturn>(
-    fn: PlainQueryFn<TArg, Query<Schema, TTable, TReturn>>,
+    fn: PlainQueryFn<TArg, Query<TTable, Schema, TReturn>>,
     params: TArg,
     options?: UseQueryOptions | boolean
   ): QueryResult<TReturn>;
 
-  // overload 3: plain function with no params
+  // overload 2: plain function with no params
   <TTable extends keyof Schema['tables'] & string, TReturn>(
-    fn: PlainQueryFn<void, Query<Schema, TTable, TReturn>>,
+    fn: PlainQueryFn<void, Query<TTable, Schema, TReturn>>,
     options?: UseQueryOptions | boolean
   ): QueryResult<TReturn>
 }
 
-export function createUseQuery<
-  Schema extends ZeroSchema,
-  const DisableInline extends boolean = false,
->({
+export function createUseQuery<Schema extends ZeroSchema>({
   DisabledContext,
-  disableInlineQueries = false as DisableInline,
+  customQueries,
 }: {
   DisabledContext: Context<boolean>
-  disableInlineQueries?: DisableInline
-}): UseQueryHook<Schema, DisableInline> {
-  const queryCache = new Map<string, SyncedQuery<any, any, any, any, any>>()
-  const parseAny = (x: unknown[]): [ReadonlyJSONValue] => [x[0] as ReadonlyJSONValue]
-
+  customQueries: AnyQueryRegistry
+}): UseQueryHook<Schema> {
   function useQuery(...args: any[]): any {
     const disabled = use(DisabledContext)
-    const [queryOrFn, paramsOrOptions, optionsArg] = args
-
-    // detect which calling pattern is being used
-    const isPlainFunction = typeof queryOrFn === 'function' && !('queryName' in queryOrFn)
-
-    const { actualQuery, options } = useMemo(() => {
-      if (!isPlainFunction) {
-        // pattern 1: original api - useQuery(query, options)
-        return {
-          actualQuery: queryOrFn,
-          options: paramsOrOptions,
-        }
-      }
+    const [fn, paramsOrOptions, optionsArg] = args
 
-      const fn = queryOrFn
+    const { queryRequest, options } = useMemo(() => {
       const queryName = getQueryName(fn)
-
       if (!queryName) {
-        throw new Error(`No query name?`)
+        const fnName = fn?.name || 'anonymous'
+        throw new Error(
+          `Query function '${fnName}' not registered. ` +
+            `Ensure it is exported from a queries file and passed to createZeroClient via groupedQueries.`
+        )
       }
 
-      // determine if this is pattern 2 (with params) or pattern 3 (no params)
+      // determine if this is with params or no params
       const hasParams =
         optionsArg !== undefined ||
         (paramsOrOptions &&
@@ -107,27 +71,28 @@ export function createUseQuery<
       const params = hasParams ? paramsOrOptions : undefined
       const opts = hasParams ? optionsArg : paramsOrOptions
 
-      let synced = queryCache.get(queryName)
-      if (!synced) {
-        synced = syncedQuery(queryName, parseAny, (arg: ReadonlyJSONValue) => {
-          return fn(arg)
-        })
-        queryCache.set(queryName, synced)
-      }
+      // look up the CustomQuery from the shared registry
+      // queryName is "namespace.name" format, e.g., "user.userById"
+      const [namespace, name] = queryName.split('.', 2)
+      const customQuery = (customQueries as any)[namespace]?.[name]
 
-      // call the SyncedQuery with params if provided
-      const query = params !== undefined ? (synced as any)(params) : synced
+      if (!customQuery) {
+        throw new Error(
+          `CustomQuery '${queryName}' not found. ` +
+            `Check that the query is exported and the namespace/name matches.`
+        )
+      }
 
-      return { actualQuery: query, options: opts }
-    }, [queryOrFn, paramsOrOptions, optionsArg, isPlainFunction])
+      const queryRequest = params !== undefined ? customQuery(params) : customQuery()
 
-    console.info('running', { actualQuery, options, queryOrFn })
+      return { queryRequest, options: opts }
+    }, [fn, paramsOrOptions, optionsArg])
 
-    const out = zeroUseQuery(actualQuery, options)
+    const out = zeroUseQuery(queryRequest as any, options)
 
     if (process.env.NODE_ENV === 'development') {
       // eslint-disable-next-line react-hooks/rules-of-hooks
-      useZeroDebug(actualQuery, options, out)
+      useZeroDebug(queryRequest as any, options, out)
     }
 
     if (disabled) {
@@ -137,5 +102,5 @@ export function createUseQuery<
     return out
   }
 
-  return useQuery as UseQueryHook<Schema, DisableInline>
+  return useQuery as UseQueryHook<Schema>
 }

package/src/createZeroClient.tsx

@@ -1,6 +1,20 @@
-import { useZero, ZeroProvider } from '@rocicorp/zero/react'
-import { createEmitter, mapObject } from '@vxrn/helpers'
-import { createContext, use, useMemo, type ReactNode } from 'react'
+import { defineQueries, defineQuery } from '@rocicorp/zero'
+import {
+  useConnectionState,
+  useZero,
+  ZeroProvider,
+  useQuery as zeroUseQuery,
+} from '@rocicorp/zero/react'
+import { createEmitter, mapObject } from '@take-out/helpers'
+import {
+  createContext,
+  memo,
+  use,
+  useEffect,
+  useMemo,
+  useRef,
+  type ReactNode,
+} from 'react'
 
 import { createPermissions } from './createPermissions'
 import { createUseQuery } from './createUseQuery'
@@ -9,7 +23,7 @@ import { prettyFormatZeroQuery } from './helpers/prettyFormatZeroQuery'
 import { registerQuery } from './queryRegistry'
 import { setAuthData, setSchema } from './state'
 
-import type { AuthData, GenericModels, GetZeroMutators, ZeroEvent } from './types'
+import type { AuthData, GenericModels, GetZeroMutators, Where, ZeroEvent } from './types'
 import type { Row, Zero, ZeroOptions, Schema as ZeroSchema } from '@rocicorp/zero'
 
 export type GroupedQueries = Record<string, Record<string, (...args: any[]) => any>>
@@ -17,17 +31,14 @@ export type GroupedQueries = Record<string, Record<string, (...args: any[]) => a
 export function createZeroClient<
   Schema extends ZeroSchema,
   Models extends GenericModels,
-  const DisableInlineQueries extends boolean = false,
 >({
   schema,
   models,
   groupedQueries,
-  disableInlineQueries = false as DisableInlineQueries,
 }: {
   schema: Schema
   models: Models
   groupedQueries: GroupedQueries
-  disableInlineQueries?: DisableInlineQueries
 }) {
   type ZeroMutators = GetZeroMutators<Models>
   type ZeroInstance = Zero<Schema, ZeroMutators>
@@ -36,25 +47,45 @@ export function createZeroClient<
   setSchema(schema)
 
   // build query registry from grouped queries
+  // this creates ONE shared defineQueries registry that matches the server's structure
+  const wrappedNamespaces: Record<
+    string,
+    Record<string, ReturnType<typeof defineQuery>>
+  > = {}
+
   for (const [namespace, queries] of Object.entries(groupedQueries)) {
+    wrappedNamespaces[namespace] = {}
     for (const [name, fn] of Object.entries(queries)) {
       registerQuery(fn, `${namespace}.${name}`)
+      // wrap each plain function in defineQuery
+      wrappedNamespaces[namespace][name] = defineQuery(({ args }: { args: any }) =>
+        fn(args)
+      )
     }
   }
 
+  // create the single shared CustomQuery registry
+  const customQueries = defineQueries(wrappedNamespaces)
+
   const DisabledContext = createContext(false)
 
-  const modelWritePermissions = mapObject(models, (val) => val.permissions) as {
-    [K in TableName]: K extends keyof Models ? Models[K]['permissions'] : never
-  }
+  const modelWritePermissions = mapObject(models, (val) => val.permissions) as Record<
+    TableName,
+    Where<any, any> | undefined
+  >
 
   let latestZeroInstance: ZeroInstance | null = null
 
-  // when we log in this is swapped out and later the exported zero is just a proxy
-  // may cause some issues, ideally zero itself supports this
+  // Proxy allows swapping the Zero instance on login without breaking existing references.
+  // Ideally rocicorp/zero would support .setAuth() natively, but for now we swap instances.
   const zero: ZeroInstance = new Proxy({} as never, {
     get(_, key) {
-      return Reflect.get(latestZeroInstance!, key, latestZeroInstance)
+      if (latestZeroInstance === null) {
+        throw new Error(
+          `Zero instance not initialized. Ensure ZeroProvider is mounted before accessing 'zero'.`
+        )
+      }
+      return Reflect.get(latestZeroInstance, key, latestZeroInstance)
     },
   })
 
@@ -72,9 +103,9 @@ export function createZeroClient<
   const AuthDataContext = createContext<AuthData>({} as AuthData)
   const useAuthData = () => use(AuthDataContext)
 
-  const useQuery = createUseQuery<Schema, DisableInlineQueries>({
+  const useQuery = createUseQuery<Schema>({
     DisabledContext,
-    disableInlineQueries,
+    customQueries,
   })
 
   // we don't want flickers as you move around and these queries are re-run
@@ -83,7 +114,7 @@ export function createZeroClient<
   // always update once the query resolves
   function usePermission<K extends TableName>(
     table: K,
-    objOrId: string | Partial<Row<Schema['tables'][K]>> | undefined,
+    objOrId: string | Partial<Row<any>> | undefined,
     enabled = typeof objOrId !== 'undefined',
     debug = false
   ): boolean | null {
@@ -93,7 +124,7 @@ export function createZeroClient<
     const permission = modelWritePermissions[table]
 
     const query = (() => {
-      let baseQuery = zero.query[table].one()
+      let baseQuery = (zero.query as any)[table].one()
 
       if (disabled || !enabled || !permission) {
         return baseQuery
@@ -109,9 +140,8 @@ export function createZeroClient<
       })
     })()
 
-    // note: usePermission is internal and uses inline queries intentionally
-    // if disableInlineQueries is enabled, this will error and need a cast
-    const [data, status] = useQuery(query as any, {
+    // usePermission is internal and uses inline queries directly via zeroUseQuery
+    const [data, status] = zeroUseQuery(query, {
       enabled: Boolean(enabled && permission && authData && objOrId),
     })
 
@@ -164,20 +194,9 @@ export function createZeroClient<
 
     return (
       <AuthDataContext.Provider value={authData}>
-        <ZeroProvider
-          schema={schema}
-          kvStore="mem"
-          onError={(error) => {
-            console.error(`Zero Error:`, error)
-            zeroEvents.emit({
-              type: 'error',
-              message: error,
-            })
-          }}
-          mutators={mutators}
-          {...props}
-        >
+        <ZeroProvider schema={schema} kvStore="mem" mutators={mutators as any} {...props}>
           <SetZeroInstance />
+          <ConnectionMonitor zeroEvents={zeroEvents} />
           {children}
         </ZeroProvider>
       </AuthDataContext.Provider>
@@ -200,6 +219,35 @@ export function createZeroClient<
     return null
   }
 
+  // monitors connection state and emits events (replaces onError callback removed in 0.25)
+  const ConnectionMonitor = memo(
+    ({
+      zeroEvents,
+    }: {
+      zeroEvents: ReturnType<typeof createEmitter<ZeroEvent | null>>
+    }) => {
+      const state = useConnectionState()
+      const prevState = useRef(state.name)
+
+      useEffect(() => {
+        if (state.name !== prevState.current) {
+          const reason = 'reason' in state ? state.reason : ''
+          prevState.current = state.name
+
+          if (state.name === 'error' || state.name === 'needs-auth') {
+            const message = typeof reason === 'string' ? reason : state.name
+            zeroEvents.emit({
+              type: 'error',
+              message,
+            })
+          }
+        }
+      }, [state, zeroEvents])
+
+      return null
+    }
+  )
+
   return {
     zeroEvents,
     ProvideZero,

package/src/createZeroServer.ts

@@ -1,6 +1,8 @@
-import { handleGetQueriesRequest, PushProcessor } from '@rocicorp/zero/pg'
+import { mustGetQuery } from '@rocicorp/zero'
+import { PushProcessor } from '@rocicorp/zero/pg'
+import { handleQueryRequest as zeroHandleQueryRequest } from '@rocicorp/zero/server'
 import { zeroNodePg } from '@rocicorp/zero/server/adapters/pg'
-import { assertString, randomId } from '@vxrn/helpers'
+import { assertString, randomId } from '@take-out/helpers'
 import { Pool } from 'pg'
 
 import { createPermissions } from './createPermissions'
@@ -16,31 +18,23 @@ import type {
   Transaction,
 } from './types'
 import type {
+  AnyQueryRegistry,
   HumanReadable,
   Query,
-  ReadonlyJSONValue,
-  SyncedQuery,
   Schema as ZeroSchema,
 } from '@rocicorp/zero'
 import type { TransactionProviderInput } from '@rocicorp/zero/pg'
 
-// grouped synced queries: { namespace: { queryName: SyncedQuery } }
-export type SyncedQueries = Record<
-  string,
-  Record<string, SyncedQuery<any, any, any, any, any>>
->
-
 export function createZeroServer<
   Schema extends ZeroSchema,
   Models extends GenericModels,
   ServerActions extends Record<string, unknown>,
-  Queries extends SyncedQueries = Record<string, never>,
 >({
   createServerActions,
   database,
   schema,
   models,
-  syncedQueries,
+  queries,
 }: {
   /**
    * The DB connection string, same as ZERO_UPSTREAM_DB
@@ -49,7 +43,7 @@ export function createZeroServer<
   schema: Schema
   models: Models
   createServerActions: () => ServerActions
-  syncedQueries?: Queries
+  queries?: AnyQueryRegistry
 }) {
   setSchema(schema)
 
@@ -59,6 +53,10 @@ export function createZeroServer<
     schema,
     new Pool({
       connectionString: dbString,
+      // handle self-signed certificates in production
+      ssl: dbString.includes('sslmode=require')
+        ? { rejectUnauthorized: false }
+        : undefined,
     })
   )
 
@@ -112,16 +110,6 @@ export function createZeroServer<
     }
   }
 
-  // build flat lookup map from grouped syncedQueries: "namespace.queryName" => SyncedQuery
-  const queryLookup = new Map<string, SyncedQuery<any, any, any, any, any>>()
-  if (syncedQueries) {
-    for (const [namespace, queries] of Object.entries(syncedQueries)) {
-      for (const [queryName, syncedQuery] of Object.entries(queries)) {
-        queryLookup.set(`${namespace}.${queryName}`, syncedQuery)
-      }
-    }
-  }
-
   const handleQueryRequest = async ({
     authData,
     request,
@@ -129,20 +117,24 @@ export function createZeroServer<
     authData: AuthData | null
     request: Request
   }) => {
-    function getQuery(name: string, args: readonly ReadonlyJSONValue[]) {
-      const q = queryLookup.get(name)
-      if (!q) {
-        throw new Error(`No such query: ${name}`)
-      }
-
-      return {
-        // @ts-expect-error zero bug atm
-        query: q(...args),
-      }
+    if (!queries) {
+      throw new Error(
+        'No queries registered with createZeroServer. ' +
+          'Pass the syncedQueries registry to createZeroServer via the queries option.'
+      )
     }
 
+    // set authData globally for permission checks in query functions
     setAuthData(authData || {})
-    const response = await handleGetQueriesRequest(getQuery, schema, request)
+
+    const response = await zeroHandleQueryRequest(
+      (name, args) => {
+        const query = (mustGetQuery as any)(queries, name)
+        return query.fn({ args, ctx: authData })
+      },
+      schema,
+      request
+    )
 
     return {
       response,
@@ -195,7 +187,7 @@ export function createZeroServer<
   }
 
   function query<R>(
-    cb: (q: Transaction['query']) => Query<Schema, any, R>
+    cb: (q: Transaction['query']) => Query<any, Schema, R>
   ): Promise<HumanReadable<R>> {
     return transaction(async (tx) => {
       return cb(tx.query)

package/src/helpers/batchQuery.ts

@@ -1,4 +1,4 @@
-import { sleep } from '@vxrn/helpers'
+import { sleep } from '@take-out/helpers'
 
 import type { Query, Row } from '@rocicorp/zero'