on-zero 0.2.10 → 0.3.0

package/readme.md

@@ -18,14 +18,14 @@ it provides a few things:
 
 - **generation** - cli with watch and generate commands
 - **queries** - convert plain TS query functions into validated synced queries
-- **mutations** - simply create CRUD queries with permissions
-- **models** - standardized co-locating schema/permissions/mutations
+- **mutations** - simply create CRUD mutations with permissions
+- **drizzle-zero** - derive zero schema + relationships from your drizzle schema
 - **permissions** - `serverWhere` for simple query-based permissions
 
 plus various hooks and helpers for react integration.
 
-models live alongside their permissions and mutations. queries are just
-functions that use a global `zql` builder.
+mutations live in `mutations/` with their permissions. queries are just
+functions that use a global `zql` builder. schema is derived from drizzle.
 
 ## queries
 
@@ -94,31 +94,21 @@ export const channelById = (props: { channelId: string }) => {
 permissions execute server-side only. on the client they automatically pass. the
 `serverWhere()` helper automatically accesses auth data via `getAuth()` so you don't need to pass it manually.
 
-## models
+## mutations
 
-models co-locate schema, permissions, and mutations in one file:
+mutations co-locate permissions and mutation handlers in one file. schema is
+derived from drizzle — no need to define it here.
 
 ```ts
-// src/data/models/message.ts
-import { number, string, table } from '@rocicorp/zero'
+// src/data/mutations/message.ts
 import { mutations, serverWhere } from 'on-zero'
 
-export const schema = table('message')
-  .columns({
-    id: string(),
-    content: string(),
-    authorId: string(),
-    channelId: string(),
-    createdAt: number(),
-  })
-  .primaryKey('id')
-
-export const permissions = serverWhere('message', (q, auth) => {
+const permissions = serverWhere('message', (q, auth) => {
   return q.cmp('authorId', auth?.id || '')
 })
 
-// CRUD mutations with permissions by passing schema + permissions:
-export const mutate = mutations(schema, permissions, {
+// pass table name as string — types are inferred from schema
+export const mutate = mutations('message', permissions, {
   async send(ctx, props: { content: string; channelId: string }) {
     await ctx.can(permissions, props)
 
@@ -191,11 +181,11 @@ export const myChannels = () => {
 }
 ```
 
-**for mutations:** define permissions in model files for CRUD operations:
+**for mutations:** define permissions in mutation files for CRUD operations:
 
 ```ts
-// src/data/models/message.ts
-export const permissions = serverWhere('message', (q, auth) => {
+// src/data/mutations/message.ts
+const permissions = serverWhere('message', (q, auth) => {
   return q.cmp('authorId', auth?.id || '')
 })
 ```
@@ -285,7 +275,7 @@ export const channelMessages = (props: { channelId: string }) => {
 
 ## generation
 
-on-zero auto-generates glue files that wire up your models, queries, and types.
+on-zero auto-generates glue files that wire up your mutations, queries, and types.
 
 ### vite plugin (recommended)
 
@@ -306,8 +296,8 @@ export default {
 **features:**
 
 - generates on dev server start
-- watches for model changes and regenerates
-- enables HMR for mutations (no page reload when editing models)
+- watches for mutation/query changes and regenerates
+- enables HMR for mutations (no page reload when editing mutation files)
 - generates before production builds
 
 **options:**
@@ -331,11 +321,12 @@ if you prefer CLI over the vite plugin:
 
 **`on-zero generate [dir]`**
 
-generates all files needed to connect your models and queries:
+generates all files needed to connect your mutations 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)
+- `schema.ts` - zero schema derived from drizzle via drizzle-zero (tables +
+  relationships)
+- `models.ts` - aggregates all mutation files into a single import
+- `types.ts` - typescript types derived from the schema
 - `syncedQueries.ts` - generates synced query definitions with valibot
   validators
 - `syncedMutations.ts` - generates valibot validators for mutation args
@@ -343,8 +334,8 @@ generates all files needed to connect your models and queries:
 
 **options:**
 
-- `dir` - base directory containing `models/` and `queries/` folders (default:
-  `src/data`)
+- `dir` - base directory containing `mutations/` and `queries/` folders
+  (default: `src/data`)
 - `--watch` - watch for changes and regenerate automatically
 - `--after` - command to run after generation completes
 
@@ -367,18 +358,13 @@ bun on-zero generate --after "bun lint:fix"
 **types.ts:**
 
 ```ts
-import type { TableInsertRow, TableUpdateRow } from 'on-zero'
-import type * as schema from './tables'
+import type { Row } from '@rocicorp/zero'
+import type { schema } from './schema'
 
-export type Channel = TableInsertRow<typeof schema.channel>
-export type ChannelUpdate = TableUpdateRow<typeof schema.channel>
-```
+type Tables = typeof schema.tables
 
-**tables.ts:**
-
-```ts
-export { schema as channel } from '~/data/models/channel'
-export { schema as message } from '~/data/models/message'
+export type Channel = Row<Tables['channel']>
+export type ChannelUpdate = Partial<Channel> & Pick<Channel, 'id'>
 ```
 
 **syncedQueries.ts:**
@@ -408,30 +394,70 @@ export const latestMessages = syncedQuery(
 
 the generator:
 
-1. scans `models/` for files with `export const schema = table(...)`
+1. scans `mutations/` for files with `export const mutate`
 2. scans `queries/` for exported arrow functions
 3. parses TypeScript AST to extract parameter types
-4. converts types to valibot schemas using typebox-codegen
+4. converts types to valibot schemas
 5. wraps query functions in `syncedQuery()` with validators
 6. extracts mutation handler param types using the TS type checker (resolves
    imports, aliases, and cross-file references)
-7. generates `syncedMutations.ts` with valibot validators for CRUD and custom
-   mutation args
-8. handles special cases (void params, user → userPublic mapping)
-9. groups query imports by source file
+7. generates `syncedMutations.ts` with valibot validators for mutation args
 
-queries with no parameters get wrapped in `v.parser(v.tuple([]))` while queries
-with params get validators like `v.parser(v.tuple([v.object({ ... })]))`.
+when using drizzle-zero integration, `schema.ts` is generated from your drizzle
+schema using `generateDrizzleSchemaFile()` — it produces `table()` + 
+`relationships()` + `createSchema()` calls with full type inference.
 
 exports named `permission` are automatically skipped during query generation.
 
+### drizzle-zero integration
+
+on-zero can derive your zero schema (tables + relationships) from a drizzle
+schema via [drizzle-zero](https://github.com/rocicorp/drizzle-zero). this
+eliminates duplicate column definitions — drizzle is the single source of truth.
+
+```ts
+// generate-schema.ts (run at build/dev time)
+import { drizzleZeroConfig } from 'drizzle-zero'
+import { generateDrizzleSchemaFile } from 'on-zero'
+import * as drizzleSchema from './database/schema'
+import { relations } from './database/relations'
+
+const dzSchema = drizzleZeroConfig(
+  { ...drizzleSchema, relations },
+  {
+    tables: {
+      user: true,
+      post: true,
+      comment: true,
+    },
+    suppressDefaultsWarning: true,
+  },
+)
+
+// generates a typed schema.ts with createSchema() + relationships()
+const output = generateDrizzleSchemaFile(dzSchema)
+writeFileSync('src/data/generated/schema.ts', output)
+```
+
+the generated file uses zero's `table()` builder and `relationships()` function,
+giving full type inference for zql queries including nested `.related()` calls.
+
+mutations then reference tables by name:
+
+```ts
+export const mutate = mutations('post', permissions, { ... })
+```
+
+the `mutations()` string overload derives insert/update/delete types from the
+global schema type — no need to import table builders.
+
 ## setup
 
 client:
 
 ```tsx
 import { createZeroClient } from 'on-zero'
-import { schema } from '~/data/schema'
+import { schema } from '~/data/generated/schema'
 import { models } from '~/data/generated/models'
 import * as groupedQueries from '~/data/generated/groupedQueries'
 
@@ -551,7 +577,7 @@ export const zeroServer = createZeroServer({
 this auto-validates args before every mutation runs. for a model like:
 
 ```ts
-export const mutate = mutations(schema, permissions, {
+export const mutate = mutations('message', permissions, {
   async send(ctx, props: { content: string; channelId: string }) {
     // ...
   },
@@ -615,7 +641,7 @@ type MutatorContext = {
 use it:
 
 ```ts
-export const mutate = mutations(schema, permissions, {
+export const mutate = mutations('message', permissions, {
   async archive(ctx, { messageId }) {
     await ctx.can(permissions, messageId)
     await ctx.tx.mutate.message.update({ id: messageId, archived: true })

package/src/createPermissions.ts

@@ -30,12 +30,7 @@ export function createPermissions<Schema extends ZeroSchema>({
   schema: Schema
   adminRoleMode?: AdminRoleMode
 }) {
-  type PermissionReturn = Condition | boolean
-
-  type PermissionsWhere<Table extends TableName = TableName> = Where<
-    Table,
-    PermissionReturn
-  >
+  type PermissionsWhere<Table extends TableName = TableName> = Where<Table>
 
   function buildPermissionQuery<PermissionWhere extends PermissionsWhere>(
     authData: AuthData | null,
@@ -43,7 +38,7 @@ export function createPermissions<Schema extends ZeroSchema>({
     permissionWhere: PermissionWhere,
     // TODO until i can get a working PickPrimaryKeys<'message'>
     objOrId: Record<string, any> | string,
-    tableNameOverride?: TableName
+    tableNameOverride?: TableName,
   ) {
     // check admin bypass for queries
     const adminBypassQueries = adminRoleMode === 'all' || adminRoleMode === 'queries'
@@ -65,7 +60,7 @@ export function createPermissions<Schema extends ZeroSchema>({
 
     const primaryKeys = tableSchema.primaryKey
 
-    let permissionReturn: PermissionReturn
+    let permissionReturn: Condition | boolean
     try {
       permissionReturn = permissionWhere(eb, authData)
     } catch (err) {
@@ -120,7 +115,7 @@ export function createPermissions<Schema extends ZeroSchema>({
     authData: AuthData | null,
     tableName: TableName,
     where: Where,
-    obj: any // TODO until i can get a working PickPrimaryKeys<'message'>
+    obj: any, // TODO until i can get a working PickPrimaryKeys<'message'>
   ): Promise<void> {
     // check admin bypass for mutations
     const adminBypassMutations = adminRoleMode === 'all' || adminRoleMode === 'mutations'

package/src/createSchemaFromDrizzle.ts

@@ -0,0 +1,3 @@
+export { drizzleZeroConfig as createSchemaFromDrizzle } from 'drizzle-zero'
+export { createZeroTableBuilder } from 'drizzle-zero'
+export { generateDrizzleSchemaFile } from './generate'

package/src/createUseQuery.tsx

@@ -1,5 +1,5 @@
 import { useQuery as zeroUseQuery } from '@rocicorp/zero/react'
-import { use, useMemo, useRef, type Context } from 'react'
+import { useContext, useMemo, useRef, type Context } from 'react'
 
 import { useZeroDebug } from './helpers/useZeroDebug'
 import { resolveQuery, type PlainQueryFn } from './resolveQuery'
@@ -29,13 +29,13 @@ export type UseQueryHook<Schema extends ZeroSchema> = {
   <TArg, TTable extends keyof Schema['tables'] & string, TReturn>(
     fn: PlainQueryFn<TArg, Query<TTable, Schema, TReturn>>,
     params: TArg,
-    options?: UseQueryOptions | boolean
+    options?: UseQueryOptions | boolean,
   ): QueryResult<TReturn>;
 
   // overload 2: plain function with no params
   <TTable extends keyof Schema['tables'] & string, TReturn>(
     fn: PlainQueryFn<void, Query<TTable, Schema, TReturn>>,
-    options?: UseQueryOptions | boolean
+    options?: UseQueryOptions | boolean,
   ): QueryResult<TReturn>
 }
 
@@ -49,7 +49,7 @@ export function createUseQuery<Schema extends ZeroSchema>({
   customQueries: AnyQueryRegistry
 }): UseQueryHook<Schema> {
   function useQuery(...args: any[]): any {
-    const disableMode = use(DisabledContext)
+    const disableMode = useContext(DisabledContext)
     const lastRef = useRef<any>(EMPTY_RESPONSE)
     const [fn, paramsOrOptions, optionsArg] = args
 

package/src/createZeroClient.tsx

@@ -4,7 +4,7 @@ import { createEmitter } from '@take-out/helpers'
 import {
   createContext,
   memo,
-  use,
+  useContext,
   useEffect,
   useMemo,
   useRef,
@@ -81,7 +81,7 @@ export function createZeroClient<
       registerQuery(fn, `${namespace}.${name}`)
       // wrap each plain function in defineQuery
       wrappedNamespaces[namespace][name] = defineQuery(({ args }: { args: any }) =>
-        fn(args)
+        fn(args),
       )
     }
   }
@@ -116,7 +116,7 @@ export function createZeroClient<
                 eb,
                 rawPerm || ((e: any) => e.and()),
                 args.objOrId,
-                table
+                table,
               )
             } finally {
               setEvaluatingPermission(false)
@@ -140,7 +140,7 @@ export function createZeroClient<
             eb,
             perm || ((e: any) => e.and()),
             args.objOrId,
-            table
+            table,
           )
         })
         .one()
@@ -172,7 +172,7 @@ export function createZeroClient<
     get(_, key) {
       if (latestZeroInstance === null) {
         throw new Error(
-          `Zero instance not initialized. Ensure ZeroProvider is mounted before accessing 'zero'.`
+          `Zero instance not initialized. Ensure ZeroProvider is mounted before accessing 'zero'.`,
         )
       }
       return Reflect.get(latestZeroInstance, key, latestZeroInstance)
@@ -194,9 +194,9 @@ export function createZeroClient<
     table: TableName | (string & {}),
     objOrId: string | Partial<Row<any>> | undefined,
     enabled = typeof objOrId !== 'undefined',
-    debug = false
+    debug = false,
   ): boolean | null {
-    const disableMode = use(DisabledContext)
+    const disableMode = useContext(DisabledContext)
     const lastRef = useRef<boolean | null>(null)
     const tableStr = table as string
     const checkFn = permissionCheckFns[tableStr]
@@ -209,7 +209,7 @@ export function createZeroClient<
     const [data, status] = useQuery(
       checkFn as any,
       { objOrId: objOrId as any, _uid },
-      { enabled: Boolean(!disableMode && enabled && objOrId && checkFn) }
+      { enabled: Boolean(!disableMode && enabled && objOrId && checkFn) },
     )
 
     if (debug) {
@@ -327,7 +327,7 @@ export function createZeroClient<
       }, [state, zeroEvents])
 
       return null
-    }
+    },
   )
 
   // preload data for a query into cache without materializing
@@ -335,16 +335,16 @@ export function createZeroClient<
   function preload<TArg, TTable extends keyof Schema['tables'] & string, TReturn>(
     fn: PlainQueryFn<TArg, Query<TTable, Schema, TReturn>>,
     params: TArg,
-    options?: PreloadOptions
+    options?: PreloadOptions,
   ): { cleanup: () => void; complete: Promise<void> }
   function preload<TTable extends keyof Schema['tables'] & string, TReturn>(
     fn: PlainQueryFn<void, Query<TTable, Schema, TReturn>>,
-    options?: PreloadOptions
+    options?: PreloadOptions,
   ): { cleanup: () => void; complete: Promise<void> }
   function preload(
     fnArg: any,
     paramsOrOptions?: any,
-    optionsArg?: PreloadOptions
+    optionsArg?: PreloadOptions,
   ): { cleanup: () => void; complete: Promise<void> } {
     const hasParams =
       optionsArg !== undefined || (paramsOrOptions && !('ttl' in paramsOrOptions))
@@ -357,10 +357,10 @@ export function createZeroClient<
 
   function getQuery<TArg, TTable extends keyof Schema['tables'] & string, TReturn>(
     fn: PlainQueryFn<TArg, Query<TTable, Schema, TReturn>>,
-    params: TArg
+    params: TArg,
   ): ReturnType<typeof resolveQuery<Schema>>
   function getQuery<TTable extends keyof Schema['tables'] & string, TReturn>(
-    fn: PlainQueryFn<void, Query<TTable, Schema, TReturn>>
+    fn: PlainQueryFn<void, Query<TTable, Schema, TReturn>>,
   ): ReturnType<typeof resolveQuery<Schema>>
   function getQuery(fn: any, params?: any) {
     return resolveQuery({ customQueries, fn, params })

package/src/createZeroServer.ts

@@ -48,7 +48,7 @@ type ServerMutate<Models extends GenericModels> = {
   [Key in keyof Models]: {
     [K in keyof Models[Key]['mutate']]: Models[Key]['mutate'][K] extends (
       ctx: MutatorContext,
-      arg: infer Arg
+      arg: infer Arg,
     ) => any
       ? (arg: Arg, options?: MutateOptions) => Promise<void>
       : (options?: MutateOptions) => Promise<void>
@@ -197,9 +197,9 @@ export function createZeroServer<
     // now finish
     if (!skipAsyncTasks && asyncTasks.length) {
       Promise.all(asyncTasks.map((task) => runWithAuthScope(authData, task))).catch(
-        (err) => {
+        (err: unknown) => {
           console.error(`[push] async tasks failed`, err)
-        }
+        },
       )
     }
 
@@ -219,7 +219,7 @@ export function createZeroServer<
     if (!queries) {
       throw new Error(
         'No queries registered with createZeroServer. ' +
-          'Pass the syncedQueries registry to createZeroServer via the queries option.'
+          'Pass the syncedQueries registry to createZeroServer via the queries option.',
       )
     }
 
@@ -249,7 +249,7 @@ export function createZeroServer<
                       eb,
                       perm,
                       objOrId,
-                      table
+                      table,
                     )
                   })
                   .one()
@@ -267,8 +267,8 @@ export function createZeroServer<
             return query.fn({ args, ctx: authData })
           },
           schema,
-          request
-        )
+          request,
+        ),
     )
 
     return {
@@ -280,7 +280,7 @@ export function createZeroServer<
     modelName: string,
     mutatorName: string,
     mutatorArg: unknown,
-    options?: MutateOptions
+    options?: MutateOptions,
   ) {
     let authData = options?.authData
 
@@ -321,12 +321,12 @@ export function createZeroServer<
     if (asyncTasks.length) {
       const resolvedAuth = authData ?? null
       const promise = Promise.all(
-        asyncTasks.map((t) => runWithAuthScope(resolvedAuth, t))
+        asyncTasks.map((t) => runWithAuthScope(resolvedAuth, t)),
       )
       if (options?.awaitEffects) {
         await promise
       } else {
-        promise.catch((err) => {
+        promise.catch((err: unknown) => {
           console.error(`[mutate] async tasks failed`, err)
         })
       }
@@ -343,7 +343,7 @@ export function createZeroServer<
             return (arg: unknown, options?: MutateOptions) =>
               runMutate(modelName, mutatorName, arg, options)
           },
-        }
+        },
       )
     },
   })
@@ -370,7 +370,7 @@ export function createZeroServer<
 
   function query<R>(
     cb: (q: QueryBuilder) => Query<any, Schema, R>,
-    authData?: AuthData | null
+    authData?: AuthData | null,
   ): Promise<HumanReadable<R>> {
     const run = () =>
       transaction(async (tx) => {