@useairfoil/flight 0.1.0

package/src/proto/google/protobuf/timestamp.ts

@@ -0,0 +1,231 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.6.1
+//   protoc               unknown
+// source: google/protobuf/timestamp.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { messageTypeRegistry } from "../../typeRegistry.js";
+
+export const protobufPackage = "google.protobuf";
+
+/**
+ * A Timestamp represents a point in time independent of any time zone or local
+ * calendar, encoded as a count of seconds and fractions of seconds at
+ * nanosecond resolution. The count is relative to an epoch at UTC midnight on
+ * January 1, 1970, in the proleptic Gregorian calendar which extends the
+ * Gregorian calendar backwards to year one.
+ *
+ * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+ * second table is needed for interpretation, using a [24-hour linear
+ * smear](https://developers.google.com/time/smear).
+ *
+ * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+ * restricting to that range, we ensure that we can convert to and from [RFC
+ * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Timestamp from POSIX `time()`.
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(time(NULL));
+ *     timestamp.set_nanos(0);
+ *
+ * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+ *
+ *     struct timeval tv;
+ *     gettimeofday(&tv, NULL);
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(tv.tv_sec);
+ *     timestamp.set_nanos(tv.tv_usec * 1000);
+ *
+ * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+ *
+ *     FILETIME ft;
+ *     GetSystemTimeAsFileTime(&ft);
+ *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ *
+ *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+ *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+ *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+ *
+ * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+ *
+ *     long millis = System.currentTimeMillis();
+ *
+ *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+ *         .setNanos((int) ((millis % 1000) * 1000000)).build();
+ *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
+ *
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
+ *
+ *     timestamp = Timestamp()
+ *     timestamp.GetCurrentTime()
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Timestamp type is encoded as a string in the
+ * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+ * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+ * where {year} is always expressed using four digits while {month}, {day},
+ * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+ * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required. A proto3 JSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a proto3 JSON parser should be
+ * able to accept both UTC and other timezones (as indicated by an offset).
+ *
+ * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, one can convert a Date object to this format using the
+ * standard
+ * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+ * method. In Python, a standard `datetime.datetime` object can be converted
+ * to this format using
+ * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+ * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+ * the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+ * ) to obtain a formatter capable of generating timestamps in this format.
+ */
+export interface Timestamp {
+  $type: "google.protobuf.Timestamp";
+  /**
+   * Represents seconds of UTC time since Unix epoch
+   * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+   * 9999-12-31T23:59:59Z inclusive.
+   */
+  readonly seconds: bigint;
+  /**
+   * Non-negative fractions of a second at nanosecond resolution. Negative
+   * second values with fractions must still have non-negative nanos values
+   * that count forward in time. Must be from 0 to 999,999,999
+   * inclusive.
+   */
+  readonly nanos: number;
+}
+
+function createBaseTimestamp(): Timestamp {
+  return { $type: "google.protobuf.Timestamp", seconds: 0n, nanos: 0 };
+}
+
+export const Timestamp: MessageFns<Timestamp, "google.protobuf.Timestamp"> = {
+  $type: "google.protobuf.Timestamp" as const,
+
+  encode(message: Timestamp, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.seconds !== 0n) {
+      if (BigInt.asIntN(64, message.seconds) !== message.seconds) {
+        throw new globalThis.Error("value provided for field message.seconds of type int64 too large");
+      }
+      writer.uint32(8).int64(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      writer.uint32(16).int32(message.nanos);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Timestamp {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTimestamp() as any;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.seconds = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.nanos = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Timestamp {
+    return {
+      $type: Timestamp.$type,
+      seconds: isSet(object.seconds) ? BigInt(object.seconds) : 0n,
+      nanos: isSet(object.nanos) ? globalThis.Number(object.nanos) : 0,
+    };
+  },
+
+  toJSON(message: Timestamp): unknown {
+    const obj: any = {};
+    if (message.seconds !== 0n) {
+      obj.seconds = message.seconds.toString();
+    }
+    if (message.nanos !== 0) {
+      obj.nanos = Math.round(message.nanos);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Timestamp>, I>>(base?: I): Timestamp {
+    return Timestamp.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Timestamp>, I>>(object: I): Timestamp {
+    const message = createBaseTimestamp() as any;
+    message.seconds = object.seconds ?? 0n;
+    message.nanos = object.nanos ?? 0;
+    return message;
+  },
+};
+
+messageTypeRegistry.set(Timestamp.$type, Timestamp);
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { readonly $case: string }
+    ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { readonly $case: T["$case"] }
+  : T extends {} ? { [K in Exclude<keyof T, "$type">]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P> | "$type">]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T, V extends string> {
+  readonly $type: V;
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}

package/src/proto/typeRegistry.ts

@@ -0,0 +1,29 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.6.1
+//   protoc               unknown
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+
+export interface MessageType<Message extends UnknownMessage = UnknownMessage> {
+  $type: Message["$type"];
+  encode(message: Message, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): Message;
+  fromJSON(object: any): Message;
+  toJSON(message: Message): unknown;
+  fromPartial(object: DeepPartial<Message>): Message;
+}
+
+export type UnknownMessage = { $type: string };
+
+export const messageTypeRegistry = new Map<string, MessageType>();
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { readonly $case: string }
+    ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { readonly $case: T["$case"] }
+  : T extends {} ? { [K in Exclude<keyof T, "$type">]?: DeepPartial<T[K]> }
+  : Partial<T>;

package/src/proto-utils.ts

@@ -0,0 +1,39 @@
+import {
+  type Channel,
+  type ChannelCredentials,
+  type ChannelOptions,
+  type CompatServiceDefinition,
+  createChannel,
+  type DefaultCallOptions,
+  type NormalizedServiceDefinition,
+} from "nice-grpc";
+
+export type RemoveTypeUrl<T> = Omit<T, "$type">;
+
+export type ClientOptions<S extends CompatServiceDefinition> = {
+  defaultCallOptions?: DefaultCallOptions<NormalizedServiceDefinition<S>>;
+};
+
+export type HostOrChannel =
+  | {
+      host: string;
+      credentials?: ChannelCredentials;
+      channelOptions?: ChannelOptions;
+      channel?: never;
+    }
+  | {
+      host?: never;
+      channel: Channel;
+    };
+
+export function createChannelFromConfig(config: HostOrChannel): Channel {
+  if (config.host !== undefined) {
+    return createChannel(
+      config.host,
+      config.credentials,
+      config.channelOptions,
+    );
+  }
+
+  return config.channel;
+}

package/src/record-batch-decoder.ts

@@ -0,0 +1,401 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: <> */
+
+// Licensed to the Apache Software Foundation (ASF) under one or mor e
+// contributor license agreements. See the NOTICE file distributed with this
+// work for additional information regarding copyright ownership. The ASF
+// licenses this file to you 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.
+
+// Originally from the arrow-js repository.
+// https://github.com/apache/arrow-js/blob/e656bcc0423f8c315ec3a66743aa96375eed1e82/src/ipc/reader.ts
+//
+// Changes:
+//
+// - Add `RecordBatchStreamReaderFromFlightData` to decode `RecordBatch` from a
+// stream of `FlightData` messages.
+import {
+  type Codec,
+  compressionRegistry,
+  type Data,
+  type DataType,
+  type Field,
+  Message,
+  MessageHeader,
+  makeData,
+  RecordBatch,
+  type Schema,
+  Struct,
+  type TypeMap,
+  Vector,
+} from "apache-arrow";
+import { ITERATOR_DONE } from "apache-arrow/io/interfaces";
+import {
+  COMPRESS_LENGTH_PREFIX,
+  LENGTH_NO_COMPRESSED_DATA,
+} from "apache-arrow/ipc/compression/constants";
+import * as metadata from "apache-arrow/ipc/metadata/message";
+import { _InternalEmptyPlaceholderRecordBatch } from "apache-arrow/recordbatch";
+import { bigIntToNumber } from "apache-arrow/util/bigint";
+import {
+  CompressedVectorLoader,
+  VectorLoader,
+} from "apache-arrow/visitor/vectorloader";
+import * as flatbuffers from "flatbuffers";
+import type { FlightData } from "./proto/Flight";
+
+const invalidMessageType = (type: MessageHeader) =>
+  `Expected ${MessageHeader[type]} Message in stream, but was null or length 0.`;
+// const nullMessage = (type: MessageHeader) =>
+//   `Header pointer of flatbuffer-encoded ${MessageHeader[type]} Message is null or length 0.`;
+// const invalidMessageMetadata = (expected: number, actual: number) =>
+//   `Expected to read ${expected} metadata bytes, but only read ${actual}.`;
+// const invalidMessageBodyLength = (expected: number, actual: number) =>
+//   `Expected to read ${expected} bytes for message body, but only read ${actual}.`;
+
+abstract class RecordBatchReaderImpl<T extends TypeMap = any>
+  implements RecordBatchReaderImpl<T>
+{
+  public declare schema: Schema<T>;
+  public closed = false;
+  public autoDestroy = true;
+  public dictionaries: Map<number, Vector>;
+
+  protected _dictionaryIndex = 0;
+  protected _recordBatchIndex = 0;
+  public get numDictionaries() {
+    return this._dictionaryIndex;
+  }
+  public get numRecordBatches() {
+    return this._recordBatchIndex;
+  }
+
+  constructor(dictionaries = new Map<number, Vector>()) {
+    this.dictionaries = dictionaries;
+  }
+
+  /*
+  public isSync(): this is RecordBatchReaders<T> {
+    return false;
+  }
+  public isAsync(): this is AsyncRecordBatchReaders<T> {
+    return false;
+  }
+  public isFile(): this is RecordBatchFileReaders<T> {
+    return false;
+  }
+  public isStream(): this is RecordBatchStreamReaders<T> {
+    return false;
+  }
+  */
+
+  public reset(schema?: Schema<T> | null) {
+    this._dictionaryIndex = 0;
+    this._recordBatchIndex = 0;
+    this.schema = <any>schema;
+    this.dictionaries = new Map();
+    return this;
+  }
+
+  protected _loadRecordBatch(
+    header: metadata.RecordBatch,
+    body: Uint8Array,
+  ): RecordBatch<T> {
+    // Ensure the body buffer is properly aligned for Apache Arrow
+    // Apache Arrow requires 8-byte aligned buffers for typed arrays
+    const alignedBody = this._ensureAlignedBuffer(body);
+
+    let children: Data<any>[];
+    if (header.compression != null) {
+      const codec = compressionRegistry.get(header.compression.type);
+      if (codec?.decode && typeof codec.decode === "function") {
+        const { decommpressedBody, buffers } = this._decompressBuffers(
+          header,
+          alignedBody,
+          codec,
+        );
+        children = this._loadCompressedVectors(
+          header,
+          decommpressedBody,
+          this.schema.fields,
+        );
+        header = new metadata.RecordBatch(
+          header.length,
+          header.nodes,
+          buffers,
+          null,
+        );
+      } else {
+        throw new Error("Record batch is compressed but codec not found");
+      }
+    } else {
+      children = this._loadVectors(header, alignedBody, this.schema.fields);
+    }
+
+    const data = makeData({
+      type: new Struct(this.schema.fields),
+      length: header.length,
+      children,
+    });
+    return new RecordBatch(this.schema, data);
+  }
+
+  /**
+   * Ensures that a buffer is properly aligned for Apache Arrow's requirements.
+   * Apache Arrow needs 8-byte aligned buffers for typed array views.
+   */
+  private _ensureAlignedBuffer(buffer: Uint8Array): Uint8Array {
+    // If the buffer's byteOffset is already properly aligned (multiple of 8), return as is
+    if (buffer.byteOffset % 8 === 0) {
+      return buffer;
+    }
+
+    // Otherwise, create a new properly aligned buffer
+    const alignedBuffer = new Uint8Array(buffer.length);
+    alignedBuffer.set(buffer);
+    return alignedBuffer;
+  }
+
+  protected _loadDictionaryBatch(
+    header: metadata.DictionaryBatch,
+    body: Uint8Array,
+  ) {
+    const { id, isDelta } = header;
+    const { dictionaries, schema } = this;
+    const dictionary = dictionaries.get(id);
+    const type = schema.dictionaries.get(id)!;
+    let data: Data<any>[];
+    if (header.data.compression != null) {
+      const codec = compressionRegistry.get(header.data.compression.type);
+      if (codec?.decode && typeof codec.decode === "function") {
+        const { decommpressedBody, buffers } = this._decompressBuffers(
+          header.data,
+          body,
+          codec,
+        );
+        data = this._loadCompressedVectors(header.data, decommpressedBody, [
+          type,
+        ]);
+        header = new metadata.DictionaryBatch(
+          new metadata.RecordBatch(
+            header.data.length,
+            header.data.nodes,
+            buffers,
+            null,
+          ),
+          id,
+          isDelta,
+        );
+      } else {
+        throw new Error("Dictionary batch is compressed but codec not found");
+      }
+    } else {
+      data = this._loadVectors(header.data, body, [type]);
+    }
+    // const data = this._loadVectors(header.data, body, [type]);
+    return (
+      dictionary && isDelta
+        ? dictionary.concat(new Vector(data))
+        : new Vector(data)
+    ).memoize() as Vector;
+  }
+
+  protected _loadVectors(
+    header: metadata.RecordBatch,
+    body: Uint8Array,
+    types: (Field | DataType)[],
+  ) {
+    return new VectorLoader(
+      body,
+      header.nodes,
+      header.buffers,
+      this.dictionaries,
+      this.schema.metadataVersion,
+    ).visitMany(types);
+  }
+
+  protected _loadCompressedVectors(
+    header: metadata.RecordBatch,
+    body: Uint8Array[],
+    types: (Field | DataType)[],
+  ) {
+    return new CompressedVectorLoader(
+      body,
+      header.nodes,
+      header.buffers,
+      this.dictionaries,
+      this.schema.metadataVersion,
+    ).visitMany(types);
+  }
+
+  private _decompressBuffers(
+    header: metadata.RecordBatch,
+    body: Uint8Array,
+    codec: Codec,
+  ): { decommpressedBody: Uint8Array[]; buffers: metadata.BufferRegion[] } {
+    const decompressedBuffers: Uint8Array[] = [];
+    const newBufferRegions: metadata.BufferRegion[] = [];
+
+    let currentOffset = 0;
+    for (const { offset, length } of header.buffers) {
+      if (length === 0) {
+        decompressedBuffers.push(new Uint8Array(0));
+        newBufferRegions.push(new metadata.BufferRegion(currentOffset, 0));
+        continue;
+      }
+      const byteBuf = new flatbuffers.ByteBuffer(
+        body.subarray(offset, offset + length),
+      );
+      const uncompressedLenth = bigIntToNumber(byteBuf.readInt64(0));
+
+      const bytes = byteBuf.bytes().subarray(COMPRESS_LENGTH_PREFIX);
+
+      const decompressed =
+        uncompressedLenth === LENGTH_NO_COMPRESSED_DATA
+          ? bytes
+          : codec.decode!(bytes);
+
+      decompressedBuffers.push(decompressed);
+
+      const padding = ((currentOffset + 7) & ~7) - currentOffset;
+      currentOffset += padding;
+      newBufferRegions.push(
+        new metadata.BufferRegion(currentOffset, decompressed.length),
+      );
+      currentOffset += decompressed.length;
+    }
+
+    return {
+      decommpressedBody: decompressedBuffers,
+      buffers: newBufferRegions,
+    };
+  }
+}
+
+export class RecordBatchStreamReaderFromFlightData<T extends TypeMap = any>
+  extends RecordBatchReaderImpl<T>
+  implements AsyncIterableIterator<RecordBatch<T>>
+{
+  protected _reader: AsyncIterator<FlightData>;
+
+  constructor(
+    protected _source: AsyncIterable<FlightData>,
+    dictionaries?: Map<number, Vector>,
+  ) {
+    super(dictionaries);
+
+    this._reader = this._source[Symbol.asyncIterator]();
+  }
+
+  // public isAsync(): this is AsyncRecordBatchReaders<T> {
+  //   return true;
+  // }
+
+  // public isStream(): this is RecordBatchStreamReaders<T> {
+  //   return true;
+  // }
+
+  public [Symbol.asyncIterator](): AsyncIterableIterator<RecordBatch<T>> {
+    return this as AsyncIterableIterator<RecordBatch<T>>;
+  }
+
+  /*
+  public async cancel() {
+    if (!this.closed && (this.closed = true)) {
+      await this.reset()._reader.return();
+      this._reader = <any>null;
+      this.dictionaries = <any>null;
+    }
+  }
+
+  public async open(options?: OpenOptions) {
+    if (!this.closed) {
+      this.autoDestroy = shouldAutoDestroy(this, options);
+      if (
+        !(this.schema || (this.schema = (await this._reader.readSchema())!))
+      ) {
+        await this.cancel();
+      }
+    }
+    return this;
+  }
+
+  public async throw(value?: any): Promise<IteratorResult<any>> {
+    if (!this.closed && this.autoDestroy && (this.closed = true)) {
+      return await this.reset()._reader.throw(value);
+    }
+    return ITERATOR_DONE;
+  }
+
+  public async return(value?: any): Promise<IteratorResult<any>> {
+    if (!this.closed && this.autoDestroy && (this.closed = true)) {
+      return await this.reset()._reader.return(value);
+    }
+    return ITERATOR_DONE;
+  }
+  */
+
+  public async next() {
+    if (this.closed) {
+      return ITERATOR_DONE;
+    }
+
+    while (true) {
+      const maybeMessage = await this._readNextMessageAndValidate();
+      if (!maybeMessage) {
+        break;
+      }
+
+      const { message, flight } = maybeMessage;
+
+      if (message.isSchema()) {
+        this.reset(message.header());
+      } else if (message.isRecordBatch()) {
+        this._recordBatchIndex++;
+        const header = message.header();
+        const recordBatch = this._loadRecordBatch(header, flight.dataBody);
+        return { done: false, value: recordBatch };
+      } else if (message.isDictionaryBatch()) {
+        this._dictionaryIndex++;
+        const header = message.header();
+        const vector = this._loadDictionaryBatch(header, flight.dataBody);
+        this.dictionaries.set(header.id, vector);
+      }
+    }
+
+    if (this.schema && this._recordBatchIndex === 0) {
+      this._recordBatchIndex++;
+      return {
+        done: false,
+        value: new _InternalEmptyPlaceholderRecordBatch<T>(this.schema),
+      };
+    }
+
+    // return await this.return();
+    return ITERATOR_DONE;
+  }
+
+  protected async _readNextMessageAndValidate<T extends MessageHeader>(
+    type?: T | null,
+  ) {
+    const { done, value } = await this._reader.next();
+    if (done) {
+      return null;
+    }
+
+    const message = Message.decode(value.dataHeader);
+    if (type != null && message.headerType !== type) {
+      throw new Error(invalidMessageType(type));
+    }
+
+    return { message, flight: value };
+  }
+}