on-zero 0.4.26 → 0.4.27

package/dist/esm/index.js

@@ -9,6 +9,7 @@ import { ensureAuth, getAuth } from "./helpers/getAuth.mjs";
 import { setAuthData, setEnvironment } from "./state.mjs";
 export * from "./combineZeroClients.mjs";
 export * from "./createZeroClient.mjs";
+export * from "./httpPullTransport.mjs";
 export * from "./createUseQuery.mjs";
 export * from "./resolveQuery.mjs";
 export * from "./run.mjs";

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["ensureAuth","getAuth","setAuthData","setEnvironment","setRunner","defineQuery","defineQueries","clearZeroClientData","showZeroClientErrorOnce","resetShownZeroClientError"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASA,UAAA,EAAYC,OAAA,QAAe;AACpC,SAASC,WAAA,EAAaC,cAAA,QAAsB;AAE5C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,SAAA,QAAkC;AAC3C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,WAAA,EAAaC,aAAA,QAAqB;AAQ3C,SACEC,mBAAA,QAEK;AACP,SACEC,uBAAA,EACAC,yBAAA,QAGK","ignoreList":[]}
+{"version":3,"names":["ensureAuth","getAuth","setAuthData","setEnvironment","setRunner","defineQuery","defineQueries","clearZeroClientData","showZeroClientErrorOnce","resetShownZeroClientError"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASA,UAAA,EAAYC,OAAA,QAAe;AACpC,SAASC,WAAA,EAAaC,cAAA,QAAsB;AAE5C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,SAAA,QAAkC;AAC3C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,WAAA,EAAaC,aAAA,QAAqB;AAQ3C,SACEC,mBAAA,QAEK;AACP,SACEC,uBAAA,EACAC,yBAAA,QAGK","ignoreList":[]}

package/dist/esm/index.mjs

@@ -9,6 +9,7 @@ import { ensureAuth, getAuth } from "./helpers/getAuth.mjs";
 import { setAuthData, setEnvironment } from "./state.mjs";
 export * from "./combineZeroClients.mjs";
 export * from "./createZeroClient.mjs";
+export * from "./httpPullTransport.mjs";
 export * from "./createUseQuery.mjs";
 export * from "./resolveQuery.mjs";
 export * from "./run.mjs";

package/dist/esm/index.mjs.map

@@ -1 +1 @@
-{"version":3,"names":["ensureAuth","getAuth","setAuthData","setEnvironment","setRunner","defineQuery","defineQueries","clearZeroClientData","showZeroClientErrorOnce","resetShownZeroClientError"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASA,UAAA,EAAYC,OAAA,QAAe;AACpC,SAASC,WAAA,EAAaC,cAAA,QAAsB;AAE5C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,SAAA,QAAkC;AAC3C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,WAAA,EAAaC,aAAA,QAAqB;AAQ3C,SACEC,mBAAA,QAEK;AACP,SACEC,uBAAA,EACAC,yBAAA,QAGK","ignoreList":[]}
+{"version":3,"names":["ensureAuth","getAuth","setAuthData","setEnvironment","setRunner","defineQuery","defineQueries","clearZeroClientData","showZeroClientErrorOnce","resetShownZeroClientError"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASA,UAAA,EAAYC,OAAA,QAAe;AACpC,SAASC,WAAA,EAAaC,cAAA,QAAsB;AAE5C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,SAAA,QAAkC;AAC3C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,WAAA,EAAaC,aAAA,QAAqB;AAQ3C,SACEC,mBAAA,QAEK;AACP,SACEC,uBAAA,EACAC,yBAAA,QAGK","ignoreList":[]}

package/dist/esm/index.native.js

@@ -9,6 +9,7 @@ import { ensureAuth, getAuth } from "./helpers/getAuth.native.js";
 import { setAuthData, setEnvironment } from "./state.native.js";
 export * from "./combineZeroClients.native.js";
 export * from "./createZeroClient.native.js";
+export * from "./httpPullTransport.native.js";
 export * from "./createUseQuery.native.js";
 export * from "./resolveQuery.native.js";
 export * from "./run.native.js";

package/dist/esm/index.native.js.map

@@ -1 +1 @@
-{"version":3,"names":["ensureAuth","getAuth","setAuthData","setEnvironment","setRunner","defineQuery","defineQueries","clearZeroClientData","showZeroClientErrorOnce","resetShownZeroClientError"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASA,UAAA,EAAYC,OAAA,QAAe;AACpC,SAASC,WAAA,EAAaC,cAAA,QAAsB;AAE5C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,SAAA,QAAkC;AAC3C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,WAAA,EAAaC,aAAA,QAAqB;AAQ3C,SAAAC,mBAAA;AAAA,SACEC,uBAAA,EAAAC,yBAAA;AAAA,SAGFF,mBAAA,EACED,aAAA,EACAD,WAAA,EAAAL,UAGK,E","ignoreList":[]}
+{"version":3,"names":["ensureAuth","getAuth","setAuthData","setEnvironment","setRunner","defineQuery","defineQueries","clearZeroClientData","showZeroClientErrorOnce","resetShownZeroClientError"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASA,UAAA,EAAYC,OAAA,QAAe;AACpC,SAASC,WAAA,EAAaC,cAAA,QAAsB;AAE5C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,SAAA,QAAkC;AAC3C,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAASC,WAAA,EAAaC,aAAA,QAAqB;AAQ3C,SAAAC,mBAAA;AAAA,SACEC,uBAAA,EAAAC,yBAAA;AAAA,SAGFF,mBAAA,EACED,aAAA,EACAD,WAAA,EAAAL,UAGK,E","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "on-zero",
-  "version": "0.4.26",
+  "version": "0.4.27",
   "description": "A typed layer over @rocicorp/zero with queries, mutations, and permissions",
   "sideEffects": false,
   "source": "src/index.ts",
@@ -77,7 +77,7 @@
     }
   },
   "dependencies": {
-    "@take-out/helpers": "0.4.26",
+    "@take-out/helpers": "0.4.27",
     "chokidar": "^4.0.3",
     "citty": "^0.1.6",
     "valibot": "^1.1.0"

package/src/createZeroClient.tsx

@@ -13,6 +13,7 @@ import {
 } from 'react'
 
 import { createPermissions } from './createPermissions'
+import { ensureHttpPullTransport } from './httpPullTransport'
 import {
   createUseQuery,
   createUseQueryDirect,
@@ -331,11 +332,20 @@ export function createZeroClient<
     children,
     authData: authDataIn,
     disable,
+    transport,
+    pullIntervalMs = 30_000,
     ...props
   }: Omit<ZeroOptions<Schema, ZeroMutators>, 'schema' | 'mutators'> & {
     children: ReactNode
     authData?: AuthData | null
     disable?: boolean
+    // 'http-pull' runs the stock zero client over stateless HTTP pull/push
+    // (no websocket, no resident server state) by intercepting the sync
+    // socket for this instance's server origin. see httpPullTransport.ts.
+    transport?: 'http-pull'
+    // http-pull only: every open connection also pulls on this interval so
+    // server-initiated changes arrive without a client-side trigger
+    pullIntervalMs?: number
   }) => {
     const authData = (authDataIn ?? null) as AuthData
 
@@ -374,6 +384,7 @@ export function createZeroClient<
         .sort(([a], [b]) => (a < b ? -1 : 1)),
       hasAuth,
       generation,
+      transport,
     ])
 
     // create/rotate in an effect — commit-safe: a discarded concurrent render
@@ -391,6 +402,14 @@ export function createZeroClient<
           ZeroOptions<Schema, ZeroMutators>,
           'schema' | 'mutators'
         >
+        // install before construction so the instance's first connect goes
+        // through HTTP. per-origin idempotent — rotation reuses the install.
+        if (transport === 'http-pull') {
+          if (typeof options.server !== 'string') {
+            throw new Error(`transport 'http-pull' requires a server URL`)
+          }
+          ensureHttpPullTransport({ origin: options.server, pullIntervalMs })
+        }
         cached = {
           key: instanceKey,
           instance: new ZeroClient<Schema, ZeroMutators>({

package/src/httpPull/auth.test.ts

@@ -0,0 +1,208 @@
+import { afterEach, describe, expect, test } from 'vitest'
+
+import {
+  eventually,
+  sleep,
+  startZeroHttpHarness,
+  waitForComplete,
+  type ZeroHttpHarness,
+} from './testHarness'
+
+let harness: ZeroHttpHarness | undefined
+
+type UserRow = { id: string; name: string }
+type MemberRow = { id: string; projectId: string; userId: string }
+type ProjectWithMembers = {
+  id: string
+  ownerId: string
+  name: string
+  members: MemberRow[]
+}
+
+afterEach(async () => {
+  await harness?.close()
+  harness = undefined
+})
+
+describe('zero-http auth parity', () => {
+  test('real clients only emit rows visible to their auth token', async () => {
+    harness = await startZeroHttpHarness({
+      seed: {
+        user: [
+          { id: 'u1', name: 'ada' },
+          { id: 'u2', name: 'ben' },
+        ],
+        project: [
+          { id: 'p-u1', ownerId: 'u1', name: 'u1 private' },
+          { id: 'p-u2', ownerId: 'u2', name: 'u2 private' },
+          { id: 'p-shared', ownerId: 'u2', name: 'shared' },
+        ],
+        member: [
+          { id: 'm-u1-owner', projectId: 'p-u1', userId: 'u1' },
+          { id: 'm-u2-owner', projectId: 'p-u2', userId: 'u2' },
+          { id: 'm-shared-u1', projectId: 'p-shared', userId: 'u1' },
+          { id: 'm-shared-u2', projectId: 'p-shared', userId: 'u2' },
+        ],
+      },
+    })
+    const u1 = harness.createZero('u1')
+    const u2 = harness.createZero('u2')
+
+    const u1Users = u1.query.user.materialize()
+    const u1Projects = u1.query.project.related('members').materialize()
+    const u2Users = u2.query.user.materialize()
+    const u2Projects = u2.query.project.related('members').materialize()
+
+    const u1UserEmissions: UserRow[][] = []
+    const u1ProjectEmissions: ProjectWithMembers[][] = []
+    const u2UserEmissions: UserRow[][] = []
+    const u2ProjectEmissions: ProjectWithMembers[][] = []
+
+    const stops = [
+      captureRows(u1Users, u1UserEmissions, normalizeUsers),
+      captureRows(u1Projects, u1ProjectEmissions, normalizeProjects),
+      captureRows(u2Users, u2UserEmissions, normalizeUsers),
+      captureRows(u2Projects, u2ProjectEmissions, normalizeProjects),
+    ]
+
+    try {
+      const [u1UsersComplete, u1ProjectsComplete, u2UsersComplete, u2ProjectsComplete] =
+        await Promise.all([
+          waitForComplete<UserRow[]>(u1Users),
+          waitForComplete<ProjectWithMembers[]>(u1Projects),
+          waitForComplete<UserRow[]>(u2Users),
+          waitForComplete<ProjectWithMembers[]>(u2Projects),
+        ])
+
+      expect(normalizeUsers(u1UsersComplete)).toEqual([{ id: 'u1', name: 'ada' }])
+      expect(normalizeProjects(u1ProjectsComplete)).toEqual([
+        {
+          id: 'p-shared',
+          ownerId: 'u2',
+          name: 'shared',
+          members: [
+            { id: 'm-shared-u1', projectId: 'p-shared', userId: 'u1' },
+            { id: 'm-shared-u2', projectId: 'p-shared', userId: 'u2' },
+          ],
+        },
+        {
+          id: 'p-u1',
+          ownerId: 'u1',
+          name: 'u1 private',
+          members: [{ id: 'm-u1-owner', projectId: 'p-u1', userId: 'u1' }],
+        },
+      ])
+
+      expect(normalizeUsers(u2UsersComplete)).toEqual([{ id: 'u2', name: 'ben' }])
+      expect(normalizeProjects(u2ProjectsComplete)).toEqual([
+        {
+          id: 'p-shared',
+          ownerId: 'u2',
+          name: 'shared',
+          members: [
+            { id: 'm-shared-u1', projectId: 'p-shared', userId: 'u1' },
+            { id: 'm-shared-u2', projectId: 'p-shared', userId: 'u2' },
+          ],
+        },
+        {
+          id: 'p-u2',
+          ownerId: 'u2',
+          name: 'u2 private',
+          members: [{ id: 'm-u2-owner', projectId: 'p-u2', userId: 'u2' }],
+        },
+      ])
+
+      assertNoUserEmission(u1UserEmissions, 'u2')
+      assertNoProjectEmission(u1ProjectEmissions, 'p-u2', 'm-u2-owner')
+      assertNoUserEmission(u2UserEmissions, 'u1')
+      assertNoProjectEmission(u2ProjectEmissions, 'p-u1', 'm-u1-owner')
+
+      await harness.transport.pull()
+      await sleep(50)
+      assertNoUserEmission(u1UserEmissions, 'u2')
+      assertNoProjectEmission(u1ProjectEmissions, 'p-u2', 'm-u2-owner')
+      assertNoUserEmission(u2UserEmissions, 'u1')
+      assertNoProjectEmission(u2ProjectEmissions, 'p-u1', 'm-u1-owner')
+    } finally {
+      for (const stop of stops) stop()
+      u1Users.destroy()
+      u1Projects.destroy()
+      u2Users.destroy()
+      u2Projects.destroy()
+    }
+  })
+
+  test('unknown token 401 reaches needs-auth without materializing data', async () => {
+    harness = await startZeroHttpHarness({
+      seed: {
+        user: [{ id: 'u1', name: 'ada' }],
+        project: [{ id: 'p-u1', ownerId: 'u1', name: 'u1 private' }],
+        member: [{ id: 'm-u1-owner', projectId: 'p-u1', userId: 'u1' }],
+      },
+    })
+    const unknown = harness.createZero('missing')
+    const projects = unknown.query.project.related('members').materialize()
+    const emissions: ProjectWithMembers[][] = []
+    const stop = captureRows(projects, emissions, normalizeProjects)
+
+    try {
+      await eventually(() =>
+        expect(unknown.connection.state.current.name).toBe('needs-auth'),
+      )
+      await sleep(50)
+
+      expect(projects.data).toEqual([])
+      expect(emissions.every((emission) => emission.length === 0)).toBe(true)
+    } finally {
+      stop()
+      projects.destroy()
+    }
+  })
+})
+
+// listener data is Immutable<T>; normalize maps to fresh mutable rows
+function captureRows<T>(
+  view: { addListener(listener: (data: any, resultType: string) => void): () => void },
+  emissions: T[],
+  normalize: (data: T) => T,
+) {
+  return view.addListener((data) => {
+    emissions.push(normalize(data))
+  })
+}
+
+function assertNoUserEmission(emissions: UserRow[][], privateUserID: string) {
+  for (const emission of emissions) {
+    expect(emission.map((row) => row.id)).not.toContain(privateUserID)
+  }
+}
+
+function assertNoProjectEmission(
+  emissions: ProjectWithMembers[][],
+  privateProjectID: string,
+  privateMemberID: string,
+) {
+  for (const emission of emissions) {
+    expect(emission.map((row) => row.id)).not.toContain(privateProjectID)
+    expect(
+      emission.flatMap((row) => row.members.map((member) => member.id)),
+    ).not.toContain(privateMemberID)
+  }
+}
+
+function normalizeUsers(users: UserRow[]) {
+  return clone(users).sort((a, b) => a.id.localeCompare(b.id))
+}
+
+function normalizeProjects(projects: ProjectWithMembers[]) {
+  return clone(projects)
+    .map((project) => ({
+      ...project,
+      members: [...project.members].sort((a, b) => a.id.localeCompare(b.id)),
+    }))
+    .sort((a, b) => a.id.localeCompare(b.id))
+}
+
+function clone<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T
+}

package/src/httpPull/churn.test.ts

@@ -0,0 +1,147 @@
+import { afterEach, expect, test } from 'vitest'
+
+import {
+  eventually,
+  startZeroHttpHarness,
+  waitForComplete,
+  type ZeroHttpHarness,
+} from './testHarness'
+
+let harness: ZeroHttpHarness | undefined
+
+afterEach(async () => {
+  await harness?.close()
+  harness = undefined
+})
+
+test('mutation burst converges while explicit pulls churn', async () => {
+  let clientGroupID = ''
+  const pullErrors: unknown[] = []
+
+  harness = await startZeroHttpHarness({
+    seed: {
+      user: [{ id: 'u1', name: 'ada' }],
+      project: [],
+      member: [],
+    },
+    interceptFetch: (next) => async (input, init) => {
+      const body = init?.body ? JSON.parse(String(init.body)) : undefined
+      if (body?.clientGroupID) clientGroupID = body.clientGroupID
+      return next(input, init)
+    },
+  })
+  const zero = harness.createZero('u1')
+  const view = zero.query.project.materialize()
+  await waitForComplete<any[]>(view)
+
+  const timer = setInterval(() => {
+    void harness?.transport.pull().catch((error) => pullErrors.push(error))
+  }, 2)
+
+  try {
+    const mutations = Array.from({ length: 15 }, (_, index) =>
+      zero.mutate.project.create({
+        id: `p${index + 1}`,
+        ownerId: 'u1',
+        name: `project ${index + 1}`,
+      }),
+    )
+    await Promise.all(mutations.map((mutation) => mutation.client))
+    await Promise.all(mutations.map((mutation) => mutation.server))
+    await harness.transport.pull()
+
+    await eventually(() => {
+      expect(projectIDs(view.data)).toEqual(
+        Array.from({ length: 15 }, (_, index) => `p${index + 1}`).sort(),
+      )
+    })
+  } finally {
+    clearInterval(timer)
+  }
+
+  expect(pullErrors).toEqual([])
+  expect(zero.connection.state.current.name).toBe('connected')
+  expect(
+    harness.server
+      .rows('project')
+      .map((row) => row.id)
+      .sort(),
+  ).toEqual(Array.from({ length: 15 }, (_, index) => `p${index + 1}`).sort())
+
+  const pull = await rawPull(harness, clientGroupID)
+  expect(Object.values(pull.lastMutationIDChanges)).toContain(15)
+  view.destroy()
+})
+
+test('two clients sharing a client group converge without cookie fights', async () => {
+  const clientGroups = new Set<string>()
+  const clientIDs = new Set<string>()
+
+  harness = await startZeroHttpHarness({
+    seed: {
+      user: [{ id: 'u1', name: 'ada' }],
+      project: [{ id: 'p1', ownerId: 'u1', name: 'first' }],
+      member: [],
+    },
+    interceptFetch: (next) => async (input, init) => {
+      const body = init?.body ? JSON.parse(String(init.body)) : undefined
+      if (body?.clientGroupID) clientGroups.add(body.clientGroupID)
+      if (body?.clientID) clientIDs.add(body.clientID)
+      return next(input, init)
+    },
+  })
+
+  const sharedStorageKey = 'zero-http-shared-client-group'
+  const zeroA = harness.createZero('u1', { storageKey: sharedStorageKey })
+  const zeroB = harness.createZero('u1', { storageKey: sharedStorageKey })
+  const viewA = zeroA.query.project.materialize()
+  const viewB = zeroB.query.project.materialize()
+  await waitForComplete<any[]>(viewA)
+  await waitForComplete<any[]>(viewB)
+
+  expect(harness.transport.connections).toBe(2)
+  expect(clientGroups.size).toBe(1)
+  expect(clientIDs.size).toBe(2)
+
+  const mutation = zeroA.mutate.project.create({
+    id: 'p2',
+    ownerId: 'u1',
+    name: 'second',
+  })
+  await mutation.client
+  await mutation.server
+  await harness.transport.pull()
+
+  await eventually(() => {
+    expect(projectIDs(viewA.data)).toEqual(['p1', 'p2'])
+    expect(projectIDs(viewB.data)).toEqual(['p1', 'p2'])
+  })
+  expect(zeroA.connection.state.current.name).toBe('connected')
+  expect(zeroB.connection.state.current.name).toBe('connected')
+
+  viewA.destroy()
+  viewB.destroy()
+})
+
+async function rawPull(harness: ZeroHttpHarness, clientGroupID: string) {
+  const response = await fetch(`${harness.server.url}/pull`, {
+    method: 'POST',
+    headers: {
+      authorization: 'Bearer token-u1',
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      clientID: 'raw-pull',
+      clientGroupID,
+      cookie: null,
+    }),
+  })
+  expect(response.status).toBe(200)
+  return response.json() as Promise<{
+    lastMutationIDChanges: Record<string, number>
+  }>
+}
+
+function projectIDs(rows: any[]) {
+  return rows.map((row) => row.id).sort()
+}

package/src/httpPull/fixtureSchema.ts

@@ -0,0 +1,82 @@
+import { createSchema, relationships, string, table } from '@rocicorp/zero'
+
+import type { Transaction } from '@rocicorp/zero'
+
+const user = table('user')
+  .columns({
+    id: string(),
+    name: string(),
+  })
+  .primaryKey('id')
+
+const project = table('project')
+  .columns({
+    id: string(),
+    ownerId: string(),
+    name: string(),
+  })
+  .primaryKey('id')
+
+const member = table('member')
+  .columns({
+    id: string(),
+    projectId: string(),
+    userId: string(),
+  })
+  .primaryKey('id')
+
+export const zeroHttpFixtureSchema = createSchema({
+  tables: [user, project, member],
+  relationships: [
+    relationships(project, ({ many }) => ({
+      members: many({
+        sourceField: ['id'],
+        destField: ['projectId'],
+        destSchema: member,
+      }),
+    })),
+  ],
+  enableLegacyQueries: true,
+})
+
+type FixtureTransaction = Transaction<typeof zeroHttpFixtureSchema>
+
+export type ProjectCreateArgs = {
+  id: string
+  ownerId: string
+  name: string
+}
+
+export type ProjectRenameArgs = {
+  id: string
+  name: string
+}
+
+export type MemberAddArgs = {
+  id: string
+  projectId: string
+  userId: string
+}
+
+export type MemberRemoveArgs = {
+  id: string
+}
+
+export const zeroHttpFixtureMutators = {
+  project: {
+    create: async (tx: FixtureTransaction, args: ProjectCreateArgs) => {
+      await tx.mutate.project.insert(args)
+    },
+    rename: async (tx: FixtureTransaction, args: ProjectRenameArgs) => {
+      await tx.mutate.project.update(args)
+    },
+  },
+  member: {
+    add: async (tx: FixtureTransaction, args: MemberAddArgs) => {
+      await tx.mutate.member.insert(args)
+    },
+    remove: async (tx: FixtureTransaction, args: MemberRemoveArgs) => {
+      await tx.mutate.member.delete({ id: args.id })
+    },
+  },
+}