weave-typescript 0.12.0 → 0.13.0

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

@@ -0,0 +1,91 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const insertEventQuery = "-- name: InsertEvent :one\nINSERT INTO atc.events (\n    id,\n    tenant_id,\n    run_id,\n    sequence,\n    type,\n    data,\n    causation_id,\n    correlation_id\n) VALUES (\n    $1,\n    $2,\n    $3,\n    $4,\n    $5,\n    $6,\n    $7,\n    $8\n)\nRETURNING id, tenant_id, run_id, sequence, type, data, causation_id, correlation_id, occurred_at, transaction_id";
+export interface InsertEventArgs {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+}
+export interface InsertEventRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+    transactionId: string;
+}
+export declare function insertEvent(client: Client, args: InsertEventArgs): Promise<InsertEventRow | null>;
+export declare const getCurrentVersionQuery = "-- name: GetCurrentVersion :one\nSELECT COALESCE(MAX(sequence), 0)::BIGINT AS version\nFROM atc.events\nWHERE tenant_id = $1\n  AND run_id = $2";
+export interface GetCurrentVersionArgs {
+    tenantId: string;
+    runId: string;
+}
+export interface GetCurrentVersionRow {
+    version: string;
+}
+export declare function getCurrentVersion(client: Client, args: GetCurrentVersionArgs): Promise<GetCurrentVersionRow | null>;
+export declare const loadEventsQuery = "-- name: LoadEvents :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 sequence > $3\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY sequence ASC";
+export interface LoadEventsArgs {
+    tenantId: string;
+    runId: string;
+    afterSequence: string;
+}
+export interface LoadEventsRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function loadEvents(client: Client, args: LoadEventsArgs): Promise<LoadEventsRow[]>;
+export declare const loadAllEventsQuery = "-- name: LoadAllEvents :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 transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY sequence ASC";
+export interface LoadAllEventsArgs {
+    tenantId: string;
+    runId: string;
+}
+export interface LoadAllEventsRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function loadAllEvents(client: Client, args: LoadAllEventsArgs): Promise<LoadAllEventsRow[]>;
+export declare const listEventsByTypeQuery = "-- name: ListEventsByType :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 = $3\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY sequence ASC";
+export interface ListEventsByTypeArgs {
+    tenantId: string;
+    runId: string;
+    eventType: string;
+}
+export interface ListEventsByTypeRow {
+    id: string;
+    tenantId: string;
+    runId: string;
+    sequence: string;
+    type: string;
+    data: any | null;
+    causationId: string | null;
+    correlationId: string | null;
+    occurredAt: Date;
+}
+export declare function listEventsByType(client: Client, args: ListEventsByTypeArgs): Promise<ListEventsByTypeRow[]>;
+export {};

