over-zero 0.0.0

package/src/createPermissions.ts

@@ -0,0 +1,281 @@
+import type {
+  Condition,
+  ExpressionBuilder,
+  Query,
+  Transaction,
+  Schema as ZeroSchema,
+} from '@rocicorp/zero'
+import { ANYONE_CAN, definePermissions } from '@rocicorp/zero'
+import { ensure, EnsureError, objectEntries } from '@vxrn/helpers'
+import type { AuthData } from 'start/types'
+// import { models } from '~/data/models'
+// import { objectEntries } from '~/helpers/types/object'
+import { prettyFormatZeroQuery } from './helpers/prettyFormatZeroQuery'
+import type { MutatorContext, Where } from './types'
+
+// TODO this will go away soon if we can get a good sync queries setup
+
+export function createPermissions<Schema extends ZeroSchema, TableName extends string>({
+  schema,
+  getContext,
+}: {
+  schema: Schema
+  getContext: () => MutatorContext
+}) {
+  runEnvironmentSafetyCheck()
+
+  // we don't want flickers as you move around and these queries are re-run
+  // 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
+
+  // Where defaults to letting you return basically anything because we want to allow it to be usable
+  // flexibly, one example is for permissions where you can return an Object with multiple wheres as values
+  // for example, PermissionsWhere below
+
+  function where<Table extends TableName, Builder extends Where = Where<Table>>(
+    tableName: Table,
+    builder: Builder
+  ): Builder
+
+  function where<Table extends TableName, Builder extends Where = Where<Table>>(
+    builder: Builder
+  ): Builder
+
+  function where<Table extends TableName, Builder extends Where = Where<Table>>(
+    a: Table | Builder,
+    b?: Builder
+  ): Builder {
+    if (b) {
+      WhereTableNameMap.set(b, a as Table)
+    }
+    return (b || a) as any
+  }
+
+  // permissions where:
+
+  const WhereTableNameMap = new WeakMap<Where, TableName>()
+
+  function getWhereTableName(where: Where) {
+    return WhereTableNameMap.get(where)
+  }
+
+  // example of a custom where we use for permissions
+
+  type PermissionPresetActions =
+    | 'read'
+    | 'write'
+    | 'insert'
+    | 'update'
+    | 'delete'
+    | 'select'
+
+  type PermissionsConditions = Partial<
+    Record<PermissionPresetActions | (string & {}), Condition | boolean>
+  >
+
+  type PermissionsWhere<Table extends TableName = TableName> = Where<
+    Table,
+    PermissionsConditions
+  >
+
+  const fallbackActions: Record<string, string> = {
+    select: 'read',
+    insert: 'write',
+    update: 'write',
+    upsert: 'write',
+    delete: 'write',
+  }
+
+  function buildPermissionQuery<
+    PermissionWhere extends PermissionsWhere,
+    Action extends string,
+  >(
+    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
+  ) {
+    const tableName = getWhereTableName(permissionWhere)
+
+    if (!tableName) {
+      throw new Error(`Must use PermissionWhere for buildPermissionQuery`)
+    }
+
+    const tableSchema = schema.tables[tableName]
+    const primaryKeys = tableSchema.primaryKey
+    const permissionQueryBuilder = permissionWhere(eb, authData)
+    const fallbackAction = fallbackActions[action]
+
+    const permissionCondition =
+      permissionQueryBuilder[action] ||
+      (fallbackAction ? permissionQueryBuilder[fallbackAction] : undefined)
+
+    if (permissionCondition == null) {
+      throw new Error(`No permission defined for ${action} (or ${fallbackAction})`)
+    }
+
+    if (permissionCondition === true) {
+      return eb.cmpLit(true, '=', true)
+    }
+
+    if (permissionCondition === false) {
+      return eb.cmpLit(true, '=', false)
+    }
+
+    const primaryKeyWheres: Condition[] = []
+
+    for (const key of primaryKeys) {
+      const value = typeof objOrId === 'string' ? objOrId : objOrId[key]
+      primaryKeyWheres.push(eb.cmp(key as any, value))
+    }
+
+    return eb.and(permissionCondition, ...primaryKeyWheres)
+  }
+
+  async function can<
+    PWhere extends PermissionsWhere,
+    Action extends keyof ReturnType<PWhere>,
+  >(where: PWhere, action: Action, obj: any) {
+    const ctx = getContext()
+    const tableName = getWhereTableName(where)
+    if (!tableName) {
+      throw new Error(`Must use where('table') style where to pass to can()`)
+    }
+
+    // on client we always allow!
+    if (process.env.VITE_ENVIRONMENT === 'ssr') {
+      await ensurePermission(
+        ctx.tx,
+        ctx.authData,
+        tableName,
+        where,
+        action as string,
+        obj
+      )
+      ctx.didCanPermissionsRun = true
+    }
+  }
+
+  type TX = Transaction<Schema>
+
+  async function ensurePermission<
+    PW extends PermissionsWhere,
+    Action extends keyof ReturnType<PW>,
+  >(
+    tx: TX,
+    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') {
+      // admin role can do any mutation
+      return
+    }
+
+    const action = String(actionIn)
+    const name = `${tableName}.${action}`
+    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)
+        })
+        .one()
+
+      ensure(await query)
+    } catch (err) {
+      const errorTitle = `${name} with auth id: ${authData?.id}`
+
+      if (err instanceof EnsureError) {
+        let msg = `[permission] 🚫 Not Allowed: ${errorTitle}`
+        if (process.env.NODE_ENV === 'development' && query) {
+          msg += `\n ${prettyFormatZeroQuery(query)}`
+        }
+        throw new Error(msg)
+      }
+
+      throw new Error(`Error running permission ${errorTitle}\n${err}`)
+    }
+  }
+
+  const readPermissions = definePermissions<AuthData, Schema>(schema, async () => {
+    const permissionsEntries = await Promise.all(
+      objectEntries(models).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 {
+    where,
+    can,
+    buildPermissionQuery,
+    readPermissions,
+  }
+}
+
+// this is just so we have some assurance that we aren't skipping permissions
+// checks due to bad VITE_ENVIRONMENT variable
+function runEnvironmentSafetyCheck() {
+  if (typeof document !== 'undefined') {
+    // web!
+  } else if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+    // react-native!
+  } else {
+    // server!
+    if (process.env.VITE_ENVIRONMENT !== 'ssr') {
+      console.error(`❌❌❌❌
+
+ERROR: VITE_ENVIRONMENT is not set to "ssr" on server, which means permissions checks won't run when they should
+This is makes Zero entirely insecure and needs to be fixed immediately.
+
+This is likely a One framework issue, unless the user Vite config is overwriting the value.
+One automatically sets this value.
+        
+        `)
+    }
+  }
+}

package/src/createZeroClient.tsx

@@ -0,0 +1,191 @@
+import type { Row, ZeroOptions, Schema as ZeroSchema } from '@rocicorp/zero'
+import { useZero, ZeroProvider, useQuery as zeroUseQuery } from '@rocicorp/zero/react'
+import { createLocalStorage, 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 { zeroEmitter } from './helpers/zeroEmitter'
+import type { AuthData } from './types'
+
+export function createZero<Schema extends ZeroSchema>({
+  schema,
+  models,
+  disable,
+}: {
+  schema: Schema
+  models: any
+  disable?: boolean
+}) {
+  // TODO
+  type TableName = string
+  type Mutators = any // typeof mutators
+  type ZeroInstance = ReturnType<typeof useZero<Schema, Mutators>>
+
+  const modelPermissions = mapObject(models, (val) => val.permissions) as {
+    [K in keyof typeof models]: (typeof models)[K]['permissions']
+  }
+
+  const permissionsHelpers = createPermissions<Schema, TableName>({
+    schema,
+    getContext: context,
+  })
+
+  const permissionCache = createLocalStorage<string, boolean>('permissions-cache', {
+    storageLimit: 24,
+  })
+
+  const AuthDataContext = createContext<AuthData>(null)
+  const useAuthData = () => use(AuthDataContext)
+
+  function usePermission<
+    K extends TableName,
+    Action extends 'insert' | 'update' | 'delete' | 'select',
+  >(
+    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 = `${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 query = (() => {
+      let baseQuery = zero.query[table].one()
+
+      if (!enabled) {
+        return baseQuery
+      }
+
+      return baseQuery.where((eb) => {
+        return permissionsHelpers.buildPermissionQuery(
+          authData,
+          eb,
+          permission,
+          action,
+          objOrId as any
+        )
+      })
+    })()
+
+    const [data, status] = useQuery(query, {
+      enabled: Boolean(enabled && authData && objOrId),
+    })
+
+    if (debug) {
+      console.info(
+        `usePermission()`,
+        { data, status, action, authData, permission },
+        prettyFormatZeroQuery(query)
+      )
+    }
+
+    const result = data
+
+    const allowed = Boolean(result)
+
+    if (!objOrId) {
+      return false
+    }
+
+    return allowed
+  }
+
+  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
+  const zero: ZeroInstance = new Proxy({} as never, {
+    get(_, key) {
+      return Reflect.get(latestZeroInstance!, key, latestZeroInstance)
+    },
+  })
+
+  const useQuery: typeof zeroUseQuery = (query, options) => {
+    if (disable) {
+      return [null, { type: 'unknown' }] as never
+    }
+
+    const out = zeroUseQuery(query, options)
+
+    if (process.env.NODE_ENV === 'development') {
+      // biome-ignore lint/correctness/useHookAtTopLevel: ok
+      useZeroDebug(query, options, out)
+    }
+
+    return out
+  }
+
+  const ProvideZero = ({
+    children,
+    authData,
+    ...props
+  }: Omit<ZeroOptions<Schema, Mutators>, 'schema' | 'mutators'> & {
+    children: ReactNode
+    authData?: any
+  }) => {
+    const mutators = useMemo(() => {
+      return createMutators({
+        models,
+        environment: 'client',
+        authData,
+        can: permissionsHelpers.can,
+      })
+    }, [models, authData])
+
+    if (disable) {
+      return children
+    }
+
+    return (
+      <AuthDataContext.Provider value={authData}>
+        <ZeroProvider
+          schema={schema}
+          kvStore={'mem'}
+          onError={(error) => {
+            console.error(`Zero Error:`, error)
+            zeroEmitter.emit({
+              type: 'error',
+              message: error,
+            })
+          }}
+          mutators={mutators}
+          {...props}
+        >
+          <SetZeroInstance />
+          {children}
+        </ZeroProvider>
+      </AuthDataContext.Provider>
+    )
+  }
+
+  const SetZeroInstance = () => {
+    const zero = useZero<Schema, Mutators>()
+
+    // TODO last hack zero wants us to use useZero but its a big migration
+    // and has some downsides (global zero import leads to simpler code)
+    // they plan to support .setAuth() at some point, and so long as we refresh
+    // when we do change zero, this should be safe - that said we don't refresh
+    // the browser for now, but we also don't handle new auth keys in general
+    // we'll need to add that soon
+    if (zero !== latestZeroInstance) {
+      latestZeroInstance = zero
+    }
+
+    return null
+  }
+
+  return {
+    ProvideZero,
+    useQuery,
+    usePermission,
+    zero,
+  }
+}

package/src/createZeroServer.ts

@@ -0,0 +1,153 @@
+import type { Schema as ZeroSchema } from '@rocicorp/zero'
+import type { TransactionProviderInput } from '@rocicorp/zero/pg'
+import { PostgresJSConnection } from '@rocicorp/zero/pg'
+import { ZQLDatabase } from '@rocicorp/zero/server'
+import postgres from 'postgres'
+// import { context, isInZeroMutation } from 'src/context'
+import type { AuthData } from './types'
+// import { type Mutators, createMutators } from '~/data/helpers/createMutators'
+// import { schema } from '~/data/schema'
+// import { createServerActions } from '~/data/server/createServerActions'
+// import type { TX } from '~/data/types'
+import { PushProcessor } from '@rocicorp/zero/pg'
+import { assertString, randomId } from '@vxrn/helpers'
+import { createMutators } from './helpers/createMutators'
+// import type { Endpoint } from 'one'
+// import type { AuthData } from 'start/data'
+// import { getAuthHeader, NotAuthenticatedError } from '~/auth/validateAuthHeader'
+// import { randomId } from '@vxrn/helpers'
+// import { createMutators } from '~/data/helpers/createMutators'
+// import { createServerActions } from '~/data/server/createServerActions'
+// import { GenericTransaction } from './types'
+
+// this sets up custom server-side mutators
+// see: https://zero.rocicorp.dev/docs/custom-mutators
+
+export function createZeroServer<
+  Schema extends ZeroSchema,
+  ServerActions extends Record<string, any>,
+>({
+  createServerActions,
+  schema,
+  models,
+  disable,
+}: {
+  schema: Schema
+  models: any
+  createServerActions: (authData: AuthData | null) => ServerActions
+  disable?: boolean
+}) {
+  // TODO
+  type TX = any
+  type Mutators = any
+
+  const dbString = assertString(process.env.ZERO_UPSTREAM_DB)
+
+  const zeroServerDatabase = new ZQLDatabase(
+    new PostgresJSConnection(postgres(dbString)),
+    schema
+  )
+
+  const processor = new PushProcessor(zeroServerDatabase)
+
+  const handleMutationRequest = async ({
+    authData,
+    request,
+    skipAsyncTasks,
+  }: {
+    authData: AuthData
+    request: Request
+    skipAsyncTasks?: boolean
+  }) => {
+    // since mutations do DB work in transaction, avoid any async tasks during
+    const asyncTasks: Array<() => Promise<void>> = []
+
+    const response = await processor.process(
+      createMutators({
+        environment: 'server',
+        asyncTasks,
+        authData,
+        createServerActions,
+      }),
+      request
+    )
+
+    // now finish
+    if (!skipAsyncTasks && asyncTasks.length) {
+      const id = randomId()
+      console.info(`[push] complete, running async tasks ${asyncTasks.length} id ${id}`)
+      Promise.all(asyncTasks.map((task) => task()))
+        .then(() => {
+          console.info(`[push] async tasks complete ${id}`)
+        })
+        .catch((err) => {
+          console.error(`[push] error: async tasks failed 😞`, err)
+        })
+    }
+
+    return {
+      response,
+      asyncTasks,
+    }
+  }
+
+  const serverMutate = async (
+    run: (tx: TX, mutators: Mutators) => Promise<void>,
+    authData?: Pick<AuthData, 'email' | 'id'> & Partial<AuthData>
+  ) => {
+    const asyncTasks: Array<() => Promise<void>> = []
+
+    const mutators = createMutators({
+      environment: 'server',
+      asyncTasks,
+      authData: {
+        id: '',
+        email: 'admin@start.chat',
+        role: 'admin',
+        ...authData,
+      },
+      createServerActions,
+    })
+
+    await serverTransaction(async (tx) => {
+      await run(tx, mutators)
+    })
+
+    await Promise.all(asyncTasks.map((t) => t()))
+  }
+
+  // shorthand but nicer for single queries
+  // TODO should unwrap q.query
+  const serverQuery = serverTransaction
+
+  // This is needed temporarily and will be cleaned up in the future.
+  const dummyTransactionInput: TransactionProviderInput = {
+    clientGroupID: 'unused',
+    clientID: 'unused',
+    mutationID: 42,
+    upstreamSchema: 'unused',
+  }
+
+  async function serverTransaction<
+    CB extends (tx: TX) => Promise<any>,
+    Returns extends CB extends (tx: TX) => Promise<infer X> ? X : never,
+  >(query: CB): Promise<Returns> {
+    try {
+      if (isInZeroMutation()) {
+        const { tx } = context()
+        return await query(tx)
+      }
+      return (await zeroServerDatabase.transaction(query, dummyTransactionInput)) as any
+    } catch (err) {
+      console.error(`Error running serverTransaction(): ${err}`)
+      throw err
+    }
+  }
+
+  return {
+    handleMutationRequest,
+    transaction: serverTransaction,
+    mutate: serverMutate,
+    query: serverQuery,
+  }
+}

package/src/helpers/batchQuery.ts

@@ -0,0 +1,45 @@
+import type { Query, Row } from '@rocicorp/zero'
+import { sleep } from '@vxrn/helpers'
+
+export async function batchQuery<Q extends Query<any, any, any>, Item extends Row<Q>>(
+  q: Q,
+  mapper: (items: Item[]) => Promise<void>,
+  {
+    chunk,
+    pause = 0,
+    stopAfter = 100_000,
+  }: {
+    chunk: number
+    pause?: number
+    stopAfter?: number
+  } = { chunk: 20 }
+) {
+  let hasMore = true
+  let last: Item | null = null
+  let iterations = 0
+
+  while (hasMore) {
+    let query = q.limit(chunk)
+
+    if (last) {
+      query = query.start(last)
+    }
+
+    const results = await query.run({ type: 'complete' })
+
+    await mapper(results as Item[])
+
+    if (results.length < chunk) {
+      hasMore = false
+    }
+
+    if (iterations > stopAfter) {
+      console.error(`[batchQuery] ‼️ stopping batch, ran ${stopAfter} chunks`)
+      break
+    }
+
+    if (pause) {
+      await sleep(pause)
+    }
+  }
+}