over-zero 0.0.9 → 0.0.11

package/src/createPermissions.ts

@@ -4,65 +4,31 @@ import type {
   Query,
   Schema as ZeroSchema,
 } from '@rocicorp/zero'
-import { ANYONE_CAN, definePermissions } from '@rocicorp/zero'
-import { ensure, EnsureError, objectEntries } from '@vxrn/helpers'
-import { runWithContext } from './helpers/context'
+import { ensure, EnsureError } from '@vxrn/helpers'
 import { setDidRunPermissionCheck } from './helpers/didRunPermissionCheck'
+import { mutatorContext } from './helpers/mutatorContext'
 import { prettyFormatZeroQuery } from './helpers/prettyFormatZeroQuery'
-import type {
-  AuthData,
-  Can,
-  MutatorContext,
-  TableName,
-  Transaction,
-  Where,
-} from './types'
+import type { AuthData, Can, TableName, Transaction, Where } from './types'
 import { getWhereTableName } from './where'
 
 export function createPermissions<Schema extends ZeroSchema>({
   environment,
   schema,
-  models,
-  getContext,
 }: {
   environment: 'client' | 'server'
   schema: Schema
-  models: any
-  getContext: () => MutatorContext
 }) {
-  type PermissionPresetActions =
-    | 'read'
-    | 'write'
-    | 'insert'
-    | 'update'
-    | 'delete'
-    | 'select'
-
-  type PermissionsConditions = Partial<
-    Record<PermissionPresetActions | (string & {}), Condition | boolean>
-  >
+  type PermissionReturn = Condition | boolean
 
   type PermissionsWhere<Table extends TableName = TableName> = Where<
     Table,
-    PermissionsConditions
+    PermissionReturn
   >
 
-  const fallbackActions: Record<string, string> = {
-    select: 'read',
-    insert: 'write',
-    update: 'write',
-    upsert: 'write',
-    delete: 'write',
-  }
-
-  function buildPermissionQuery<
-    PermissionWhere extends PermissionsWhere,
-    Action extends string,
-  >(
+  function buildPermissionQuery<PermissionWhere extends PermissionsWhere>(
     authData: AuthData | null,
     eb: ExpressionBuilder<any, any>,
     permissionWhere: PermissionWhere,
-    action: Action,
     // TODO until i can get a working PickPrimaryKeys<'message'>
     objOrId: Record<string, any> | string
   ) {
@@ -79,22 +45,17 @@ export function createPermissions<Schema extends ZeroSchema>({
     }
 
     const primaryKeys = tableSchema.primaryKey
-    const permissionQueryBuilder = permissionWhere(eb, authData)
-    const fallbackAction = fallbackActions[action]
+    const permissionReturn = permissionWhere(eb, authData)
 
-    const permissionCondition =
-      permissionQueryBuilder[action] ||
-      (fallbackAction ? permissionQueryBuilder[fallbackAction] : undefined)
-
-    if (permissionCondition == null) {
-      throw new Error(`No permission defined for ${action} (or ${fallbackAction})`)
+    if (permissionReturn == null) {
+      throw new Error(`No permission defined for ${tableName}`)
     }
 
-    if (permissionCondition === true) {
+    if (permissionReturn === true) {
       return eb.cmpLit(true, '=', true)
     }
 
-    if (permissionCondition === false) {
+    if (permissionReturn === false) {
       return eb.cmpLit(true, '=', false)
     }
 
@@ -105,39 +66,27 @@ export function createPermissions<Schema extends ZeroSchema>({
       primaryKeyWheres.push(eb.cmp(key as any, value))
     }
 
-    return eb.and(permissionCondition, ...primaryKeyWheres)
+    return eb.and(permissionReturn, ...primaryKeyWheres)
   }
 
-  const can: Can = async (where, action, obj) => {
-    const ctx = getContext()
-    const tableName = getWhereTableName(where)
-    if (!tableName) {
-      throw new Error(`Must use where('table') style where to pass to can()`)
-    }
-
+  const can: Can = async (where, obj) => {
     // on client we always allow! we only check on server (like zero does)
     if (environment === 'server') {
-      await ensurePermission(
-        ctx.tx,
-        ctx.authData,
-        tableName,
-        where,
-        action as string,
-        obj
-      )
+      const ctx = mutatorContext()
+      const tableName = getWhereTableName(where)
+      if (!tableName) {
+        throw new Error(`Must use where('table') style where to pass to can()`)
+      }
+      await ensurePermission(ctx.tx, ctx.authData, tableName, where, obj)
       setDidRunPermissionCheck(ctx)
     }
   }
 
-  async function ensurePermission<
-    PW extends PermissionsWhere,
-    Action extends keyof ReturnType<PW>,
-  >(
+  async function ensurePermission(
     tx: Transaction,
     authData: AuthData | null,
     tableName: TableName,
     where: Where,
-    actionIn: Action,
     obj: any // TODO until i can get a working PickPrimaryKeys<'message'>
   ): Promise<void> {
     if (authData?.role === 'admin') {
@@ -145,16 +94,13 @@ export function createPermissions<Schema extends ZeroSchema>({
       return
     }
 
-    const action = String(actionIn)
-    const name = `${tableName}.${action}`
-    // @ts-ignore TODO its the right type but need to figure out better way to get TableName
     const queryBase = tx.query[tableName] as Query<any, any>
     let query: Query<any, any, any> | null = null
 
     try {
       query = queryBase
         .where((eb) => {
-          return buildPermissionQuery(authData, eb, where, action, obj)
+          return buildPermissionQuery(authData, eb, where, obj)
         })
         .one()
 
@@ -174,56 +120,8 @@ export function createPermissions<Schema extends ZeroSchema>({
     }
   }
 
-  const readPermissions = definePermissions<AuthData, Schema>(schema, async () => {
-    const permissionsEntries = await Promise.all(
-      objectEntries(models)
-        // non permissioned models dont turn into read permissions
-        .filter(([_, model]) => !!model.permissions)
-        .map(async ([key, model]) => {
-          return await runWithContext(
-            {
-              authData: { id: '', role: undefined, email: '' },
-            } as any,
-            () => {
-              return [
-                key,
-                {
-                  row: {
-                    select: [
-                      (authData: AuthData, eb: ExpressionBuilder<any, any>) => {
-                        const out = model.permissions(eb, authData).read
-
-                        if (out === true) {
-                          return eb.and()
-                        }
-
-                        if (out === false) {
-                          return eb.cmpLit(true, '=', false)
-                        }
-
-                        return out
-                      },
-                    ],
-                    // we have permissions on these through our model system with custom mutators:
-                    insert: ANYONE_CAN,
-                    update: ANYONE_CAN,
-                    delete: ANYONE_CAN,
-                  },
-                },
-              ]
-            }
-          )
-        })
-    )
-
-    const permissions = Object.fromEntries(permissionsEntries)
-
-    return permissions as any
-  })
-
   return {
     can,
     buildPermissionQuery,
-    readPermissions,
   }
 }

package/src/createZeroClient.tsx

@@ -1,13 +1,22 @@
-import type { Row, Zero, ZeroOptions, Schema as ZeroSchema } from '@rocicorp/zero'
+import type {
+  HumanReadable,
+  Query,
+  ReadonlyJSONValue,
+  Row,
+  SyncedQuery,
+  Zero,
+  ZeroOptions,
+  Schema as ZeroSchema,
+} from '@rocicorp/zero'
+import { syncedQuery } from '@rocicorp/zero'
 import { useZero, ZeroProvider, useQuery as zeroUseQuery } from '@rocicorp/zero/react'
 import { createEmitter, mapObject } from '@vxrn/helpers'
 import { createContext, use, useMemo, type ReactNode } from 'react'
 import { createPermissions } from './createPermissions'
-import { context } from './helpers/context'
 import { createMutators } from './helpers/createMutators'
 import { prettyFormatZeroQuery } from './helpers/prettyFormatZeroQuery'
 import { useZeroDebug } from './helpers/useZeroDebug'
-
+import { setAuthData, setSchema } from './state'
 import type { AuthData, GenericModels, GetZeroMutators, ZeroEvent } from './types'
 
 export function createZeroClient<
@@ -18,7 +27,9 @@ export function createZeroClient<
   type ZeroInstance = Zero<Schema, ZeroMutators>
   type TableName = keyof ZeroInstance['query']
 
-  const modelPermissions = mapObject(models, (val) => val.permissions) as {
+  setSchema(schema)
+
+  const modelWritePermissions = mapObject(models, (val) => val.permissions) as {
     [K in TableName]: K extends keyof Models ? Models[K]['permissions'] : never
   }
 
@@ -34,8 +45,6 @@ export function createZeroClient<
 
   const permissionsHelpers = createPermissions<Schema>({
     schema,
-    models,
-    getContext: context,
     environment: 'client',
   })
 
@@ -52,22 +61,15 @@ export function createZeroClient<
   // and things generally aren't changing with permissions rapidly, so lets
   // cache the last results and use that when first rendering, they will
   // always update once the query resolves
-  function usePermission<
-    K extends TableName,
-    Action extends 'insert' | 'update' | 'delete' | 'select',
-  >(
+  function usePermission<K extends TableName>(
     table: K,
-    action: Action,
     objOrId: string | Partial<Row<Schema['tables'][K]>> | undefined,
     enabled = typeof objOrId !== 'undefined',
     debug = false
   ): boolean | null {
-    // we fallback to just table.action, to avoid flickers for now
-    const keyBase = `${String(table)}${action}`
-    const key = `${keyBase}${typeof objOrId === 'string' ? objOrId : JSON.stringify(objOrId)}`
     // const cacheVal = permissionCache.get(key) ?? permissionCache.get(keyBase)
     const authData = useAuthData()
-    const permission = modelPermissions[table]
+    const permission = modelWritePermissions[table]
 
     const query = (() => {
       let baseQuery = zero.query[table].one()
@@ -81,7 +83,6 @@ export function createZeroClient<
           authData,
           eb,
           permission,
-          action,
           objOrId as any
         )
       })
@@ -94,7 +95,7 @@ export function createZeroClient<
     if (debug) {
       console.info(
         `usePermission()`,
-        { data, status, action, authData, permission },
+        { data, status, authData, permission },
         prettyFormatZeroQuery(query)
       )
     }
@@ -110,16 +111,97 @@ export function createZeroClient<
     return allowed
   }
 
-  const useQuery: typeof zeroUseQuery = (query, options) => {
-    if (disable) {
-      return [null, { type: 'unknown' }] as never
-    }
+  type PlainQueryFn<
+    TArg = any,
+    TReturn extends Query<any, any, any> = Query<any, any, any>,
+  > = (args: TArg) => TReturn
+
+  type UseQueryOptions = {
+    enabled?: boolean | undefined
+    ttl?: 'always' | 'never' | number | undefined
+  }
+
+  type QueryResultDetails = ReturnType<typeof zeroUseQuery>[1]
+  type QueryResult<TReturn> = readonly [HumanReadable<TReturn>, QueryResultDetails]
 
-    const out = zeroUseQuery(query, options)
+  const queryCache = new Map<string, SyncedQuery<any, any, any, any, any>>()
+
+  const parseAny = (x: unknown[]): [ReadonlyJSONValue] => [x[0] as ReadonlyJSONValue]
+
+  // Overload 1: Original API - Query or SyncedQuery with options
+  function useQuery<TTable extends keyof Schema['tables'] & string, TReturn>(
+    query:
+      | Query<Schema, TTable, TReturn>
+      | SyncedQuery<any, any, any, any, Query<Schema, TTable, TReturn>>,
+    options?: UseQueryOptions | boolean
+  ): QueryResult<TReturn>
+
+  // Overload 2: Plain function with params
+  function useQuery<TArg, TTable extends keyof Schema['tables'] & string, TReturn>(
+    fn: PlainQueryFn<TArg, Query<Schema, TTable, TReturn>>,
+    params: TArg,
+    options?: UseQueryOptions | boolean
+  ): QueryResult<TReturn>
+
+  // Overload 3: Plain function with no params
+  function useQuery<TTable extends keyof Schema['tables'] & string, TReturn>(
+    fn: PlainQueryFn<void, Query<Schema, TTable, TReturn>>,
+    options?: UseQueryOptions | boolean
+  ): QueryResult<TReturn>
+
+  // Implementation - keep it simple with any
+  function useQuery(...args: any[]): any {
+    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 = queryOrFn
+      const queryName = fn.name || 'anonymousQuery'
+
+      // Determine if this is Pattern 2 (with params) or Pattern 3 (no params)
+      const hasParams =
+        optionsArg !== undefined ||
+        (paramsOrOptions &&
+          typeof paramsOrOptions === 'object' &&
+          !('enabled' in paramsOrOptions) &&
+          !('ttl' in paramsOrOptions))
+
+      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)
+      }
+
+      // Call the SyncedQuery with params if provided
+      const query = params !== undefined ? (synced as any)(params) : synced
+
+      return { actualQuery: query, options: opts }
+    }, [queryOrFn, paramsOrOptions, optionsArg, isPlainFunction])
+
+    const out = zeroUseQuery(actualQuery, options)
 
     if (process.env.NODE_ENV === 'development') {
       // biome-ignore lint/correctness/useHookAtTopLevel: ok
-      useZeroDebug(query, options, out)
+      useZeroDebug(actualQuery, options, out)
+    }
+
+    if (disable) {
+      return [null, { type: 'unknown' }] as never
     }
 
     return out
@@ -134,6 +216,8 @@ export function createZeroClient<
     authData?: any
   }) => {
     const mutators = useMemo(() => {
+      setAuthData(authData)
+
       return createMutators({
         models,
         environment: 'client',

package/src/createZeroServer.ts

@@ -1,12 +1,19 @@
-import type { Query, Schema as ZeroSchema } from '@rocicorp/zero'
+import type {
+  HumanReadable,
+  Query,
+  ReadonlyJSONValue,
+  SyncedQuery,
+  Schema as ZeroSchema,
+} from '@rocicorp/zero'
 import type { TransactionProviderInput } from '@rocicorp/zero/pg'
-import { PostgresJSConnection, PushProcessor } from '@rocicorp/zero/pg'
-import { ZQLDatabase } from '@rocicorp/zero/server'
+import { handleGetQueriesRequest, PushProcessor } from '@rocicorp/zero/pg'
+import { zeroNodePg } from '@rocicorp/zero/server/adapters/pg'
 import { assertString, randomId } from '@vxrn/helpers'
-import postgres from 'postgres'
+import { Pool } from 'pg'
 import { createPermissions } from './createPermissions'
-import { context, isInZeroMutation } from './helpers/context'
 import { createMutators } from './helpers/createMutators'
+import { isInZeroMutation, mutatorContext } from './helpers/mutatorContext'
+import { setAuthData, setSchema } from './state'
 import type {
   AsyncAction,
   AuthData,
@@ -19,11 +26,16 @@ export function createZeroServer<
   Schema extends ZeroSchema,
   Models extends GenericModels,
   ServerActions extends Record<string, unknown>,
+  Queries extends Record<string, SyncedQuery<any, any, any, any, any>> = Record<
+    string,
+    never
+  >,
 >({
   createServerActions,
   database,
   schema,
   models,
+  queries,
 }: {
   /**
    * The DB connection string, same as ZERO_UPSTREAM_DB
@@ -32,26 +44,25 @@ export function createZeroServer<
   schema: Schema
   models: Models
   createServerActions: () => ServerActions
+  queries?: Queries
 }) {
-  const dbString = assertString(database, `"database" prop`)
-  const db = postgres(dbString)
-
-  const zeroServerDatabase = new ZQLDatabase(
-    new PostgresJSConnection(
-      // TODO if you have duplicate postgres due to zero having its own in node_modules TS types break
-      db as any
-    ),
-    schema
+  setSchema(schema)
+
+  const dbString = assertString(database, `createZeroServer "database"`)
+
+  const zeroDb = zeroNodePg(
+    schema,
+    new Pool({
+      connectionString: dbString,
+    })
   )
 
   const permissions = createPermissions<Schema>({
     environment: 'server',
     schema,
-    models,
-    getContext: context,
   })
 
-  const processor = new PushProcessor(zeroServerDatabase)
+  const processor = new PushProcessor(zeroDb)
 
   const handleMutationRequest = async ({
     authData,
@@ -96,6 +107,33 @@ export function createZeroServer<
     }
   }
 
+  const handleQueryRequest = async ({
+    authData,
+    request,
+  }: {
+    authData: AuthData | null
+    request: Request
+  }) => {
+    function getQuery(name: string, args: readonly ReadonlyJSONValue[]) {
+      const q = queries?.[name]
+      if (!q) {
+        throw new Error(`No such query: ${name}`)
+      }
+
+      return {
+        // @ts-expect-error zero bug atm
+        query: q(...args),
+      }
+    }
+
+    setAuthData(authData || {})
+    const response = await handleGetQueriesRequest(getQuery, schema, request)
+
+    return {
+      response,
+    }
+  }
+
   const mutate = async (
     run: (tx: Transaction, mutators: GetZeroMutators<Models>) => Promise<void>,
     authData?: Pick<AuthData, 'email' | 'id'> & Partial<AuthData>
@@ -129,11 +167,11 @@ export function createZeroServer<
   >(query: CB): Promise<Returns> {
     try {
       if (isInZeroMutation()) {
-        const { tx } = context()
+        const { tx } = mutatorContext()
         return await query(tx)
       }
       // @ts-ignore type
-      const output = await zeroServerDatabase.transaction(query, dummyTransactionInput)
+      const output = await zeroDb.transaction(query, dummyTransactionInput)
       return output as any
     } catch (err) {
       console.error(`Error running transaction(): ${err}`)
@@ -141,16 +179,12 @@ export function createZeroServer<
     }
   }
 
-  type ZeroQueryFn<Response extends Query<any, any>> = (
-    query: Transaction['query']
-  ) => Promise<Response>
-
-  async function query<GetQuery extends ZeroQueryFn<any>>(
-    cb: GetQuery
-  ): Promise<ReturnType<GetQuery>> {
-    return await transaction(async (tx) => {
-      return await cb(tx.query)
-    })
+  function query<R>(
+    cb: (q: Transaction['query']) => Query<Schema, any, R>
+  ): Promise<HumanReadable<R>> {
+    return transaction(async (tx) => {
+      return cb(tx.query)
+    }) as any
   }
 
   // This is needed temporarily and will be cleaned up in the future.
@@ -163,6 +197,7 @@ export function createZeroServer<
 
   return {
     handleMutationRequest,
+    handleQueryRequest,
     transaction,
     mutate,
     query,

package/src/helpers/createMutators.ts

@@ -7,7 +7,7 @@ import type {
   MutatorContext,
   Transaction,
 } from '../types'
-import { runWithContext } from './context'
+import { runWithContext } from './mutatorContext'
 
 export function createMutators<Models extends GenericModels>({
   environment,

package/src/helpers/ensureLoggedIn.ts

@@ -1,9 +1,9 @@
 import { ensure } from '@vxrn/helpers'
 import type { AuthData } from '../types'
-import { context } from './context'
+import { mutatorContext } from './mutatorContext'
 
 export const ensureLoggedIn = (): AuthData => {
-  const { authData } = context()
+  const { authData } = mutatorContext()
   ensure(authData, 'logged in')
   return authData
 }

package/src/helpers/getQueryOrMutatorAuthData.ts

@@ -0,0 +1,11 @@
+import { getAuthData } from '../state'
+import type { AuthData } from '../types'
+import { isInZeroMutation, mutatorContext } from './mutatorContext'
+
+export function getQueryOrMutatorAuthData(): AuthData {
+  if (isInZeroMutation()) {
+    return mutatorContext().authData as AuthData
+  }
+
+  return getAuthData()
+}

package/src/helpers/{context.ts → mutatorContext.ts}

@@ -1,16 +1,12 @@
 import { createAsyncContext } from '@vxrn/helpers'
 import type { MutatorContext } from '../types'
 
-// TODO likely should be called "DataContext" or "ZeroContext" as its useful for permissions outside mutators
-
 const asyncContext = createAsyncContext<MutatorContext>()
 
-// TODO probably rename mutatorContext()
-
-export function context(): MutatorContext {
+export function mutatorContext(): MutatorContext {
   const currentContext = asyncContext.get()
   if (!currentContext) {
-    throw new Error('context must be called within a mutator')
+    throw new Error('mutatorContext must be called within a mutator')
   }
 
   return currentContext

package/src/index.ts

@@ -1,11 +1,12 @@
 export * from './createPermissions'
 export * from './helpers/batchQuery'
-export * from './helpers/context'
 export * from './helpers/createMutators'
 export * from './helpers/ensureLoggedIn'
+export * from './helpers/mutatorContext'
 
+export * from './createZeroClient'
 export * from './mutations'
 export * from './where'
-export * from './createZeroClient'
+export * from './zql'
 
 export type * from './types'

package/src/mutations.ts

@@ -89,7 +89,7 @@ export function mutations<
 
           // only validate on the server
           if (process.env.VITE_ENVIRONMENT === 'ssr') {
-            await ctx.can(permissions, action, obj)
+            await ctx.can(permissions, obj)
           }
         }