@midnightntwrk/wallet-sdk-indexer-client 1.2.3

package/README.md

@@ -0,0 +1,86 @@
+# @midnightntwrk/wallet-sdk-indexer-client
+
+Client for communicating with the Midnight indexer service.
+
+## Installation
+
+```bash
+npm install @midnightntwrk/wallet-sdk-indexer-client
+```
+
+## Overview
+
+This package provides a GraphQL-based client for interacting with the Midnight indexer service. The indexer aggregates
+blockchain data and provides efficient access to:
+
+- **Subscriptions** for real-time event streaming:
+  - Shielded transactions (Zswap)
+  - Unshielded transactions
+  - Zswap events
+  - Dust ledger events
+
+- **Queries** for fetching blockchain data:
+  - Block information (height, hash, timestamp)
+  - Ledger parameters (including cost model)
+  - Connection management
+
+## Usage
+
+### Subscriptions
+
+Subscribe to real-time events from the indexer:
+
+```typescript
+import {
+  ShieldedTransactions,
+  UnshieldedTransactions,
+  ZswapEvents,
+  DustLedgerEvents,
+} from '@midnightntwrk/wallet-sdk-indexer-client';
+
+// Subscribe to shielded transaction events
+// Subscribe to unshielded transaction events
+// Subscribe to Zswap events
+// Subscribe to dust ledger events
+```
+
+### Queries
+
+Query blockchain data:
+
+```typescript
+import { BlockHash } from '@midnightntwrk/wallet-sdk-indexer-client';
+
+// Query block information including:
+// - Block height
+// - Block hash
+// - Ledger parameters (cost model, etc.)
+// - Timestamp
+```
+
+## Exports
+
+### Default Export
+
+- GraphQL queries: `Connect`, `Disconnect`, `BlockHash`
+- GraphQL subscriptions: `ShieldedTransactions`, `UnshieldedTransactions`, `ZswapEvents`, `DustLedgerEvents`
+- Generated GraphQL types
+
+### Effect Submodule (`/effect`)
+
+Effect.ts-based implementation for functional programming patterns:
+
+```typescript
+import {
+  Query,
+  Subscription,
+  QueryClient,
+  SubscriptionClient,
+  HttpQueryClient,
+  WsSubscriptionClient,
+} from '@midnightntwrk/wallet-sdk-indexer-client/effect';
+```
+
+## License
+
+Apache-2.0

package/dist/effect/Backpressure.d.ts

