@apibara/protocol 2.0.0-beta.5 → 2.0.0-beta.6

package/dist/testing/index.cjs

@@ -0,0 +1,105 @@
+'use strict';
+
+const schema = require('@effect/schema');
+const config = require('../shared/protocol.474b6107.cjs');
+require('protobufjs/minimal');
+require('effect');
+require('viem');
+require('long');
+
+class MockClient {
+  constructor(messageFactory) {
+    this.messageFactory = messageFactory;
+  }
+  async status(request, options) {
+    throw new Error("Client.status is not implemented for VcrClient");
+  }
+  streamData(request, options) {
+    const messages = this.messageFactory(request, options);
+    return new StreamDataIterable(messages);
+  }
+}
+class StreamDataIterable {
+  constructor(messages) {
+    this.messages = messages;
+  }
+  [Symbol.asyncIterator]() {
+    let index = 0;
+    const messages = this.messages;
+    return {
+      async next() {
+        if (index >= messages.length) {
+          return { done: true, value: void 0 };
+        }
+        const message = messages[index++];
+        if (message instanceof Error) {
+          throw message;
+        }
+        return { done: false, value: message };
+      }
+    };
+  }
+}
+
+const MockFilter = schema.Schema.Struct({
+  filter: schema.Schema.optional(schema.Schema.String)
+});
+const MockFilterFromBytes = schema.Schema.transform(
+  schema.Schema.Uint8ArrayFromSelf,
+  MockFilter,
+  {
+    strict: false,
+    decode(value) {
+      return config.MockFilter.decode(value);
+    },
+    encode(value) {
+      return config.MockFilter.encode(value).finish();
+    }
+  }
+);
+const MockBlock = schema.Schema.Struct({
+  data: schema.Schema.optional(schema.Schema.String)
+});
+const MockBlockFromBytes = schema.Schema.transform(
+  schema.Schema.Uint8ArrayFromSelf,
+  schema.Schema.NullOr(MockBlock),
+  {
+    strict: false,
+    decode(value) {
+      if (value.length === 0) {
+        return null;
+      }
+      return config.MockBlock.decode(value);
+    },
+    encode(value) {
+      if (value === null) {
+        return new Uint8Array();
+      }
+      return config.MockBlock.encode(value).finish();
+    }
+  }
+);
+function mergeMockFilter(a, b) {
+  let filter = "";
+  if (a.filter) {
+    filter += a.filter;
+  }
+  if (b.filter) {
+    filter += b.filter;
+  }
+  return { filter };
+}
+const MockStream = new config.StreamConfig(
+  MockFilterFromBytes,
+  MockBlockFromBytes,
+  mergeMockFilter
+);
+const MockStreamResponse = config.StreamDataResponse(MockBlockFromBytes);
+
+exports.MockBlockFromBytes = MockBlockFromBytes;
+exports.MockClient = MockClient;
+exports.MockFilter = MockFilter;
+exports.MockFilterFromBytes = MockFilterFromBytes;
+exports.MockStream = MockStream;
+exports.MockStreamResponse = MockStreamResponse;
+exports.StreamDataIterable = StreamDataIterable;

package/dist/testing/index.d.cts

@@ -0,0 +1,75 @@
+import { A as Client, q as StreamDataRequest, z as StreamDataOptions, w as StreamDataResponse, S as StatusRequest, y as ClientCallOptions, l as StatusResponse, x as StreamConfig, c as Cursor, C as CursorProto, K as DataFinality } from '../shared/protocol.42d7ad57.cjs';
+import { Schema } from '@effect/schema';
+import 'nice-grpc';
+import 'nice-grpc-common';
+import 'protobufjs/minimal';
+import '@effect/schema/AST';
+
+declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
+    private messageFactory;
+    constructor(messageFactory: (request: StreamDataRequest<TFilter>, options?: StreamDataOptions) => (StreamDataResponse<TBlock> | Error)[]);
+    status(request?: StatusRequest, options?: ClientCallOptions): Promise<StatusResponse>;
+    streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): StreamDataIterable<TBlock>;
+}
+declare class StreamDataIterable<TBlock> {
+    private messages;
+    constructor(messages: (StreamDataResponse<TBlock> | Error)[]);
+    [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
+}
+
+declare const MockFilter: Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>;
+type MockFilter = typeof MockFilter.Type;
+declare const MockFilterFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>>;
+declare const MockBlock: Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>;
+type MockBlock = typeof MockBlock.Type;
+declare const MockBlockFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.NullOr<Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>>>;
+declare const MockStream: StreamConfig<{
+    readonly filter?: string | undefined;
+}, {
+    readonly data?: string | undefined;
+}>;
+declare const MockStreamResponse: Schema.Union<[Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "data", "$case", ":", "data", false, never>;
+    data: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        finality: Schema.transform<Schema.Enums<typeof DataFinality>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        data: Schema.Array$<Schema.Schema<{
+            readonly data?: string | undefined;
+        } | null, Uint8Array, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "invalidate", "$case", ":", "invalidate", false, never>;
+    invalidate: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "finalize", "$case", ":", "finalize", false, never>;
+    finalize: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
+    systemMessage: Schema.Struct<{
+        output: Schema.optional<Schema.Union<[Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
+            stdout: typeof Schema.String;
+        }>, Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
+            stderr: typeof Schema.String;
+        }>]>>;
+    }>;
+}>]>;
+type MockStreamResponse = typeof MockStreamResponse.Type;
+
+export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/dist/testing/index.d.mts

