weave-typescript 0.15.0 → 0.17.0

package/dist/weavesql/atcdb/event_sql.d.ts

@@ -98,4 +98,72 @@ export interface LockRunRow {
     pgAdvisoryXactLock: string;
 }
 export declare function lockRun(client: Client, args: LockRunArgs): Promise<void>;
+export declare const queryEventsByTypeQuery = "-- name: QueryEventsByType :many\nSELECT\n    id,\n    tenant_id,\n    run_id,\n    sequence,\n    type,\n    data,\n    causation_id,\n    correlation_id,\n    occurred_at\nFROM atc.events\nWHERE tenant_id = $1\n  AND type = $2\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\n  AND (\n      $3::timestamptz IS NULL\n      OR (occurred_at, sequence) < ($3::timestamptz, $4::bigint)\n  )\nORDER BY occurred_at DESC, sequence DESC\nLIMIT $5";
+export interface QueryEventsByTypeArgs {
+    tenantId: string;
+    eventType: string;
+    afterOccurredAt: Date;
+    afterSequence: string;
+    pageSize: string;
+}
+export interface QueryEventsByTypeRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function queryEventsByType(client: Client, args: QueryEventsByTypeArgs): Promise<QueryEventsByTypeRow[]>;
+export declare const queryEventsByTimeRangeQuery = "-- name: QueryEventsByTimeRange :many\nSELECT\n    id,\n    tenant_id,\n    run_id,\n    sequence,\n    type,\n    data,\n    causation_id,\n    correlation_id,\n    occurred_at\nFROM atc.events\nWHERE tenant_id = $1\n  AND occurred_at >= $2\n  AND occurred_at < $3\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY occurred_at ASC, sequence ASC\nLIMIT $4";
+export interface QueryEventsByTimeRangeArgs {
+    tenantId: string;
+    startTime: Date;
+    endTime: Date;
+    pageSize: string;
+}
+export interface QueryEventsByTimeRangeRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function queryEventsByTimeRange(client: Client, args: QueryEventsByTimeRangeArgs): Promise<QueryEventsByTimeRangeRow[]>;
+export declare const queryEventsByRunAndTypesQuery = "-- name: QueryEventsByRunAndTypes :many\nSELECT\n    id,\n    tenant_id,\n    run_id,\n    sequence,\n    type,\n    data,\n    causation_id,\n    correlation_id,\n    occurred_at\nFROM atc.events\nWHERE tenant_id = $1\n  AND run_id = $2\n  AND type = ANY($3::text[])\n  AND sequence > $4\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY sequence ASC\nLIMIT $5";
+export interface QueryEventsByRunAndTypesArgs {
+    tenantId: string;
+    runId: string;
+    eventTypes: string[];
+    afterSequence: string;
+    pageSize: string;
+}
+export interface QueryEventsByRunAndTypesRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function queryEventsByRunAndTypes(client: Client, args: QueryEventsByRunAndTypesArgs): Promise<QueryEventsByRunAndTypesRow[]>;
+export declare const countEventsByTypeQuery = "-- name: CountEventsByType :one\nSELECT COUNT(*)::BIGINT AS total\nFROM atc.events\nWHERE tenant_id = $1\n  AND type = $2\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())";
+export interface CountEventsByTypeArgs {
+    tenantId: string;
+    eventType: string;
+}
+export interface CountEventsByTypeRow {
+    total: string;
+}
+export declare function countEventsByType(client: Client, args: CountEventsByTypeArgs): Promise<CountEventsByTypeRow | null>;
 export {};

package/dist/weavesql/atcdb/event_sql.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lockRunQuery = exports.listEventsByTypeQuery = exports.loadAllEventsQuery = exports.loadEventsQuery = exports.getCurrentVersionQuery = exports.insertEventQuery = void 0;
+exports.countEventsByTypeQuery = exports.queryEventsByRunAndTypesQuery = exports.queryEventsByTimeRangeQuery = exports.queryEventsByTypeQuery = exports.lockRunQuery = exports.listEventsByTypeQuery = exports.loadAllEventsQuery = exports.loadEventsQuery = exports.getCurrentVersionQuery = exports.insertEventQuery = void 0;
 exports.insertEvent = insertEvent;
 exports.getCurrentVersion = getCurrentVersion;
 exports.loadEvents = loadEvents;
 exports.loadAllEvents = loadAllEvents;
 exports.listEventsByType = listEventsByType;
 exports.lockRun = lockRun;