@@ -0,0 +1,97 @@
+import { Stream } from 'effect';
+/**
+ * Options controlling the bounded backpressure behavior.
+ *
+ * The implementation caps the number of in-flight (emitted but not yet consumed downstream) items. Once
+ * {@link bufferSize} is reached the underlying source is disposed; when the consumer drains back down to
+ * {@link resumeThreshold} a fresh subscription is opened with `variables(cursor)` for the running cursor.
+ *
+ * Emitted items are guaranteed strictly monotonic by {@link key}. Dedup uses a single exclusive watermark: any item with
+ * a key `<= watermark` is dropped, and each emitted key advances the watermark. The watermark seeds from {@link from},
+ * so the item _at_ `from` is treated as already-seen and dropped. This is what makes resume safe over an inclusive
+ * cursor: the boundary item a resume re-delivers has a key equal to the watermark and is dropped — without it, the
+ * first item after a resume would duplicate the last one emitted before the pause. A caller that needs the item at its
+ * logical cursor emitted (e.g. to let an already-caught-up consumer observe its tip) passes `from` one below that
+ * cursor.
+ *
+ * The cursor is the single source of truth for both initial open and resume — no separate "initial variables" field;
+ * `variables(from)` opens the first subscription, `variables(key(lastItem))` opens every subsequent one.
+ *
+ * No items above the watermark are dropped — the producer is paused, never thrown away.
+ *
+ * **Totality contract:** {@link key} and {@link variables} MUST be total — they must not throw for any input of their
+ * declared types. The wrapper does not catch exceptions from these closures: a throw from `key` propagates back through
+ * the source's sync callback (undefined behavior depending on the source's internals), and a throw from `variables`
+ * surfaces as an unhandled defect on the resulting `Stream` rather than a typed `E`. The signatures `(cursor: bigint)
+ * => V` and `(item: Item) => bigint` are the contract; honor them.
+ */
+export interface BackpressureOptions<Item, V> {
+    /** Pause the underlying subscription once in-flight reaches this count. */
+    readonly bufferSize: number;
+    /**
+     * Resume once in-flight drains back to this count. Must be strictly less than `bufferSize` to give the consumer real
+     * hysteresis.
+     */
+    readonly resumeThreshold: number;
+    /** Initial cursor (bigint watermark). The first subscription opens with `variables(from)`. */
+    readonly from: bigint;
+    /** Derives subscription variables from a cursor. Used for the initial open and on every resume. */
+    readonly variables: (cursor: bigint) => V;
+    /** Monotonic key extractor — items with a key not strictly greater than the running watermark are dropped. */
+    readonly key: (result: Item) => bigint;
+}
+/**
+ * A push-based source. Each call opens a fresh session and returns a dispose handle. Items, errors and completion flow
+ * through the supplied callbacks.
+ *
+ * The source MUST stop delivering callbacks after `dispose()` is invoked. The caller pauses by disposing and resumes by
+ * calling the factory again with new variables; the source has no other backpressure signalling.
+ */
+export type Source<Item, V, E> = (params: {
+    readonly variables: V;
+    readonly onItem: (item: Item) => void;
+    readonly onError: (error: E) => void;
+    readonly onComplete: () => void;
+}) => () => void;
+/** @internal — exported only for unit tests; not part of the public API. */
+export type BPState = {
+    readonly paused: boolean;
+    readonly inFlight: number;
+    readonly lastKey: bigint;
+    readonly generation: number;
+    readonly terminal: boolean;
+};
+/** @internal */
+export type ItemDecision = {
+    readonly emit: boolean;
+    readonly pause: boolean;
+};
+/** @internal */
+export declare const initialBPState: (from: bigint) => BPState;
+/**
+ * @internal Decide what to do with an item arriving on `onItem`.
+ *
+ * The watermark is exclusive throughout: an item is dropped iff its key is `<= lastKey`, and each emitted key advances
+ * the watermark. The watermark seeds from `from`, so the item at `from` itself is treated as already-seen and dropped —
+ * a caller that wants the item at its logical cursor emitted seeds `from` one below it. The same exclusive rule drops
+ * the boundary item an inclusive-cursor resume re-delivers (its key equals `lastKey`).
+ */
+export declare const decideItem: (s: BPState, k: bigint, myGen: number, bufferSize: number) => readonly [ItemDecision, BPState];
+/** @internal Decide whether an error callback should surface (false for stale/terminal). */
+export declare const decideTerminate: (s: BPState, myGen: number) => readonly [boolean, BPState];
+/** @internal Decide whether a completion is consumer-visible end-of-stream or dispose-induced. */
+export declare const decideComplete: (s: BPState, myGen: number) => readonly [boolean, BPState];
+/**
+ * @internal Decide whether to resume the source after a downstream consume. Paused implies we've emitted at least
+ * bufferSize items, so lastKey is meaningful. Returns true when the caller should open a new session — the caller
+ * derives the resume variables from `state.lastKey` itself.
+ */
+export declare const decideResume: (s: BPState, resumeThreshold: number) => readonly [boolean, BPState];
+/**
+ * Wrap a push-based {@link Source} with bounded backpressure. The source is paused (disposed) when the in-flight count
+ * reaches `bufferSize` and resumed (re-opened with `variables(lastKey)`) once the consumer drains back to
+ * `resumeThreshold`.
+ *
+ * See {@link BackpressureOptions} for the monotonic-key dedup invariant.
+ */
+export declare const withBackpressure: <Item, V, E>(source: Source<Item, V, E>, options: BackpressureOptions<Item, V>) => Stream.Stream<Item, E>;

package/dist/effect/Backpressure.js