@@ -0,0 +1,75 @@
+import { A as Client, q as StreamDataRequest, z as StreamDataOptions, w as StreamDataResponse, S as StatusRequest, y as ClientCallOptions, l as StatusResponse, x as StreamConfig, c as Cursor, C as CursorProto, K as DataFinality } from '../shared/protocol.42d7ad57.mjs';
+import { Schema } from '@effect/schema';
+import 'nice-grpc';
+import 'nice-grpc-common';
+import 'protobufjs/minimal';
+import '@effect/schema/AST';
+
+declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
+    private messageFactory;
+    constructor(messageFactory: (request: StreamDataRequest<TFilter>, options?: StreamDataOptions) => (StreamDataResponse<TBlock> | Error)[]);
+    status(request?: StatusRequest, options?: ClientCallOptions): Promise<StatusResponse>;
+    streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): StreamDataIterable<TBlock>;
+}
+declare class StreamDataIterable<TBlock> {
+    private messages;
+    constructor(messages: (StreamDataResponse<TBlock> | Error)[]);
+    [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
+}
+
+declare const MockFilter: Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>;
+type MockFilter = typeof MockFilter.Type;
+declare const MockFilterFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>>;
+declare const MockBlock: Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>;
+type MockBlock = typeof MockBlock.Type;
+declare const MockBlockFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.NullOr<Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>>>;
+declare const MockStream: StreamConfig<{
+    readonly filter?: string | undefined;
+}, {
+    readonly data?: string | undefined;
+}>;
+declare const MockStreamResponse: Schema.Union<[Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "data", "$case", ":", "data", false, never>;
+    data: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        finality: Schema.transform<Schema.Enums<typeof DataFinality>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        data: Schema.Array$<Schema.Schema<{
+            readonly data?: string | undefined;
+        } | null, Uint8Array, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "invalidate", "$case", ":", "invalidate", false, never>;
+    invalidate: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "finalize", "$case", ":", "finalize", false, never>;
+    finalize: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
+    systemMessage: Schema.Struct<{
+        output: Schema.optional<Schema.Union<[Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
+            stdout: typeof Schema.String;
+        }>, Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
+            stderr: typeof Schema.String;
+        }>]>>;
+    }>;
+}>]>;
+type MockStreamResponse = typeof MockStreamResponse.Type;
+
+export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/dist/testing/index.d.ts

