@svgrid/enterprise 2.5.2 → 2.6.0

package/src/sveltekit/transport-scope.test.ts

@@ -1,125 +0,0 @@
-/**
- * Row scoping (`scope`) - the mechanism behind multi-tenancy.
- *
- * Scoping reads is the easy half and the useless half on its own: if create can
- * plant a row in another tenant, or update/delete can reach one by guessing an
- * id, the isolation is decorative. These tests cover all four paths plus the
- * ways a client might try to talk its way out of the scope.
- */
-import { describe, expect, it } from 'vitest'
-import type { ServerRequest } from '@svgrid/grid'
-import type { EntitySchema } from '../schema'
-import { createInMemoryDataSource } from './in-memory'
-import { createKitDataSource, createKitHandlers } from './transport'
-
-type Row = { id: string; name: string; tenantId: string }
-
-const schema: EntitySchema<Row> = {
-  name: 'notes',
-  fields: [
-    { field: 'id', type: 'text', primaryKey: true },
-    { field: 'name', type: 'text' },
-    { field: 'tenantId', type: 'text' },
-  ],
-}
-
-const seed: Row[] = [
-  { id: '1', name: 'Acme note', tenantId: 'acme' },
-  { id: '2', name: 'Acme second', tenantId: 'acme' },
-  { id: '3', name: 'Globex secret', tenantId: 'globex' },
-]
-
-/** Wire a client to handlers scoped to `tenant` (null = unscoped/super-admin). */
-function wire(tenant: string | null, opts: { throwOnResolve?: boolean } = {}) {
-  const backend = createInMemoryDataSource(seed.map((r) => ({ ...r })), schema)
-  const handlers = createKitHandlers({
-    schema,
-    source: backend,
-    scope: () => {
-      if (opts.throwOnResolve) throw new Error('no tenant on session')
-      return tenant ? { field: 'tenantId', value: tenant } : null
-    },
-  })
-  const fakeFetch = (url: string, init?: RequestInit) =>
-    handlers.handle(new Request(`http://localhost${url}`, init))
-  const client = createKitDataSource<Row>({ endpoint: '/api/notes', fetch: fakeFetch })
-  return { client, backend, handlers }
-}
-
-const req = (partial: Partial<ServerRequest> = {}): ServerRequest => ({
-  startRow: 0, endRow: 50, pageIndex: 0, pageSize: 50, sortModel: [], filterModel: {}, ...partial,
-})
-
-describe('row scoping: reads', () => {
-  it('returns only the caller tenant\'s rows', async () => {
-    const { client } = wire('acme')
-    const { rows } = await client.getRows(req())
-    expect(rows.map((r) => r.id)).toEqual(['1', '2'])
-  })
-
-  it('is unscoped when the resolver returns null', async () => {
-    const { client } = wire(null)
-    const { rows } = await client.getRows(req())
-    expect(rows).toHaveLength(3)
-  })
-
-  it('a client-supplied tenant filter cannot widen the scope', async () => {
-    const { client } = wire('acme')
-    // Ask for globex explicitly - the server's predicate is written last.
-    const { rows } = await client.getRows(
-      req({ filterModel: { columns: { tenantId: { operator: 'equals', value: 'globex' } } } }),
-    )
-    expect(rows.every((r) => r.tenantId === 'acme')).toBe(true)
-  })
-})
-
-describe('row scoping: writes', () => {
-  it('stamps the tenant on create, overriding what the client sent', async () => {
-    const { client, backend } = wire('acme')
-    const created = await client.createRow!({ id: '9', name: 'New', tenantId: 'globex' } as Partial<Row>)
-    expect(created.tenantId).toBe('acme')
-    const { rows } = await backend.getRows(req())
-    expect(rows.find((r) => r.id === '9')!.tenantId).toBe('acme')
-  })
-
-  it('rejects updating a row in another tenant', async () => {
-    const { client } = wire('acme')
-    await expect(client.updateRow!('3', { name: 'hacked' })).rejects.toThrow()
-  })
-
-  it('rejects deleting a row in another tenant', async () => {
-    const { client } = wire('acme')
-    await expect(client.deleteRow!('3')).rejects.toThrow()
-  })
-
-  it('leaves the other tenant\'s data untouched after a rejected write', async () => {
-    const { client, backend } = wire('acme')
-    await client.updateRow!('3', { name: 'hacked' }).catch(() => {})
-    await client.deleteRow!('3').catch(() => {})
-    const { rows } = await backend.getRows(req())
-    expect(rows.find((r) => r.id === '3')).toEqual({ id: '3', name: 'Globex secret', tenantId: 'globex' })
-  })
-
-  it('allows updating and deleting the caller\'s own rows', async () => {
-    const { client } = wire('acme')
-    const updated = await client.updateRow!('1', { name: 'Renamed' })
-    expect(updated.name).toBe('Renamed')
-    await expect(client.deleteRow!('2')).resolves.not.toThrow()
-  })
-
-  it('a patch cannot move a row into another tenant', async () => {
-    const { client, backend } = wire('acme')
-    await client.updateRow!('1', { tenantId: 'globex' } as Partial<Row>)
-    const { rows } = await backend.getRows(req())
-    expect(rows.find((r) => r.id === '1')!.tenantId).toBe('acme')
-  })
-})
-
-describe('row scoping: resolver failure', () => {
-  it('rejects rather than falling through to an unscoped query', async () => {
-    // The dangerous failure mode: "I cannot tell which tenant you are" must not
-    // mean "show everything".
-    const { client } = wire('acme', { throwOnResolve: true })
-    await expect(client.getRows(req())).rejects.toThrow()
-  })
-})

