@midnightntwrk/wallet-sdk-indexer-client 1.2.3

package/dist/effect/Subscription.js

@@ -0,0 +1,56 @@
+// 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, Stream, Context, Effectable, Option, identity } from 'effect';
+import { SubscriptionClient } from './SubscriptionClient.js';
+export const make = (name, document) => new SubscriptionImpl(`${name}Subscription`, document);
+class SubscriptionImpl extends Effectable.Class {
+    name;
+    document;
+    constructor(name, document) {
+        super();
+        this.document = document;
+        this.name = name;
+        this.tag = Context.GenericTag(name);
+        this.run = ((variables) => Stream.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),
+            });
+        });
+    }
+    runWithBackpressure(options) {
+        const self = this; // eslint-disable-line @typescript-eslint/no-this-alias
+        // Mirror the `run`/`commit` dispatch: if a caller has provided an override
+        // via `self.tag` (test mocks do this), fall back to it — those overrides
+        // can't speak backpressure, but tests don't need to. The override is
+        // invoked with the initial variables derived from the cursor, since the
+        // override doesn't know the cursor protocol. Without an override, take the
+        // bounded pause/resume path against the underlying client.
+        return Stream.unwrap(Effect.gen(function* () {
+            const tagged = yield* Effect.serviceOption(self.tag);
+            return Option.match(tagged, {
+                onSome: (fn) => fn(options.variables(options.from)),
+                onNone: () => SubscriptionClient.pipe(Stream.flatMap((client) => client.subscribeWithBackpressure(self.document, options))),
+            });
+        }));
+    }
+    defaultFn(variables) {
+        return SubscriptionClient.pipe(Stream.flatMap((client) => client.subscribe(this.document, variables)));
+    }
+}

package/dist/effect/SubscriptionClient.d.ts

@@ -0,0 +1,23 @@
+import { type Stream, Context } from 'effect';
+import type { Query } from './Query.js';
+import type { BackpressureOptions as BackpressureOptionsImpl } from './Backpressure.js';
+import { type ClientError, type ServerError } from '@midnightntwrk/wallet-sdk-utilities/networking';
+declare const SubscriptionClient_base: Context.TagClass<SubscriptionClient, "@midnight-ntwrk/indexer-client#SubscriptionClient", SubscriptionClient.Service>;
+export declare class SubscriptionClient extends SubscriptionClient_base {
+}
+export declare namespace SubscriptionClient {
+    interface ServerConfig {
+        readonly url: URL | string;
+        readonly keepAlive?: number | undefined;
+    }
+    /**
+     * Options for {@link Service.subscribeWithBackpressure}. Canonical definition lives in
+     * {@link ./Backpressure.BackpressureOptions} — re-exported here for ergonomic access through the namespace.
+     */
+    type BackpressureOptions<R, V> = BackpressureOptionsImpl<R, V>;
+    interface Service {
+        subscribe<R, V, T extends Query.Document<R, V> = Query.Document<R, V>>(document: T, variables: V): Stream.Stream<Query.Result<T>, ClientError | ServerError>;
+        subscribeWithBackpressure<R, V, T extends Query.Document<R, V> = Query.Document<R, V>>(document: T, options: BackpressureOptions<Query.Result<T>, V>): Stream.Stream<Query.Result<T>, ClientError | ServerError>;
+    }
+}
+export {};

package/dist/effect/SubscriptionClient.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 SubscriptionClient extends Context.Tag('@midnight-ntwrk/indexer-client#SubscriptionClient')() {
+}

package/dist/effect/WsSubscriptionClient.d.ts

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

package/dist/effect/WsSubscriptionClient.js

