@oomol-lab/open-flow 0.1.0-beta.72 → 0.1.0-beta.74

package/src/trigger/common/poll.ts

@@ -0,0 +1,187 @@
+export { resolveTriggerConfig, triggerConfigValues } from './config.ts'
+import type { ConnectorProxy } from '../../connector/common/proxy.ts'
+import type { JsonValue, TriggerKeySnapshot, TriggerSchedule } from '../../flow/common/change.ts'
+import type { TriggerConfigOption, TriggerConfigOptionsContext } from './configOptions.ts'
+
+const encoder = new TextEncoder()
+
+export const maximumPollCheckpointBytes = 64 * 1024
+export const maximumPollDedupeKeyBytes = 1024
+export const maximumPollEventsPerPage = 100
+
+export interface PollEvent {
+  readonly dedupeKey: string
+  readonly payload: Readonly<Record<string, JsonValue>>
+}
+
+export interface PollResult {
+  readonly checkpoint: JsonValue
+  readonly events: readonly PollEvent[]
+  readonly filtered?: number
+  readonly hasMore?: boolean
+}
+
+export interface PollContext {
+  readonly checkpoint: JsonValue
+  /** Fixed inputs resolved with resolveTriggerConfig before invoking the Provider. */
+  readonly config: Readonly<Record<string, JsonValue>>
+  readonly connector: ConnectorProxy
+  readonly now: Date
+  readonly signal?: AbortSignal
+}
+
+export function eventsPollOutputs(events: readonly PollEvent[]): Readonly<Record<string, JsonValue>> {
+  return { events: events.map((event) => event.payload) }
+}
+
+export interface PollDefinition {
+  /** Constructs one Run's outputs from a nonempty batch of fresh, deduplicated events. */
+  readonly buildOutputs: (events: readonly PollEvent[]) => Readonly<Record<string, JsonValue>>
+  readonly configOptions?: (context: TriggerConfigOptionsContext) => Promise<readonly TriggerConfigOption[]>
+  readonly poll: (context: PollContext) => Promise<PollResult>
+  readonly snapshot: TriggerKeySnapshot & { readonly type: 'poll' }
+}
+
+export class PollConnectionError extends Error {
+  override readonly name = 'PollConnectionError'
+}
+
+export class PermanentPollError extends Error {
+  override readonly name = 'PermanentPollError'
+}
+
+export class TransientPollError extends Error {
+  override readonly name = 'TransientPollError'
+}
+
+export async function pollPageClaimId(bindingId: string, runtimeVersion: number, rootOccurrenceId: string, page: number): Promise<string> {
+  if (!Number.isSafeInteger(page) || page <= 0) throw new RangeError('Poll continuation page must be a positive integer.')
+  return await digest(`${bindingId}\0${runtimeVersion}\0${rootOccurrenceId}\0${page}`)
+}
+
+export async function providerEventId(bindingId: string, triggerKey: string, dedupeKey: string): Promise<string> {
+  if (encoder.encode(dedupeKey).byteLength > maximumPollDedupeKeyBytes) throw new RangeError('Poll event dedupe key exceeds 1024 bytes.')
+  return await digest(`${bindingId}\0${triggerKey}\0${dedupeKey}`)
+}
+
+export interface PollConformanceFixture {
+  readonly config: Readonly<Record<string, JsonValue>>
+  readonly connectionId: string
+  readonly publishedAt: string
+  readonly rules: readonly TriggerSchedule[]
+}
+
+export interface PollConformanceState {
+  readonly calls: number
+  readonly checkpoint: JsonValue
+  readonly health: 'healthy' | 'initializing'
+  readonly payloads: readonly JsonValue[]
+}
+
+export interface PollConformanceHarness {
+  dispose(): Promise<void>
+  replayLast(): Promise<void>
+  republish(at: string, change?: { readonly config?: Readonly<Record<string, JsonValue>>; readonly connectionId?: string }): Promise<void>
+  restart(): Promise<void>
+  retire(at: string): Promise<void>
+  state(): Promise<PollConformanceState>
+  tick(at: string, pages: readonly PollResult[]): Promise<void>
+}
+
+export interface PollConformanceCase {
+  readonly fixture: PollConformanceFixture
+  readonly name: string
+  verify(harness: PollConformanceHarness): Promise<void>
+}
+
+const minutely: readonly TriggerSchedule[] = [{ type: 'every', unit: 'minute', value: 1 }]
+const fixture: PollConformanceFixture = {
+  config: { source: 'primary' },
+  connectionId: 'connection-primary',
+  publishedAt: '2026-08-21T00:00:30.000Z',
+  rules: minutely,
+}
+
+export const pollConformanceCases: readonly PollConformanceCase[] = [
+  {
+    fixture,
+    name: 'baselines every continuation page before becoming healthy',
+    async verify(harness) {
+      await harness.tick('2026-08-21T00:01:00.000Z', [
+        { checkpoint: { cursor: 'baseline-1' }, events: [{ dedupeKey: 'old-1', payload: { value: 'old-1' } }], hasMore: true },
+        { checkpoint: { cursor: 'baseline-2' }, events: [{ dedupeKey: 'old-2', payload: { value: 'old-2' } }] },
+      ])
+      equal(await harness.state(), { calls: 2, checkpoint: { cursor: 'baseline-2' }, health: 'healthy', payloads: [] }, 'Baseline state')
+    },
+  },
+  {
+    fixture,
+    name: 'batches fresh page events and suppresses duplicate identities',
+    async verify(harness) {
+      await harness.tick('2026-08-21T00:01:00.000Z', [{ checkpoint: { cursor: 'baseline' }, events: [] }])
+      const event = { dedupeKey: 'event-1', payload: { value: 'first' } } as const
+      await harness.tick('2026-08-21T00:02:00.000Z', [
+        { checkpoint: { cursor: 'next' }, events: [event, event, { dedupeKey: 'event-2', payload: { value: 'second' } }] },
+      ])
+      await harness.tick('2026-08-21T00:03:00.000Z', [{ checkpoint: { cursor: 'last' }, events: [event] }])
+      equal(
+        await harness.state(),
+        {
+          calls: 3,
+          checkpoint: { cursor: 'last' },
+          health: 'healthy',
+          payloads: [{ events: [{ value: 'first' }, { value: 'second' }] }],
+        },
+        'Deduplicated state',
+      )
+    },
+  },
+  {
+    fixture,
+    name: 'replays a completed root across restart without polling again',
+    async verify(harness) {
+      await harness.tick('2026-08-21T00:01:00.000Z', [{ checkpoint: { cursor: 'baseline' }, events: [] }])
+      await harness.tick('2026-08-21T00:02:00.000Z', [{ checkpoint: { cursor: 'event' }, events: [{ dedupeKey: 'event-1', payload: { value: 'first' } }] }])
+      await harness.restart()
+      await harness.replayLast()
+      equal(
+        await harness.state(),
+        {
+          calls: 2,
+          checkpoint: { cursor: 'event' },
+          health: 'healthy',
+          payloads: [{ events: [{ value: 'first' }] }],
+        },
+        'Replayed state',
+      )
+    },
+  },
+  {
+    fixture,
+    name: 'preserves an unchanged checkpoint and baselines changed semantics',
+    async verify(harness) {
+      await harness.tick('2026-08-21T00:01:00.000Z', [{ checkpoint: { cursor: 'baseline' }, events: [] }])
+      await harness.republish('2026-08-21T00:01:30.000Z')
+      equal(await harness.state(), { calls: 1, checkpoint: { cursor: 'baseline' }, health: 'healthy', payloads: [] }, 'Unchanged publication state')
+      await harness.republish('2026-08-21T00:01:40.000Z', { config: { source: 'secondary' } })
+      await harness.tick('2026-08-21T00:02:00.000Z', [
+        { checkpoint: { cursor: 'secondary-baseline' }, events: [{ dedupeKey: 'old-secondary', payload: { value: 'old' } }] },
+      ])
+      equal(await harness.state(), { calls: 2, checkpoint: { cursor: 'secondary-baseline' }, health: 'healthy', payloads: [] }, 'Changed publication state')
+      await harness.retire('2026-08-21T00:02:30.000Z')
+      await harness.tick('2026-08-21T00:03:00.000Z', [{ checkpoint: { cursor: 'retired' }, events: [] }])
+      equal(await harness.state(), { calls: 2, checkpoint: { cursor: 'secondary-baseline' }, health: 'healthy', payloads: [] }, 'Retired state')
+    },
+  },
+]
+
+async function digest(value: string): Promise<string> {
+  const bytes = new Uint8Array(await crypto.subtle.digest('SHA-256', encoder.encode(value)))
+  return `sha256:${Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('')}`
+}
+
+function equal(actual: unknown, expected: unknown, message: string): void {
+  if (JSON.stringify(actual) != JSON.stringify(expected)) {
+    throw new Error(`${message}: expected ${JSON.stringify(expected)}, received ${JSON.stringify(actual)}.`)
+  }
+}