package/src/sveltekit/transport.test.ts

@@ -1,201 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { ServerRequest } from '@svgrid/grid'
-import type { EntitySchema } from '../schema'
-import { createInMemoryDataSource } from './in-memory'
-import { createKitDataSource, createKitHandlers } from './transport'
-
-type Customer = { id: string; name: string; age: number; tier: string }
-
-const schema: EntitySchema<Customer> = {
-  name: 'customers',
-  fields: [
-    { field: 'id', type: 'text', primaryKey: true },
-    { field: 'name', type: 'text' },
-    { field: 'age', type: 'number' },
-    { field: 'tier', type: 'enum' },
-  ],
-}
-
-const seed: Customer[] = [
-  { id: '1', name: 'Ann', age: 30, tier: 'pro' },
-  { id: '2', name: 'Bob', age: 41, tier: 'free' },
-]
-
-/**
- * Stand up the full loop in-process: an in-memory backend behind the server
- * handlers, and a client whose `fetch` routes straight into those handlers via
- * a real `Request`. This exercises the wire protocol end to end without a
- * running SvelteKit server.
- */
-function wireClientToServer() {
-  const backend = createInMemoryDataSource(seed, schema)
-  const handlers = createKitHandlers({ schema, source: backend })
-  const fakeFetch = (url: string, init?: RequestInit) =>
-    handlers.handle(new Request(`http://localhost${url}`, init))
-  const client = createKitDataSource<Customer>({ endpoint: '/api/customers', fetch: fakeFetch })
-  return { client, backend }
-}
-
-const req = (partial: Partial<ServerRequest>): ServerRequest => ({
-  startRow: 0,
-  endRow: 50,
-  pageIndex: 0,
-  pageSize: 50,
-  sortModel: [],
-  filterModel: {},
-  ...partial,
-})
-
-describe('SvelteKit transport round trip', () => {
-  it('getRows travels client -> server -> backend and back', async () => {
-    const { client } = wireClientToServer()
-    const res = await client.getRows(req({ sortModel: [{ id: 'age', desc: true }] }))
-    expect(res.rowCount).toBe(2)
-    expect(res.rows[0]?.name).toBe('Bob')
-  })
-
-  it('createRow / updateRow / deleteRow mutate the backend through the protocol', async () => {
-    const { client, backend } = wireClientToServer()
-
-    const created = await client.createRow({ id: '3', name: 'Cara', age: 25, tier: 'pro' })
-    expect(created.name).toBe('Cara')
-    expect(backend.rows()).toHaveLength(3)
-
-    const updated = await client.updateRow('3', { age: 26 })
-    expect(updated.age).toBe(26)
-
-    await client.deleteRow('1')
-    expect(backend.rows().some((r) => r.id === '1')).toBe(false)
-  })
-
-  it('surfaces a backend error as a rejected fetch', async () => {
-    const { client } = wireClientToServer()
-    // updating a non-existent id makes the in-memory source throw -> 500
-    await expect(client.updateRow('nope', { age: 1 })).rejects.toThrow(/svgrid kit: 500/)
-  })
-
-  it('returns 405 when the backend lacks a writer', async () => {
-    const readOnly = { getRows: async () => ({ rows: [], rowCount: 0 }) }
-    const handlers = createKitHandlers({ schema, source: readOnly })
-    const client = createKitDataSource<Customer>({
-      endpoint: '/x',
-      fetch: (url, init) => handlers.handle(new Request(`http://localhost${url}`, init)),
-    })
-    await expect(client.createRow({ name: 'x' })).rejects.toThrow(/405/)
-  })
-})
-
-describe('createKitHandlers server-enforced validation', () => {
-  const vSchema: EntitySchema<Customer> = {
-    name: 'customers',
-    fields: [
-      { field: 'id', type: 'text', primaryKey: true },
-      { field: 'name', type: 'text', required: true },
-      { field: 'age', type: 'number', min: 0, max: 120 },
-      { field: 'tier', type: 'enum' },
-    ],
-  }
-  const post = (h: ReturnType<typeof createKitHandlers>, body: unknown) =>
-    h.handle(new Request('http://localhost/api/customers', { method: 'POST', body: JSON.stringify(body) }))
-
-  it('rejects a constraint-violating create with 422 + fieldErrors', async () => {
-    const handlers = createKitHandlers({ schema: vSchema, source: createInMemoryDataSource<Customer>([], vSchema), validate: true })
-    const res = await post(handlers, { kind: 'mutate', op: 'create', input: { id: '9', age: 999 } })
-    expect(res.status).toBe(422)
-    const body = await res.json()
-    expect(body.fieldErrors.name).toBeTruthy() // required missing
-    expect(body.fieldErrors.age).toBeTruthy()  // above max
-  })
-
-  it('accepts a valid create', async () => {
-    const handlers = createKitHandlers({ schema: vSchema, source: createInMemoryDataSource<Customer>([], vSchema), validate: true })
-    const res = await post(handlers, { kind: 'mutate', op: 'create', input: { id: '9', name: 'Zoe', age: 22 } })
-    expect(res.status).toBe(200)
-  })
-
-  it('validates only the fields present in an update patch', async () => {
-    const handlers = createKitHandlers({ schema: vSchema, source: createInMemoryDataSource<Customer>(seed, vSchema), validate: true })
-    // omits required `name` (fine - not in the patch), valid age -> 200
-    expect((await post(handlers, { kind: 'mutate', op: 'update', id: '1', patch: { age: 33 } })).status).toBe(200)
-    // bad age in the patch -> 422
-    expect((await post(handlers, { kind: 'mutate', op: 'update', id: '1', patch: { age: -5 } })).status).toBe(422)
-  })
-
-  it('is off by default (no validation unless opted in)', async () => {
-    const handlers = createKitHandlers({ schema: vSchema, source: createInMemoryDataSource<Customer>([], vSchema) })
-    const res = await post(handlers, { kind: 'mutate', op: 'create', input: { id: '9', age: 999 } })
-    expect(res.status).toBe(200)
-  })
-
-  it('business-rule hooks transform the payload, reject writes, and fire after-effects', async () => {
-    const audited: string[] = []
-    const handlers = createKitHandlers({
-      schema: vSchema,
-      source: createInMemoryDataSource<Customer>([], vSchema),
-      hooks: {
-        beforeCreate: ({ values }) => {
-          const v = values as Record<string, unknown>
-          if (v['name'] == null || v['name'] === '') throw new Error('name required')
-          if (v['tier'] == null) v['tier'] = 'free' // default a field server-side
-        },
-        afterCreate: ({ row }) => { audited.push(String((row as Record<string, unknown>).id)) },
-      },
-    })
-    // transform: tier defaulted to 'free', afterCreate fired
-    const ok = await post(handlers, { kind: 'mutate', op: 'create', input: { id: '1', name: 'Ada' } })
-    expect(ok.status).toBe(200)
-    expect((await ok.json()).tier).toBe('free')
-    expect(audited).toEqual(['1'])
-    // reject: a thrown before-hook -> 422 with the message, no after-effect
-    const bad = await post(handlers, { kind: 'mutate', op: 'create', input: { id: '2' } })
-    expect(bad.status).toBe(422)
-    expect((await bad.json()).error).toBe('name required')
-    expect(audited).toEqual(['1']) // unchanged - the write never happened
-  })
-})
-
-describe('createKitHandlers audit hook', () => {
-  const post = (h: ReturnType<typeof createKitHandlers>, b: unknown) =>
-    h.handle(new Request('http://localhost/api/customers', { method: 'POST', body: JSON.stringify(b) }))
-
-  it('fires after create / update / delete with the change details', async () => {
-    const log: Array<{ action: string; id: string | null; values?: unknown }> = []
-    const handlers = createKitHandlers({ schema, source: createInMemoryDataSource(seed, schema), audit: (e) => { log.push({ action: e.action, id: e.id, values: e.values }) } })
-    await post(handlers, { kind: 'mutate', op: 'create', input: { id: '9', name: 'Zoe', age: 20, tier: 'pro' } })
-    await post(handlers, { kind: 'mutate', op: 'update', id: '9', patch: { age: 21 } })
-    await post(handlers, { kind: 'mutate', op: 'delete', id: '9' })
-    expect(log.map((e) => e.action)).toEqual(['create', 'update', 'delete'])
-    expect(log[0]!.id).toBe('9')
-    expect(log[1]!.values).toEqual({ age: 21 })
-  })
-
-  it('never fires on reads, and a throwing audit sink does not fail the write', async () => {
-    let fired = 0
-    const handlers = createKitHandlers({ schema, source: createInMemoryDataSource(seed, schema), audit: () => { fired++; throw new Error('sink down') } })
-    expect((await post(handlers, { kind: 'query', request: req({}) })).status).toBe(200)
-    expect(fired).toBe(0)
-    expect((await post(handlers, { kind: 'mutate', op: 'create', input: { id: '9', name: 'Z', age: 1, tier: 'x' } })).status).toBe(200)
-    expect(fired).toBe(1) // audit ran, but the write still succeeded
-  })
-})
-
-describe('createKitHandlers authorize (RBAC seam)', () => {
-  const body = (b: unknown, init: RequestInit = {}) =>
-    new Request('http://localhost/api/customers', { method: 'POST', body: JSON.stringify(b), ...init })
-
-  it('reads pass but writes 403 when authorize denies them', async () => {
-    const handlers = createKitHandlers({ schema, source: createInMemoryDataSource(seed, schema), authorize: ({ action }) => action === 'read' })
-    expect((await handlers.handle(body({ kind: 'query', request: req({}) }))).status).toBe(200)
-    expect((await handlers.handle(body({ kind: 'mutate', op: 'delete', id: '1' }))).status).toBe(403)
-  })
-
-  it('resolves the role from event.locals', async () => {
-    const handlers = createKitHandlers({
-      schema,
-      source: createInMemoryDataSource(seed, schema),
-      authorize: ({ action, event }) => action === 'read' || event.locals?.role === 'admin',
-    })
-    expect((await handlers.handle(body({ kind: 'mutate', op: 'delete', id: '1' }), { locals: { role: 'viewer' } })).status).toBe(403)
-    expect((await handlers.handle(body({ kind: 'mutate', op: 'delete', id: '2' }), { locals: { role: 'admin' } })).status).toBe(200)
-  })
-})