@@ -0,0 +1,89 @@
+// 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, Stream, Layer, Array as Arr } from 'effect';
+import { createClient } from 'graphql-ws';
+import { print } from 'graphql';
+import { SubscriptionClient } from './SubscriptionClient.js';
+import { withBackpressure } from './Backpressure.js';
+import { WsURL, ClientError, ServerError, } from '@midnightntwrk/wallet-sdk-utilities/networking';
+// ============================================================================
+// Error classification
+// ============================================================================
+// graphql-ws delivers a subscription sink error as one of: `Error`, `CloseEvent`,
+// or `readonly GraphQLError[]` (per its Sink docs). Only the array form should
+// surface as a ClientError; everything else is a transport/server failure.
+const isGraphQLErrorArray = (err) => {
+    if (!Arr.isArray(err) || err.length === 0)
+        return false;
+    const first = err[0];
+    return typeof first === 'object' && first !== null && 'message' in first && typeof first.message === 'string';
+};
+const toClientOrServerError = (err) => isGraphQLErrorArray(err)
+    ? new ClientError({ message: err.map((e) => e.message).join('; '), cause: err })
+    : new ServerError({ message: String(err) });
+// ============================================================================
+// Layer / class
+// ============================================================================
+export const layer = (config) => Layer.scoped(SubscriptionClient, WsURL.make(config.url).pipe(Effect.flatMap((url) => Effect.acquireRelease(Effect.sync(() => createClient({ url: url.toString(), shouldRetry: () => false, keepAlive: config.keepAlive ?? 15_000 })), (client) => Effect.sync(() => client.dispose()))), Effect.map((client) => new WebSocketSubscriptionClientImpl(client))));
+class WebSocketSubscriptionClientImpl {
+    constructor(client) {
+        this.client = client;
+    }
+    client;
+    subscribe(document, variables) {
+        // Stream.async forks a top-level fiber per emit.single (via
+        // Runtime.runPromiseExit), which leaks into Effect's Global.roots at the
+        // ~1k msg/sec rate the indexer pushes. Stream.asyncPush writes straight
+        // to an internal queue and tears it down with the surrounding scope.
+        return Stream.asyncPush((emit) => Effect.acquireRelease(Effect.sync(() => this.client.subscribe({ query: print(document), variables: variables }, {
+            next: (data) => {
+                if (data.errors) {
+                    emit.fail(new ClientError({
+                        message: data.errors.map((e) => e.message).join('; '),
+                        cause: data.errors,
+                    }));
+                }
+                else {
+                    emit.single(data.data);
+                }
+            },
+            error: (err) => {
+                if (isGraphQLErrorArray(err)) {
+                    emit.fail(new ClientError({ message: err.map((e) => e.message).join('; '), cause: err }));
+                }
+                else {
+                    emit.fail(new ServerError({ message: String(err) }));
+                }
+            },
+            complete: () => {
+                emit.end();
+            },
+        })), (dispose) => Effect.sync(() => dispose())), { bufferSize: 'unbounded' });
+    }
+    subscribeWithBackpressure(document, options) {
+        const client = this.client;
+        // Adapt graphql-ws's Sink callbacks to the generic Source contract; the
+        // backpressure/lifecycle logic lives in `withBackpressure`.
+        const source = ({ variables, onItem, onError, onComplete }) => client.subscribe({ query: print(document), variables: variables }, {
+            next: (data) => {
+                if (data.errors)
+                    onError(toClientOrServerError(data.errors));
+                else
+                    onItem(data.data);
+            },
+            error: (err) => onError(toClientOrServerError(err)),
+            complete: onComplete,
+        });
+        return withBackpressure(source, options);
+    }
+}

package/dist/effect/index.d.ts

@@ -0,0 +1,8 @@
+export * as Query from './Query.js';
+export * as Subscription from './Subscription.js';
+export * from './QueryClient.js';
+export * as HttpQueryClient from './HttpQueryClient.js';
+export * from './SubscriptionClient.js';
+export * as WsSubscriptionClient from './WsSubscriptionClient.js';
+export * as ConnectionHelper from './ConnectionHelper.js';
+export * as QueryRunner from './QueryRunner.js';

package/dist/effect/index.js

@@ -0,0 +1,20 @@
+// 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.
+export * as Query from './Query.js';
+export * as Subscription from './Subscription.js';
+export * from './QueryClient.js';
+export * as HttpQueryClient from './HttpQueryClient.js';
+export * from './SubscriptionClient.js';
+export * as WsSubscriptionClient from './WsSubscriptionClient.js';
+export * as ConnectionHelper from './ConnectionHelper.js';
+export * as QueryRunner from './QueryRunner.js';