@@ -0,0 +1,75 @@
+import { A as Client, q as StreamDataRequest, z as StreamDataOptions, w as StreamDataResponse, S as StatusRequest, y as ClientCallOptions, l as StatusResponse, x as StreamConfig, c as Cursor, C as CursorProto, K as DataFinality } from '../shared/protocol.42d7ad57.js';
+import { Schema } from '@effect/schema';
+import 'nice-grpc';
+import 'nice-grpc-common';
+import 'protobufjs/minimal';
+import '@effect/schema/AST';
+
+declare class MockClient<TFilter, TBlock> implements Client<TFilter, TBlock> {
+    private messageFactory;
+    constructor(messageFactory: (request: StreamDataRequest<TFilter>, options?: StreamDataOptions) => (StreamDataResponse<TBlock> | Error)[]);
+    status(request?: StatusRequest, options?: ClientCallOptions): Promise<StatusResponse>;
+    streamData(request: StreamDataRequest<TFilter>, options?: StreamDataOptions): StreamDataIterable<TBlock>;
+}
+declare class StreamDataIterable<TBlock> {
+    private messages;
+    constructor(messages: (StreamDataResponse<TBlock> | Error)[]);
+    [Symbol.asyncIterator](): AsyncIterator<StreamDataResponse<TBlock>>;
+}
+
+declare const MockFilter: Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>;
+type MockFilter = typeof MockFilter.Type;
+declare const MockFilterFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.Struct<{
+    filter: Schema.optional<typeof Schema.String>;
+}>>;
+declare const MockBlock: Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>;
+type MockBlock = typeof MockBlock.Type;
+declare const MockBlockFromBytes: Schema.transform<Schema.Schema<Uint8Array, Uint8Array, never>, Schema.NullOr<Schema.Struct<{
+    data: Schema.optional<typeof Schema.String>;
+}>>>;
+declare const MockStream: StreamConfig<{
+    readonly filter?: string | undefined;
+}, {
+    readonly data?: string | undefined;
+}>;
+declare const MockStreamResponse: Schema.Union<[Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "data", "$case", ":", "data", false, never>;
+    data: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        endCursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+        finality: Schema.transform<Schema.Enums<typeof DataFinality>, Schema.Literal<["finalized", "accepted", "pending", "unknown"]>>;
+        data: Schema.Array$<Schema.Schema<{
+            readonly data?: string | undefined;
+        } | null, Uint8Array, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "invalidate", "$case", ":", "invalidate", false, never>;
+    invalidate: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "finalize", "$case", ":", "finalize", false, never>;
+    finalize: Schema.Struct<{
+        cursor: Schema.optional<Schema.Schema<Cursor, CursorProto, never>>;
+    }>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "heartbeat", "$case", ":", "heartbeat", false, never>;
+}>, Schema.Struct<{
+    _tag: Schema.PropertySignature<":", "systemMessage", "$case", ":", "systemMessage", false, never>;
+    systemMessage: Schema.Struct<{
+        output: Schema.optional<Schema.Union<[Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stdout", "$case", ":", "stdout", false, never>;
+            stdout: typeof Schema.String;
+        }>, Schema.Struct<{
+            _tag: Schema.PropertySignature<":", "stderr", "$case", ":", "stderr", false, never>;
+            stderr: typeof Schema.String;
+        }>]>>;
+    }>;
+}>]>;
+type MockStreamResponse = typeof MockStreamResponse.Type;
+
+export { MockBlock, MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/dist/testing/index.mjs

@@ -0,0 +1,97 @@
+import { Schema } from '@effect/schema';
+import { M as MockFilter$1, p as MockBlock$1, o as StreamConfig, S as StreamDataResponse } from '../shared/protocol.ff7dfded.mjs';
+import 'protobufjs/minimal';
+import 'effect';
+import 'viem';
+import 'long';
+
+class MockClient {
+  constructor(messageFactory) {
+    this.messageFactory = messageFactory;
+  }
+  async status(request, options) {
+    throw new Error("Client.status is not implemented for VcrClient");
+  }
+  streamData(request, options) {
+    const messages = this.messageFactory(request, options);
+    return new StreamDataIterable(messages);
+  }
+}
+class StreamDataIterable {
+  constructor(messages) {
+    this.messages = messages;
+  }
+  [Symbol.asyncIterator]() {
+    let index = 0;
+    const messages = this.messages;
+    return {
+      async next() {
+        if (index >= messages.length) {
+          return { done: true, value: void 0 };
+        }
+        const message = messages[index++];
+        if (message instanceof Error) {
+          throw message;
+        }
+        return { done: false, value: message };
+      }
+    };
+  }
+}
+
+const MockFilter = Schema.Struct({
+  filter: Schema.optional(Schema.String)
+});
+const MockFilterFromBytes = Schema.transform(
+  Schema.Uint8ArrayFromSelf,
+  MockFilter,
+  {
+    strict: false,
+    decode(value) {
+      return MockFilter$1.decode(value);
+    },
+    encode(value) {
+      return MockFilter$1.encode(value).finish();
+    }
+  }
+);
+const MockBlock = Schema.Struct({
+  data: Schema.optional(Schema.String)
+});
+const MockBlockFromBytes = Schema.transform(
+  Schema.Uint8ArrayFromSelf,
+  Schema.NullOr(MockBlock),
+  {
+    strict: false,
+    decode(value) {
+      if (value.length === 0) {
+        return null;
+      }
+      return MockBlock$1.decode(value);
+    },
+    encode(value) {
+      if (value === null) {
+        return new Uint8Array();
+      }
+      return MockBlock$1.encode(value).finish();
+    }
+  }
+);
+function mergeMockFilter(a, b) {
+  let filter = "";
+  if (a.filter) {
+    filter += a.filter;
+  }
+  if (b.filter) {
+    filter += b.filter;
+  }
+  return { filter };
+}
+const MockStream = new StreamConfig(
+  MockFilterFromBytes,
+  MockBlockFromBytes,
+  mergeMockFilter
+);
+const MockStreamResponse = StreamDataResponse(MockBlockFromBytes);
+
+export { MockBlockFromBytes, MockClient, MockFilter, MockFilterFromBytes, MockStream, MockStreamResponse, StreamDataIterable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apibara/protocol",
-  "version": "2.0.0-beta.5",
+  "version": "2.0.0-beta.6",
   "type": "module",
   "source": "./src/index.ts",
   "main": "./dist/index.mjs",