@@ -0,0 +1,146 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Bounded backpressure over a push-only source whose only knob is "dispose and
+// re-open from a cursor". The classic shape for graphql-ws / SSE-style feeds
+// that don't support pull or pause signalling.
+//
+// Composition:
+//   - Pure state machine (decideItem/decideTerminate/decideComplete/decideResume)
+//     contains all transition rules and is unit-testable in isolation.
+//   - `withBackpressure` wires the state machine to a {@link Source}, an
+//     internal Stream.asyncPush queue, and a Stream.tap drain detector.
+//   - Source authors translate their callbacks to the {@link Source} contract
+//     once; backpressure is independent of the underlying transport.
+import { Effect, Stream, Ref } from 'effect';
+/** @internal */
+export const initialBPState = (from) => ({
+    paused: false,
+    inFlight: 0,
+    lastKey: from,
+    generation: 0,
+    terminal: false,
+});
+/**
+ * @internal Decide what to do with an item arriving on `onItem`.
+ *
+ * The watermark is exclusive throughout: an item is dropped iff its key is `<= lastKey`, and each emitted key advances
+ * the watermark. The watermark seeds from `from`, so the item at `from` itself is treated as already-seen and dropped —
+ * a caller that wants the item at its logical cursor emitted seeds `from` one below it. The same exclusive rule drops
+ * the boundary item an inclusive-cursor resume re-delivers (its key equals `lastKey`).
+ */
+export const decideItem = (s, k, myGen, bufferSize) => {
+    if (s.terminal || s.generation !== myGen)
+        return [{ emit: false, pause: false }, s];
+    if (k <= s.lastKey)
+        return [{ emit: false, pause: false }, s];
+    const inFlight = s.inFlight + 1;
+    const pause = inFlight >= bufferSize && !s.paused;
+    return [
+        { emit: true, pause },
+        { ...s, inFlight, lastKey: k, paused: s.paused || pause },
+    ];
+};
+/** @internal Decide whether an error callback should surface (false for stale/terminal). */
+export const decideTerminate = (s, myGen) => s.terminal || s.generation !== myGen ? [false, s] : [true, { ...s, terminal: true }];
+/** @internal Decide whether a completion is consumer-visible end-of-stream or dispose-induced. */
+export const decideComplete = (s, myGen) => {
+    if (s.paused || s.terminal || s.generation !== myGen)
+        return [false, s];
+    return [true, { ...s, terminal: true }];
+};
+/**
+ * @internal Decide whether to resume the source after a downstream consume. Paused implies we've emitted at least
+ * bufferSize items, so lastKey is meaningful. Returns true when the caller should open a new session — the caller
+ * derives the resume variables from `state.lastKey` itself.
+ */
+export const decideResume = (s, resumeThreshold) => {
+    if (s.terminal)
+        return [false, s];
+    const inFlight = Math.max(0, s.inFlight - 1);
+    if (s.paused && inFlight <= resumeThreshold) {
+        return [true, { ...s, inFlight, paused: false, generation: s.generation + 1 }];
+    }
+    return [false, { ...s, inFlight }];
+};
+// ============================================================================
+// Stream wrapper
+// ============================================================================
+/**
+ * Wrap a push-based {@link Source} with bounded backpressure. The source is paused (disposed) when the in-flight count
+ * reaches `bufferSize` and resumed (re-opened with `variables(lastKey)`) once the consumer drains back to
+ * `resumeThreshold`.
+ *
+ * See {@link BackpressureOptions} for the monotonic-key dedup invariant.
+ */
+export const withBackpressure = (source, options) => {
+    const { bufferSize, resumeThreshold, key, from, variables } = options;
+    // Stream.unwrap re-runs the factory per subscription, so each consumer of
+    // the returned Stream gets its own Refs and its own source session.
+    return Stream.unwrap(Effect.gen(function* () {
+        // Three refs cover the inherently mutable bridge between sync source
+        // callbacks and Effect: the state machine, the current dispose handle,
+        // and the asyncPush emit handle (only bound while a consumer is
+        // attached).
+        const stateRef = yield* Ref.make(initialBPState(from));
+        const disposerRef = yield* Ref.make(null);
+        const emitRef = yield* Ref.make(null);
+        // Source callbacks are sync JS. Ref ops are sync internally, so runSync
+        // is safe here. Confined to these two helpers for auditability.
+        const modify = (f) => Effect.runSync(Ref.modify(stateRef, f));
+        const takeDisposer = () => Effect.runSync(Ref.getAndSet(disposerRef, null));
+        const openSession = () => Effect.gen(function* () {
+            const state = yield* Ref.get(stateRef);
+            if (state.terminal)
+                return;
+            const emit = yield* Ref.get(emitRef);
+            if (emit === null)
+                return;
+            const myGen = state.generation;
+            const dispose = source({
+                variables: variables(state.lastKey),
+                onItem: (item) => {
+                    const action = modify((s) => decideItem(s, key(item), myGen, bufferSize));
+                    if (!action.emit)
+                        return;
+                    emit.single(item);
+                    if (action.pause)
+                        takeDisposer()?.();
+                },
+                onError: (error) => {
+                    if (modify((s) => decideTerminate(s, myGen)))
+                        emit.fail(error);
+                },
+                onComplete: () => {
+                    if (modify((s) => decideComplete(s, myGen)))
+                        emit.end();
+                },
+            });
+            yield* Ref.set(disposerRef, dispose);
+        });
+        return Stream.asyncPush((emit) => Effect.acquireRelease(Effect.gen(function* () {
+            yield* Ref.set(emitRef, emit);
+            yield* openSession();
+        }), () => Effect.gen(function* () {
+            yield* Ref.update(stateRef, (s) => ({ ...s, terminal: true }));
+            const d = yield* Ref.getAndSet(disposerRef, null);
+            if (d !== null)
+                yield* Effect.sync(() => d());
+            yield* Ref.set(emitRef, null);
+        })), { bufferSize: 'unbounded' }).pipe(Stream.tap(() => Effect.gen(function* () {
+            const shouldResume = yield* Ref.modify(stateRef, (s) => decideResume(s, resumeThreshold));
+            if (shouldResume)
+                yield* openSession();
+        })));
+    }));
+};