package/dist/effect/test/backpressure.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/effect/test/backpressure.test.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.
+import { describe, it, expect } from 'vitest';
+import { initialBPState, decideItem, decideTerminate, decideComplete, decideResume, } from '../Backpressure.js';
+const state = (overrides = {}) => ({
+    ...initialBPState(0n),
+    ...overrides,
+});
+describe('Backpressure state machine', () => {
+    describe('decideItem', () => {
+        it('emits and advances watermark when key is strictly greater than lastKey', () => {
+            const [decision, next] = decideItem(state({ lastKey: 5n }), 6n, 0, 1000);
+            expect(decision).toEqual({ emit: true, pause: false });
+            expect(next.lastKey).toBe(6n);
+            expect(next.inFlight).toBe(1);
+        });
+        it('drops the item at `from` on the initial session (exclusive watermark)', () => {
+            // The watermark seeds from `from`, so the item whose key equals `from` is treated as
+            // already-seen. A caller that wants the item at its logical cursor emitted seeds `from` one
+            // below it (e.g. a wallet passes `appliedIndex - 1` to still receive the boundary event).
+            const before = initialBPState(5n);
+            const [decision, next] = decideItem(before, 5n, 0, 1000);
+            expect(decision.emit).toBe(false);
+            expect(next).toBe(before);
+        });
+        it('drops a re-delivered boundary equal to lastKey (inclusive-cursor dedup)', () => {
+            // An inclusive resume cursor re-delivers the last-emitted key; the exclusive watermark drops
+            // it so it is not emitted twice.
+            const before = state({ lastKey: 5n, inFlight: 0 });
+            const [decision, next] = decideItem(before, 5n, 0, 1000);
+            expect(decision.emit).toBe(false);
+            expect(next).toBe(before);
+        });
+        it('drops items below lastKey', () => {
+            const before = state({ lastKey: 5n });
+            const [decision, next] = decideItem(before, 3n, 0, 1000);
+            expect(decision.emit).toBe(false);
+            expect(next).toBe(before);
+        });
+        it('drops items from a stale generation', () => {
+            const before = state({ generation: 2 });
+            const [decision, next] = decideItem(before, 1n, 1, 1000);
+            expect(decision.emit).toBe(false);
+            expect(next).toBe(before);
+        });
+        it('drops items when terminal', () => {
+            const before = state({ terminal: true });
+            const [decision, next] = decideItem(before, 1n, 0, 1000);
+            expect(decision.emit).toBe(false);
+            expect(next).toBe(before);
+        });
+        it('sets pause when inFlight reaches bufferSize', () => {
+            const [decision, next] = decideItem(state({ lastKey: 5n, inFlight: 2 }), 6n, 0, 3);
+            expect(decision).toEqual({ emit: true, pause: true });
+            expect(next.paused).toBe(true);
+            expect(next.inFlight).toBe(3);
+        });
+        it('does not re-pause when already paused', () => {
+            const [decision, next] = decideItem(state({ lastKey: 5n, inFlight: 3, paused: true }), 6n, 0, 3);
+            expect(decision).toEqual({ emit: true, pause: false });
+            expect(next.paused).toBe(true);
+        });
+    });
+    describe('decideTerminate', () => {
+        it('surfaces a terminal event and marks state terminal', () => {
+            const [shouldSurface, next] = decideTerminate(state(), 0);
+            expect(shouldSurface).toBe(true);
+            expect(next.terminal).toBe(true);
+        });
+        it('swallows terminal events from a stale generation', () => {
+            const before = state({ generation: 2 });
+            const [shouldSurface, next] = decideTerminate(before, 1);
+            expect(shouldSurface).toBe(false);
+            expect(next).toBe(before);
+        });
+        it('is idempotent — already-terminal state returns false', () => {
+            const before = state({ terminal: true });
+            const [shouldSurface, next] = decideTerminate(before, 0);
+            expect(shouldSurface).toBe(false);
+            expect(next).toBe(before);
+        });
+    });
+    describe('decideComplete', () => {
+        it('signals end-of-stream when not paused, stale, or terminal', () => {
+            const [shouldEnd, next] = decideComplete(state(), 0);
+            expect(shouldEnd).toBe(true);
+            expect(next.terminal).toBe(true);
+        });
+        it('treats paused completion as dispose-induced (no end)', () => {
+            // This is the regression case: without the paused check, a dispose-on-pause
+            // would deliver a `complete:` from the old session and terminate the
+            // consumer-visible stream mid-resume.
+            const before = state({ paused: true });
+            const [shouldEnd, next] = decideComplete(before, 0);
+            expect(shouldEnd).toBe(false);
+            expect(next).toBe(before);
+        });
+        it('swallows completions from a stale generation', () => {
+            const before = state({ generation: 2 });
+            const [shouldEnd, next] = decideComplete(before, 1);
+            expect(shouldEnd).toBe(false);
+            expect(next).toBe(before);
+        });
+    });
+    describe('decideResume', () => {
+        it('resumes and bumps generation when paused and drained to threshold', () => {
+            const [shouldResume, next] = decideResume(state({ paused: true, inFlight: 3, generation: 4 }), 2);
+            expect(shouldResume).toBe(true);
+            expect(next).toMatchObject({ paused: false, inFlight: 2, generation: 5 });
+        });
+        it('decrements inFlight even when not resuming (drain accounting)', () => {
+            const [shouldResume, next] = decideResume(state({ paused: false, inFlight: 7 }), 2);
+            expect(shouldResume).toBe(false);
+            expect(next.inFlight).toBe(6);
+        });
+        it('does not resume when above threshold', () => {
+            const [shouldResume, next] = decideResume(state({ paused: true, inFlight: 5 }), 2);
+            expect(shouldResume).toBe(false);
+            expect(next).toMatchObject({ paused: true, inFlight: 4 });
+        });
+        it('does not resume when terminal', () => {
+            const before = state({ paused: true, inFlight: 3, terminal: true });
+            const [shouldResume, next] = decideResume(before, 2);
+            expect(shouldResume).toBe(false);
+            expect(next).toBe(before);
+        });
+        it('clamps inFlight at zero (defensive against drain underflow)', () => {
+            const [, next] = decideResume(state({ inFlight: 0 }), 2);
+            expect(next.inFlight).toBe(0);
+        });
+        it('does not resume when not paused, even if drained', () => {
+            const [shouldResume] = decideResume(state({ paused: false, inFlight: 0 }), 2);
+            expect(shouldResume).toBe(false);
+        });
+    });
+});