package/dist/weavesql/atcdb/event_sql.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.insertEventQuery = `-- name: InsertEvent :one
+INSERT INTO atc.events (
+    id,
+    tenant_id,
+    run_id,
+    sequence,
+    type,
+    data,
+    causation_id,
+    correlation_id
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7,
+    $8
+)
+RETURNING id, tenant_id, run_id, sequence, type, data, causation_id, correlation_id, occurred_at, transaction_id`;
+async function insertEvent(client, args) {
+    const result = await client.query({
+        text: exports.insertEventQuery,
+        values: [args.id, args.tenantId, args.runId, args.sequence, args.type, args.data, args.causationId, args.correlationId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    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],
+        transactionId: row[9]
+    };
+}
+exports.getCurrentVersionQuery = `-- name: GetCurrentVersion :one
+SELECT COALESCE(MAX(sequence), 0)::BIGINT AS version
+FROM atc.events
+WHERE tenant_id = $1
+  AND run_id = $2`;
+async function getCurrentVersion(client, args) {
+    const result = await client.query({
+        text: exports.getCurrentVersionQuery,
+        values: [args.tenantId, args.runId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        version: row[0]
+    };
+}
+exports.loadEventsQuery = `-- name: LoadEvents :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 sequence > $3
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY sequence ASC`;
+async function loadEvents(client, args) {
+    const result = await client.query({
+        text: exports.loadEventsQuery,
+        values: [args.tenantId, args.runId, args.afterSequence],
+        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.loadAllEventsQuery = `-- name: LoadAllEvents :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 transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY sequence ASC`;
+async function loadAllEvents(client, args) {
+    const result = await client.query({
+        text: exports.loadAllEventsQuery,
+        values: [args.tenantId, args.runId],
+        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.listEventsByTypeQuery = `-- name: ListEventsByType :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 = $3
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY sequence ASC`;
+async function listEventsByType(client, args) {
+    const result = await client.query({
+        text: exports.listEventsByTypeQuery,
+        values: [args.tenantId, args.runId, args.eventType],
+        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]
+        };
+    });
+}

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

@@ -0,0 +1,43 @@
+import { QueryArrayConfig, QueryArrayResult } from "pg";
+interface Client {
+    query: (config: QueryArrayConfig) => Promise<QueryArrayResult>;
+}
+export declare const ensureMailboxCursorQuery = "-- name: EnsureMailboxCursor :exec\nINSERT INTO atc.mailbox_cursors (tenant_id, process_id)\nVALUES ($1, $2)\nON CONFLICT (tenant_id, process_id) DO NOTHING";
+export interface EnsureMailboxCursorArgs {
+    tenantId: string;
+    processId: string;
+}
+export declare function ensureMailboxCursor(client: Client, args: EnsureMailboxCursorArgs): Promise<void>;
+export declare const lockMailboxCursorQuery = "-- name: LockMailboxCursor :one\nSELECT\n    last_acked_sequence,\n    last_processed_transaction_id::text AS last_processed_transaction_id\nFROM atc.mailbox_cursors\nWHERE tenant_id = $1\n  AND process_id = $2\nFOR UPDATE";
+export interface LockMailboxCursorArgs {
+    tenantId: string;
+    processId: string;
+}
+export interface LockMailboxCursorRow {
+    lastAckedSequence: string;
+    lastProcessedTransactionId: string;
+}
+export declare function lockMailboxCursor(client: Client, args: LockMailboxCursorArgs): Promise<LockMailboxCursorRow | null>;
+export declare const readMailboxQuery = "-- name: ReadMailbox :many\nSELECT\n    sequence,\n    transaction_id::text AS transaction_id,\n    data\nFROM atc.events\nWHERE tenant_id = $1\n  AND data->>'to' = $2\n  AND data->>'category' IN ('protocol', 'semantic')\n  AND (\n      sequence > $3\n      OR (sequence = $3 AND transaction_id > $4::xid8)\n  )\n  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())\nORDER BY sequence ASC\nLIMIT $5";
+export interface ReadMailboxArgs {
+    tenantId: string;
+    processId: any | null;
+    afterSequence: string;
+    afterTransactionId: string;
+    batchLimit: string;
+}
+export interface ReadMailboxRow {
+    sequence: string;
+    transactionId: string;
+    data: any | null;
+}
+export declare function readMailbox(client: Client, args: ReadMailboxArgs): Promise<ReadMailboxRow[]>;
+export declare const acknowledgeMailboxQuery = "-- name: AcknowledgeMailbox :exec\nUPDATE atc.mailbox_cursors\nSET\n    last_acked_sequence = $1,\n    last_processed_transaction_id = $2::xid8\nWHERE tenant_id = $3\n  AND process_id = $4";
+export interface AcknowledgeMailboxArgs {
+    lastSequence: string;
+    lastTransactionId: string;
+    tenantId: string;
+    processId: string;
+}
+export declare function acknowledgeMailbox(client: Client, args: AcknowledgeMailboxArgs): Promise<void>;
+export {};

package/dist/weavesql/atcdb/mailbox_sql.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acknowledgeMailboxQuery = exports.readMailboxQuery = exports.lockMailboxCursorQuery = exports.ensureMailboxCursorQuery = void 0;
+exports.ensureMailboxCursor = ensureMailboxCursor;
+exports.lockMailboxCursor = lockMailboxCursor;
+exports.readMailbox = readMailbox;
+exports.acknowledgeMailbox = acknowledgeMailbox;
+exports.ensureMailboxCursorQuery = `-- name: EnsureMailboxCursor :exec
+INSERT INTO atc.mailbox_cursors (tenant_id, process_id)
+VALUES ($1, $2)
+ON CONFLICT (tenant_id, process_id) DO NOTHING`;
+async function ensureMailboxCursor(client, args) {
+    await client.query({
+        text: exports.ensureMailboxCursorQuery,
+        values: [args.tenantId, args.processId],
+        rowMode: "array"
+    });
+}
+exports.lockMailboxCursorQuery = `-- name: LockMailboxCursor :one
+SELECT
+    last_acked_sequence,
+    last_processed_transaction_id::text AS last_processed_transaction_id
+FROM atc.mailbox_cursors
+WHERE tenant_id = $1
+  AND process_id = $2
+FOR UPDATE`;
+async function lockMailboxCursor(client, args) {
+    const result = await client.query({
+        text: exports.lockMailboxCursorQuery,
+        values: [args.tenantId, args.processId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        lastAckedSequence: row[0],
+        lastProcessedTransactionId: row[1]
+    };
+}
+exports.readMailboxQuery = `-- name: ReadMailbox :many
+SELECT
+    sequence,
+    transaction_id::text AS transaction_id,
+    data
+FROM atc.events
+WHERE tenant_id = $1
+  AND data->>'to' = $2
+  AND data->>'category' IN ('protocol', 'semantic')
+  AND (
+      sequence > $3
+      OR (sequence = $3 AND transaction_id > $4::xid8)
+  )
+  AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())
+ORDER BY sequence ASC
+LIMIT $5`;
+async function readMailbox(client, args) {
+    const result = await client.query({
+        text: exports.readMailboxQuery,
+        values: [args.tenantId, args.processId, args.afterSequence, args.afterTransactionId, args.batchLimit],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            sequence: row[0],
+            transactionId: row[1],
+            data: row[2]
+        };
+    });
+}
+exports.acknowledgeMailboxQuery = `-- name: AcknowledgeMailbox :exec
+UPDATE atc.mailbox_cursors
+SET
+    last_acked_sequence = $1,
+    last_processed_transaction_id = $2::xid8
+WHERE tenant_id = $3
+  AND process_id = $4`;
+async function acknowledgeMailbox(client, args) {
+    await client.query({
+        text: exports.acknowledgeMailboxQuery,
+        values: [args.lastSequence, args.lastTransactionId, args.tenantId, args.processId],
+        rowMode: "array"
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weave-typescript",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [