@relayfx/sdk 0.7.10 → 0.7.12

package/dist/types/store-sql/execution/execution-event-archive-repository.d.ts

@@ -0,0 +1,175 @@
+import { Ids } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Service as EventHistoryStore } from "./event-history-store";
+import { makeMemoryLayer } from "./execution-event-archive-repository-memory";
+export declare const ArchiveBlockDescriptor: Schema.Struct<{
+    readonly firstSequence: Schema.Int;
+    readonly lastSequence: Schema.Int;
+    readonly eventCount: Schema.Int;
+    readonly object: Schema.Struct<{
+        readonly key: Schema.String;
+        readonly checksum: Schema.String;
+        readonly size: Schema.Int;
+    }>;
+    readonly codecVersion: Schema.Literals<readonly [1, 2]>;
+    readonly encoding: Schema.Literal<"json">;
+    readonly compression: Schema.Literals<readonly ["none", "gzip"]>;
+    readonly payloadChecksum: Schema.String;
+    readonly storedPayloadBytes: Schema.Int;
+    readonly uncompressedBytes: Schema.Int;
+}>;
+export interface ArchiveBlockDescriptor extends Schema.Schema.Type<typeof ArchiveBlockDescriptor> {
+}
+export declare const PublicationInput: Schema.Struct<{
+    readonly executionId: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly generation: Schema.Int;
+    readonly archivedThrough: Schema.Int;
+    readonly eventCount: Schema.Int;
+    readonly maxSequence: Schema.Int;
+    readonly usageTokens: Schema.Int;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly blocks: Schema.$Array<Schema.Struct<{
+        readonly firstSequence: Schema.Int;
+        readonly lastSequence: Schema.Int;
+        readonly eventCount: Schema.Int;
+        readonly object: Schema.Struct<{
+            readonly key: Schema.String;
+            readonly checksum: Schema.String;
+            readonly size: Schema.Int;
+        }>;
+        readonly codecVersion: Schema.Literals<readonly [1, 2]>;
+        readonly encoding: Schema.Literal<"json">;
+        readonly compression: Schema.Literals<readonly ["none", "gzip"]>;
+        readonly payloadChecksum: Schema.String;
+        readonly storedPayloadBytes: Schema.Int;
+        readonly uncompressedBytes: Schema.Int;
+    }>>;
+}>;
+export interface PublicationInput extends Schema.Schema.Type<typeof PublicationInput> {
+}
+export declare const Manifest: Schema.Struct<{
+    readonly executionId: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly generation: Schema.Int;
+    readonly archivedThrough: Schema.Int;
+    readonly eventCount: Schema.Int;
+    readonly maxSequence: Schema.Int;
+    readonly usageTokens: Schema.Int;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly blocks: Schema.$Array<Schema.Struct<{
+        readonly firstSequence: Schema.Int;
+        readonly lastSequence: Schema.Int;
+        readonly eventCount: Schema.Int;
+        readonly object: Schema.Struct<{
+            readonly key: Schema.String;
+            readonly checksum: Schema.String;
+            readonly size: Schema.Int;
+        }>;
+        readonly codecVersion: Schema.Literals<readonly [1, 2]>;
+        readonly encoding: Schema.Literal<"json">;
+        readonly compression: Schema.Literals<readonly ["none", "gzip"]>;
+        readonly payloadChecksum: Schema.String;
+        readonly storedPayloadBytes: Schema.Int;
+        readonly uncompressedBytes: Schema.Int;
+    }>>;
+    readonly tenantId: Schema.brand<Schema.String, "Relay.TenantId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.TenantId">;
+    };
+}>;
+export interface Manifest extends Schema.Schema.Type<typeof Manifest> {
+}
+declare const ArchiveManifestInvalid_base: Schema.Class<ArchiveManifestInvalid, Schema.TaggedStruct<"ArchiveManifestInvalid", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly generation: Schema.Int;
+    readonly reason: Schema.Literals<readonly ["invalid-schema", "invalid-bounds", "invalid-block-order", "invalid-block-count", "invalid-object-size", "prefix-mismatch", "exceeds-head"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ArchiveManifestInvalid extends ArchiveManifestInvalid_base {
+}
+declare const ArchiveGenerationConflict_base: Schema.Class<ArchiveGenerationConflict, Schema.TaggedStruct<"ArchiveGenerationConflict", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly generation: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+export declare class ArchiveGenerationConflict extends ArchiveGenerationConflict_base {
+}
+declare const ArchivePublicationStale_base: Schema.Class<ArchivePublicationStale, Schema.TaggedStruct<"ArchivePublicationStale", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly generation: Schema.Int;
+    readonly current_generation: Schema.Int;
+    readonly current_archived_through: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+export declare class ArchivePublicationStale extends ArchivePublicationStale_base {
+}
+declare const ArchiveHeadNotFound_base: Schema.Class<ArchiveHeadNotFound, Schema.TaggedStruct<"ArchiveHeadNotFound", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ArchiveHeadNotFound extends ArchiveHeadNotFound_base {
+}
+declare const ArchiveRepositoryError_base: Schema.Class<ArchiveRepositoryError, Schema.TaggedStruct<"ArchiveRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ArchiveRepositoryError extends ArchiveRepositoryError_base {
+}
+declare const ArchiveIntegrityError_base: Schema.Class<ArchiveIntegrityError, Schema.TaggedStruct<"ArchiveIntegrityError", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ArchiveIntegrityError extends ArchiveIntegrityError_base {
+}
+export type PublicationFailure = ArchiveManifestInvalid | ArchiveGenerationConflict | ArchivePublicationStale | ArchiveHeadNotFound | ArchiveIntegrityError | ArchiveRepositoryError;
+export interface Interface {
+    readonly publish: (input: PublicationInput) => Effect.Effect<Manifest, PublicationFailure>;
+    readonly getCurrent: (executionId: Ids.ExecutionId) => Effect.Effect<Manifest | undefined, ArchiveRepositoryError | ArchiveIntegrityError>;
+    readonly getGeneration: (executionId: Ids.ExecutionId, generation: number) => Effect.Effect<Manifest | undefined, ArchiveRepositoryError | ArchiveIntegrityError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/execution/execution-event-archive-repository/Service", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const validatePublication: (candidate: PublicationInput) => Effect.Effect<Schema.Struct.ReadonlySide<{
+    readonly executionId: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly generation: Schema.Int;
+    readonly archivedThrough: Schema.Int;
+    readonly eventCount: Schema.Int;
+    readonly maxSequence: Schema.Int;
+    readonly usageTokens: Schema.Int;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly blocks: Schema.$Array<Schema.Struct<{
+        readonly firstSequence: Schema.Int;
+        readonly lastSequence: Schema.Int;
+        readonly eventCount: Schema.Int;
+        readonly object: Schema.Struct<{
+            readonly key: Schema.String;
+            readonly checksum: Schema.String;
+            readonly size: Schema.Int;
+        }>;
+        readonly codecVersion: Schema.Literals<readonly [1, 2]>;
+        readonly encoding: Schema.Literal<"json">;
+        readonly compression: Schema.Literals<readonly ["none", "gzip"]>;
+        readonly payloadChecksum: Schema.String;
+        readonly storedPayloadBytes: Schema.Int;
+        readonly uncompressedBytes: Schema.Int;
+    }>>;
+}, "Type">, ArchiveManifestInvalid, never>;
+export declare const layer: Layer.Layer<Service, never, import("effect/Crypto").Crypto | EventHistoryStore | import("effect/unstable/sql/SqlClient").SqlClient>;
+export declare const memoryLayer: Layer.Layer<Service, never, import("effect/Crypto").Crypto | import("./execution-event-head-memory").Service | import("./execution-event-repository").Service | EventHistoryStore>;
+export declare const memoryLayerWithRestoredState: (restored: Parameters<typeof makeMemoryLayer>[1]) => Layer.Layer<Service, never, import("effect/Crypto").Crypto | import("./execution-event-head-memory").Service | import("./execution-event-repository").Service | EventHistoryStore>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
+export declare const publish: (input: PublicationInput) => Effect.Effect<Manifest, PublicationFailure, Service>;
+export declare const getCurrent: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Manifest | undefined, ArchiveIntegrityError | ArchiveRepositoryError, Service>;
+export declare const getGeneration: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">, generation: number) => Effect.Effect<Manifest | undefined, ArchiveIntegrityError | ArchiveRepositoryError, Service>;
+export {};