package/dist/effect/ConnectionHelper.d.ts

@@ -0,0 +1,4 @@
+import * as Either from 'effect/Either';
+import { type URLError } from '@midnightntwrk/wallet-sdk-utilities/networking';
+export declare const deriveWebSocketUrl: (url: URL | string) => Either.Either<string, URLError>;
+export declare const createWebSocketUrl: (httpUrl: URL | string, wsUrl?: string) => Either.Either<string, URLError>;

package/dist/effect/ConnectionHelper.js

@@ -0,0 +1,41 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import * as Either from 'effect/Either';
+import { FailedToDeriveWebSocketUrlError } from '@midnightntwrk/wallet-sdk-utilities/networking';
+export const deriveWebSocketUrl = (url) => {
+    const httpUrl = typeof url === 'string' ? new URL(url) : url;
+    try {
+        const wsUrl = new URL(httpUrl);
+        // Convert protocol
+        wsUrl.protocol = httpUrl.protocol === 'https:' ? 'wss:' : 'ws:';
+        // Ensure pathname ends with '/ws'
+        if (!wsUrl.pathname.endsWith('/')) {
+            wsUrl.pathname += '/';
+        }
+        wsUrl.pathname += 'ws';
+        return Either.right(wsUrl.toString());
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        return Either.left(new FailedToDeriveWebSocketUrlError({
+            message: `Failed to derive WebSocket URL from ${httpUrl.toString()}`,
+            cause: error,
+        }));
+    }
+};
+export const createWebSocketUrl = (httpUrl, wsUrl) => {
+    if (wsUrl) {
+        return Either.right(wsUrl);
+    }
+    return deriveWebSocketUrl(httpUrl);
+};

package/dist/effect/HttpQueryClient.d.ts

@@ -0,0 +1,4 @@
+import { Layer, type Scope } from 'effect';
+import { QueryClient } from './QueryClient.js';
+import { type InvalidProtocolSchemeError } from '@midnightntwrk/wallet-sdk-utilities/networking';
+export declare const layer: (config: QueryClient.ServerConfig) => Layer.Layer<QueryClient, InvalidProtocolSchemeError, Scope.Scope>;

package/dist/effect/HttpQueryClient.js