package/dist/effect/test/connectionHelper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/effect/test/connectionHelper.test.js

@@ -0,0 +1,34 @@
+// 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 { Either } from 'effect';
+import { describe, expect, it } from 'vitest';
+import { createWebSocketUrl, deriveWebSocketUrl } from '../ConnectionHelper.js';
+const right = (e) => (Either.isRight(e) ? e.right : undefined);
+describe('deriveWebSocketUrl', () => {
+    it('flips http→ws and https→wss', () => {
+        expect(right(deriveWebSocketUrl('http://example.com/api'))).toBe('ws://example.com/api/ws');
+        expect(right(deriveWebSocketUrl('https://example.com/api'))).toBe('wss://example.com/api/ws');
+    });
+    it('appends /ws regardless of whether the input path ends with a slash', () => {
+        expect(right(deriveWebSocketUrl('http://example.com/api'))).toBe('ws://example.com/api/ws');
+        expect(right(deriveWebSocketUrl('http://example.com/api/'))).toBe('ws://example.com/api/ws');
+    });
+});
+describe('createWebSocketUrl', () => {
+    it('returns the provided wsUrl as-is, ignoring httpUrl', () => {
+        expect(right(createWebSocketUrl('http://example.com/api', 'ws://override.example/custom'))).toBe('ws://override.example/custom');
+    });
+    it('falls back to deriveWebSocketUrl when wsUrl is undefined', () => {
+        expect(right(createWebSocketUrl('https://example.com/api'))).toBe('wss://example.com/api/ws');
+    });
+});

package/dist/effect/test/httpQueryClient.spied.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/effect/test/httpQueryClient.spied.test.js

