Remove native classes from TS runtime

ts/packages/flow/src/query/embeddings/qdrant-doc-service.ts

@@ -8,10 +8,11 @@
  */
 
 import {
-  FlowProcessor,
-  ConsumerSpec,
-  ProducerSpec,
+  makeFlowProcessor,
+  makeConsumerSpec,
+  makeProducerSpec,
   type ProcessorConfig,
+  type FlowProcessorRuntime,
   type FlowContext,
   type FlowResourceNotFoundError,
   type MessagingDeliveryError,
@@ -78,37 +79,34 @@ const onDocEmbeddingsQueryMessage = Effect.fn("DocEmbeddingsQueryService.onMessa
 });
 
 export const makeDocEmbeddingsQuerySpecs = (): ReadonlyArray<Spec<QdrantDocEmbeddingsQueryService>> => [
-  new ConsumerSpec<
+  makeConsumerSpec<
     DocumentEmbeddingsRequest,
     FlowResourceNotFoundError | MessagingDeliveryError,
     QdrantDocEmbeddingsQueryService
   >("document-embeddings-request", onDocEmbeddingsQueryMessage),
-  new ProducerSpec<DocumentEmbeddingsResponse>("document-embeddings-response"),
+  makeProducerSpec<DocumentEmbeddingsResponse>("document-embeddings-response"),
 ];
 