@@ -0,0 +1,50 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Effect, Layer } from 'effect';
+import { print } from 'graphql';
+import { createClient } from 'graphql-http';
+import { QueryClient } from './QueryClient.js';
+import { ClientError, ServerError, HttpURL, } from '@midnightntwrk/wallet-sdk-utilities/networking';
+export const layer = (config) => Layer.effect(QueryClient, HttpURL.make(config.url).pipe(Effect.flatMap((url) => Effect.acquireRelease(Effect.sync(() => createClient({
+    url: url.toString(),
+    shouldRetry: (error, retries) => {
+        const statusCode = error.response?.status ?? 500;
+        return Promise.resolve(retries < 3 && statusCode >= 502 && statusCode <= 504);
+    },
+})), (client) => Effect.sync(() => client.dispose()))), Effect.map((client) => new HttpQueryClientImpl(client))));
+class HttpQueryClientImpl {
+    constructor(client) {
+        this.client = client;
+    }
+    client;
+    query(document, variables) {
+        return Effect.async((resume) => {
+            let result;
+            const dispose = this.client.subscribe({ query: print(document), variables: variables }, {
+                next: (data) => (result = data),
+                error: (error) => {
+                    const statusCode = error.response?.status ?? 500;
+                    const message = error.response?.statusText ?? 'An unknown error occurred';
+                    resume(Effect.fail(statusCode >= 400 && statusCode < 500
+                        ? new ClientError({ message, cause: error })
+                        : new ServerError({ message })));
+                },
+                complete: () => resume(result.errors
+                    ? Effect.fail(new ClientError({ message: result.errors[0].message, cause: result.errors }))
+                    : Effect.succeed(result.data)),
+            });
+            // Ensure we dispose of the query if the running Fiber is terminated.
+            return Effect.sync(dispose);
+        });
+    }
+}

package/dist/effect/Query.d.ts

@@ -0,0 +1,39 @@
+import { Effect, Context } from 'effect';
+import { type ClientError, type ServerError } from '@midnightntwrk/wallet-sdk-utilities/networking';
+import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
+import { QueryClient } from './QueryClient.js';
+/** Describes an invocable GraphQL query. */
+export interface Query<R, V, F extends Query.QueryFn<R, V> = Query.QueryFn<R, V>> extends Effect.Effect<F> {
+    readonly tag: Context.Tag<Query<R, V>, F>;
+    readonly run: F;
+}
+export declare namespace Query {
+    /**
+     * A GraphQL query (that may be parameterized with variables), that returns a typed document.
+     *
+     * @remarks
+     *   `Document` is a simple type alias for `TypedDocumentNode`.
+     * @typeParam R The type returned by the GraphQL query.
+     * @typeParam V A type that describes the variables present in the GraphQL query.
+     */
+    type Document<R, V> = TypedDocumentNode<R, V>;
+    /** The variables of a {@link Document}. */
+    type Variables<T> = T extends Document<any, infer V> ? V : never;
+    /** The expected result of executing a {@link Document}. */
+    type Result<T> = T extends Document<infer R, any> ? R : never;
+    /**
+     * Describes a function that executes a GraphQL query over some given variables.
+     *
+     * @param variables The variables to be used in the GraphQL query.
+     * @returns An `Effect` that will yield the result of the GraphQL query.
+     */
+    type QueryFn<R, V> = (variables: V) => Effect.Effect<R, ClientError | ServerError, QueryClient>;
+}
+/**
+ * Constructs a new invocable GraphQL query.
+ *
+ * @param name The name of the tag to be associated with this query.
+ * @param document A parsed GraphQL query document that represents the query.
+ * @returns A {@link Query}.
+ */
+export declare const make: <Name extends string, T extends Query.Document<R, V>, R = Query.Result<T>, V = Query.Variables<T>>(name: Name, document: T) => Query<R, V>;

package/dist/effect/Query.js

@@ -0,0 +1,47 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Effect, Context, Effectable, Option, identity } from 'effect';
+import { QueryClient } from './QueryClient.js';
+/**
+ * Constructs a new invocable GraphQL query.
+ *
+ * @param name The name of the tag to be associated with this query.
+ * @param document A parsed GraphQL query document that represents the query.
+ * @returns A {@link Query}.
+ */
+export const make = (name, document) => new QueryImpl(`${name}Query`, document);
+class QueryImpl extends Effectable.Class {
+    name;
+    document;
+    constructor(name, document) {
+        super();
+        this.document = document;
+        this.name = name;
+        this.tag = Context.GenericTag(name);
+        this.run = ((variables) => Effect.flatMap(this, (f) => f(variables)));
+    }
+    tag;
+    run;
+    commit() {
+        const self = this; // eslint-disable-line @typescript-eslint/no-this-alias
+        return Effect.gen(function* () {
+            return Option.match(yield* Effect.serviceOption(self.tag), {
+                onSome: identity,
+                onNone: () => self.defaultFn.bind(self),
+            });
+        });
+    }
+    defaultFn(variables) {
+        return QueryClient.pipe(Effect.flatMap((client) => client.query(this.document, variables)));
+    }
+}