@@ -0,0 +1,37 @@
+// 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 { describe, expect, it, vi } from 'vitest';
+import * as QueryClient from '../QueryClient.js';
+vi.mock('graphql-http', () => ({
+    createClient: vi.fn(),
+}));
+describe('HttpQueryClient', () => {
+    describe('layer', () => {
+        it('disposes of underlying scoped client', async () => {
+            const graphqlHTTP = await import('graphql-http');
+            const SpiedHttpQueryClient = await import('../HttpQueryClient.js');
+            const dispose = vi.fn();
+            const spiedCreateClient = vi
+                .spyOn(graphqlHTTP, 'createClient')
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-explicit-any
+                .mockImplementationOnce(() => ({ dispose }));
+            await Effect.gen(function* () {
+                const client = yield* QueryClient.QueryClient;
+                expect(client).toBeDefined();
+            }).pipe(Effect.provide(SpiedHttpQueryClient.layer({ url: 'http://localhost.com' })), Effect.scoped, Effect.runPromise);
+            expect(spiedCreateClient).toHaveBeenCalled();
+            expect(dispose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/effect/test/httpQueryClient.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/effect/test/httpQueryClient.test.js

@@ -0,0 +1,32 @@
+// 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 { describe, it } from 'vitest';
+import * as QueryClient from '../QueryClient.js';
+import * as HttpQueryClient from '../HttpQueryClient.js';
+describe('HttpQueryClient', () => {
+    describe('layer', () => {
+        // Ensures that we cannot construct a layer for HttpQueryClient when we use common incorrect URI schemes.
+        it.each(['ftp:', 'mailto:', 'ws:', 'wss:', 'file:'])('should fail when constructed with %s as the URI scheme', async (scheme) => {
+            await Effect.gen(function* () {
+                // We should never be able to resolve a QueryClient since the configuration used to create the
+                // associated HttpQueryClient layer is invalid with the protocol schemes being used.
+                return yield* QueryClient.QueryClient;
+            }).pipe(Effect.flatMap((_) => Effect.fail('Unexpectedly resolved a QueryClient')), Effect.provide(HttpQueryClient.layer({ url: `${scheme}//localhost.com` })), 
+            // Ensure the reported invalid protocol scheme is the one used.
+            Effect.catchTag('InvalidProtocolSchemeError', (err) => err.invalidScheme !== scheme
+                ? Effect.fail(`Expected '${scheme}' but received '${err.invalidScheme}'`)
+                : Effect.succeed(void 0)), Effect.scoped, Effect.runPromise);
+        });
+    });
+});

package/dist/effect/test/queryRunner.spied.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/effect/test/queryRunner.spied.test.js

@@ -0,0 +1,46 @@
+// 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 { describe, expect, it, vi } from 'vitest';
+import { BlockHash } from '../../graphql/queries/BlockHash.js';
+vi.mock('graphql-http', () => ({
+    createClient: vi.fn(),
+}));
+describe('QueryRunner', () => {
+    describe('runPromise', () => {
+        it('should resolve with query result', async () => {
+            const graphqlHTTP = await import('graphql-http');
+            const SpiedQueryRunner = await import('../QueryRunner.js');
+            const block = {
+                block: { height: 1_000, hash: 'SOME_HASH', ledgerParameters: '0x0', timestamp: 1 },
+            };
+            const dispose = vi.fn();
+            const spiedCreateClient = vi
+                .spyOn(graphqlHTTP, 'createClient')
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-explicit-any
+                .mockImplementationOnce(() => ({ subscribe, dispose }));
+            function subscribe(_params, sink) {
+                sink.next({ data: block });
+                sink.complete();
+                return vi.fn();
+            }
+            const result = await SpiedQueryRunner.runPromise(BlockHash, { offset: null }, { url: 'http://localhost:8088/api/v4/graphql' });
+            expect(result).toEqual(block);
+            expect(spiedCreateClient).toHaveBeenCalled();
+            expect(dispose).toHaveBeenCalled();
+        });
+        it('should reject for invalid URL scheme', async () => {
+            const SpiedQueryRunner = await import('../QueryRunner.js');
+            await expect(SpiedQueryRunner.runPromise(BlockHash, { offset: null }, { url: 'ftp://localhost:8088/api/v4/graphql' })).rejects.toThrow();
+        });
+    });
+});

package/dist/effect/test/wsSubscriptionClient.spied.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/effect/test/wsSubscriptionClient.spied.test.js

@@ -0,0 +1,37 @@
+// 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 { describe, expect, it, vi } from 'vitest';
+import * as SubscriptionClient from '../SubscriptionClient.js';
+vi.mock('graphql-ws', () => ({
+    createClient: vi.fn(),
+}));
+describe('WsSubscriptionClient', () => {
+    describe('layer', () => {
+        it('disposes of underlying scoped client', async () => {
+            const graphqlWS = await import('graphql-ws');
+            const SpiedWsSubscriptionClient = await import('../WsSubscriptionClient.js');
+            const dispose = vi.fn();
+            const spiedCreateClient = vi
+                .spyOn(graphqlWS, 'createClient')
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-explicit-any
+                .mockImplementationOnce(() => ({ dispose }));
+            await Effect.gen(function* () {
+                const client = yield* SubscriptionClient.SubscriptionClient;
+                expect(client).toBeDefined();
+            }).pipe(Effect.provide(SpiedWsSubscriptionClient.layer({ url: 'ws://localhost.com' })), Effect.scoped, Effect.runPromise);
+            expect(spiedCreateClient).toHaveBeenCalled();
+            expect(dispose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/effect/test/wsSubscriptionClient.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/effect/test/wsSubscriptionClient.test.js

@@ -0,0 +1,32 @@
+// 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 { describe, it } from 'vitest';
+import * as SubscriptionClient from '../SubscriptionClient.js';
+import * as WsSubscriptionClient from '../WsSubscriptionClient.js';
+describe('WsSubscriptionClient', () => {
+    describe('layer', () => {
+        // Ensures that we cannot construct a layer for WsSubscriptionClient when we use common incorrect URI schemes.
+        it.each(['ftp:', 'mailto:', 'http:', 'https:', 'file:'])('should fail when constructed with %s as the URI scheme', async (scheme) => {
+            await Effect.gen(function* () {
+                // We should never be able to resolve a SubscriptionClient since the configuration used to create the
+                // associated WsSubscriptionClient layer is invalid with the protocol schemes being used.
+                return yield* SubscriptionClient.SubscriptionClient;
+            }).pipe(Effect.flatMap((_) => Effect.fail('Unexpectedly resolved a SubscriptionClient')), Effect.provide(WsSubscriptionClient.layer({ url: `${scheme}//localhost.com` })), 
+            // Ensure the reported invalid protocol scheme is the one used.
+            Effect.catchTag('InvalidProtocolSchemeError', (err) => err.invalidScheme !== scheme
+                ? Effect.fail(`Expected '${scheme}' but received '${err.invalidScheme}'`)
+                : Effect.succeed(void 0)), Effect.scoped, Effect.runPromise);
+        });
+    });
+});

package/dist/graphql/generated/fragment-masking.d.ts

@@ -0,0 +1,19 @@
+import type { ResultOf, DocumentTypeDecoration, TypedDocumentNode } from '@graphql-typed-document-node/core';
+import type { Incremental } from './graphql.js';
+export type FragmentType<TDocumentType extends DocumentTypeDecoration<any, any>> = TDocumentType extends DocumentTypeDecoration<infer TType, any> ? [TType] extends [{
+    ' $fragmentName'?: infer TKey;
+}] ? TKey extends string ? {
+    ' $fragmentRefs'?: {
+        [key in TKey]: TType;
+    };
+} : never : never : never;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>>): TType;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | undefined): TType | undefined;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null): TType | null;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: FragmentType<DocumentTypeDecoration<TType, any>> | null | undefined): TType | null | undefined;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: Array<FragmentType<DocumentTypeDecoration<TType, any>>>): Array<TType>;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: Array<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined): Array<TType> | null | undefined;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>>): ReadonlyArray<TType>;
+export declare function useFragment<TType>(_documentNode: DocumentTypeDecoration<TType, any>, fragmentType: ReadonlyArray<FragmentType<DocumentTypeDecoration<TType, any>>> | null | undefined): ReadonlyArray<TType> | null | undefined;
+export declare function makeFragmentData<F extends DocumentTypeDecoration<any, any>, FT extends ResultOf<F>>(data: FT, _fragment: F): FragmentType<F>;
+export declare function isFragmentReady<TQuery, TFrag>(queryNode: DocumentTypeDecoration<TQuery, any>, fragmentNode: TypedDocumentNode<TFrag>, data: FragmentType<TypedDocumentNode<Incremental<TFrag>, any>> | null | undefined): data is FragmentType<typeof fragmentNode>;