package/src/trigger/common/webhook.ts

@@ -0,0 +1,412 @@
+import type { JsonValue, WebhookBodyField, WebhookMethod, WebhookOptions } from '../../flow/common/change.ts'
+
+import { dequal } from 'dequal/lite'
+import { isJsonObject } from '../../base/common/json.ts'
+import { webhookHeaderNameIssue, validWebhookStatus, webhookHeaderValues, encodeWebhookBody } from '../../flow/common/webhookResponse.ts'
+
+export { webhookSupportsBody } from './contract.ts'
+export { webhookResponseAllowsBody, webhookResponseTimeout } from '../../flow/common/webhookResponse.ts'
+
+export type { WebhookResponseSnapshot } from '../../flow/common/webhookResponse.ts'
+
+export const maximumWebhookBodyBytes = 64 * 1024
+
+/** Serialize only declared workflow business outputs, never node logs or execution metadata. */
+export function webhookResponseBody(
+  result: unknown,
+  source: Extract<NonNullable<WebhookOptions['responseBody']>, { kind: 'workflow-outputs' }>,
+): { readonly body: string; readonly contentType: string } | undefined {
+  const value = workflowOutputValue(result, source.output)
+  if (value === undefined) return
+  return encodeWebhookBody(value)
+}
+
+export function webhookResponseStatusCode(result: unknown, output: string): number | undefined {
+  const value = workflowOutputValue(result, output)
+  if (validWebhookStatus(value)) return value
+}
+
+/** Project business headers before the HTTP layer applies its deployment-owned header policy. */
+export function webhookResponseHeaders(result: unknown, options: WebhookOptions): Readonly<Record<string, string>> | undefined {
+  const whole = options.responseHeadersSource
+  const source = whole == null ? (options.responseHeaders ?? {}) : workflowOutputValue(result, whole.output)
+  if (!isJsonObject(source)) return
+  const values = new Map<string, { name: string; value: unknown }>()
+  for (const [name, value] of Object.entries(source)) {
+    if (
+      webhookHeaderNameIssue(
+        name,
+        [...values.values()].map((entry) => entry.name),
+      ) != null
+    )
+      return
+    values.set(name.toLowerCase(), { name, value })
+  }
+  if (whole == null) {
+    const names: string[] = []
+    for (const [name, output] of Object.entries(options.responseHeaderOutputs ?? {})) {
+      if (webhookHeaderNameIssue(name, names) != null) return
+      names.push(name)
+      values.set(name.toLowerCase(), { name, value: workflowOutputValue(result, output) })
+    }
+  }
+  return webhookHeaderValues(Object.fromEntries([...values.values()].map(({ name, value }) => [name, value])))
+}
+
+function workflowOutputValue(result: unknown, output?: string): JsonValue | undefined {
+  if (!isJsonObject(result) || result.kind != 'node-results' || !isJsonObject(result.outputs)) return
+  return output == null ? result.outputs : Object.hasOwn(result.outputs, output) ? result.outputs[output] : undefined
+}
+
+const endpointPattern = /^\/v1\/webhooks\/(endpoint_[0-9a-f]{32})$/
+const encoder = new TextEncoder()
+
+export function webhookEndpointId(url: URL): string | undefined {
+  return endpointPattern.exec(url.pathname)?.[1]
+}
+
+export async function webhookOccurrenceId(endpointId: string, runtimeVersion: number, key: string | null): Promise<string | undefined> {
+  if (key == null) return `webhook_${crypto.randomUUID().replaceAll('-', '')}`
+  if (key.trim().length == 0 || key.length > 256) return
+  const source = JSON.stringify([2, 'webhook-occurrence', endpointId, runtimeVersion, key])
+  const bytes = new Uint8Array(await crypto.subtle.digest('SHA-256', encoder.encode(source)))
+  return [...bytes].map((byte) => byte.toString(16).padStart(2, '0')).join('')
+}
+
+export interface WebhookConformanceFixture {
+  readonly bodyFields: readonly WebhookBodyField[]
+  readonly method: WebhookMethod
+  readonly options?: WebhookOptions
+}
+
+export interface WebhookConformanceHarness {
+  readonly endpointUrl: string
+  dispose(): Promise<void>
+  outputs(): Promise<readonly Readonly<Record<string, JsonValue>>[]>
+  republish(): Promise<void>
+  request(request: Request): Promise<Response>
+  retire(): Promise<void>
+}
+
+export interface WebhookConformanceCase {
+  readonly fixture: WebhookConformanceFixture
+  readonly name: string
+  verify(harness: WebhookConformanceHarness): Promise<void>
+}
+
+function equal(actual: unknown, expected: unknown, message: string): void {
+  if (!dequal(actual, expected)) {
+    throw new Error(`${message}: expected ${JSON.stringify(expected)}, received ${JSON.stringify(actual)}.`)
+  }
+}
+
+async function response(
+  actual: Response,
+  expected: { readonly body?: string; readonly headers?: Readonly<Record<string, string | null>>; readonly status: number },
+  message: string,
+): Promise<void> {
+  equal(actual.status, expected.status, `${message} status`)
+  if (expected.body != null) equal(await actual.text(), expected.body, `${message} body`)
+  for (const [name, value] of Object.entries(expected.headers ?? {})) equal(actual.headers.get(name), value, `${message} header ${name}`)
+}
+
+function call(
+  harness: WebhookConformanceHarness,
+  input: { readonly body?: string; readonly headers?: Headers | Readonly<Record<string, string>>; readonly method?: string; readonly url?: string } = {},
+): Promise<Response> {
+  return harness.request(
+    new Request(input.url ?? harness.endpointUrl, {
+      ...(input.body == null ? {} : { body: input.body }),
+      headers: input.headers,
+      method: input.method ?? 'POST',
+    }),
+  )
+}
+
+const noInputs: readonly WebhookBodyField[] = []
+const messageInputs: readonly WebhookBodyField[] = [
+  {
+    handle: 'event',
+    jsonSchema: {
+      additionalProperties: false,
+      properties: { message: { type: 'string' } },
+      required: ['message'],
+      type: 'object',
+    },
+    nullable: false,
+  },
+]
+
+const messagePayload = { event: { message: 'hello' } } as const
+
+export const webhookConformanceCases: readonly WebhookConformanceCase[] = [
+  {
+    fixture: { bodyFields: messageInputs, method: 'POST' },
+    name: 'stores complete outputs and compares query and body for idempotency',
+    async verify(harness) {
+      const url = `${harness.endpointUrl}?tag=a&tag=b&single=x&__proto__=safe&constructor=value`
+      const input = {
+        url,
+        body: JSON.stringify(messagePayload),
+        headers: { 'Idempotency-Key': 'output-contract', 'X-Request-ID': 'first', 'Content-Type': 'application/json' },
+      }
+      const replies = await Promise.all([call(harness, input), call(harness, input)])
+      equal(
+        replies.map((reply) => reply.status),
+        [200, 200],
+        'Concurrent retry statuses',
+      )
+      const stored = await harness.outputs()
+      equal(stored.length, 1, 'One admitted Run')
+      const output = stored[0]!
+      equal(Object.keys(output).toSorted(), ['body', 'headers', 'query', 'webhookUrl'], 'Exact output handles')
+      equal(output.body, messagePayload, 'Body')
+      equal(output.query, JSON.parse('{"tag":["a","b"],"single":"x","__proto__":"safe","constructor":"value"}'), 'Query')
+      equal(output.webhookUrl, harness.endpointUrl, 'Endpoint without query')
+      equal((output.headers as Record<string, JsonValue>)['x-request-id'], 'first', 'Lowercase headers')
+      await response(await call(harness, { ...input, headers: { ...input.headers, 'X-Request-ID': 'retry' } }), { status: 200 }, 'Changed header retry')
+      await response(await call(harness, { ...input, url: url.replace(new URL(url).host, 'retry.example.com') }), { status: 200 }, 'Changed request URL host')
+      equal(await harness.outputs(), stored, 'First outputs remain unchanged')
+      await response(await call(harness, { ...input, method: 'PUT' }), { headers: { allow: 'POST' }, status: 405 }, 'Rejected method')
+      await response(await call(harness, { ...input, url: `${url}&extra=1` }), { status: 409 }, 'Changed query')
+      await response(await call(harness, { ...input, body: JSON.stringify({ event: { message: 'changed' } }) }), { status: 409 }, 'Changed body')
+    },
+  },
+  {
+    fixture: { bodyFields: noInputs, method: 'POST' },
+    name: 'rejects malformed and unknown endpoint identities',
+    async verify(harness) {
+      const endpoint = new URL(harness.endpointUrl)
+      await response(
+        await call(harness, { url: new URL('/v1/webhooks/not-an-endpoint', endpoint).href }),
+        { body: '', headers: { 'cache-control': 'no-store' }, status: 404 },
+        'Malformed endpoint',
+      )
+      await response(
+        await call(harness, { url: new URL('/v1/webhooks/endpoint_00000000000000000000000000000000', endpoint).href }),
+        { body: '', headers: { 'cache-control': 'no-store' }, status: 404 },
+        'Unknown endpoint',
+      )
+    },
+  },
+  {
+    fixture: { bodyFields: noInputs, method: 'POST' },
+    name: 'uses configured POST and decodes an empty body as an empty object',
+    async verify(harness) {
+      await response(await call(harness, { method: 'GET' }), { headers: { 'allow': 'POST', 'cache-control': 'no-store' }, status: 405 }, 'Default method')
+      await response(await call(harness), { body: '', headers: { 'cache-control': 'no-store' }, status: 200 }, 'Empty payload')
+      equal(
+        (await harness.outputs()).map((outputs) => outputs.body),
+        [{}],
+        'Decoded empty payloads',
+      )
+    },
+  },
+  {
+    fixture: {
+      bodyFields: noInputs,
+      method: 'PUT',
+      options: {
+        allowedOrigins: ['https://client.example'],
+        responseData: 'accepted',
+        responseHeaders: { 'x-webhook-response': 'configured' },
+        responseStatusCode: 202,
+      },
+    },
+    name: 'applies configured methods, CORS, preflight, and success response',
+    async verify(harness) {
+      await response(
+        await call(harness, {
+          headers: {
+            'access-control-request-headers': 'content-type, idempotency-key',
+            'access-control-request-method': 'PUT',
+            'origin': 'https://client.example',
+          },
+          method: 'OPTIONS',
+        }),
+        {
+          body: '',
+          headers: {
+            'access-control-allow-headers': 'content-type, idempotency-key',
+            'access-control-allow-methods': 'PUT',
+            'access-control-allow-origin': 'https://client.example',
+            'access-control-max-age': '600',
+          },
+          status: 204,
+        },
+        'Preflight',
+      )
+      await response(
+        await call(harness, { body: '{}', headers: { origin: 'https://client.example' }, method: 'PUT' }),
+        {
+          body: 'accepted',
+          headers: {
+            'access-control-allow-origin': 'https://client.example',
+            'cache-control': 'no-store',
+            'x-webhook-response': 'configured',
+          },
+          status: 202,
+        },
+        'Configured success',
+      )
+      await response(
+        await call(harness, { body: '{}', headers: { origin: 'https://other.example' }, method: 'PUT' }),
+        { body: '', headers: { 'cache-control': 'no-store' }, status: 403 },
+        'Disallowed origin',
+      )
+    },
+  },
+  {
+    fixture: {
+      bodyFields: noInputs,
+      method: 'POST',
+      options: {
+        responseData: '<script>globalThis.compromised = true</script>',
+        responseHeaders: {
+          'access-control-allow-credentials': 'true',
+          'content-security-policy': "default-src * 'unsafe-inline'",
+          'content-type': 'text/html',
+          'location': 'https://attacker.example',
+          'set-cookie': 'open_flow_operator_session=forged',
+          'x-accel-redirect': '/auth/session',
+        },
+      },
+    },
+    name: 'prevents Flow responses from becoming executable or controlling deployment headers',
+    async verify(harness) {
+      await response(
+        await call(harness),
+        {
+          body: '<script>globalThis.compromised = true</script>',
+          headers: {
+            'access-control-allow-credentials': null,
+            'content-security-policy': "default-src 'none'; frame-ancestors 'none'; sandbox",
+            'content-type': 'text/html',
+            'location': null,
+            'referrer-policy': 'no-referrer',
+            'set-cookie': null,
+            'x-accel-redirect': null,
+            'x-content-type-options': 'nosniff',
+            'x-frame-options': 'DENY',
+          },
+          status: 200,
+        },
+        'Safe configured response',
+      )
+    },
+  },
+  {
+    fixture: { bodyFields: messageInputs, method: 'POST' },
+    name: 'rejects invalid JSON, invalid payloads, invalid idempotency keys, and oversized bodies',
+    async verify(harness) {
+      await response(await call(harness, { body: '{' }), { body: '', headers: { 'cache-control': 'no-store' }, status: 400 }, 'Invalid JSON')
+      await response(
+        await call(harness, { body: JSON.stringify({ event: {} }) }),
+        { body: '', headers: { 'cache-control': 'no-store' }, status: 400 },
+        'Invalid payload',
+      )
+      await response(
+        await call(harness, { body: JSON.stringify(messagePayload), headers: { 'idempotency-key': '   ' } }),
+        { body: '', headers: { 'cache-control': 'no-store' }, status: 400 },
+        'Empty key',
+      )
+      await response(
+        await call(harness, { body: JSON.stringify(messagePayload), headers: { 'idempotency-key': 'x'.repeat(257) } }),
+        { body: '', headers: { 'cache-control': 'no-store' }, status: 400 },
+        'Oversized key',
+      )
+      await response(
+        await call(harness, { body: 'x'.repeat(maximumWebhookBodyBytes + 1) }),
+        { body: '', headers: { 'cache-control': 'no-store' }, status: 413 },
+        'Oversized body',
+      )
+      equal(
+        (await harness.outputs()).map((outputs) => outputs.body),
+        [],
+        'Rejected payloads',
+      )
+    },
+  },
+  {
+    fixture: { bodyFields: messageInputs, method: 'POST' },
+    name: 'replays one idempotent occurrence and rejects conflicting payloads',
+    async verify(harness) {
+      const headers = { 'idempotency-key': 'delivery-1' }
+      await response(await call(harness, { body: JSON.stringify(messagePayload), headers }), { status: 200 }, 'Initial delivery')
+      await response(await call(harness, { body: JSON.stringify(messagePayload), headers }), { status: 200 }, 'Repeated delivery')
+      await response(
+        await call(harness, { body: JSON.stringify({ event: { message: 'different' } }), headers }),
+        { body: '', headers: { 'cache-control': 'no-store' }, status: 409 },
+        'Conflicting delivery',
+      )
+      equal(
+        (await harness.outputs()).map((outputs) => outputs.body),
+        [messagePayload],
+        'Idempotent payloads',
+      )
+    },
+  },
+  {
+    fixture: { bodyFields: messageInputs, method: 'POST' },
+    name: 'admits requests without an idempotency key as separate occurrences',
+    async verify(harness) {
+      const body = JSON.stringify(messagePayload)
+      await response(await call(harness, { body }), { status: 200 }, 'First unkeyed delivery')
+      await response(await call(harness, { body }), { status: 200 }, 'Second unkeyed delivery')
+      equal(
+        (await harness.outputs()).map((outputs) => outputs.body),
+        [messagePayload, messagePayload],
+        'Unkeyed payloads',
+      )
+    },
+  },
+  {
+    fixture: { bodyFields: messageInputs, method: 'POST' },
+    name: 'scopes occurrence identity to the current runtime version',
+    async verify(harness) {
+      const body = JSON.stringify(messagePayload)
+      const headers = { 'idempotency-key': 'delivery-across-publish' }
+      await response(await call(harness, { body, headers }), { status: 200 }, 'Delivery before publish')
+      const endpointUrl = harness.endpointUrl
+      await harness.republish()
+      equal(harness.endpointUrl, endpointUrl, 'Endpoint after publish')
+      await response(await call(harness, { body, headers }), { status: 200 }, 'Delivery after publish')
+      equal(
+        (await harness.outputs()).map((outputs) => outputs.body),
+        [messagePayload, messagePayload],
+        'Payloads across publish',
+      )
+    },
+  },
+  {
+    fixture: { bodyFields: noInputs, method: 'POST' },
+    name: 'fails closed after its trigger is retired',
+    async verify(harness) {
+      await harness.retire()
+      await response(await call(harness, { body: '{}' }), { body: '', headers: { 'cache-control': 'no-store' }, status: 404 }, 'Retired endpoint')
+      equal(
+        (await harness.outputs()).map((outputs) => outputs.body),
+        [],
+        'Payloads after retirement',
+      )
+    },
+  },
+  {
+    fixture: { bodyFields: noInputs, method: 'POST', options: { responseData: 'ignored', responseStatusCode: 204 } },
+    name: 'omits a configured response body for null-body statuses',
+    async verify(harness) {
+      await response(await call(harness, { body: '{}' }), { body: '', status: 204 }, 'Null-body status')
+    },
+  },
+  {
+    fixture: { bodyFields: noInputs, method: 'GET', options: { responseData: 'ignored' } },
+    name: 'omits the body output for GET requests',
+    async verify(harness) {
+      await response(await call(harness, { method: 'GET' }), { body: 'ignored', status: 200 }, 'GET response')
+      const outputs = await harness.outputs()
+      equal(outputs.length, 1, 'One GET run')
+      equal(Object.keys(outputs[0]!).toSorted(), ['headers', 'query', 'webhookUrl'], 'GET outputs omit body')
+      await response(await call(harness, { method: 'HEAD' }), { body: '', headers: { allow: 'GET' }, status: 405 }, 'HEAD rejected')
+    },
+  },
+]

