@segmentstream-cloud/ontology 0.24.1 → 0.25.0

package/dist/runtime/pipeline.js

@@ -16,6 +16,7 @@ import { Edit } from "./history.js";
 import { makeOntologyRuntime } from "./sql-runtime.js";
 import { AgentFileRecords, resolveFileRecord } from "./files.js";
 import { validate } from "./validation.js";
+import { ACTION_TRANSACTION_LIMITS, ActionTransactionDeadline, ActionTransactions, } from "./action-transactions.js";
 /** How long `prepare` may take, connection calls included; each call has its own 30 s deadline. */
 export const PREPARE_TIMEOUT = Duration.seconds(60);
 export const ActionValidation = Schema.Struct({
@@ -173,6 +174,7 @@ export function runAction(ontology, request) {
             ...(request.branchId ? { branchId: request.branchId } : {}),
             ...(request.options?.createIntent ? { createIntent: request.options.createIntent } : {}),
             onEdit: (edit) => edits.push(edit),
+            replicationInitialized: true,
         });
         const handle = action.handler;
         const handler = Effect.suspend(() => handle({ ...context, prepared }));
@@ -209,9 +211,21 @@ export function runAction(ontology, request) {
             }
             return result;
         });
-        const result = yield* sql
-            .withTransaction(beginReplicationWrite(sql).pipe(Effect.andThen(transactionalHandler)))
-            .pipe(Effect.catchIf(isSqlError, (error) => Effect.die(error)));
+        const admission = Option.getOrUndefined(yield* Effect.serviceOption(ActionTransactions));
+        const limits = admission?.limits ?? ACTION_TRANSACTION_LIMITS;
+        const transactionBody = Effect.gen(function* () {
+            // Server deadlines also protect the reserved connection if client cancellation cannot arrive.
+            yield* sql.unsafe(`SELECT set_config('statement_timeout', $1, true), set_config('lock_timeout', $2, true)`, [`${limits.statementTimeoutMs}ms`, `${limits.lockTimeoutMs}ms`]);
+            yield* beginReplicationWrite(sql);
+            return yield* transactionalHandler;
+        }).pipe(Effect.timeoutOrElse({
+            duration: Duration.millis(limits.handlerTimeoutMs),
+            orElse: () => Effect.logWarning("ontology.action.transaction_deadline").pipe(Effect.annotateLogs({ deadlineMs: limits.handlerTimeoutMs }), Effect.andThen(Effect.die(new ActionTransactionDeadline(`${qualified} exceeded its transaction deadline.`)))),
+        }));
+        // Time out the interruptible body only. The SQL manager must finish rollback/commit and
+        // release its connection; a lost COMMIT response must never cause an automatic replay.
+        const transaction = sql.withTransaction(transactionBody);
+        const result = yield* (admission ? admission.admit(transaction) : transaction).pipe(Effect.annotateLogs({ action: qualified, actionId, requestId }), Effect.catchIf(isSqlError, (error) => Effect.die(error)));
         if (replay) {
             return replay;
         }

package/dist/runtime/service-binding.js

@@ -14,6 +14,7 @@ import { runAction } from "./pipeline.js";
 import { checkSignIn, resolvePrincipalByApiKey, resolvePrincipalByIdentity, resolvePipelineWorker, } from "./principals.js";
 import { postgresTls } from "./postgres-tls.js";
 import { makeOntologyRuntime } from "./sql-runtime.js";
+import { ActionTransactions, makeActionTransactions } from "./action-transactions.js";
 /** Connections one service instance holds to the database's pooler. */
 const MAX_CONNECTIONS = 5;
 /**
@@ -28,6 +29,7 @@ export function backendLayer(ontology, blobStorage) {
     return Layer.effect(OntologyBackend, Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient;
         const runtime = makeOntologyRuntime(ontology, sql);
+        const actionTransactions = makeActionTransactions();
         const withSql = (effect) => Effect.provideService(effect, SqlClient.SqlClient, sql);
         const binding = blobStorage ? Redacted.value(blobStorage) : undefined;
         const provider = binding
@@ -49,7 +51,7 @@ export function backendLayer(ontology, blobStorage) {
                 afterCommit: input.afterCommit === undefined ? [] : [input.afterCommit],
                 ...(input.requestId === undefined ? {} : { requestId: input.requestId }),
                 ...(input.connections === undefined ? {} : { connections: input.connections }),
-            })).pipe(Effect.catchTag("UnknownAction", (error) => Effect.die(error))),
+            })).pipe(Effect.provideService(ActionTransactions, actionTransactions), Effect.catchTag("UnknownAction", (error) => Effect.die(error))),
             get: (input) => runtime.get(input),
             find: (input) => runtime.query(input),
             history: (input) => runtime.history(input),
@@ -87,6 +89,7 @@ export function postgresLayer(databaseUrl) {
         url: databaseUrl,
         ssl: postgresTls(databaseUrl),
         maxConnections: MAX_CONNECTIONS,
+        connectTimeout: "5 seconds",
         applicationName: "segmentstream-ontology",
     });
 }

package/dist/runtime/sql-runtime.d.ts

@@ -11,6 +11,8 @@ import type { Edit, HistoryEntry, HistoryScope } from "./history.js";
  * `created_by`/`updated_by` to its principal.
  */
 export interface WriteScope extends HistoryScope {
+    /** Set only when the enclosing action initialized replication in its outer transaction. */
+    readonly replicationInitialized?: boolean;
     /** Receives the edits of each write that succeeded, in order. */
     readonly onEdit?: (edit: Edit) => void;
 }

