@apibara/protocol 2.1.0-beta.23 → 2.1.0-beta.24

package/src/stream.ts

@@ -1,179 +1,180 @@
-import { Schema } from "@effect/schema";
-
+import {
+  ArrayCodec,
+  BigIntCodec,
+  type Codec,
+  type CodecType,
+  MessageCodec,
+  MutableArrayCodec,
+  NumberCodec,
+  OneOfCodec,
+  OptionalCodec,
+  StringCodec,
+  UndefinedCodec,
+} from "./codec";
 import { Cursor } from "./common";
 import * as proto from "./proto";
 
 /** Data finality. */
-export const DataFinality = Schema.transform(
-  Schema.Enums(proto.stream.DataFinality),
-  Schema.Literal("finalized", "accepted", "pending", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.stream.DataFinality.FINALIZED]: "finalized",
-        [proto.stream.DataFinality.ACCEPTED]: "accepted",
-        [proto.stream.DataFinality.PENDING]: "pending",
-        [proto.stream.DataFinality.UNKNOWN]: "unknown",
-        [proto.stream.DataFinality.UNRECOGNIZED]: "unknown",
-      } as const;
-
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      const enumMap = {
-        finalized: proto.stream.DataFinality.FINALIZED,
-        accepted: proto.stream.DataFinality.ACCEPTED,
-        pending: proto.stream.DataFinality.PENDING,
-        unknown: proto.stream.DataFinality.UNKNOWN,
-      };
-
-      return enumMap[value] ?? proto.stream.DataFinality.UNKNOWN;
-    },
+export const DataFinality: Codec<
+  "finalized" | "accepted" | "pending" | "unknown",
+  proto.stream.DataFinality
+> = {
+  encode(x) {
+    const enumMap = {
+      finalized: proto.stream.DataFinality.FINALIZED,
+      accepted: proto.stream.DataFinality.ACCEPTED,
+      pending: proto.stream.DataFinality.PENDING,
+      unknown: proto.stream.DataFinality.UNKNOWN,
+    };
+
+    return enumMap[x] ?? proto.stream.DataFinality.UNKNOWN;
+  },
+  decode(p) {
+    const enumMap = {
+      [proto.stream.DataFinality.FINALIZED]: "finalized",
+      [proto.stream.DataFinality.ACCEPTED]: "accepted",
+      [proto.stream.DataFinality.PENDING]: "pending",
+      [proto.stream.DataFinality.UNKNOWN]: "unknown",
+      [proto.stream.DataFinality.UNRECOGNIZED]: "unknown",
+    } as const;
+
+    return enumMap[p] ?? "unknown";
   },
-);
+};
 
-export type DataFinality = typeof DataFinality.Type;
+export type DataFinality = CodecType<typeof DataFinality>;
 
 /** Data production mode. */
