@relayfx/sdk 0.0.50 → 0.2.0

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

@@ -0,0 +1,80 @@
+import { Ids, Shared, State } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { Service as ExecutionEventRepositoryService } from "../execution/execution-event-repository";
+import { Service as ExecutionRepositoryService } from "../execution/execution-repository";
+declare const StateVersionConflict_base: Schema.Class<StateVersionConflict, Schema.TaggedStruct<"StateVersionConflict", {
+    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 key: Schema.String;
+    readonly expected_version: Schema.Int;
+    readonly actual_version: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+export declare class StateVersionConflict extends StateVersionConflict_base {
+}
+declare const ExecutionStateRepositoryError_base: Schema.Class<ExecutionStateRepositoryError, Schema.TaggedStruct<"ExecutionStateRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionStateRepositoryError extends ExecutionStateRepositoryError_base {
+}
+declare const ExecutionStateExecutionNotFound_base: Schema.Class<ExecutionStateExecutionNotFound, Schema.TaggedStruct<"ExecutionStateExecutionNotFound", {
+    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 ExecutionStateExecutionNotFound extends ExecutionStateExecutionNotFound_base {
+}
+declare const StateIdempotencyConflict_base: Schema.Class<StateIdempotencyConflict, Schema.TaggedStruct<"StateIdempotencyConflict", {
+    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 idempotency_key: Schema.String;
+    readonly recorded_key: Schema.String;
+    readonly requested_key: Schema.String;
+    readonly recorded_op: Schema.Literals<readonly ["put", "delete"]>;
+    readonly requested_op: Schema.Literals<readonly ["put", "delete"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class StateIdempotencyConflict extends StateIdempotencyConflict_base {
+}
+export interface OperationResult {
+    readonly key: string;
+    readonly op: "put" | "delete";
+    readonly record: State.StateRecordView | undefined;
+}
+export interface PutInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly key: string;
+    readonly value: Shared.JsonValue;
+    readonly eventData: (version: number) => Shared.Metadata;
+    readonly expectedVersion?: number;
+    readonly idempotencyKey?: string;
+    readonly updatedAt: number;
+}
+export interface RemoveInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly key: string;
+    readonly expectedVersion?: number;
+    readonly idempotencyKey?: string;
+    readonly removedAt: number;
+}
+export interface ListInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly prefix?: string;
+    readonly afterKey?: string;
+    readonly limit?: number;
+}
+export interface Interface {
+    readonly findOperation: (executionId: Ids.ExecutionId, idempotencyKey: string) => Effect.Effect<OperationResult | undefined, ExecutionStateRepositoryError>;
+    readonly get: (executionId: Ids.ExecutionId, key: string) => Effect.Effect<State.StateRecordView | undefined, ExecutionStateRepositoryError>;
+    readonly put: (input: PutInput) => Effect.Effect<State.StateRecordView, StateVersionConflict | StateIdempotencyConflict | ExecutionStateExecutionNotFound | ExecutionStateRepositoryError>;
+    readonly remove: (input: RemoveInput) => Effect.Effect<State.StateRecordView | undefined, StateVersionConflict | StateIdempotencyConflict | ExecutionStateExecutionNotFound | ExecutionStateRepositoryError>;
+    readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<State.StateRecordView>, ExecutionStateRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ExecutionStateRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const memoryLayer: Layer.Layer<Service, never, ExecutionEventRepositoryService | ExecutionRepositoryService>;
+export declare const layer: Layer.Layer<Service, never, SqlClient | ExecutionEventRepositoryService>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};

package/dist/types/store-sql/tenant/tenant-id.d.ts

@@ -1,5 +1,4 @@
 import { Ids } from "../../schema/index";