package/dist/effect/QueryClient.d.ts

@@ -0,0 +1,15 @@
+import { type Effect, Context } from 'effect';
+import { type ClientError, type ServerError } from '@midnightntwrk/wallet-sdk-utilities/networking';
+import type { Query } from './Query.js';
+declare const QueryClient_base: Context.TagClass<QueryClient, "@midnight-ntwrk/indexer-client#QueryClient", QueryClient.Service>;
+export declare class QueryClient extends QueryClient_base {
+}
+export declare namespace QueryClient {
+    interface ServerConfig {
+        readonly url: URL | string;
+    }
+    interface Service {
+        query<R, V, T extends Query.Document<R, V> = Query.Document<R, V>>(document: T, variables: V): Effect.Effect<Query.Result<T>, ClientError | ServerError>;
+    }
+}
+export {};

package/dist/effect/QueryClient.js

@@ -0,0 +1,15 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Context } from 'effect';
+export class QueryClient extends Context.Tag('@midnight-ntwrk/indexer-client#QueryClient')() {
+}

package/dist/effect/QueryRunner.d.ts

@@ -0,0 +1,11 @@
+import type { Query } from './Query.js';
+import type { QueryClient } from './QueryClient.js';
+/**
+ * Executes a {@link Query} as a `Promise` using the {@link HttpQueryClient}.
+ *
+ * @param query The query to execute.
+ * @param variables The variables to supply to the query.
+ * @param config The server configuration (URL) for the HTTP query client.
+ * @returns A `Promise` that resolves with the query result.
+ */
+export declare const runPromise: <R, V>(query: Query<R, V>, variables: V, config: QueryClient.ServerConfig) => Promise<R>;

package/dist/effect/QueryRunner.js

@@ -0,0 +1,23 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Effect } from 'effect';
+import * as HttpQueryClient from './HttpQueryClient.js';
+/**
+ * Executes a {@link Query} as a `Promise` using the {@link HttpQueryClient}.
+ *
+ * @param query The query to execute.
+ * @param variables The variables to supply to the query.
+ * @param config The server configuration (URL) for the HTTP query client.
+ * @returns A `Promise` that resolves with the query result.
+ */
+export const runPromise = (query, variables, config) => query.run(variables).pipe(Effect.provide(HttpQueryClient.layer(config)), Effect.scoped, Effect.runPromise);

package/dist/effect/Subscription.d.ts

@@ -0,0 +1,25 @@
+import { Effect, Stream, Context } from 'effect';
+import { type ClientError, type ServerError } from '@midnightntwrk/wallet-sdk-utilities/networking';
+import { SubscriptionClient } from './SubscriptionClient.js';
+import type { Query } from './Query.js';
+/** Describes a subscription of elements from an invocable GraphQL query. */
+export interface Subscription<R, V, F extends Subscription.SubscriptionFn<R, V> = Subscription.SubscriptionFn<R, V>> extends Effect.Effect<F> {
+    readonly tag: Context.Tag<Subscription<R, V>, F>;
+    readonly run: F;
+    /**
+     * Like {@link run}, but caps the in-flight item count by disposing the underlying GraphQL subscription when the
+     * consumer can't keep up, and re-opens it with `variables(cursor)` for the running monotonic cursor once the queue
+     * drains. Items are never dropped.
+     */
+    readonly runWithBackpressure: (options: SubscriptionClient.BackpressureOptions<R, V>) => Stream.Stream<R, ClientError | ServerError, SubscriptionClient>;
+}
+export declare namespace Subscription {
+    /**
+     * Describes a function that streams a GraphQL subscription for some given variables.
+     *
+     * @param variables The variables to be used in the GraphQL query.
+     * @returns A `Stream` that will yield the elements of the GraphQL subscription.
+     */
+    type SubscriptionFn<R, V> = (variables: V) => Stream.Stream<R, ClientError | ServerError, SubscriptionClient>;
+}
+export declare const make: <Name extends string, T extends Query.Document<R, V>, R = Query.Result<T>, V = Query.Variables<T>>(name: Name, document: T) => Subscription<R, V>;