package/dist/types/store-sql/execution/execution-event-head-memory.d.ts

@@ -0,0 +1,13 @@
+import { Ids } from "../../schema/index";
+import { Context, Effect, Layer } from "effect";
+type TransactionAction = Effect.Effect<void, never>;
+export interface Interface {
+    readonly transaction: <A, E, R>(executionId: Ids.ExecutionId, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+    readonly registerRollback: (action: TransactionAction) => Effect.Effect<void>;
+    readonly registerAfterCommit: (action: TransactionAction) => Effect.Effect<void>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/execution/execution-event-head-memory/Service", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, never>;
+export {};

package/dist/types/store-sql/execution/execution-event-head.d.ts

@@ -0,0 +1,40 @@
+import { Execution, Ids } from "../../schema/index";
+import { Effect, Schema } from "effect";
+import type { SqlClient } from "effect/unstable/sql/SqlClient";
+declare const ExecutionEventHeadError_base: Schema.Class<ExecutionEventHeadError, Schema.TaggedStruct<"ExecutionEventHeadError", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly reason: Schema.Literals<readonly ["not-found", "integrity"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionEventHeadError extends ExecutionEventHeadError_base {
+}
+export interface LockedHead {
+    readonly nextSequence: number;
+    readonly maxSequence: number | undefined;
+    readonly eventCount: number;
+    readonly usageTokens: number;
+    readonly archivedThrough: number | undefined;
+    readonly archiveGeneration: number | undefined;
+}
+export interface HeadResult<A> {
+    readonly value: A;
+    readonly appended: boolean;
+}
+declare const withLockedHead: <A, E, R>(sql: SqlClient, input: {
+    readonly tenantId: Ids.TenantId;
+    readonly executionId: Ids.ExecutionId;
+    readonly use: (head: LockedHead) => Effect.Effect<A, E, R>;
+}) => Effect.Effect<A, E | ExecutionEventHeadError | import("effect/unstable/sql/SqlError").SqlError, R>;
+declare const withEventHead: <A, E, R>(sql: SqlClient, input: {
+    readonly tenantId: Ids.TenantId;
+    readonly executionId: Ids.ExecutionId;
+    readonly usageTokens: number;
+    readonly use: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<HeadResult<A>, E, R>;
+}) => Effect.Effect<A, E | ExecutionEventHeadError | import("effect/unstable/sql/SqlError").SqlError, R>;
+export declare const ExecutionEventHead: {
+    withEventHead: typeof withEventHead;
+    withLockedHead: typeof withLockedHead;
+};
+export {};

package/dist/types/store-sql/execution/execution-event-identity-directory.d.ts

@@ -0,0 +1,26 @@
+import { Execution, Ids } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+export interface EventIdentity {
+    readonly cursor: string;
+    readonly eventId: Ids.EventId;
+    readonly executionId: Ids.ExecutionId;
+    readonly sequence: Execution.ExecutionEventSequence;
+}
+declare const EventIdentityDirectoryError_base: Schema.Class<EventIdentityDirectoryError, Schema.TaggedStruct<"EventIdentityDirectoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EventIdentityDirectoryError extends EventIdentityDirectoryError_base {
+}
+export interface Interface {
+    readonly findByCursor: (cursor: string) => Effect.Effect<EventIdentity | undefined, EventIdentityDirectoryError>;
+    readonly findByEventId: (eventId: Ids.EventId) => Effect.Effect<EventIdentity | undefined, EventIdentityDirectoryError>;
+    readonly findBySequence: (executionId: Ids.ExecutionId, sequence: Execution.ExecutionEventSequence) => Effect.Effect<EventIdentity | undefined, EventIdentityDirectoryError>;
+    readonly listRange: (executionId: Ids.ExecutionId, firstSequence: Execution.ExecutionEventSequence, lastSequence: Execution.ExecutionEventSequence) => Effect.Effect<ReadonlyArray<EventIdentity>, EventIdentityDirectoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/execution/execution-event-identity-directory/Service", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, SqlClient>;
+export declare const testLayer: (identities: ReadonlyArray<EventIdentity>) => Layer.Layer<Service>;
+export {};

package/dist/types/store-sql/execution/execution-event-repository-archive-aware.d.ts

@@ -0,0 +1,7 @@
+import { Crypto, Layer } from "effect";
+import { Service as ArchiveRepository } from "./execution-event-archive-repository";
+import { Service as HistoryStore } from "./event-history-store";
+import { Service as IdentityDirectory } from "./execution-event-identity-directory";
+import { Service, type Interface } from "./execution-event-repository";
+/** Package-private composition seam. Public runtime wiring remains SQL-only until the configuration slice. */
+export declare const layerForHotRepository: (hot: Interface) => Layer.Layer<Service, never, ArchiveRepository | HistoryStore | IdentityDirectory | Crypto.Crypto>;

package/dist/types/store-sql/execution/execution-event-repository-memory.d.ts

@@ -1,8 +1,13 @@
 import { Layer } from "effect";
+import { Service as MemoryEventHeadService } from "./execution-event-head-memory";
 import type { DuplicateExecutionEvent, ExecutionEventCursorNotFound, ExecutionEventOrderViolation, Service } from "./execution-event-repository";
 export declare const makeMemoryLayer: (repository: {
     readonly DuplicateExecutionEvent: typeof DuplicateExecutionEvent;
     readonly ExecutionEventOrderViolation: typeof ExecutionEventOrderViolation;
     readonly ExecutionEventCursorNotFound: typeof ExecutionEventCursorNotFound;
     readonly Service: typeof Service;
-}) => Layer.Layer<Service, never, never>;
+}) => {
+    layer: Layer.Layer<MemoryEventHeadService | Service, never, never>;
+    layerWithoutEventHead: Layer.Layer<Service, never, MemoryEventHeadService>;
+    eventHeadLayer: Layer.Layer<MemoryEventHeadService, never, never>;
+};

package/dist/types/store-sql/execution/execution-event-repository.d.ts

@@ -38,8 +38,8 @@ export interface ListInput {
     readonly afterCursor?: string;
     readonly limit?: number;
 }
-export interface AppendNextInput extends Omit<Execution.ExecutionEvent, "sequence"> {
-    readonly minimumSequence?: Execution.ExecutionEventSequence;
+export type ExecutionEventDraft = Omit<Execution.ExecutionEvent, "sequence">;
+export interface AppendNextInput extends ExecutionEventDraft {
 }
 export interface AppendNextResult {
     readonly event: Execution.ExecutionEvent;
@@ -119,8 +119,10 @@ export declare const ExecutionEventRow: Schema.Struct<{
 }>;
 export declare const layer: Layer.Layer<Service, never, import("../database/notification-bus").Service | import("effect/unstable/sql/SqlClient").SqlClient>;
 export declare const layerWithBus: Layer.Layer<Service, never, import("effect/unstable/sql/SqlClient").SqlClient>;
-export declare const memoryLayer: Layer.Layer<Service, never, never>;
-export type TestImplementation = Omit<Interface, "appendNext" | "page"> & Partial<Pick<Interface, "appendNext" | "page">>;
+export declare const memoryLayer: Layer.Layer<import("./execution-event-head-memory").Service | Service, never, never>;
+export declare const memoryLayerWithoutEventHead: Layer.Layer<Service, never, import("./execution-event-head-memory").Service>;
+export declare const memoryEventHeadLayer: Layer.Layer<import("./execution-event-head-memory").Service, never, never>;
+export type TestImplementation = Omit<Interface, "page"> & Partial<Pick<Interface, "page">>;
 export declare const testLayer: (implementation: TestImplementation) => Layer.Layer<Service, never, never>;
 export declare const append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, DuplicateExecutionEvent | ExecutionEventOrderViolation | ExecutionEventRepositoryError, Service>;
 export declare const appendNext: (input: AppendNextInput) => Effect.Effect<AppendNextResult, DuplicateExecutionEvent | ExecutionEventRepositoryError, Service>;

package/dist/types/store-sql/inbox/inbox-repository.d.ts

@@ -2,12 +2,16 @@ import { Ids, Inbox, Shared } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
 import type { AcceptEnvelopeInput } from "../envelope/envelope-repository";
+import { Service as ExecutionEventRepositoryService } from "../execution/execution-event-repository";
+import { Service as MemoryEventHeadService } from "../execution/execution-event-head-memory";
 declare const InboxRepositoryError_base: Schema.Class<InboxRepositoryError, Schema.TaggedStruct<"InboxRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InboxRepositoryError extends InboxRepositoryError_base {
 }
 export interface DeliverInput {
+    /** Stable coordinate for deliveries that have neither an envelope nor an idempotency key. */
+    readonly operationId?: string;
     readonly acceptance?: AcceptEnvelopeInput;
     readonly executionId: Ids.ExecutionId;
     readonly from: Ids.AddressId;
@@ -46,8 +50,8 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/inbox/inbox-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, SqlClient>;
-export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const layer: Layer.Layer<Service, never, ExecutionEventRepositoryService | SqlClient>;
+export declare const memoryLayer: Layer.Layer<Service, never, MemoryEventHeadService>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const deliver: (input: DeliverInput) => Effect.Effect<DeliverResult, InboxRepositoryError, Service>;
 export declare const drain: (input: DrainInput) => Effect.Effect<readonly Inbox.Message[], InboxRepositoryError, Service>;

package/dist/types/store-sql/schema/communication-schema.d.ts

@@ -33,6 +33,21 @@ export declare const relaySteeringMessages: import("drizzle-orm/pg-core").PgTabl
             identity: undefined;
             generated: undefined;
         }>;
+        idempotencyKey: import("drizzle-orm/pg-core").PgBuildColumn<"relay_steering_messages", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "relay_steering_messages";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
         kind: import("drizzle-orm/pg-core").PgBuildColumn<"relay_steering_messages", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>, {
             name: string;
             tableName: "relay_steering_messages";