-import { type AnyColumn, type SQLWrapper } from "drizzle-orm";
 import { Context, Effect, Layer } from "effect";
 export interface Interface {
     readonly tenantId: Ids.TenantId;
@@ -13,5 +12,4 @@ export declare const systemLayer: Layer.Layer<Service, never, never>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (tenantId: Ids.TenantId) => Layer.Layer<Service, never, never>;
 export declare const current: () => Effect.Effect<string & import("effect/Brand").Brand<"Relay.TenantId">, never, never>;
-export declare const predicate: (tenantId: Ids.TenantId, tenantColumn: AnyColumn, ...conditions: ReadonlyArray<SQLWrapper | undefined>) => import("drizzle-orm").SQL<unknown> | undefined;
 export {};

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

@@ -0,0 +1,44 @@
+import { Ids, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+declare const TopicRepositoryError_base: Schema.Class<TopicRepositoryError, Schema.TaggedStruct<"TopicRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class TopicRepositoryError extends TopicRepositoryError_base {
+}
+export interface Subscription {
+    readonly topic_address_id: Ids.AddressId;
+    readonly subscriber_execution_id: Ids.ExecutionId;
+    readonly metadata?: Shared.Metadata;
+    readonly created_at: number;
+}
+export interface UpsertInput {
+    readonly topicAddressId: Ids.AddressId;
+    readonly subscriberExecutionId: Ids.ExecutionId;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface RemoveInput {
+    readonly topicAddressId: Ids.AddressId;
+    readonly subscriberExecutionId: Ids.ExecutionId;
+}
+export interface ListInput {
+    readonly topicAddressId?: Ids.AddressId;
+    readonly subscriberExecutionId?: Ids.ExecutionId;
+    readonly limit?: number;
+}
+export interface Interface {
+    readonly upsert: (input: UpsertInput) => Effect.Effect<Subscription, TopicRepositoryError>;
+    readonly remove: (input: RemoveInput) => Effect.Effect<void, TopicRepositoryError>;
+    readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<Subscription>, TopicRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/TopicRepository", 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 testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const upsert: (input: UpsertInput) => Effect.Effect<Subscription, TopicRepositoryError, Service>;
+export declare const remove: (input: RemoveInput) => Effect.Effect<void, TopicRepositoryError, Service>;
+export declare const list: (input: ListInput) => Effect.Effect<readonly Subscription[], TopicRepositoryError, Service>;
+export {};

package/dist/types/store-sql/workflow/workflow-definition-repository.d.ts

@@ -0,0 +1,29 @@
+import { Ids, Workflow } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+declare const RepositoryError_base: Schema.Class<RepositoryError, Schema.TaggedStruct<"WorkflowDefinitionRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class RepositoryError extends RepositoryError_base {
+}
+export interface Interface {
+    readonly register: (input: Workflow.RegisterDefinitionPayload) => Effect.Effect<Workflow.DefinitionRevisionRecord, unknown>;
+    readonly get: (id: Ids.WorkflowDefinitionId, revision?: Workflow.DefinitionRevision) => Effect.Effect<Workflow.DefinitionRevisionRecord | undefined, unknown>;
+    readonly list: (id: Ids.WorkflowDefinitionId) => Effect.Effect<ReadonlyArray<Workflow.DefinitionRevisionRecord>, unknown>;
+    readonly start: (input: Workflow.StartRunPayload) => Effect.Effect<Workflow.RunRecord, unknown>;
+    readonly inspect: (id: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, unknown>;
+    readonly listNonterminal: () => Effect.Effect<ReadonlyArray<Workflow.RunRecord>, unknown>;
+    readonly cancel: (id: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, unknown>;
+    readonly getOperation: (executionId: Ids.ExecutionId, operationId: Ids.WorkflowOperationId) => Effect.Effect<Workflow.OperationState | undefined, unknown>;
+    readonly putOperation: (state: Workflow.OperationState) => Effect.Effect<Workflow.OperationState, unknown>;
+    readonly listOperations: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<Workflow.OperationState>, unknown>;
+    readonly appendLifecycle: (event: Omit<Workflow.LifecycleEvent, "sequence">) => Effect.Effect<Workflow.LifecycleEvent, unknown>;
+    readonly listLifecycle: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<Workflow.LifecycleEvent>, unknown>;
+    readonly finish: (id: Ids.ExecutionId, status: "completed" | "failed") => Effect.Effect<Workflow.RunRecord | undefined, unknown>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/WorkflowDefinitionRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const layer: Layer.Layer<Service, never, SqlClient>;
+export {};

package/package.json

@@ -1,7 +1,8 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@relayfx/sdk",
-  "version": "0.0.50",
+  "version": "0.2.0",
+  "description": "Effect-native durable execution SDK for addressable agents and tools",
   "type": "module",
   "exports": {
     ".": {
@@ -12,16 +13,36 @@
       "types": "./dist/types/ai/index.d.ts",
       "import": "./dist/ai.js"
     },
+    "./sqlite": {
+      "types": "./dist/types/relay/sqlite.d.ts",
+      "import": "./dist/sqlite.js"
+    },
     "./migrations/*": "./dist/migrations/*"
   },
   "types": "./dist/types/relay/index.d.ts",
+  "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
+  "engines": {
+    "node": ">=22",
+    "bun": ">=1.3.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/In-Time-Tec/relayfx.git",
+    "directory": "packages/relay"
+  },
+  "homepage": "https://github.com/In-Time-Tec/relayfx#readme",
+  "bugs": {
+    "url": "https://github.com/In-Time-Tec/relayfx/issues"
+  },
   "scripts": {
-    "build": "bun build ./src/index.ts ./src/ai.ts --outdir dist --target bun --format esm --external effect --external 'effect/*' --external '@effect/*' --external drizzle-orm --external 'drizzle-orm/*' --external pg && bun scripts/build-types.ts",
+    "build": "rm -rf dist && bun build ./src/index.ts ./src/ai.ts ./src/sqlite.ts --outdir dist --target bun --format esm --splitting --external effect --external 'effect/*' --external '@effect/*' --external drizzle-orm --external 'drizzle-orm/*' --external pg && bun scripts/build-types.ts",
     "lint": "bun --cwd ../.. oxlint packages/relay/src packages/relay/scripts packages/relay/test",
-    "test": "bun --cwd ../.. vitest run packages/relay/test --passWithNoTests",
+    "test": "bun --cwd ../.. vitest run packages/relay/test --passWithNoTests && bun test/sqlite.integration.ts",
+    "test:package-consumer": "bun --cwd ../.. scripts/package-consumer.ts",
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
@@ -32,6 +53,7 @@
     "@effect/ai-openai-compat": "4.0.0-beta.93",
     "@effect/ai-openrouter": "4.0.0-beta.93",
     "@effect/sql-pg": "4.0.0-beta.93",
+    "@effect/sql-sqlite-bun": "4.0.0-beta.93",
     "drizzle-orm": "1.0.0-rc.3",
     "effect": "4.0.0-beta.93",
     "pg": "8.21.0"