package/src/trigger/providers/airtable/locales/fr.json

@@ -0,0 +1,18 @@
+{
+  "airtable.on_record_changed": {
+    "displayName": "Création ou mise à jour d’un enregistrement",
+    "description": "Interroge périodiquement une table Airtable et se déclenche à la création ou à la mise à jour d’un enregistrement, dans l’ordre d’un champ temporel.",
+    "configInputs": {
+      "baseId": "ID de la base Airtable à surveiller.",
+      "fields": "Champs à inclure dans chaque enregistrement retourné. Laissez vide pour inclure tous les champs.",
+      "formula": "Formule Airtable utilisée pour filtrer les enregistrements. Laissez vide pour inclure tous les enregistrements.",
+      "maxRecordsPerPoll": "Nombre maximal d'enregistrements traités par interrogation.",
+      "tableIdOrName": "ID ou nom de la table Airtable à surveiller.",
+      "triggerField": "Champ de date ou d'heure utilisé pour détecter les enregistrements créés ou mis à jour.",
+      "view": "Vue Airtable utilisée pour filtrer et trier les enregistrements. Laissez vide pour utiliser la vue par défaut de la table."
+    },
+    "outputs": {
+      "events": "Enregistrements créés ou mis à jour depuis la précédente interrogation."
+    }
+  }
+}