-export const DataProduction = Schema.transform(
-  Schema.Enums(proto.stream.DataProduction),
-  Schema.Literal("backfill", "live", "unknown"),
-  {
-    decode(value) {
-      const enumMap = {
-        [proto.stream.DataProduction.BACKFILL]: "backfill",
-        [proto.stream.DataProduction.LIVE]: "live",
-        [proto.stream.DataProduction.UNKNOWN]: "unknown",
-        [proto.stream.DataProduction.UNRECOGNIZED]: "unknown",
-      } as const;
-
-      return enumMap[value] ?? "unknown";
-    },
-    encode(value) {
-      const enumMap = {
-        backfill: proto.stream.DataProduction.BACKFILL,
-        live: proto.stream.DataProduction.LIVE,
-        unknown: proto.stream.DataProduction.UNKNOWN,
-      };
-
-      return enumMap[value] ?? proto.stream.DataProduction.UNKNOWN;
-    },
+export const DataProduction: Codec<
+  "backfill" | "live" | "unknown",
+  proto.stream.DataProduction
+> = {
+  encode(x) {
+    switch (x) {
+      case "backfill":
+        return proto.stream.DataProduction.BACKFILL;
+      case "live":
+        return proto.stream.DataProduction.LIVE;
+      case "unknown":
+        return proto.stream.DataProduction.UNKNOWN;
+      default:
+        return proto.stream.DataProduction.UNRECOGNIZED;
+    }
+  },
+  decode(p) {
+    const enumMap = {
+      [proto.stream.DataProduction.BACKFILL]: "backfill",
+      [proto.stream.DataProduction.LIVE]: "live",
+      [proto.stream.DataProduction.UNKNOWN]: "unknown",
+      [proto.stream.DataProduction.UNRECOGNIZED]: "unknown",
+    } as const;
+
+    return enumMap[p] ?? "unknown";
   },
-);
+};
 
-export type DataProduction = typeof DataProduction.Type;
+export type DataProduction = CodecType<typeof DataProduction>;
 
-export const Duration = Schema.Struct({
-  seconds: Schema.BigIntFromSelf,
-  nanos: Schema.Number,
+export const DurationCodec = MessageCodec({
+  seconds: BigIntCodec,
+  nanos: NumberCodec,
 });
 
+export type Duration = CodecType<typeof DurationCodec>;
+
 /** Create a `StreamDataRequest` with the given filter schema. */
-export const StreamDataRequest = <TA, TR>(
-  filter: Schema.Schema<TA, Uint8Array, TR>,
-) =>
-  Schema.Struct({
-    finality: Schema.optional(DataFinality),
-    startingCursor: Schema.optional(Cursor),
-    filter: Schema.mutable(Schema.Array(filter)),
-    heartbeatInterval: Schema.optional(Duration),
+export const StreamDataRequest = <TA>(filter: Codec<TA, Uint8Array>) =>
+  MessageCodec({
+    finality: OptionalCodec(DataFinality),
+    startingCursor: OptionalCodec(Cursor),
+    filter: MutableArrayCodec(filter),
+    heartbeatInterval: OptionalCodec(DurationCodec),
   });
 
-export type StreamDataRequest<TA> = {
-  finality?: DataFinality | undefined;
-  startingCursor?: Cursor | undefined;
-  filter: TA[];
-};
+export type StreamDataRequest<TA> = CodecType<
+  ReturnType<typeof StreamDataRequest<TA>>
+>;
 
-export const Invalidate = Schema.Struct({
-  _tag: tag("invalidate"),
-  invalidate: Schema.Struct({
-    cursor: Schema.optional(Cursor),
-  }),
+export const Invalidate = MessageCodec({
+  cursor: OptionalCodec(Cursor),
 });
 
-export type Invalidate = typeof Invalidate.Type;
+export type Invalidate = CodecType<typeof Invalidate>;
 
-export const Finalize = Schema.Struct({
-  _tag: tag("finalize"),
-  finalize: Schema.Struct({
-    cursor: Schema.optional(Cursor),
-  }),
+export const Finalize = MessageCodec({
+  cursor: OptionalCodec(Cursor),
 });
 
-export type Finalize = typeof Finalize.Type;
+export type Finalize = CodecType<typeof Finalize>;
 
-export const Heartbeat = Schema.Struct({
-  _tag: tag("heartbeat"),
-});
+// TODO: Double check this; This is a hack to make the heartbeat variant undefined
+export const Heartbeat = UndefinedCodec;
 
-export type Heartbeat = typeof Heartbeat.Type;
+export type Heartbeat = CodecType<typeof Heartbeat>;
 
-export const StdOut = Schema.Struct({
-  _tag: tag("stdout"),
-  stdout: Schema.String,
-});
+export const StdOut = StringCodec;
 
-export type StdOut = typeof StdOut.Type;
+export type StdOut = CodecType<typeof StdOut>;
 
-export const StdErr = Schema.Struct({
-  _tag: tag("stderr"),
-  stderr: Schema.String,
-});
+export const StdErr = StringCodec;
 
-export type StdErr = typeof StdErr.Type;
+export type StdErr = CodecType<typeof StdErr>;
 
-export const SystemMessage = Schema.Struct({
-  _tag: tag("systemMessage"),
-  systemMessage: Schema.Struct({
-    output: Schema.Union(StdOut, StdErr),
+export const SystemMessage = MessageCodec({
+  output: OneOfCodec({
+    stdout: StdOut,
+    stderr: StdErr,
   }),
 });
 
-export type SystemMessage = typeof SystemMessage.Type;
-
-export const Data = <TA, TR>(
-  schema: Schema.Schema<TA | null, Uint8Array, TR>,
-) =>
-  Schema.Struct({
-    _tag: tag("data"),
-    data: Schema.Struct({
-      cursor: Schema.optional(Cursor),
-      endCursor: Cursor,
-      finality: DataFinality,
-      production: DataProduction,
-      data: Schema.Array(schema),
-    }),
+export type SystemMessage = CodecType<typeof SystemMessage>;
+
+const _DataOrNull = <TA>(
+  schema: Codec<TA, Uint8Array>,
+): Codec<TA | null, Uint8Array> => ({
+  encode(x) {
+    if (x === null) {
+      return new Uint8Array();
+    }
+    return schema.encode(x);
+  },
+  decode(p) {
+    if (p.length === 0) {
+      return null;
+    }
+    return schema.decode(p);
+  },
+});
+
+export const Data = <TA>(schema: Codec<TA | null, Uint8Array>) =>
+  MessageCodec({
+    cursor: OptionalCodec(Cursor),
+    endCursor: Cursor,
+    finality: DataFinality,
+    production: DataProduction,
+    data: ArrayCodec(_DataOrNull(schema)),
   });
 
-export const StreamDataResponse = <TA, TR>(
-  data: Schema.Schema<TA | null, Uint8Array, TR>,
-) => Schema.Union(Data(data), Invalidate, Finalize, Heartbeat, SystemMessage);
-
-const ResponseWithoutData = Schema.Union(
-  Invalidate,
-  Finalize,
-  Heartbeat,
-  SystemMessage,
-);
-type ResponseWithoutData = typeof ResponseWithoutData.Type;
-
-export type StreamDataResponse<TA> =
-  | ResponseWithoutData
-  | {
-      _tag: "data";
-      data: {
-        cursor?: Cursor | undefined;
-        endCursor: Cursor;
-        finality: DataFinality;
-        production: DataProduction;
-        data: readonly (TA | null)[];
-      };
-    };
+export type Data<TA> = CodecType<ReturnType<typeof Data<TA>>>;
+
+export const StreamDataResponse = <TA>(schema: Codec<TA | null, Uint8Array>) =>
+  OneOfCodec({
+    data: Data(schema),
+    invalidate: Invalidate,
+    finalize: Finalize,
+    heartbeat: Heartbeat,
+    systemMessage: SystemMessage,
+  });
+
+export const ResponseWithoutData = OneOfCodec({
+  invalidate: Invalidate,
+  finalize: Finalize,
+  heartbeat: Heartbeat,
+  systemMessage: SystemMessage,
+});
+
+export type ResponseWithoutData = CodecType<typeof ResponseWithoutData>;
 
-function tag<T extends string>(tag: T) {
-  return Schema.Literal(tag).pipe(
-    Schema.propertySignature,
-    Schema.fromKey("$case"),
-  );
-}
+export type StreamDataResponse<TA> = CodecType<
+  ReturnType<typeof StreamDataResponse<TA>>
+>;

package/src/testing/mock.ts

@@ -1,53 +1,49 @@
-import { Schema } from "@effect/schema";
+import {
+  type Codec,
+  type CodecType,
+  MessageCodec,
+  OptionalCodec,
+  StringCodec,
+} from "../codec";
 import { StreamConfig } from "../config";
 import * as proto from "../proto";
 import { StreamDataResponse } from "../stream";
 
-export const MockFilter = Schema.Struct({
-  filter: Schema.optional(Schema.String),
+export const MockFilter = MessageCodec({
+  filter: OptionalCodec(StringCodec),
 });
 
-export type MockFilter = typeof MockFilter.Type;
+export type MockFilter = CodecType<typeof MockFilter>;
 
-export const MockFilterFromBytes = Schema.transform(
-  Schema.Uint8ArrayFromSelf,
-  MockFilter,
-  {
-    strict: false,
-    decode(value) {
-      return proto.testing.MockFilter.decode(value);
-    },
-    encode(value) {
-      return proto.testing.MockFilter.encode(value).finish();
-    },
+export const MockFilterFromBytes: Codec<MockFilter, Uint8Array> = {
+  decode(value) {
+    return proto.testing.MockFilter.decode(value);
   },
-);
+  encode(value) {
+    return proto.testing.MockFilter.encode(value).finish();
+  },
+};
 
-const MockBlock = Schema.Struct({
-  data: Schema.optional(Schema.String),
+const MockBlock = MessageCodec({
+  data: OptionalCodec(StringCodec),
 });
 
-export type MockBlock = typeof MockBlock.Type;
+export type MockBlock = CodecType<typeof MockBlock>;
 
-export const MockBlockFromBytes = Schema.transform(
-  Schema.Uint8ArrayFromSelf,
-  Schema.NullOr(MockBlock),
-  {
-    strict: false,
-    decode(value) {
-      if (value.length === 0) {
-        return null;
-      }
-      return proto.testing.MockBlock.decode(value);
-    },
-    encode(value) {
-      if (value === null) {
-        return new Uint8Array();
-      }
-      return proto.testing.MockBlock.encode(value).finish();
-    },
+export const MockBlockFromBytes: Codec<MockBlock | null, Uint8Array> = {
+  decode(value) {
+    if (value.length === 0) {
+      return null;
+    }
+    return proto.testing.MockBlock.decode(value);
   },
-);
+  encode(value) {
+    if (value === null) {
+      return new Uint8Array();
+    }
+    return proto.testing.MockBlock.encode(value).finish();
+  },
+};
 
 /** For testing, simply concatenate the values of `.filter` */
 function mergeMockFilter(a: MockFilter, b: MockFilter): MockFilter {
@@ -68,4 +64,5 @@ export const MockStream = new StreamConfig(
 );
 
 export const MockStreamResponse = StreamDataResponse(MockBlockFromBytes);
-export type MockStreamResponse = typeof MockStreamResponse.Type;
+
+export type MockStreamResponse = CodecType<typeof MockStreamResponse>;

package/src/common.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createCursor, cursorFromProto, cursorToProto } from "./common";
-
-describe("Cursor", () => {
-  describe("proto", () => {
-    it("should encode and decode (with uniqueKey)", () => {
-      const cursor = createCursor({
-        orderKey: 123n,
-        uniqueKey: "0xcafecafe",
-      });
-
-      const proto = cursorToProto(cursor);
-      expect(proto).toMatchInlineSnapshot(`
-        {
-          "orderKey": 123n,
-          "uniqueKey": Uint8Array [
-            202,
-            254,
-            202,
-            254,
-          ],
-        }
-      `);
-      const back = cursorFromProto(proto);
-      expect(back).toEqual(cursor);
-    });
-
-    it("should encode and decode (without uniqueKey)", () => {
-      const cursor = createCursor({
-        orderKey: 123n,
-      });
-
-      const proto = cursorToProto(cursor);
-      expect(proto).toMatchInlineSnapshot(`
-        {
-          "orderKey": 123n,
-          "uniqueKey": Uint8Array [],
-        }
-      `);
-      const back = cursorFromProto(proto);
-      expect(back).toEqual(cursor);
-    });
-  });
-
-  describe("bytes", () => {
-    it("should encode and decode (with uniqueKey)", () => {
-      const cursor = createCursor({
-        orderKey: 123n,
-        uniqueKey: "0xcafecafe",
-      });
-
-      const proto = cursorToProto(cursor);
-      const back = cursorFromProto(proto);
-      expect(back).toEqual(cursor);
-    });
-
-    it("should encode and decode (without uniqueKey)", () => {
-      const cursor = createCursor({
-        orderKey: 123n,
-      });
-
-      const proto = cursorToProto(cursor);
-      const back = cursorFromProto(proto);
-      expect(back).toEqual(cursor);
-    });
-  });
-});

package/src/status.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  StatusResponse,
-  statusRequestFromProto,
-  statusRequestToProto,
-  statusResponseFromProto,
-  statusResponseToProto,
-} from "./status";
-
-describe("StatusRequest", () => {
-  describe("proto", () => {
-    it("should encode and decode", () => {
-      const proto = statusRequestToProto({});
-      expect(proto).toMatchInlineSnapshot("{}");
-      const back = statusRequestFromProto(proto);
-      expect(back).toEqual({});
-    });
-  });
-});
-
-describe("StatusResponse", () => {
-  describe("proto", () => {
-    it("should encode and decode", () => {
-      const response = StatusResponse.make({
-        currentHead: {
-          orderKey: 123n,
-        },
-        lastIngested: {
-          orderKey: 123n,
-        },
-      });
-
-      const proto = statusResponseToProto(response);
-      expect(proto).toMatchInlineSnapshot(`
-        {
-          "currentHead": {
-            "orderKey": 123n,
-            "uniqueKey": Uint8Array [],
-          },
-          "lastIngested": {
-            "orderKey": 123n,
-            "uniqueKey": Uint8Array [],
-          },
-        }
-      `);
-      const back = statusResponseFromProto(proto);
-      expect(back).toEqual(response);
-    });
-  });
-});

package/src/stream.test-d.ts

@@ -1,33 +0,0 @@
-import { Schema } from "@effect/schema";
-import { test } from "vitest";
-
-import { Data } from "./stream";
-
-const Inner = Schema.Struct({
-  data: Schema.String,
-});
-
-const Good = Schema.transform(Schema.Uint8ArrayFromSelf, Schema.NullOr(Inner), {
-  decode(value) {
-    throw new Error("not implemented");
-  },
-  encode(value) {
-    throw new Error("not implemented");
-  },
-});
-
-const Bad = Schema.transform(Schema.Uint8ArrayFromSelf, Inner, {
-  decode(value) {
-    throw new Error("not implemented");
-  },
-  encode(value) {
-    throw new Error("not implemented");
-  },
-});
-
-test("Data", () => {
-  const GoodData = Data(Good);
-
-  // @ts-expect-error
-  const BadData = Data(Bad);
-});