-export class DocEmbeddingsQueryService extends FlowProcessor<QdrantDocEmbeddingsQueryService> {
-  private readonly query = makeQdrantDocEmbeddingsQueryService();
+export type DocEmbeddingsQueryService = FlowProcessorRuntime<QdrantDocEmbeddingsQueryService>;
 
-  constructor(config: ProcessorConfig) {
-    super(config);
-
-    for (const spec of makeDocEmbeddingsQuerySpecs()) {
-      this.registerSpecification(spec);
-    }
-
-    console.log("[DocEmbeddingsQuery] Service initialized");
-  }
-
-  override startEffect() {
-    return super.startEffect().pipe(
-      Effect.provideService(
-        QdrantDocEmbeddingsQueryService,
-        QdrantDocEmbeddingsQueryService.of(this.query),
+export function makeDocEmbeddingsQueryService(config: ProcessorConfig): DocEmbeddingsQueryService {
+  const query = makeQdrantDocEmbeddingsQueryService();
+  const service = makeFlowProcessor(config, {
+    specifications: makeDocEmbeddingsQuerySpecs(),
+    provide: (effect) =>
+      effect.pipe(
+        Effect.provideService(
+          QdrantDocEmbeddingsQueryService,
+          QdrantDocEmbeddingsQueryService.of(query),
+        ),
       ),
-    );
-  }
+  });
+  console.log("[DocEmbeddingsQuery] Service initialized");
+  return service;
 }
 
+export const DocEmbeddingsQueryService = makeDocEmbeddingsQueryService;
+
 export const program = makeFlowProcessorProgram<ProcessorConfig & QdrantDocQueryConfig, never, QdrantDocEmbeddingsQueryService>({
   id: "doc-embeddings-query",
   specs: () => makeDocEmbeddingsQuerySpecs(),

ts/packages/flow/src/query/embeddings/qdrant-doc.ts

@@ -30,22 +30,24 @@ export interface DocEmbeddingsQueryRequest {
   limit: number;
 }
 
-export class QdrantDocEmbeddingsQuery {
-  private client: QdrantClient;
+export interface QdrantDocEmbeddingsQuery {
+  readonly query: (request: DocEmbeddingsQueryRequest) => Promise<ChunkMatch[]>;
+}
 
-  constructor(config: QdrantDocQueryConfig = {}) {
-    const url = config.url ?? process.env.QDRANT_URL ?? "http://localhost:6333";
-    const apiKey = config.apiKey ?? process.env.QDRANT_API_KEY;
+export function makeQdrantDocEmbeddingsQuery(
+  config: QdrantDocQueryConfig = {},
+): QdrantDocEmbeddingsQuery {
+  const url = config.url ?? process.env.QDRANT_URL ?? "http://localhost:6333";
+  const apiKey = config.apiKey ?? process.env.QDRANT_API_KEY;
 
-    this.client = new QdrantClient({
-      url,
-      ...(apiKey !== undefined && apiKey.length > 0 ? { apiKey } : {}),
-    });
+  const client = new QdrantClient({
+    url,
+    ...(apiKey !== undefined && apiKey.length > 0 ? { apiKey } : {}),
+  });
 
-    console.log("[QdrantDocQuery] Query service initialized");
-  }
+  console.log("[QdrantDocQuery] Query service initialized");
 
-  async query(request: DocEmbeddingsQueryRequest): Promise<ChunkMatch[]> {
+  const query = async (request: DocEmbeddingsQueryRequest): Promise<ChunkMatch[]> => {
     const { vector, user, collection, limit } = request;
 
     if (vector.length === 0) {
@@ -56,7 +58,7 @@ export class QdrantDocEmbeddingsQuery {
     const collectionName = `d_${user}_${collection}_${dim}`;
 
     // Check if collection exists -- return empty if not
-    const exists = await this.client.collectionExists(collectionName);
+    const exists = await client.collectionExists(collectionName);
     if (!exists.exists) {
       console.log(
         `[QdrantDocQuery] Collection ${collectionName} does not exist, returning empty results`,
@@ -64,7 +66,7 @@ export class QdrantDocEmbeddingsQuery {
       return [];
     }
 
-    const searchResult = await this.client.search(collectionName, {
+    const searchResult = await client.search(collectionName, {
       vector,
       limit,
       with_payload: true,
@@ -84,7 +86,9 @@ export class QdrantDocEmbeddingsQuery {
     }
 
     return chunks;
-  }
+  };
+
+  return { query };
 }
 
 export class QdrantDocEmbeddingsQueryError extends S.TaggedErrorClass<QdrantDocEmbeddingsQueryError>()(
@@ -119,7 +123,7 @@ const qdrantDocEmbeddingsQueryError = (operation: string, cause: unknown) =>
 export const makeQdrantDocEmbeddingsQueryService = (
   config: QdrantDocQueryConfig = {},
 ): QdrantDocEmbeddingsQueryServiceShape => {
-  const query = new QdrantDocEmbeddingsQuery(config);
+  const query = makeQdrantDocEmbeddingsQuery(config);
   return {
     query: Effect.fn("QdrantDocEmbeddingsQuery.query")(function* (request) {
       return yield* Effect.tryPromise({

ts/packages/flow/src/query/embeddings/qdrant-graph-service.ts

@@ -8,10 +8,11 @@
  */
 
 import {
-  FlowProcessor,
-  ConsumerSpec,
-  ProducerSpec,
+  makeFlowProcessor,
+  makeConsumerSpec,
+  makeProducerSpec,
   type ProcessorConfig,
+  type FlowProcessorRuntime,
   type FlowContext,
   type FlowResourceNotFoundError,
   type MessagingDeliveryError,
@@ -79,37 +80,34 @@ const onGraphEmbeddingsQueryMessage = Effect.fn("GraphEmbeddingsQueryService.onM
 });
 
 export const makeGraphEmbeddingsQuerySpecs = (): ReadonlyArray<Spec<QdrantGraphEmbeddingsQueryService>> => [
-  new ConsumerSpec<
+  makeConsumerSpec<
     GraphEmbeddingsRequest,
     FlowResourceNotFoundError | MessagingDeliveryError,
     QdrantGraphEmbeddingsQueryService
   >("graph-embeddings-request", onGraphEmbeddingsQueryMessage),
-  new ProducerSpec<GraphEmbeddingsResponse>("graph-embeddings-response"),
+  makeProducerSpec<GraphEmbeddingsResponse>("graph-embeddings-response"),
 ];
 
-export class GraphEmbeddingsQueryService extends FlowProcessor<QdrantGraphEmbeddingsQueryService> {
-  private readonly query = makeQdrantGraphEmbeddingsQueryService();
+export type GraphEmbeddingsQueryService = FlowProcessorRuntime<QdrantGraphEmbeddingsQueryService>;
 
-  constructor(config: ProcessorConfig) {
-    super(config);
-
-    for (const spec of makeGraphEmbeddingsQuerySpecs()) {
-      this.registerSpecification(spec);
-    }
-
-    console.log("[GraphEmbeddingsQuery] Service initialized");
-  }
-
-  override startEffect() {
-    return super.startEffect().pipe(
-      Effect.provideService(
-        QdrantGraphEmbeddingsQueryService,
-        QdrantGraphEmbeddingsQueryService.of(this.query),
+export function makeGraphEmbeddingsQueryService(config: ProcessorConfig): GraphEmbeddingsQueryService {
+  const query = makeQdrantGraphEmbeddingsQueryService();
+  const service = makeFlowProcessor(config, {
+    specifications: makeGraphEmbeddingsQuerySpecs(),
+    provide: (effect) =>
+      effect.pipe(
+        Effect.provideService(
+          QdrantGraphEmbeddingsQueryService,
+          QdrantGraphEmbeddingsQueryService.of(query),
+        ),
       ),
-    );
-  }
+  });
+  console.log("[GraphEmbeddingsQuery] Service initialized");
+  return service;
 }
 
+export const GraphEmbeddingsQueryService = makeGraphEmbeddingsQueryService;
+
 export const program = makeFlowProcessorProgram<ProcessorConfig & QdrantGraphQueryConfig, never, QdrantGraphEmbeddingsQueryService>({
   id: "graph-embeddings-query",
   specs: () => makeGraphEmbeddingsQuerySpecs(),

ts/packages/flow/src/query/embeddings/qdrant-graph.ts

@@ -39,22 +39,24 @@ function createTerm(value: string): Term {
   return { type: "LITERAL", value };
 }
 
-export class QdrantGraphEmbeddingsQuery {
-  private client: QdrantClient;
+export interface QdrantGraphEmbeddingsQuery {
+  readonly query: (request: GraphEmbeddingsQueryRequest) => Promise<EntityMatch[]>;
+}
 
-  constructor(config: QdrantGraphQueryConfig = {}) {
-    const url = config.url ?? process.env.QDRANT_URL ?? "http://localhost:6333";
-    const apiKey = config.apiKey ?? process.env.QDRANT_API_KEY;
+export function makeQdrantGraphEmbeddingsQuery(
+  config: QdrantGraphQueryConfig = {},
+): QdrantGraphEmbeddingsQuery {
+  const url = config.url ?? process.env.QDRANT_URL ?? "http://localhost:6333";
+  const apiKey = config.apiKey ?? process.env.QDRANT_API_KEY;
 
-    this.client = new QdrantClient({
-      url,
-      ...(apiKey !== undefined && apiKey.length > 0 ? { apiKey } : {}),
-    });
+  const client = new QdrantClient({
+    url,
+    ...(apiKey !== undefined && apiKey.length > 0 ? { apiKey } : {}),
+  });
 
-    console.log("[QdrantGraphQuery] Query service initialized");
-  }
+  console.log("[QdrantGraphQuery] Query service initialized");
 
-  async query(request: GraphEmbeddingsQueryRequest): Promise<EntityMatch[]> {
+  const query = async (request: GraphEmbeddingsQueryRequest): Promise<EntityMatch[]> => {
     const { vector, user, collection, limit } = request;
 
     if (vector.length === 0) {
@@ -65,7 +67,7 @@ export class QdrantGraphEmbeddingsQuery {
     const collectionName = `t_${user}_${collection}_${dim}`;
 
     // Check if collection exists -- return empty if not
-    const exists = await this.client.collectionExists(collectionName);
+    const exists = await client.collectionExists(collectionName);
     if (!exists.exists) {
       console.log(
         `[QdrantGraphQuery] Collection ${collectionName} does not exist, returning empty results`,
@@ -75,7 +77,7 @@ export class QdrantGraphEmbeddingsQuery {
 
     // Query 2x the limit so we have a better chance of getting `limit`
     // unique entities after deduplication (same heuristic as Python impl)
-    const searchResult = await this.client.search(collectionName, {
+    const searchResult = await client.search(collectionName, {
       vector,
       limit: limit * 2,
       with_payload: true,
@@ -104,7 +106,9 @@ export class QdrantGraphEmbeddingsQuery {
     }
 
     return entities;
-  }
+  };
+
+  return { query };
 }
 
 export class QdrantGraphEmbeddingsQueryError extends S.TaggedErrorClass<QdrantGraphEmbeddingsQueryError>()(
@@ -139,7 +143,7 @@ const qdrantGraphEmbeddingsQueryError = (operation: string, cause: unknown) =>
 export const makeQdrantGraphEmbeddingsQueryService = (
   config: QdrantGraphQueryConfig = {},
 ): QdrantGraphEmbeddingsQueryServiceShape => {
-  const query = new QdrantGraphEmbeddingsQuery(config);
+  const query = makeQdrantGraphEmbeddingsQuery(config);
   return {
     query: Effect.fn("QdrantGraphEmbeddingsQuery.query")(function* (request) {
       return yield* Effect.tryPromise({

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

@@ -8,10 +8,11 @@
  */
 
 import {
-  FlowProcessor,
-  ConsumerSpec,
-  ProducerSpec,
+  makeFlowProcessor,
+  makeConsumerSpec,
+  makeProducerSpec,
   type ProcessorConfig,
+  type FlowProcessorRuntime,
   type FlowContext,
   type FlowResourceNotFoundError,
   type MessagingDeliveryError,
@@ -65,37 +66,34 @@ const onTriplesQueryMessage = Effect.fn("TriplesQueryService.onMessage")(functio
 });
 
 export const makeTriplesQuerySpecs = (): ReadonlyArray<Spec<FalkorDBTriplesQueryService>> => [
-  new ConsumerSpec<
+  makeConsumerSpec<
     TriplesQueryRequest,
     FlowResourceNotFoundError | MessagingDeliveryError,
     FalkorDBTriplesQueryService
   >("triples-request", onTriplesQueryMessage),
-  new ProducerSpec<TriplesQueryResponse>("triples-response"),
+  makeProducerSpec<TriplesQueryResponse>("triples-response"),
 ];
 
-export class TriplesQueryService extends FlowProcessor<FalkorDBTriplesQueryService> {
-  private readonly query = makeFalkorDBTriplesQueryService();
+export type TriplesQueryService = FlowProcessorRuntime<FalkorDBTriplesQueryService>;
 
-  constructor(config: ProcessorConfig) {
-    super(config);
-
-    for (const spec of makeTriplesQuerySpecs()) {
-      this.registerSpecification(spec);
-    }
-
-    console.log("[TriplesQuery] Service initialized");
-  }
-
-  override startEffect() {
-    return super.startEffect().pipe(
-      Effect.provideService(
-        FalkorDBTriplesQueryService,
-        FalkorDBTriplesQueryService.of(this.query),
+export function makeTriplesQueryService(config: ProcessorConfig): TriplesQueryService {
+  const query = makeFalkorDBTriplesQueryService();
+  const service = makeFlowProcessor(config, {
+    specifications: makeTriplesQuerySpecs(),
+    provide: (effect) =>
+      effect.pipe(
+        Effect.provideService(
+          FalkorDBTriplesQueryService,
+          FalkorDBTriplesQueryService.of(query),
+        ),
       ),
-    );
-  }
+  });
+  console.log("[TriplesQuery] Service initialized");
+  return service;
 }
 
+export const TriplesQueryService = makeTriplesQueryService;
+
 export const program = makeFlowProcessorProgram<ProcessorConfig & FalkorDBQueryConfig, never, FalkorDBTriplesQueryService>({
   id: "triples-query",
   specs: () => makeTriplesQuerySpecs(),

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

@@ -41,35 +41,194 @@ function field(row: unknown, key: string): string {
   return (row as Record<string, unknown>)?.[key] as string ?? "";
 }
 
-export class FalkorDBTriplesQuery {
-  private graph: Graph;
-  private connectPromise: Promise<void>;
+export interface FalkorDBTriplesQuery {
+  readonly queryTriples: (
+    s?: Term,
+    p?: Term,
+    o?: Term,
+    limit?: number,
+  ) => Promise<Triple[]>;
+}
 
-  constructor(config: FalkorDBQueryConfig = {}) {
-    const url = config.url ?? process.env.FALKORDB_URL ?? "redis://localhost:6379";
-    const database = config.database ?? "falkordb";
+export function makeFalkorDBTriplesQuery(
+  config: FalkorDBQueryConfig = {},
+): FalkorDBTriplesQuery {
+  const url = config.url ?? process.env.FALKORDB_URL ?? "redis://localhost:6379";
+  const database = config.database ?? "falkordb";
 
-    const client = createClient({ url });
-    this.graph = new Graph(client, database);
-    this.connectPromise = client.connect().then(() => {
-      console.log(`[FalkorDBTriplesQuery] Connected to ${url}, graph: ${database}`);
-    }).catch((err) => {
-      console.error(`[FalkorDBTriplesQuery] Connection failed:`, err);
-      throw err;
-    });
-  }
+  const client = createClient({ url });
+  const graph = new Graph(client, database);
+  const connectPromise = client.connect().then(() => {
+    console.log(`[FalkorDBTriplesQuery] Connected to ${url}, graph: ${database}`);
+  }).catch((err) => {
+    console.error(`[FalkorDBTriplesQuery] Connection failed:`, err);
+    throw err;
+  });
 
-  private async ensureConnected(): Promise<void> {
-    await this.connectPromise;
-  }
+  const ensureConnected = async (): Promise<void> => {
+    await connectPromise;
+  };
 
-  async queryTriples(
+  const matchPattern = async (
+    out: [string, string, string][],
+    sv: string, pv: string, ov: string, limit: number,
+  ): Promise<void> => {
+    for (const destType of ["Literal", "Node"] as const) {
+      const destKey = destType === "Literal" ? "value" : "uri";
+      const result = await graph.query(
+        `MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:${destType} {${destKey}: $dest}) ` +
+        `RETURN src.uri LIMIT ${limit}`,
+        { params: { src: sv, rel: pv, dest: ov } },
+      );
+      for (const _rec of (result.data ?? [])) {
+        out.push([sv, pv, ov]);
+      }
+    }
+  };
+
+  const matchSP = async (
+    out: [string, string, string][],
+    sv: string, pv: string, limit: number,
+  ): Promise<void> => {
+    // Literals
+    const litResult = await graph.query(
+      `MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Literal) ` +
+      `RETURN dest.value as dest LIMIT ${limit}`,
+      { params: { src: sv, rel: pv } },
+    );
+    for (const rec of (litResult.data ?? [])) {
+      out.push([sv, pv, field(rec, "dest")]);
+    }
+    // Nodes
+    const nodeResult = await graph.query(
+      `MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Node) ` +
+      `RETURN dest.uri as dest LIMIT ${limit}`,
+      { params: { src: sv, rel: pv } },
+    );
+    for (const rec of (nodeResult.data ?? [])) {
+      out.push([sv, pv, field(rec, "dest")]);
+    }
+  };
+
+  const matchSO = async (
+    out: [string, string, string][],
+    sv: string, ov: string, limit: number,
+  ): Promise<void> => {
+    for (const [destType, destKey] of [["Literal", "value"], ["Node", "uri"]] as const) {
+      const result = await graph.query(
+        `MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:${destType} {${destKey}: $dest}) ` +
+        `RETURN rel.uri as rel LIMIT ${limit}`,
+        { params: { src: sv, dest: ov } },
+      );
+      for (const rec of (result.data ?? [])) {
+        out.push([sv, field(rec, "rel"), ov]);
+      }
+    }
+  };
+
+  const matchPO = async (
+    out: [string, string, string][],
+    pv: string, ov: string, limit: number,
+  ): Promise<void> => {
+    for (const [destType, destKey] of [["Literal", "value"], ["Node", "uri"]] as const) {
+      const result = await graph.query(
+        `MATCH (src:Node)-[rel:Rel {uri: $rel}]->(dest:${destType} {${destKey}: $dest}) ` +
+        `RETURN src.uri as src LIMIT ${limit}`,
+        { params: { rel: pv, dest: ov } },
+      );
+      for (const rec of (result.data ?? [])) {
+        out.push([field(rec, "src"), pv, ov]);
+      }
+    }
+  };
+
+  const matchS = async (
+    out: [string, string, string][],
+    sv: string, limit: number,
+  ): Promise<void> => {
+    const litResult = await graph.query(
+      `MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Literal) ` +
+      `RETURN rel.uri as rel, dest.value as dest LIMIT ${limit}`,
+      { params: { src: sv } },
+    );
+    for (const rec of (litResult.data ?? [])) {
+      out.push([sv, field(rec, "rel"), field(rec, "dest")]);
+    }
+    const nodeResult = await graph.query(
+      `MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Node) ` +
+      `RETURN rel.uri as rel, dest.uri as dest LIMIT ${limit}`,
+      { params: { src: sv } },
+    );
+    for (const rec of (nodeResult.data ?? [])) {
+      out.push([sv, field(rec, "rel"), field(rec, "dest")]);
+    }
+  };
+
+  const matchP = async (
+    out: [string, string, string][],
+    pv: string, limit: number,
+  ): Promise<void> => {
+    const litResult = await graph.query(
+      `MATCH (src:Node)-[rel:Rel {uri: $rel}]->(dest:Literal) ` +
+      `RETURN src.uri as src, dest.value as dest LIMIT ${limit}`,
+      { params: { rel: pv } },
+    );
+    for (const rec of (litResult.data ?? [])) {
+      out.push([field(rec, "src"), pv, field(rec, "dest")]);
+    }
+    const nodeResult = await graph.query(
+      `MATCH (src:Node)-[rel:Rel {uri: $rel}]->(dest:Node) ` +
+      `RETURN src.uri as src, dest.uri as dest LIMIT ${limit}`,
+      { params: { rel: pv } },
+    );
+    for (const rec of (nodeResult.data ?? [])) {
+      out.push([field(rec, "src"), pv, field(rec, "dest")]);
+    }
+  };
+
+  const matchO = async (
+    out: [string, string, string][],
+    ov: string, limit: number,
+  ): Promise<void> => {
+    for (const [destType, destKey] of [["Literal", "value"], ["Node", "uri"]] as const) {
+      const result = await graph.query(
+        `MATCH (src:Node)-[rel:Rel]->(dest:${destType} {${destKey}: $dest}) ` +
+        `RETURN src.uri as src, rel.uri as rel LIMIT ${limit}`,
+        { params: { dest: ov } },
+      );
+      for (const rec of (result.data ?? [])) {
+        out.push([field(rec, "src"), field(rec, "rel"), ov]);
+      }
+    }
+  };
+
+  const matchAll = async (
+    out: [string, string, string][],
+    limit: number,
+  ): Promise<void> => {
+    const litResult = await graph.query(
+      `MATCH (src:Node)-[rel:Rel]->(dest:Literal) ` +
+      `RETURN src.uri as src, rel.uri as rel, dest.value as dest LIMIT ${limit}`,
+    );
+    for (const rec of (litResult.data ?? [])) {
+      out.push([field(rec, "src"), field(rec, "rel"), field(rec, "dest")]);
+    }
+    const nodeResult = await graph.query(
+      `MATCH (src:Node)-[rel:Rel]->(dest:Node) ` +
+      `RETURN src.uri as src, rel.uri as rel, dest.uri as dest LIMIT ${limit}`,
+    );
+    for (const rec of (nodeResult.data ?? [])) {
+      out.push([field(rec, "src"), field(rec, "rel"), field(rec, "dest")]);
+    }
+  };
+
+  const queryTriples = async (
     s?: Term,
     p?: Term,
     o?: Term,
     limit = 100,
-  ): Promise<Triple[]> {
-    await this.ensureConnected();
+  ): Promise<Triple[]> => {
+    await ensureConnected();
     const sv = termToValue(s);
     const pv = termToValue(p);
     const ov = termToValue(o);
@@ -79,28 +238,28 @@ export class FalkorDBTriplesQuery {
     // Query both Node and Literal targets for each pattern
     if (sv !== null && pv !== null && ov !== null) {
       // SPO — exact match
-      await this.matchPattern(rawTriples, sv, pv, ov, limit);
+      await matchPattern(rawTriples, sv, pv, ov, limit);
     } else if (sv !== null && pv !== null) {
       // SP — known subject + predicate
-      await this.matchSP(rawTriples, sv, pv, limit);
+      await matchSP(rawTriples, sv, pv, limit);
     } else if (sv !== null && ov !== null) {
       // SO — known subject + object
-      await this.matchSO(rawTriples, sv, ov, limit);
+      await matchSO(rawTriples, sv, ov, limit);
     } else if (pv !== null && ov !== null) {
       // PO — known predicate + object
-      await this.matchPO(rawTriples, pv, ov, limit);
+      await matchPO(rawTriples, pv, ov, limit);
     } else if (sv !== null) {
       // S only
-      await this.matchS(rawTriples, sv, limit);
+      await matchS(rawTriples, sv, limit);
     } else if (pv !== null) {
       // P only
-      await this.matchP(rawTriples, pv, limit);
+      await matchP(rawTriples, pv, limit);
     } else if (ov !== null) {
       // O only
-      await this.matchO(rawTriples, ov, limit);
+      await matchO(rawTriples, ov, limit);
     } else {
       // Wildcard — all triples
-      await this.matchAll(rawTriples, limit);
+      await matchAll(rawTriples, limit);
     }
 
     return rawTriples
@@ -111,160 +270,9 @@ export class FalkorDBTriplesQuery {
         p: createTerm(p),
         o: createTerm(o),
       }));
-  }
+  };
 
-  private async matchPattern(
-    out: [string, string, string][],
-    sv: string, pv: string, ov: string, limit: number,
-  ): Promise<void> {
-    for (const destType of ["Literal", "Node"] as const) {
-      const destKey = destType === "Literal" ? "value" : "uri";
-      const result = await this.graph.query(
-        `MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:${destType} {${destKey}: $dest}) ` +
-        `RETURN src.uri LIMIT ${limit}`,
-        { params: { src: sv, rel: pv, dest: ov } },
-      );
-      for (const _rec of (result.data ?? [])) {
-        out.push([sv, pv, ov]);
-      }
-    }
-  }
-
-  private async matchSP(
-    out: [string, string, string][],
-    sv: string, pv: string, limit: number,
-  ): Promise<void> {
-    // Literals
-    const litResult = await this.graph.query(
-      `MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Literal) ` +
-      `RETURN dest.value as dest LIMIT ${limit}`,
-      { params: { src: sv, rel: pv } },
-    );
-    for (const rec of (litResult.data ?? [])) {
-      out.push([sv, pv, field(rec, "dest")]);
-    }
-    // Nodes
-    const nodeResult = await this.graph.query(
-      `MATCH (src:Node {uri: $src})-[rel:Rel {uri: $rel}]->(dest:Node) ` +
-      `RETURN dest.uri as dest LIMIT ${limit}`,
-      { params: { src: sv, rel: pv } },
-    );
-    for (const rec of (nodeResult.data ?? [])) {
-      out.push([sv, pv, field(rec, "dest")]);
-    }
-  }
-
-  private async matchSO(
-    out: [string, string, string][],
-    sv: string, ov: string, limit: number,
-  ): Promise<void> {
-    for (const [destType, destKey] of [["Literal", "value"], ["Node", "uri"]] as const) {
-      const result = await this.graph.query(
-        `MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:${destType} {${destKey}: $dest}) ` +
-        `RETURN rel.uri as rel LIMIT ${limit}`,
-        { params: { src: sv, dest: ov } },
-      );
-      for (const rec of (result.data ?? [])) {
-        out.push([sv, field(rec, "rel"), ov]);
-      }
-    }
-  }
-
-  private async matchPO(
-    out: [string, string, string][],
-    pv: string, ov: string, limit: number,
-  ): Promise<void> {
-    for (const [destType, destKey] of [["Literal", "value"], ["Node", "uri"]] as const) {
-      const result = await this.graph.query(
-        `MATCH (src:Node)-[rel:Rel {uri: $rel}]->(dest:${destType} {${destKey}: $dest}) ` +
-        `RETURN src.uri as src LIMIT ${limit}`,
-        { params: { rel: pv, dest: ov } },
-      );
-      for (const rec of (result.data ?? [])) {
-        out.push([field(rec, "src"), pv, ov]);
-      }
-    }
-  }
-
-  private async matchS(
-    out: [string, string, string][],
-    sv: string, limit: number,
-  ): Promise<void> {
-    const litResult = await this.graph.query(
-      `MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Literal) ` +
-      `RETURN rel.uri as rel, dest.value as dest LIMIT ${limit}`,
-      { params: { src: sv } },
-    );
-    for (const rec of (litResult.data ?? [])) {
-      out.push([sv, field(rec, "rel"), field(rec, "dest")]);
-    }
-    const nodeResult = await this.graph.query(
-      `MATCH (src:Node {uri: $src})-[rel:Rel]->(dest:Node) ` +
-      `RETURN rel.uri as rel, dest.uri as dest LIMIT ${limit}`,
-      { params: { src: sv } },
-    );
-    for (const rec of (nodeResult.data ?? [])) {
-      out.push([sv, field(rec, "rel"), field(rec, "dest")]);
-    }
-  }
-
-  private async matchP(
-    out: [string, string, string][],
-    pv: string, limit: number,
-  ): Promise<void> {
-    const litResult = await this.graph.query(
-      `MATCH (src:Node)-[rel:Rel {uri: $rel}]->(dest:Literal) ` +
-      `RETURN src.uri as src, dest.value as dest LIMIT ${limit}`,
-      { params: { rel: pv } },
-    );
-    for (const rec of (litResult.data ?? [])) {
-      out.push([field(rec, "src"), pv, field(rec, "dest")]);
-    }
-    const nodeResult = await this.graph.query(
-      `MATCH (src:Node)-[rel:Rel {uri: $rel}]->(dest:Node) ` +
-      `RETURN src.uri as src, dest.uri as dest LIMIT ${limit}`,
-      { params: { rel: pv } },
-    );
-    for (const rec of (nodeResult.data ?? [])) {
-      out.push([field(rec, "src"), pv, field(rec, "dest")]);
-    }
-  }
-
-  private async matchO(
-    out: [string, string, string][],
-    ov: string, limit: number,
-  ): Promise<void> {
-    for (const [destType, destKey] of [["Literal", "value"], ["Node", "uri"]] as const) {
-      const result = await this.graph.query(
-        `MATCH (src:Node)-[rel:Rel]->(dest:${destType} {${destKey}: $dest}) ` +
-        `RETURN src.uri as src, rel.uri as rel LIMIT ${limit}`,
-        { params: { dest: ov } },
-      );
-      for (const rec of (result.data ?? [])) {
-        out.push([field(rec, "src"), field(rec, "rel"), ov]);
-      }
-    }
-  }
-
-  private async matchAll(
-    out: [string, string, string][],
-    limit: number,
-  ): Promise<void> {
-    const litResult = await this.graph.query(
-      `MATCH (src:Node)-[rel:Rel]->(dest:Literal) ` +
-      `RETURN src.uri as src, rel.uri as rel, dest.value as dest LIMIT ${limit}`,
-    );
-    for (const rec of (litResult.data ?? [])) {
-      out.push([field(rec, "src"), field(rec, "rel"), field(rec, "dest")]);
-    }
-    const nodeResult = await this.graph.query(
-      `MATCH (src:Node)-[rel:Rel]->(dest:Node) ` +
-      `RETURN src.uri as src, rel.uri as rel, dest.uri as dest LIMIT ${limit}`,
-    );
-    for (const rec of (nodeResult.data ?? [])) {
-      out.push([field(rec, "src"), field(rec, "rel"), field(rec, "dest")]);
-    }
-  }
+  return { queryTriples };
 }
 
 export class FalkorDBTriplesQueryError extends S.TaggedErrorClass<FalkorDBTriplesQueryError>()(
@@ -302,7 +310,7 @@ const falkorDBTriplesQueryError = (operation: string, cause: unknown) =>
 export const makeFalkorDBTriplesQueryService = (
   config: FalkorDBQueryConfig = {},
 ): FalkorDBTriplesQueryServiceShape => {
-  const query = new FalkorDBTriplesQuery(config);
+  const query = makeFalkorDBTriplesQuery(config);
   return {
     queryTriples: Effect.fn("FalkorDBTriplesQuery.queryTriples")((
       s: Term | undefined,