on-zero 0.7.2-1784530701923 → 0.7.2

package/src/createZeroServer.test.ts

@@ -0,0 +1,421 @@
+import { describe, expect, test, vi } from 'vitest'
+
+import { createZeroServer } from './createZeroServer'
+import { zeroHttpFixtureSchema } from './httpPull/fixtureSchema'
+
+class FakePgClient {
+  lastMutationID = 0
+  pendingLastMutationID: number | undefined
+  mutationResultInserts: unknown[][] = []
+
+  async query(sql: string, params: unknown[] = []) {
+    if (sql === 'BEGIN') {
+      this.pendingLastMutationID = undefined
+      return { rows: [] }
+    }
+
+    if (sql === 'COMMIT') {
+      if (this.pendingLastMutationID !== undefined) {
+        this.lastMutationID = this.pendingLastMutationID
+      }
+      this.pendingLastMutationID = undefined
+      return { rows: [] }
+    }
+
+    if (sql === 'ROLLBACK') {
+      this.pendingLastMutationID = undefined
+      return { rows: [] }
+    }
+
+    if (sql.includes('.clients') && sql.includes('RETURNING "lastMutationID"')) {
+      const nextMutationID = this.lastMutationID + 1
+      this.pendingLastMutationID = nextMutationID
+      return { rows: [{ lastMutationID: nextMutationID }] }
+    }
+
+    if (sql.includes('information_schema.columns')) {
+      return {
+        rows: [
+          ...schemaRows('user', ['id', 'name']),
+          ...schemaRows('project', ['id', 'ownerId', 'name']),
+          ...schemaRows('member', ['id', 'projectId', 'userId']),
+        ],
+      }
+    }
+
+    if (
+      sql.includes('INSERT INTO "zero_0"."mutations"') ||
+      sql.includes('INSERT INTO "zero_0".mutations')
+    ) {
+      this.mutationResultInserts.push(params)
+      return { rows: [] }
+    }
+
+    throw new Error(`unexpected fake pg query: ${sql}`)
+  }
+}
+
+function schemaRows(table: string, columns: string[]) {
+  return columns.map((column) => ({
+    schema: 'public',
+    table,
+    column,
+    dataType: 'text',
+    length: null,
+    precision: null,
+    scale: null,
+    typtype: 'b',
+    typename: 'text',
+    elemTyptype: null,
+    elemTypname: null,
+  }))
+}
+
+function pushRequest(mutationIDs: number | number[]) {
+  const ids = Array.isArray(mutationIDs) ? mutationIDs : [mutationIDs]
+  return new Request('http://localhost/push?schema=zero_0&appID=zero', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      clientGroupID: 'cg1',
+      mutations: ids.map((mutationID) => ({
+        type: 'custom',
+        id: mutationID,
+        clientID: 'client-a',
+        name: 'project.touch',
+        args: [{}],
+        timestamp: 1,
+      })),
+      pushVersion: 1,
+      timestamp: 1,
+      requestID: `req-${ids.join('-')}`,
+    }),
+  })
+}
+
+describe('createZeroServer mutation recovery', () => {
+  test('discards async tasks from a rolled-back PostgreSQL mutation', async () => {
+    const pg = new FakePgClient()
+    let effectRuns = 0
+    const consoleWarn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const zeroServer = createZeroServer({
+      schema: zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async ({ server }) => {
+              server?.enqueueTask(async () => {
+                effectRuns++
+              })
+              throw new Error('rejected')
+            },
+          },
+        },
+      },
+      createServerActions: () => ({}),
+      pool: pg as any,
+    })
+
+    const result = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1),
+      skipAsyncTasks: true,
+    })
+
+    expect((result.response as any).mutations[0].result).toMatchObject({
+      error: 'app',
+      message: 'rejected',
+    })
+    expect(result.asyncTasks).toEqual([])
+    expect(effectRuns).toBe(0)
+    expect(consoleWarn).toHaveBeenCalledWith(
+      'PushProcessor',
+      expect.stringContaining('Error processing mutation'),
+      expect.stringContaining('rejected'),
+    )
+    consoleWarn.mockRestore()
+  })
+
+  test('awaits barrier tasks before resolving the push response', async () => {
+    const pg = new FakePgClient()
+    let releaseBarrier!: () => void
+    let markBarrierStarted!: () => void
+    const barrierStarted = new Promise<void>((resolve) => {
+      markBarrierStarted = resolve
+    })
+    const barrier = new Promise<void>((resolve) => {
+      releaseBarrier = resolve
+    })
+    const zeroServer = createZeroServer({
+      schema: zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async ({ server }) => {
+              server?.enqueueTask(
+                async () => {
+                  markBarrierStarted()
+                  await barrier
+                },
+                { barrier: true },
+              )
+            },
+          },
+        },
+      },
+      createServerActions: () => ({}),
+      pool: pg as any,
+    })
+
+    let responseResolved = false
+    const resultPromise = zeroServer
+      .handleMutationRequest({
+        authData: null,
+        request: pushRequest(1),
+      })
+      .then((result) => {
+        responseResolved = true
+        return result
+      })
+
+    await barrierStarted
+    await Promise.resolve()
+    expect(responseResolved).toBe(false)
+
+    releaseBarrier()
+    const result = await resultPromise
+    expect((result.response as any).mutations[0].result).toEqual({})
+  })
+
+  test('does not fail the push when a background task rejects', async () => {
+    const pg = new FakePgClient()
+    const error = new Error('background failed')
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const zeroServer = createZeroServer({
+      schema: zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async ({ server }) => {
+              server?.enqueueTask(async () => {
+                throw error
+              })
+            },
+          },
+        },
+      },
+      createServerActions: () => ({}),
+      pool: pg as any,
+    })
+
+    const result = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1),
+    })
+
+    expect((result.response as any).mutations[0].result).toEqual({})
+    await vi.waitFor(() => {
+      expect(consoleError).toHaveBeenCalledWith('[on-zero] async task failed', error)
+    })
+    consoleError.mockRestore()
+  })
+
+  test('registers a promise that settles every background task with the request scheduler', async () => {
+    const pg = new FakePgClient()
+    const error = new Error('background failed')
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+    let releaseSibling!: () => void
+    const siblingGate = new Promise<void>((resolve) => {
+      releaseSibling = resolve
+    })
+    let siblingFinished = false
+    let scheduled: Promise<void> | undefined
+    const zeroServer = createZeroServer({
+      schema: zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async ({ server }) => {
+              server?.enqueueTask(async () => {
+                throw error
+              })
+              server?.enqueueTask(async () => {
+                await siblingGate
+                siblingFinished = true
+              })
+            },
+          },
+        },
+      },
+      createServerActions: () => ({}),
+      pool: pg as any,
+    })
+
+    const result = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1),
+      scheduleBackgroundTask: (promise) => {
+        scheduled = promise
+      },
+    })
+
+    expect((result.response as any).mutations[0].result).toEqual({})
+    expect(scheduled).toBeInstanceOf(Promise)
+    expect(siblingFinished).toBe(false)
+
+    let scheduledSettled = false
+    void scheduled!.then(() => {
+      scheduledSettled = true
+    })
+    await Promise.resolve()
+    expect(scheduledSettled).toBe(false)
+
+    releaseSibling()
+    await scheduled
+
+    expect(siblingFinished).toBe(true)
+    expect(consoleError).toHaveBeenCalledWith('[on-zero] async task failed', error)
+    consoleError.mockRestore()
+  })
+
+  test('awaits background tasks when the request has no scheduler', async () => {
+    const pg = new FakePgClient()
+    let markTaskStarted!: () => void
+    const taskStarted = new Promise<void>((resolve) => {
+      markTaskStarted = resolve
+    })
+    let releaseTask!: () => void
+    const taskGate = new Promise<void>((resolve) => {
+      releaseTask = resolve
+    })
+    const zeroServer = createZeroServer({
+      schema: zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async ({ server }) => {
+              server?.enqueueTask(async () => {
+                markTaskStarted()
+                await taskGate
+              })
+            },
+          },
+        },
+      },
+      createServerActions: () => ({}),
+      pool: pg as any,
+    })
+
+    let responseResolved = false
+    const resultPromise = zeroServer
+      .handleMutationRequest({
+        authData: null,
+        request: pushRequest(1),
+      })
+      .then((result) => {
+        responseResolved = true
+        return result
+      })
+
+    await taskStarted
+    await Promise.resolve()
+    expect(responseResolved).toBe(false)
+
+    releaseTask()
+    const result = await resultPromise
+    expect((result.response as any).mutations[0].result).toEqual({})
+  })
+
+  test('persists alreadyProcessed duplicate results for zero-cache recovery rows', async () => {
+    const pg = new FakePgClient()
+    const consoleWarn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const zeroServer = createZeroServer({
+      schema: zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async () => {},
+          },
+        },
+      },
+      createServerActions: () => ({}),
+      pool: pg as any,
+    })
+
+    const first = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1),
+    })
+
+    expect((first.response as any).mutations[0].result).toEqual({})
+    expect(pg.lastMutationID).toBe(1)
+    expect(pg.mutationResultInserts).toEqual([])
+
+    const duplicate = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1),
+    })
+
+    const duplicateResult = (duplicate.response as any).mutations[0].result
+    expect(duplicateResult.error).toBe('alreadyProcessed')
+    expect(pg.lastMutationID).toBe(1)
+    expect(pg.mutationResultInserts).toEqual([
+      [
+        'cg1',
+        'client-a',
+        1,
+        JSON.stringify({
+          error: 'alreadyProcessed',
+          details: duplicateResult.details,
+        }),
+      ],
+    ])
+    expect(consoleWarn).not.toHaveBeenCalled()
+    consoleWarn.mockRestore()
+  })
+
+  test('persists only alreadyProcessed results in a mixed recovery push', async () => {
+    const pg = new FakePgClient()
+    const zeroServer = createZeroServer({
+      schema: zeroHttpFixtureSchema,
+      models: {
+        project: {
+          mutate: {
+            touch: async () => {},
+          },
+        },
+      },
+      createServerActions: () => ({}),
+      pool: pg as any,
+    })
+
+    await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest(1),
+    })
+
+    const mixed = await zeroServer.handleMutationRequest({
+      authData: null,
+      request: pushRequest([1, 2]),
+    })
+
+    const results = (mixed.response as any).mutations.map((mutation: any) => ({
+      id: mutation.id.id,
+      result: mutation.result,
+    }))
+    expect(results[0].result.error).toBe('alreadyProcessed')
+    expect(results[1]).toEqual({ id: 2, result: {} })
+    expect(pg.lastMutationID).toBe(2)
+    expect(pg.mutationResultInserts).toEqual([
+      [
+        'cg1',
+        'client-a',
+        1,
+        JSON.stringify({
+          error: 'alreadyProcessed',
+          details: results[0].result.details,
+        }),
+      ],
+    ])
+  })
+})