+exports.queryEventsByType = queryEventsByType;
+exports.queryEventsByTimeRange = queryEventsByTimeRange;
+exports.queryEventsByRunAndTypes = queryEventsByRunAndTypes;
+exports.countEventsByType = countEventsByType;
 exports.insertEventQuery = `-- name: InsertEvent :one
 INSERT INTO atc.events (
     id,
@@ -189,3 +193,141 @@ async function lockRun(client, args) {
         rowMode: "array"
     });
 }
+exports.queryEventsByTypeQuery = `-- name: QueryEventsByType :many
+SELECT
+    id,
+    tenant_id,
+    run_id,
+    sequence,
+    type,
+    data,
+    causation_id,
+    correlation_id,
+    occurred_at
+FROM atc.events
+WHERE tenant_id = $1
+  AND type = $2
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+  AND (
+      $3::timestamptz IS NULL
+      OR (occurred_at, sequence) < ($3::timestamptz, $4::bigint)
+  )
+ORDER BY occurred_at DESC, sequence DESC
+LIMIT $5`;
+async function queryEventsByType(client, args) {
+    const result = await client.query({
+        text: exports.queryEventsByTypeQuery,
+        values: [args.tenantId, args.eventType, args.afterOccurredAt, args.afterSequence, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            tenantId: row[1],
+            runId: row[2],
+            sequence: row[3],
+            type: row[4],
+            data: row[5],
+            causationId: row[6],
+            correlationId: row[7],
+            occurredAt: row[8]
+        };
+    });
+}
+exports.queryEventsByTimeRangeQuery = `-- name: QueryEventsByTimeRange :many
+SELECT
+    id,
+    tenant_id,
+    run_id,
+    sequence,
+    type,
+    data,
+    causation_id,
+    correlation_id,
+    occurred_at
+FROM atc.events
+WHERE tenant_id = $1
+  AND occurred_at >= $2
+  AND occurred_at < $3
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY occurred_at ASC, sequence ASC
+LIMIT $4`;
+async function queryEventsByTimeRange(client, args) {
+    const result = await client.query({
+        text: exports.queryEventsByTimeRangeQuery,
+        values: [args.tenantId, args.startTime, args.endTime, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            tenantId: row[1],
+            runId: row[2],
+            sequence: row[3],
+            type: row[4],
+            data: row[5],
+            causationId: row[6],
+            correlationId: row[7],
+            occurredAt: row[8]
+        };
+    });
+}
+exports.queryEventsByRunAndTypesQuery = `-- name: QueryEventsByRunAndTypes :many
+SELECT
+    id,
+    tenant_id,
+    run_id,
+    sequence,
+    type,
+    data,
+    causation_id,
+    correlation_id,
+    occurred_at
+FROM atc.events
+WHERE tenant_id = $1
+  AND run_id = $2
+  AND type = ANY($3::text[])
+  AND sequence > $4
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY sequence ASC
+LIMIT $5`;
+async function queryEventsByRunAndTypes(client, args) {
+    const result = await client.query({
+        text: exports.queryEventsByRunAndTypesQuery,
+        values: [args.tenantId, args.runId, args.eventTypes, args.afterSequence, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            tenantId: row[1],
+            runId: row[2],
+            sequence: row[3],
+            type: row[4],
+            data: row[5],
+            causationId: row[6],
+            correlationId: row[7],
+            occurredAt: row[8]
+        };
+    });
+}
+exports.countEventsByTypeQuery = `-- name: CountEventsByType :one
+SELECT COUNT(*)::BIGINT AS total
+FROM atc.events
+WHERE tenant_id = $1
+  AND type = $2
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())`;
+async function countEventsByType(client, args) {
+    const result = await client.query({
+        text: exports.countEventsByTypeQuery,
+        values: [args.tenantId, args.eventType],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        total: row[0]
+    };
+}

package/dist/weavesql/atcdb/inspection_sql.d.ts

@@ -0,0 +1,139 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const insertInspectionEventQuery = "-- name: InsertInspectionEvent :one\nINSERT INTO atc.inspection_events (\n    id,\n    tenant_id,\n    occurred_at,\n    type,\n    category,\n    subject_kind,\n    subject_id,\n    actor_kind,\n    actor_id,\n    run_id,\n    process_id,\n    action,\n    outcome,\n    reason,\n    correlation_id,\n    causation_id,\n    schema_version,\n    data,\n    expires_at\n) VALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5,\n    $6,\n    $7,\n    $8,\n    $9,\n    $10,\n    $11,\n    $12,\n    $13,\n    $14,\n    $15,\n    $16,\n    $17,\n    $18,\n    $19\n)\nRETURNING\n    id,\n    tenant_id,\n    occurred_at,\n    type,\n    category,\n    subject_kind,\n    subject_id,\n    actor_kind,\n    actor_id,\n    run_id,\n    process_id,\n    action,\n    outcome,\n    reason,\n    correlation_id,\n    causation_id,\n    schema_version,\n    data,\n    expires_at,\n    sequence";
+export interface InsertInspectionEventArgs {
+    id: string;
+    tenantId: string;
+    occurredAt: Date;
+    type: string;
+    category: string;
+    subjectKind: string;
+    subjectId: string;
+    actorKind: string;
+    actorId: string;
+    runId: string | null;
+    processId: string | null;
+    action: string;
+    outcome: string;
+    reason: string | null;
+    correlationId: string | null;
+    causationId: string | null;
+    schemaVersion: number;
+    data: any;
+    expiresAt: Date;
+}
+export interface InsertInspectionEventRow {
+    id: string;
+    tenantId: string;
+    occurredAt: Date;
+    type: string;
+    category: string;
+    subjectKind: string;
+    subjectId: string;
+    actorKind: string;
+    actorId: string;
+    runId: string | null;
+    processId: string | null;
+    action: string;
+    outcome: string;
+    reason: string | null;
+    correlationId: string | null;
+    causationId: string | null;
+    schemaVersion: number;
+    data: any;
+    expiresAt: Date;
+    sequence: string;
+}
+export declare function insertInspectionEvent(client: Client, args: InsertInspectionEventArgs): Promise<InsertInspectionEventRow | null>;
+export declare const queryInspectionEventsQuery = "-- name: QueryInspectionEvents :many\nSELECT\n    id,\n    tenant_id,\n    occurred_at,\n    type,\n    category,\n    subject_kind,\n    subject_id,\n    actor_kind,\n    actor_id,\n    run_id,\n    process_id,\n    action,\n    outcome,\n    reason,\n    correlation_id,\n    causation_id,\n    schema_version,\n    data,\n    expires_at,\n    sequence\nFROM atc.inspection_events\nWHERE tenant_id = $1\n  AND (\n      $2::text IS NULL\n      OR (\n          subject_kind = $2::text\n          AND subject_id = $3::text\n      )\n  )\n  AND (\n      $4::text IS NULL\n      OR (\n          actor_kind = $4::text\n          AND actor_id = $5::text\n      )\n  )\n  AND ($6::text IS NULL OR run_id = $6::text)\n  AND ($7::text IS NULL OR process_id = $7::text)\n  AND ($8::text IS NULL OR action = $8::text)\n  AND ($9::text IS NULL OR outcome = $9::text)\n  AND (\n      $10::timestamptz IS NULL\n      OR occurred_at >= $10::timestamptz\n  )\n  AND (\n      $11::timestamptz IS NULL\n      OR occurred_at < $11::timestamptz\n  )\n  AND (\n      $12::text IS NULL\n      OR type LIKE replace(replace($12::text, '*', '%'), '?', '_')\n  )\n  AND (\n      $13::timestamptz IS NULL\n      OR (\n          occurred_at,\n          sequence\n      ) < (\n          $13::timestamptz,\n          $14::bigint\n      )\n  )\nORDER BY occurred_at DESC, sequence DESC\nLIMIT $15";
+export interface QueryInspectionEventsArgs {
+    tenantId: string;
+    subjectKind: string | null;
+    subjectId: string | null;
+    actorKind: string | null;
+    actorId: string | null;
+    runId: string | null;
+    processId: string | null;
+    action: string | null;
+    outcome: string | null;
+    startTime: Date | null;
+    endTime: Date | null;
+    typeFilter: string | null;
+    afterOccurredAt: Date | null;
+    afterSequence: string;
+    pageSize: string;
+}
+export interface QueryInspectionEventsRow {
+    id: string;
+    tenantId: string;
+    occurredAt: Date;
+    type: string;
+    category: string;
+    subjectKind: string;
+    subjectId: string;
+    actorKind: string;
+    actorId: string;
+    runId: string | null;
+    processId: string | null;
+    action: string;
+    outcome: string;
+    reason: string | null;
+    correlationId: string | null;
+    causationId: string | null;
+    schemaVersion: number;
+    data: any;
+    expiresAt: Date;
+    sequence: string;
+}
+export declare function queryInspectionEvents(client: Client, args: QueryInspectionEventsArgs): Promise<QueryInspectionEventsRow[]>;
+export declare const loadInspectionEventsFromSequenceQuery = "-- name: LoadInspectionEventsFromSequence :many\nSELECT\n    id,\n    tenant_id,\n    occurred_at,\n    type,\n    category,\n    subject_kind,\n    subject_id,\n    actor_kind,\n    actor_id,\n    run_id,\n    process_id,\n    action,\n    outcome,\n    reason,\n    correlation_id,\n    causation_id,\n    schema_version,\n    data,\n    expires_at,\n    sequence\nFROM atc.inspection_events\nWHERE tenant_id = $1\n  AND sequence > $2\n  AND (\n      $3::text IS NULL\n      OR (\n          subject_kind = $3::text\n          AND subject_id = $4::text\n      )\n  )\n  AND (\n      $5::text IS NULL\n      OR (\n          actor_kind = $5::text\n          AND actor_id = $6::text\n      )\n  )\n  AND ($7::text IS NULL OR run_id = $7::text)\n  AND ($8::text IS NULL OR process_id = $8::text)\n  AND ($9::text IS NULL OR action = $9::text)\n  AND ($10::text IS NULL OR outcome = $10::text)\n  AND (\n      $11::timestamptz IS NULL\n      OR occurred_at >= $11::timestamptz\n  )\n  AND (\n      $12::timestamptz IS NULL\n      OR occurred_at < $12::timestamptz\n  )\n  AND (\n      $13::text IS NULL\n      OR type LIKE replace(replace($13::text, '*', '%'), '?', '_')\n  )\nORDER BY sequence ASC";
+export interface LoadInspectionEventsFromSequenceArgs {
+    tenantId: string;
+    afterSequence: string;
+    subjectKind: string | null;
+    subjectId: string | null;
+    actorKind: string | null;
+    actorId: string | null;
+    runId: string | null;
+    processId: string | null;
+    action: string | null;
+    outcome: string | null;
+    startTime: Date | null;
+    endTime: Date | null;
+    typeFilter: string | null;
+}
+export interface LoadInspectionEventsFromSequenceRow {
+    id: string;
+    tenantId: string;
+    occurredAt: Date;
+    type: string;
+    category: string;
+    subjectKind: string;
+    subjectId: string;
+    actorKind: string;
+    actorId: string;
+    runId: string | null;
+    processId: string | null;
+    action: string;
+    outcome: string;
+    reason: string | null;
+    correlationId: string | null;
+    causationId: string | null;
+    schemaVersion: number;
+    data: any;
+    expiresAt: Date;
+    sequence: string;
+}
+export declare function loadInspectionEventsFromSequence(client: Client, args: LoadInspectionEventsFromSequenceArgs): Promise<LoadInspectionEventsFromSequenceRow[]>;
+export declare const deleteExpiredInspectionEventsQuery = "-- name: DeleteExpiredInspectionEvents :one\nWITH expired AS (\n    SELECT id\n    FROM atc.inspection_events\n    WHERE expires_at < $1::timestamptz\n    ORDER BY expires_at ASC\n    LIMIT $2\n),\ndeleted AS (\n    DELETE FROM atc.inspection_events\n    WHERE id IN (SELECT id FROM expired)\n    RETURNING id\n)\nSELECT COUNT(*)::BIGINT AS total\nFROM deleted";
+export interface DeleteExpiredInspectionEventsArgs {
+    expiresBefore: Date;
+    deleteLimit: string;
+}
+export interface DeleteExpiredInspectionEventsRow {
+    total: string;
+}
+export declare function deleteExpiredInspectionEvents(client: Client, args: DeleteExpiredInspectionEventsArgs): Promise<DeleteExpiredInspectionEventsRow | null>;
+export {};

package/dist/weavesql/atcdb/inspection_sql.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteExpiredInspectionEventsQuery = exports.loadInspectionEventsFromSequenceQuery = exports.queryInspectionEventsQuery = exports.insertInspectionEventQuery = void 0;
+exports.insertInspectionEvent = insertInspectionEvent;
+exports.queryInspectionEvents = queryInspectionEvents;
+exports.loadInspectionEventsFromSequence = loadInspectionEventsFromSequence;
+exports.deleteExpiredInspectionEvents = deleteExpiredInspectionEvents;
+exports.insertInspectionEventQuery = `-- name: InsertInspectionEvent :one
+INSERT INTO atc.inspection_events (
+    id,
+    tenant_id,
+    occurred_at,
+    type,
+    category,
+    subject_kind,
+    subject_id,
+    actor_kind,
+    actor_id,
+    run_id,
+    process_id,
+    action,
+    outcome,
+    reason,
+    correlation_id,
+    causation_id,
+    schema_version,
+    data,
+    expires_at
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7,
+    $8,
+    $9,
+    $10,
+    $11,
+    $12,
+    $13,
+    $14,
+    $15,
+    $16,
+    $17,
+    $18,
+    $19
+)
+RETURNING
+    id,
+    tenant_id,
+    occurred_at,
+    type,
+    category,
+    subject_kind,
+    subject_id,
+    actor_kind,
+    actor_id,
+    run_id,
+    process_id,
+    action,
+    outcome,
+    reason,
+    correlation_id,
+    causation_id,
+    schema_version,
+    data,
+    expires_at,
+    sequence`;
+async function insertInspectionEvent(client, args) {
+    const result = await client.query({
+        text: exports.insertInspectionEventQuery,
+        values: [args.id, args.tenantId, args.occurredAt, args.type, args.category, args.subjectKind, args.subjectId, args.actorKind, args.actorId, args.runId, args.processId, args.action, args.outcome, args.reason, args.correlationId, args.causationId, args.schemaVersion, args.data, args.expiresAt],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        tenantId: row[1],
+        occurredAt: row[2],
+        type: row[3],
+        category: row[4],
+        subjectKind: row[5],
+        subjectId: row[6],
+        actorKind: row[7],
+        actorId: row[8],
+        runId: row[9],
+        processId: row[10],
+        action: row[11],
+        outcome: row[12],
+        reason: row[13],
+        correlationId: row[14],
+        causationId: row[15],
+        schemaVersion: row[16],
+        data: row[17],
+        expiresAt: row[18],
+        sequence: row[19]
+    };
+}
+exports.queryInspectionEventsQuery = `-- name: QueryInspectionEvents :many
+SELECT
+    id,
+    tenant_id,
+    occurred_at,
+    type,
+    category,
+    subject_kind,
+    subject_id,
+    actor_kind,
+    actor_id,
+    run_id,
+    process_id,
+    action,
+    outcome,
+    reason,
+    correlation_id,
+    causation_id,
+    schema_version,
+    data,
+    expires_at,
+    sequence
+FROM atc.inspection_events
+WHERE tenant_id = $1
+  AND (
+      $2::text IS NULL
+      OR (
+          subject_kind = $2::text
+          AND subject_id = $3::text
+      )
+  )
+  AND (
+      $4::text IS NULL
+      OR (
+          actor_kind = $4::text
+          AND actor_id = $5::text
+      )
+  )
+  AND ($6::text IS NULL OR run_id = $6::text)
+  AND ($7::text IS NULL OR process_id = $7::text)
+  AND ($8::text IS NULL OR action = $8::text)
+  AND ($9::text IS NULL OR outcome = $9::text)
+  AND (
+      $10::timestamptz IS NULL
+      OR occurred_at >= $10::timestamptz
+  )
+  AND (
+      $11::timestamptz IS NULL
+      OR occurred_at < $11::timestamptz
+  )
+  AND (
+      $12::text IS NULL
+      OR type LIKE replace(replace($12::text, '*', '%'), '?', '_')
+  )
+  AND (
+      $13::timestamptz IS NULL
+      OR (
+          occurred_at,
+          sequence
+      ) < (
+          $13::timestamptz,
+          $14::bigint
+      )
+  )
+ORDER BY occurred_at DESC, sequence DESC
+LIMIT $15`;
+async function queryInspectionEvents(client, args) {
+    const result = await client.query({
+        text: exports.queryInspectionEventsQuery,
+        values: [args.tenantId, args.subjectKind, args.subjectId, args.actorKind, args.actorId, args.runId, args.processId, args.action, args.outcome, args.startTime, args.endTime, args.typeFilter, args.afterOccurredAt, args.afterSequence, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            tenantId: row[1],
+            occurredAt: row[2],
+            type: row[3],
+            category: row[4],
+            subjectKind: row[5],
+            subjectId: row[6],
+            actorKind: row[7],
+            actorId: row[8],
+            runId: row[9],
+            processId: row[10],
+            action: row[11],
+            outcome: row[12],
+            reason: row[13],
+            correlationId: row[14],
+            causationId: row[15],
+            schemaVersion: row[16],
+            data: row[17],
+            expiresAt: row[18],
+            sequence: row[19]
+        };
+    });
+}
+exports.loadInspectionEventsFromSequenceQuery = `-- name: LoadInspectionEventsFromSequence :many
+SELECT
+    id,
+    tenant_id,
+    occurred_at,
+    type,
+    category,
+    subject_kind,
+    subject_id,
+    actor_kind,
+    actor_id,
+    run_id,
+    process_id,
+    action,
+    outcome,
+    reason,
+    correlation_id,
+    causation_id,
+    schema_version,
+    data,
+    expires_at,
+    sequence
+FROM atc.inspection_events
+WHERE tenant_id = $1
+  AND sequence > $2
+  AND (
+      $3::text IS NULL
+      OR (
+          subject_kind = $3::text
+          AND subject_id = $4::text
+      )
+  )
+  AND (
+      $5::text IS NULL
+      OR (
+          actor_kind = $5::text
+          AND actor_id = $6::text
+      )
+  )
+  AND ($7::text IS NULL OR run_id = $7::text)
+  AND ($8::text IS NULL OR process_id = $8::text)
+  AND ($9::text IS NULL OR action = $9::text)
+  AND ($10::text IS NULL OR outcome = $10::text)
+  AND (
+      $11::timestamptz IS NULL
+      OR occurred_at >= $11::timestamptz
+  )
+  AND (
+      $12::timestamptz IS NULL
+      OR occurred_at < $12::timestamptz
+  )
+  AND (
+      $13::text IS NULL
+      OR type LIKE replace(replace($13::text, '*', '%'), '?', '_')
+  )
+ORDER BY sequence ASC`;
+async function loadInspectionEventsFromSequence(client, args) {
+    const result = await client.query({
+        text: exports.loadInspectionEventsFromSequenceQuery,
+        values: [args.tenantId, args.afterSequence, args.subjectKind, args.subjectId, args.actorKind, args.actorId, args.runId, args.processId, args.action, args.outcome, args.startTime, args.endTime, args.typeFilter],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            tenantId: row[1],
+            occurredAt: row[2],
+            type: row[3],
+            category: row[4],
+            subjectKind: row[5],
+            subjectId: row[6],
+            actorKind: row[7],
+            actorId: row[8],
+            runId: row[9],
+            processId: row[10],
+            action: row[11],
+            outcome: row[12],
+            reason: row[13],
+            correlationId: row[14],
+            causationId: row[15],
+            schemaVersion: row[16],
+            data: row[17],
+            expiresAt: row[18],
+            sequence: row[19]
+        };
+    });
+}
+exports.deleteExpiredInspectionEventsQuery = `-- name: DeleteExpiredInspectionEvents :one
+WITH expired AS (
+    SELECT id
+    FROM atc.inspection_events
+    WHERE expires_at < $1::timestamptz
+    ORDER BY expires_at ASC
+    LIMIT $2
+),
+deleted AS (
+    DELETE FROM atc.inspection_events
+    WHERE id IN (SELECT id FROM expired)
+    RETURNING id
+)
+SELECT COUNT(*)::BIGINT AS total
+FROM deleted`;
+async function deleteExpiredInspectionEvents(client, args) {
+    const result = await client.query({
+        text: exports.deleteExpiredInspectionEventsQuery,
+        values: [args.expiresBefore, args.deleteLimit],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        total: row[0]
+    };
+}