Advance TS port Effect workbench

ts/packages/flow/src/storage/triples/falkordb-service.ts

@@ -14,47 +14,72 @@ import {
   type ProcessorConfig,
   type FlowContext,
   type Triples,
+  type Spec,
 } from "@trustgraph/base";
-import { makeProcessorProgram } from "@trustgraph/base";
-import { FalkorDBTriplesStore } from "./falkordb.js";
+import { makeFlowProcessorProgram } from "@trustgraph/base";
+import { Effect } from "effect";
+import {
+  FalkorDBTriplesStoreLive,
+  FalkorDBTriplesStoreService,
+  makeFalkorDBTriplesStoreService,
+  type FalkorDBConfig,
+  type FalkorDBTriplesStoreError,
+} from "./falkordb.js";
 
-export class TriplesStoreService extends FlowProcessor {
-  private store: FalkorDBTriplesStore;
+const onStoreTriplesMessage = Effect.fn("TriplesStoreService.onMessage")(function* (
+  msg: Triples,
+  _properties: Record<string, string>,
+  _flowCtx: FlowContext<FalkorDBTriplesStoreService>,
+): Effect.fn.Return<void, FalkorDBTriplesStoreError, FalkorDBTriplesStoreService> {
+  if (msg.triples.length === 0) return;
+
+  const user = msg.metadata?.user ?? "default";
+  const collection = msg.metadata?.collection ?? "default";
+  const store = yield* FalkorDBTriplesStoreService;
+
+  yield* store.storeTriples(msg.triples, user, collection);
+
+  yield* Effect.log(
+    `[TriplesStore] Stored ${msg.triples.length} triples for ${user}/${collection}`,
+  );
+});
+
+export const makeTriplesStoreSpecs = (): ReadonlyArray<Spec<FalkorDBTriplesStoreService>> => [
+  new ConsumerSpec<Triples, FalkorDBTriplesStoreError, FalkorDBTriplesStoreService>(
+    "store-triples-input",
+    onStoreTriplesMessage,
+  ),
+];
+
+export class TriplesStoreService extends FlowProcessor<FalkorDBTriplesStoreService> {
+  private readonly store = makeFalkorDBTriplesStoreService();
 
   constructor(config: ProcessorConfig) {
     super(config);
-    this.store = new FalkorDBTriplesStore();
 
-    this.registerSpecification(
-      ConsumerSpec.fromPromise<Triples>("store-triples-input", this.onMessage.bind(this)),
-    );
+    for (const spec of makeTriplesStoreSpecs()) {
+      this.registerSpecification(spec);
+    }
 
     console.log("[TriplesStore] Service initialized");
   }
 
-  private async onMessage(
-    msg: Triples,
-    _properties: Record<string, string>,
-    _flowCtx: FlowContext,
-  ): Promise<void> {
-    if (msg.triples.length === 0) return;
-
-    const user = msg.metadata?.user ?? "default";
-    const collection = msg.metadata?.collection ?? "default";
-
-    await this.store.storeTriples(msg.triples, user, collection);
-
-    console.log(
-      `[TriplesStore] Stored ${msg.triples.length} triples for ${user}/${collection}`,
+  override startEffect() {
+    return super.startEffect().pipe(
+      Effect.provideService(
+        FalkorDBTriplesStoreService,
+        FalkorDBTriplesStoreService.of(this.store),
+      ),
     );
   }
 }
 
-export const program = makeProcessorProgram({
+export const program = makeFlowProcessorProgram<ProcessorConfig & FalkorDBConfig, never, FalkorDBTriplesStoreService>({
   id: "triples-store",
-  make: (config) => new TriplesStoreService(config),
+  specs: () => makeTriplesStoreSpecs(),
+  layer: (config) => FalkorDBTriplesStoreLive(config),
 });
 
 export async function run(): Promise<void> {
-  await TriplesStoreService.launch("triples-store");
+  await Effect.runPromise(program);
 }

ts/packages/flow/src/storage/triples/falkordb.ts

@@ -8,7 +8,9 @@
  */
 
 import { createClient, Graph } from "falkordb";
-import type { Term, Triple } from "@trustgraph/base";
+import { errorMessage, type Term, type Triple } from "@trustgraph/base";
+import { Context, Effect, Layer } from "effect";
+import * as S from "effect/Schema";
 
 export interface FalkorDBConfig {
   url?: string;
@@ -130,3 +132,71 @@ export class FalkorDBTriplesStore {
     );
   }
 }
+
+export class FalkorDBTriplesStoreError extends S.TaggedErrorClass<FalkorDBTriplesStoreError>()(
+  "FalkorDBTriplesStoreError",
+  {
+    message: S.String,
+    operation: S.String,
+    cause: S.DefectWithStack,
+  },
+) {}
+
+export interface FalkorDBTriplesStoreServiceShape {
+  readonly storeTriples: (
+    triples: ReadonlyArray<Triple>,
+    user: string,
+    collection: string,
+  ) => Effect.Effect<void, FalkorDBTriplesStoreError>;
+  readonly deleteCollection: (
+    user: string,
+    collection: string,
+  ) => Effect.Effect<void, FalkorDBTriplesStoreError>;
+}
+
+export class FalkorDBTriplesStoreService extends Context.Service<
+  FalkorDBTriplesStoreService,
+  FalkorDBTriplesStoreServiceShape
+>()(
+  "@trustgraph/flow/storage/triples/falkordb/FalkorDBTriplesStoreService",
+) {}
+
+const falkorDBTriplesStoreError = (operation: string, cause: unknown) =>
+  new FalkorDBTriplesStoreError({
+    operation,
+    message: errorMessage(cause),
+    cause,
+  });
+
+export const makeFalkorDBTriplesStoreService = (
+  config: FalkorDBConfig = {},
+): FalkorDBTriplesStoreServiceShape => {
+  const store = new FalkorDBTriplesStore(config);
+  return {
+    storeTriples: Effect.fn("FalkorDBTriplesStore.storeTriples")((
+      triples: ReadonlyArray<Triple>,
+      user: string,
+      collection: string,
+    ) =>
+      Effect.tryPromise({
+        try: () => store.storeTriples(Array.from(triples), user, collection),
+        catch: (cause) => falkorDBTriplesStoreError("store-triples", cause),
+      })),
+    deleteCollection: Effect.fn("FalkorDBTriplesStore.deleteCollection")((
+      user: string,
+      collection: string,
+    ) =>
+      Effect.tryPromise({
+        try: () => store.deleteCollection(user, collection),
+        catch: (cause) => falkorDBTriplesStoreError("delete-collection", cause),
+      })),
+  };
+};
+
+export const FalkorDBTriplesStoreLive = (
+  config: FalkorDBConfig = {},
+): Layer.Layer<FalkorDBTriplesStoreService> =>
+  Layer.succeed(
+    FalkorDBTriplesStoreService,
+    FalkorDBTriplesStoreService.of(makeFalkorDBTriplesStoreService(config)),
+  );