package/dist/runtime/sql-runtime.js

@@ -1,4 +1,4 @@
-import { Effect } from "effect";
+import { Effect, Option } from "effect";
 import { beginReplicationWrite } from "../replication/transaction.js";
 import { isSqlError } from "effect/unstable/sql/SqlError";
 import { Conflict } from "../errors.js";
@@ -100,8 +100,10 @@ export function makeOntologyRuntime(ontology, sql, scope) {
             }));
         }
         const edits = [];
+        const enclosingTransaction = yield* Effect.serviceOption(sql.transactionService);
+        const initialized = scope.replicationInitialized && Option.isSome(enclosingTransaction);
         const result = yield* sql
-            .withTransaction(beginReplicationWrite(sql).pipe(Effect.andThen(operation({ ...context, scope, edits }, entity))))
+            .withTransaction((initialized ? Effect.void : beginReplicationWrite(sql)).pipe(Effect.andThen(operation({ ...context, scope, edits }, entity))))
             .pipe(Effect.catchIf(isSqlError, (error) => uniqueConflict(entity, error)));
         for (const edit of edits) {
             scope.onEdit?.(edit);

package/dist/service/replication.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
 import type { OntologyEnvironment } from "./config.js";
 export type ReplicationKick = (identity: string | undefined) => Effect.Effect<void>;
-/** A fast path only. The committed history, not this request, makes delivery durable. */
+/** Coalesce best-effort wakes without adding network latency to committed actions. Durable recovery owns retries. */
 export declare function deployedReplication(environment: OntologyEnvironment, fetchImpl?: typeof fetch): ReplicationKick;

package/dist/service/replication.js

@@ -1,25 +1,36 @@
 import { Effect } from "effect";
-/** A fast path only. The committed history, not this request, makes delivery durable. */
+/** Coalesce best-effort wakes without adding network latency to committed actions. Durable recovery owns retries. */
 export function deployedReplication(environment, fetchImpl = fetch) {
+    let inFlight = false;
+    let nextWakeAt = 0;
     return (identity) => {
         if (!identity) {
             return Effect.void;
         }
-        return Effect.tryPromise(async () => {
-            const response = await fetchImpl(`${environment.segmentstreamUrl}/api/internal/v1/workspaces/` +
-                `${encodeURIComponent(environment.workspaceId)}/ontology/replication/drain`, {
-                method: "POST",
-                redirect: "error",
-                signal: AbortSignal.timeout(5000),
-                headers: {
-                    "x-segmentstream-runtime-identity": identity,
-                    "x-segmentstream-organization-id": environment.organizationId,
-                },
-            });
-            await response.body?.cancel();
-            if (!response.ok) {
-                throw new Error(`Replication wake-up returned HTTP ${response.status}.`);
+        return Effect.suspend(() => {
+            if (inFlight || Date.now() < nextWakeAt) {
+                return Effect.void;
             }
-        }).pipe(Effect.catchCause((cause) => Effect.logWarning("ontology.replication.deferred", cause)));
+            inFlight = true;
+            nextWakeAt = Date.now() + 1000;
+            return Effect.tryPromise(async () => {
+                const response = await fetchImpl(`${environment.segmentstreamUrl}/api/internal/v1/workspaces/` +
+                    `${encodeURIComponent(environment.workspaceId)}/ontology/replication/drain`, {
+                    method: "POST",
+                    redirect: "error",
+                    signal: AbortSignal.timeout(5000),
+                    headers: {
+                        "x-segmentstream-runtime-identity": identity,
+                        "x-segmentstream-organization-id": environment.organizationId,
+                    },
+                });
+                await response.body?.cancel();
+                if (!response.ok) {
+                    throw new Error(`Replication wake-up returned HTTP ${response.status}.`);
+                }
+            }).pipe(Effect.catchCause((cause) => Effect.logWarning("ontology.replication.deferred", cause)), Effect.ensuring(Effect.sync(() => {
+                inFlight = false;
+            })), Effect.forkDetach, Effect.asVoid);
+        });
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segmentstream-cloud/ontology",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "description": "Define a SegmentStream workspace app's ontology: entities, relationships, roles and actions, written with Effect.",
   "license": "Apache-2.0",
   "author": "SegmentStream",