package/src/createZeroServer.ts

@@ -0,0 +1,105 @@
+import { zeroNodePg } from '@rocicorp/zero/server/adapters/pg'
+import { assertString } from '@take-out/helpers'
+import { Pool } from 'pg'
+
+import { createZeroServerCore } from './createZeroServerCore'
+
+import type {
+  PersistAlreadyProcessedArgs,
+  ZeroServer,
+  ZeroServerCommonOptions,
+  ZeroServerDatabase,
+} from './createZeroServerCore'
+import type { GenericModels } from './types'
+import type { Schema as ZeroSchema } from '@rocicorp/zero'
+import type { NodePgTransaction } from '@rocicorp/zero/server/adapters/pg'
+
+export type {
+  BackgroundTaskScheduler,
+  HandleMutationRequestOptions,
+  ValidateMutationArgs,
+  ValidateMutationFn,
+  ValidateQueryArgs,
+  ValidateQueryFn,
+} from './createZeroServerCore'
+
+export function createZeroServer<
+  Schema extends ZeroSchema,
+  Models extends GenericModels,
+  ServerActions extends Record<string, unknown>,
+>({
+  database,
+  pool: externalPool,
+  ...options
+}: ZeroServerCommonOptions<Schema, Models, ServerActions> & {
+  /**
+   * Optional pre-built Pool-like object, such as a PGlite wrapper.
+   * When provided, database is not required.
+   */
+  pool?: NodePgTransaction
+  /**
+   * The PostgreSQL connection string.
+   * Not required when pool is provided.
+   */
+  database?: string
+}): ZeroServer<Schema, Models, ServerActions> {
+  let pool: NodePgTransaction
+  if (externalPool) {
+    pool = externalPool
+  } else {
+    const dbString = assertString(database, 'createZeroServer "database"')
+    const pgPool = new Pool({
+      connectionString: dbString,
+      ssl: dbString.includes('sslmode=require')
+        ? { rejectUnauthorized: false }
+        : undefined,
+    })
+    pgPool.on('error', (error) => {
+      console.error('[on-zero] pool error', error.message)
+    })
+    pgPool.on('connect', (client) => {
+      client.on('error', (error) => {
+        console.error('[on-zero] client error', error.message)
+      })
+    })
+    pool = pgPool
+  }
+
+  const databaseProvider = zeroNodePg(options.schema, pool)
+
+  return createZeroServerCore({
+    ...options,
+    createDatabase: () => databaseProvider as unknown as ZeroServerDatabase,
+    persistAlreadyProcessed: (args) => persistAlreadyProcessedMutationResults(pool, args),
+  })
+}
+
+async function persistAlreadyProcessedMutationResults(
+  pool: NodePgTransaction,
+  { clientGroupID, mutations, upstreamSchema }: PersistAlreadyProcessedArgs,
+) {
+  const table = `${quotePgIdentifier(upstreamSchema)}."mutations"`
+  const values = mutations
+    .map((_, index) => {
+      const offset = index * 4
+      return `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}::json)`
+    })
+    .join(', ')
+  const params = mutations.flatMap((mutation) => [
+    clientGroupID,
+    mutation.id.clientID,
+    mutation.id.id,
+    JSON.stringify(mutation.result),
+  ])
+
+  await pool.query(
+    `INSERT INTO ${table} ("clientGroupID", "clientID", "mutationID", "result")
+     VALUES ${values}
+     ON CONFLICT ("clientGroupID", "clientID", "mutationID") DO NOTHING`,
+    params,
+  )
+}
+
+function quotePgIdentifier(value: string) {
+  return `"${value.replaceAll('"', '""')}"`
+}