package/src/trigger/providers/airtable/locales/ja.json

@@ -0,0 +1,18 @@
+{
+  "airtable.on_record_changed": {
+    "displayName": "レコードの作成・更新",
+    "description": "Airtable のテーブルを定期的に確認し、時刻フィールド順にレコードの作成や更新を検出すると実行します。",
+    "configInputs": {
+      "baseId": "監視対象のAirtableベースのID。",
+      "fields": "返される各レコードに含めるフィールド。空欄にするとすべてのフィールドを含みます。",
+      "formula": "レコードをフィルタリングするために使用するAirtableの式。空欄にするとすべてのレコードを含みます。",
+      "maxRecordsPerPoll": "1回のポーリングで処理する最大レコード数。",
+      "tableIdOrName": "監視対象のAirtableテーブルのIDまたは名前。",
+      "triggerField": "作成または更新されたレコードを検出するために使用する日付または時刻のフィールド。",
+      "view": "レコードをフィルタリングおよび並べ替えるために使用するAirtableビュー。空欄にするとテーブルのデフォルトを使用します。"
+    },
+    "outputs": {
+      "events": "前のポーリング以降に作成または更新されたレコード。"
+    }
+  }
+}

package/src/trigger/providers/airtable/locales/ko.json

@@ -0,0 +1,18 @@
+{
+  "airtable.on_record_changed": {
+    "displayName": "레코드 생성 또는 업데이트",
+    "description": "Airtable 테이블을 주기적으로 확인하고 시간 필드 순서에 따라 레코드가 생성되거나 업데이트되면 실행합니다.",
+    "configInputs": {
+      "baseId": "모니터링할 Airtable 베이스 ID.",
+      "fields": "반환되는 각 레코드에 포함할 필드. 모든 필드를 포함하려면 비워 두세요.",
+      "formula": "레코드를 필터링하는 Airtable 수식. 모든 레코드를 포함하려면 비워 두세요.",
+      "maxRecordsPerPoll": "각 폴링에서 처리할 최대 레코드 수.",
+      "tableIdOrName": "모니터링할 Airtable 테이블 ID 또는 이름.",
+      "triggerField": "생성 또는 업데이트된 레코드를 감지하는 데 사용되는 날짜 또는 시간 필드.",
+      "view": "레코드를 필터링하고 정렬하는 데 사용되는 Airtable 보기. 테이블 기본값을 사용하려면 비워 두세요."
+    },
+    "outputs": {
+      "events": "이전 폴링 이후 생성되거나 업데이트된 레코드."
+    }
+  }
+}

package/src/trigger/providers/airtable/locales/ru.json

@@ -0,0 +1,18 @@
+{
+  "airtable.on_record_changed": {
+    "displayName": "Создание или изменение записи",
+    "description": "Периодически проверяет таблицу Airtable и срабатывает при создании или изменении записи, упорядочивая записи по полю времени.",
+    "configInputs": {
+      "baseId": "ID базы Airtable, которую нужно отслеживать.",
+      "fields": "Поля, которые должны быть включены в каждую возвращаемую запись. Оставьте пустым, чтобы включить все поля.",
+      "formula": "Формула Airtable, используемая для фильтрации записей. Оставьте пустым, чтобы включить все записи.",
+      "maxRecordsPerPoll": "Максимальное количество записей, обрабатываемых за одно опрос.",
+      "tableIdOrName": "ID или название таблицы Airtable, которую нужно отслеживать.",
+      "triggerField": "Поле даты или времени, используемое для определения созданных или обновленных записей.",
+      "view": "Вид Airtable, используемый для фильтрации и сортировки записей. Оставьте пустым, чтобы использовать настройку по умолчанию для таблицы."
+    },
+    "outputs": {
+      "events": "Записи, созданные или обновленные с момента предыдущего опроса."
+    }
+  }
+}