@useairfoil/flight 0.1.0

package/dist/test/index.d.ts

@@ -0,0 +1,29 @@
+import { StartedTestContainer } from "testcontainers";
+import { Context, Effect, Layer } from "effect";
+
+//#region test/wings-container.d.ts
+declare class WingsContainer {
+  private container;
+  start(): Promise<WingsContainer>;
+  stop(): Promise<void>;
+  getGrpcPort(): number;
+  getHttpPort(): number;
+  getGrpcHost(): string;
+  getHttpHost(): string;
+  private getHost;
+  getContainer(): StartedTestContainer;
+}
+//#endregion
+//#region test/wings-container.effect.d.ts
+declare const EffectWingsContainer_base: Context.TagClass<EffectWingsContainer, "EffectWingsContainer", {
+  readonly getGrpcPort: Effect.Effect<number>;
+  readonly getHttpPort: Effect.Effect<number>;
+  readonly getGrpcHost: Effect.Effect<string>;
+  readonly getHttpHost: Effect.Effect<string>;
+  readonly getContainer: Effect.Effect<StartedTestContainer>;
+}>;
+declare class EffectWingsContainer extends EffectWingsContainer_base {}
+declare const EffectWingsContainerLive: Layer.Layer<EffectWingsContainer, Error, never>;
+//#endregion
+export { EffectWingsContainer, EffectWingsContainerLive, WingsContainer };
+//# sourceMappingURL=index.d.ts.map

package/dist/test/index.js

@@ -0,0 +1,79 @@
+import { GenericContainer, Wait } from "testcontainers";
+import { Context, Effect, Layer, Scope } from "effect";
+
+//#region test/wings-container.ts
+var WingsContainer = class {
+	container = null;
+	async start() {
+		this.container = await new GenericContainer("docker.useairfoil.com/airfoil/wings:latest").withCommand([
+			"dev",
+			"--http-address=0.0.0.0:7780",
+			"--metadata-address=0.0.0.0:7777"
+		]).withExposedPorts(7777, 7780).withTmpFs({ "/tmp": "rw" }).withWaitStrategy(Wait.forLogMessage(/gRPC server listening on 0\.0\.0\.0:7777/)).withStartupTimeout(6e4).start();
+		return this;
+	}
+	async stop() {
+		if (this.container) {
+			await this.container.stop();
+			this.container = null;
+		}
+	}
+	getGrpcPort() {
+		if (!this.container) throw new Error("Container not started");
+		return this.container.getMappedPort(7777);
+	}
+	getHttpPort() {
+		if (!this.container) throw new Error("Container not started");
+		return this.container.getMappedPort(7780);
+	}
+	getGrpcHost() {
+		return `${this.getHost()}:${this.getGrpcPort()}`;
+	}
+	getHttpHost() {
+		return `${this.getHost()}:${this.getHttpPort()}`;
+	}
+	getHost() {
+		if (!this.container) throw new Error("Container not started");
+		return this.container.getHost();
+	}
+	getContainer() {
+		if (!this.container) throw new Error("Container not started");
+		return this.container;
+	}
+};
+
+//#endregion
+//#region test/wings-container.effect.ts
+var EffectWingsContainer = class extends Context.Tag("EffectWingsContainer")() {};
+const EffectWingsContainerLive = Layer.scoped(EffectWingsContainer, Effect.gen(function* () {
+	const scope = yield* Scope.Scope;
+	const container = yield* Effect.tryPromise({
+		try: () => new GenericContainer("docker.useairfoil.com/airfoil/wings:latest").withCommand([
+			"dev",
+			"--http-address=0.0.0.0:7780",
+			"--metadata-address=0.0.0.0:7777"
+		]).withExposedPorts(7777, 7780).withTmpFs({ "/tmp": "rw" }).withWaitStrategy(Wait.forLogMessage(/gRPC server listening on 0\.0\.0\.0:7777/)).withStartupTimeout(6e4).start(),
+		catch: (error) => /* @__PURE__ */ new Error(`Failed to start container: ${error}`)
+	});
+	yield* Scope.addFinalizer(scope, Effect.tryPromise({
+		try: () => container.stop(),
+		catch: (error) => /* @__PURE__ */ new Error(`Failed to stop container: ${error}`)
+	}).pipe(Effect.tap(() => Effect.log("Container stopped successfully")), Effect.catchAll((error) => Effect.log(`Error stopping container: ${error}`))));
+	return {
+		getGrpcPort: Effect.sync(() => container.getMappedPort(7777)),
+		getHttpPort: Effect.sync(() => container.getMappedPort(7780)),
+		getGrpcHost: Effect.gen(function* () {
+			const port = yield* Effect.sync(() => container.getMappedPort(7777));
+			return `${yield* Effect.sync(() => container.getHost())}:${port}`;
+		}),
+		getHttpHost: Effect.gen(function* () {
+			const port = yield* Effect.sync(() => container.getMappedPort(7780));
+			return `${yield* Effect.sync(() => container.getHost())}:${port}`;
+		}),
+		getContainer: Effect.succeed(container)
+	};
+}));
+
+//#endregion
+export { EffectWingsContainer, EffectWingsContainerLive, WingsContainer };
+//# sourceMappingURL=index.js.map

package/dist/test/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../test/wings-container.ts","../../test/wings-container.effect.ts"],"sourcesContent":["import {\n  GenericContainer,\n  type StartedTestContainer,\n  Wait,\n} from \"testcontainers\";\n\nexport class WingsContainer {\n  private container: StartedTestContainer | null = null;\n\n  async start(): Promise<WingsContainer> {\n    const container = new GenericContainer(\n      \"docker.useairfoil.com/airfoil/wings:latest\",\n    )\n      .withCommand([\n        \"dev\",\n        \"--http-address=0.0.0.0:7780\",\n        \"--metadata-address=0.0.0.0:7777\",\n      ])\n      .withExposedPorts(7777, 7780)\n      .withTmpFs({ \"/tmp\": \"rw\" })\n      .withWaitStrategy(\n        Wait.forLogMessage(/gRPC server listening on 0\\.0\\.0\\.0:7777/),\n      )\n      .withStartupTimeout(60_000);\n\n    this.container = await container.start();\n    return this;\n  }\n\n  async stop(): Promise<void> {\n    if (this.container) {\n      await this.container.stop();\n      this.container = null;\n    }\n  }\n\n  getGrpcPort(): number {\n    if (!this.container) {\n      throw new Error(\"Container not started\");\n    }\n    return this.container.getMappedPort(7777);\n  }\n\n  getHttpPort(): number {\n    if (!this.container) {\n      throw new Error(\"Container not started\");\n    }\n    return this.container.getMappedPort(7780);\n  }\n\n  getGrpcHost(): string {\n    return `${this.getHost()}:${this.getGrpcPort()}`;\n  }\n\n  getHttpHost(): string {\n    return `${this.getHost()}:${this.getHttpPort()}`;\n  }\n\n  private getHost(): string {\n    if (!this.container) {\n      throw new Error(\"Container not started\");\n    }\n    return this.container.getHost();\n  }\n\n  getContainer(): StartedTestContainer {\n    if (!this.container) {\n      throw new Error(\"Container not started\");\n    }\n    return this.container;\n  }\n}\n","import { Context, Effect, Layer, Scope } from \"effect\";\nimport {\n  GenericContainer,\n  type StartedTestContainer,\n  Wait,\n} from \"testcontainers\";\n\nexport class EffectWingsContainer extends Context.Tag(\"EffectWingsContainer\")<\n  EffectWingsContainer,\n  {\n    readonly getGrpcPort: Effect.Effect<number>;\n    readonly getHttpPort: Effect.Effect<number>;\n    readonly getGrpcHost: Effect.Effect<string>;\n    readonly getHttpHost: Effect.Effect<string>;\n    readonly getContainer: Effect.Effect<StartedTestContainer>;\n  }\n>() {}\n\nexport const EffectWingsContainerLive = Layer.scoped(\n  EffectWingsContainer,\n  Effect.gen(function* () {\n    const scope = yield* Scope.Scope;\n\n    const container = yield* Effect.tryPromise({\n      try: () =>\n        new GenericContainer(\"docker.useairfoil.com/airfoil/wings:latest\")\n          .withCommand([\n            \"dev\",\n            \"--http-address=0.0.0.0:7780\",\n            \"--metadata-address=0.0.0.0:7777\",\n          ])\n          .withExposedPorts(7777, 7780)\n          .withTmpFs({ \"/tmp\": \"rw\" })\n          .withWaitStrategy(\n            Wait.forLogMessage(/gRPC server listening on 0\\.0\\.0\\.0:7777/),\n          )\n          .withStartupTimeout(60_000)\n          .start(),\n      catch: (error) => new Error(`Failed to start container: ${error}`),\n    });\n\n    yield* Scope.addFinalizer(\n      scope,\n      Effect.tryPromise({\n        try: () => container.stop(),\n        catch: (error) => new Error(`Failed to stop container: ${error}`),\n      }).pipe(\n        Effect.tap(() => Effect.log(\"Container stopped successfully\")),\n        Effect.catchAll((error) =>\n          Effect.log(`Error stopping container: ${error}`),\n        ),\n      ),\n    );\n\n    return {\n      getGrpcPort: Effect.sync(() => container.getMappedPort(7777)),\n      getHttpPort: Effect.sync(() => container.getMappedPort(7780)),\n      getGrpcHost: Effect.gen(function* () {\n        const port = yield* Effect.sync(() => container.getMappedPort(7777));\n        const host = yield* Effect.sync(() => container.getHost());\n        return `${host}:${port}`;\n      }),\n      getHttpHost: Effect.gen(function* () {\n        const port = yield* Effect.sync(() => container.getMappedPort(7780));\n        const host = yield* Effect.sync(() => container.getHost());\n        return `${host}:${port}`;\n      }),\n      getContainer: Effect.succeed(container),\n    };\n  }),\n);\n"],"mappings":";;;;AAMA,IAAa,iBAAb,MAA4B;CAC1B,AAAQ,YAAyC;CAEjD,MAAM,QAAiC;AAgBrC,OAAK,YAAY,MAfC,IAAI,iBACpB,6CACD,CACE,YAAY;GACX;GACA;GACA;GACD,CAAC,CACD,iBAAiB,MAAM,KAAK,CAC5B,UAAU,EAAE,QAAQ,MAAM,CAAC,CAC3B,iBACC,KAAK,cAAc,2CAA2C,CAC/D,CACA,mBAAmB,IAAO,CAEI,OAAO;AACxC,SAAO;;CAGT,MAAM,OAAsB;AAC1B,MAAI,KAAK,WAAW;AAClB,SAAM,KAAK,UAAU,MAAM;AAC3B,QAAK,YAAY;;;CAIrB,cAAsB;AACpB,MAAI,CAAC,KAAK,UACR,OAAM,IAAI,MAAM,wBAAwB;AAE1C,SAAO,KAAK,UAAU,cAAc,KAAK;;CAG3C,cAAsB;AACpB,MAAI,CAAC,KAAK,UACR,OAAM,IAAI,MAAM,wBAAwB;AAE1C,SAAO,KAAK,UAAU,cAAc,KAAK;;CAG3C,cAAsB;AACpB,SAAO,GAAG,KAAK,SAAS,CAAC,GAAG,KAAK,aAAa;;CAGhD,cAAsB;AACpB,SAAO,GAAG,KAAK,SAAS,CAAC,GAAG,KAAK,aAAa;;CAGhD,AAAQ,UAAkB;AACxB,MAAI,CAAC,KAAK,UACR,OAAM,IAAI,MAAM,wBAAwB;AAE1C,SAAO,KAAK,UAAU,SAAS;;CAGjC,eAAqC;AACnC,MAAI,CAAC,KAAK,UACR,OAAM,IAAI,MAAM,wBAAwB;AAE1C,SAAO,KAAK;;;;;;AC9DhB,IAAa,uBAAb,cAA0C,QAAQ,IAAI,uBAAuB,EAS1E,CAAC;AAEJ,MAAa,2BAA2B,MAAM,OAC5C,sBACA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,OAAO,MAAM;CAE3B,MAAM,YAAY,OAAO,OAAO,WAAW;EACzC,WACE,IAAI,iBAAiB,6CAA6C,CAC/D,YAAY;GACX;GACA;GACA;GACD,CAAC,CACD,iBAAiB,MAAM,KAAK,CAC5B,UAAU,EAAE,QAAQ,MAAM,CAAC,CAC3B,iBACC,KAAK,cAAc,2CAA2C,CAC/D,CACA,mBAAmB,IAAO,CAC1B,OAAO;EACZ,QAAQ,0BAAU,IAAI,MAAM,8BAA8B,QAAQ;EACnE,CAAC;AAEF,QAAO,MAAM,aACX,OACA,OAAO,WAAW;EAChB,WAAW,UAAU,MAAM;EAC3B,QAAQ,0BAAU,IAAI,MAAM,6BAA6B,QAAQ;EAClE,CAAC,CAAC,KACD,OAAO,UAAU,OAAO,IAAI,iCAAiC,CAAC,EAC9D,OAAO,UAAU,UACf,OAAO,IAAI,6BAA6B,QAAQ,CACjD,CACF,CACF;AAED,QAAO;EACL,aAAa,OAAO,WAAW,UAAU,cAAc,KAAK,CAAC;EAC7D,aAAa,OAAO,WAAW,UAAU,cAAc,KAAK,CAAC;EAC7D,aAAa,OAAO,IAAI,aAAa;GACnC,MAAM,OAAO,OAAO,OAAO,WAAW,UAAU,cAAc,KAAK,CAAC;AAEpE,UAAO,GADM,OAAO,OAAO,WAAW,UAAU,SAAS,CAAC,CAC3C,GAAG;IAClB;EACF,aAAa,OAAO,IAAI,aAAa;GACnC,MAAM,OAAO,OAAO,OAAO,WAAW,UAAU,cAAc,KAAK,CAAC;AAEpE,UAAO,GADM,OAAO,OAAO,WAAW,UAAU,SAAS,CAAC,CAC3C,GAAG;IAClB;EACF,cAAc,OAAO,QAAQ,UAAU;EACxC;EACD,CACH"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@useairfoil/flight",
+  "version": "0.1.0",
+  "type": "module",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js",
+      "default": "./dist/src/index.js"
+    },
+    "./test": {
+      "types": "./dist/test/index.d.ts",
+      "import": "./dist/test/index.js",
+      "default": "./dist/test/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "build:proto": "buf generate proto",
+    "typecheck": "tsc --noEmit",
+    "format": "biome format --write .",
+    "lint": "biome check .",
+    "lint:fix": "biome check . --write",
+    "test": "vitest",
+    "test:ci": "vitest run"
+  },
+  "peerDependencies": {
+    "effect": "^3.19.15"
+  },
+  "optionalDependencies": {
+    "testcontainers": "^11.11.0"
+  },
+  "devDependencies": {
+    "@bufbuild/buf": "^1.57.2",
+    "@effect/vitest": "^0.27.0",
+    "@rollup/plugin-typescript": "^12.1.4",
+    "effect": "^3.19.15",
+    "testcontainers": "^11.11.0",
+    "tsdown": "^0.15.6",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "^2.9.0",
+    "apache-arrow": "^21.1.0",
+    "flatbuffers": "^25.9.23",
+    "iter-ops": "^3.5.0",
+    "long": "^5.3.2",
+    "nice-grpc": "^2.1.13",
+    "nice-grpc-common": "^2.0.2"
+  }
+}

package/src/arrow-flight-sql.ts

@@ -0,0 +1,121 @@
+import type { CallOptions } from "nice-grpc";
+import { ArrowFlightClient } from "./arrow-flight";
+import { Any } from "./proto/any";
+import {
+  FlightDescriptor,
+  FlightDescriptor_DescriptorType,
+  type FlightInfo,
+  type FlightServiceDefinition,
+} from "./proto/Flight";
+import {
+  CommandGetCatalogs,
+  CommandGetDbSchemas,
+  CommandGetTables,
+  CommandGetTableTypes,
+  CommandStatementQuery,
+} from "./proto/FlightSql";
+import type {
+  ClientOptions,
+  HostOrChannel,
+  RemoveTypeUrl,
+} from "./proto-utils";
+
+export class ArrowFlightSqlClient {
+  private inner: ArrowFlightClient;
+
+  constructor(
+    config: HostOrChannel,
+    options: ClientOptions<FlightServiceDefinition> = {},
+  ) {
+    this.inner = new ArrowFlightClient(config, options);
+  }
+
+  executeFlightInfo(request: FlightInfo, options?: CallOptions) {
+    return this.inner.executeFlightInfo(request, options);
+  }
+
+  async getCatalogs(
+    request: RemoveTypeUrl<CommandGetCatalogs>,
+    options?: CallOptions,
+  ) {
+    const descriptor = createCommandDescriptor(
+      CommandGetCatalogs.$type,
+      CommandGetCatalogs.encode({
+        $type: CommandGetCatalogs.$type,
+        ...request,
+      }).finish(),
+    );
+    return this.inner.getFlightInfo(descriptor, options);
+  }
+
+  async getDbSchemas(
+    request: RemoveTypeUrl<CommandGetDbSchemas>,
+    options?: CallOptions,
+  ) {
+    const descriptor = createCommandDescriptor(
+      CommandGetDbSchemas.$type,
+      CommandGetDbSchemas.encode({
+        $type: CommandGetDbSchemas.$type,
+        ...request,
+      }).finish(),
+    );
+    return this.inner.getFlightInfo(descriptor, options);
+  }
+
+  async getTables(
+    request: RemoveTypeUrl<CommandGetTables>,
+    options?: CallOptions,
+  ) {
+    const descriptor = createCommandDescriptor(
+      CommandGetTables.$type,
+      CommandGetTables.encode({
+        $type: CommandGetTables.$type,
+        ...request,
+      }).finish(),
+    );
+    return this.inner.getFlightInfo(descriptor, options);
+  }
+
+  async getTableTypes(
+    request: RemoveTypeUrl<CommandGetTableTypes>,
+    options?: CallOptions,
+  ) {
+    const descriptor = createCommandDescriptor(
+      CommandGetTableTypes.$type,
+      CommandGetTableTypes.encode({
+        $type: CommandGetTableTypes.$type,
+        ...request,
+      }).finish(),
+    );
+    return this.inner.getFlightInfo(descriptor, options);
+  }
+
+  async executeQuery(
+    request: RemoveTypeUrl<CommandStatementQuery>,
+    options?: CallOptions,
+  ) {
+    const descriptor = createCommandDescriptor(
+      CommandStatementQuery.$type,
+      CommandStatementQuery.encode({
+        $type: CommandStatementQuery.$type,
+        ...request,
+      }).finish(),
+    );
+    return this.inner.getFlightInfo(descriptor, options);
+  }
+}
+
+function createCommandDescriptor(
+  typeUrl: string,
+  value: Uint8Array,
+): FlightDescriptor {
+  const cmd = Any.create({
+    typeUrl: `type.googleapis.com/${typeUrl}`,
+    value,
+  });
+
+  return FlightDescriptor.create({
+    type: FlightDescriptor_DescriptorType.CMD,
+    cmd: Any.encode(cmd).finish(),
+  });
+}

package/src/arrow-flight.ts

@@ -0,0 +1,149 @@
+import type { RecordBatch, Schema } from "apache-arrow";
+import { type CallOptions, createClient } from "nice-grpc";
+import {
+  decodeFlightDataStream,
+  decodeSchemaFromFlightInfo,
+} from "./arrow-utils";
+import {
+  type FlightData,
+  type FlightDescriptor,
+  type FlightInfo,
+  type FlightServiceClient,
+  FlightServiceDefinition,
+  type HandshakeRequest,
+  type HandshakeResponse,
+  type PutResult,
+  type Ticket,
+} from "./proto/Flight";
+import {
+  type ClientOptions,
+  createChannelFromConfig,
+  type HostOrChannel,
+} from "./proto-utils";
+
+export class ArrowFlightClient {
+  private client: FlightServiceClient;
+
+  constructor(
+    config: HostOrChannel,
+    options: ClientOptions<FlightServiceDefinition> = {},
+  ) {
+    const channel = createChannelFromConfig(config);
+
+    this.client = createClient(
+      FlightServiceDefinition,
+      channel,
+      options.defaultCallOptions,
+    );
+  }
+
+  executeFlightInfo(
+    info: FlightInfo,
+    options?: CallOptions,
+  ): AsyncGenerator<RecordBatch> {
+    const schema = decodeSchemaFromFlightInfo(info);
+    if (!schema) {
+      throw new Error("FlightInfo must have a schema");
+    }
+
+    const client = this;
+
+    return (async function* () {
+      for (const endpoint of info.endpoint) {
+        if (endpoint.ticket === undefined) {
+          continue;
+        }
+
+        yield* client.doGet(endpoint.ticket, { schema, ...options });
+      }
+    })();
+  }
+
+  /**
+   * Handshake between client and server.
+   *
+   * Depending on the server, the handshake may be required to determine the
+   * token that should be used for future operations. Both request and response
+   * are streams to allow multiple round-trips depending on auth mechanism.
+   */
+  handshake(
+    request: AsyncIterable<HandshakeRequest>,
+    options?: CallOptions,
+  ): AsyncIterable<HandshakeResponse> {
+    return this.client.handshake(request, options);
+  }
+
+  /** Get a list of available streams given a particular criteria. */
+  // listFlights(
+  //   request: proto.arrow_flight.Criteria,
+  //   options?: ClientCallOptions,
+  // ): AsyncIterable<proto.arrow_flight.FlightInfo>;
+
+  getFlightInfo(
+    request: FlightDescriptor,
+    options?: CallOptions,
+  ): Promise<FlightInfo> {
+    return this.client.getFlightInfo(request, options);
+  }
+
+  // /** Start a query and get information to poll its execution status. */
+  // pollFlightInfo(
+  //   request: proto.arrow_flight.FlightDescriptor,
+  //   options?: ClientCallOptions,
+  // ): Promise<proto.arrow_flight.PollInfo>;
+
+  // /** Get the schema for a given FlightDescriptor. */
+  // getSchema(
+  //   request: proto.arrow_flight.FlightDescriptor,
+  //   options?: ClientCallOptions,
+  // ): Promise<proto.arrow_flight.SchemaResult>;
+
+  /**
+   * Retrieve a single stream associated with a particular descriptor
+   * associated with the referenced ticket. A Flight can be composed of one or
+   * more streams where each stream can be retrieved using a separate opaque
+   * ticket that the flight service uses for managing a collection of streams.
+   */
+  doGet(
+    request: Ticket,
+    options: { schema: Schema } & CallOptions,
+  ): AsyncIterable<RecordBatch> {
+    const { schema: expectedSchema } = options;
+    return decodeFlightDataStream(this.client.doGet(request, options), {
+      expectedSchema,
+    });
+  }
+
+  /**
+   * Push a stream to the flight service associated with a particular
+   * flight stream. This allows a client of a flight service to upload a stream
+   * of data. Depending on the particular flight service, a client consumer
+   * could be allowed to upload a single stream per descriptor or an unlimited
+   * number. In the latter, the service might implement a 'seal' action that
+   * can be applied to a descriptor once all streams are uploaded.
+   */
+  doPut(
+    request: AsyncIterable<FlightData>,
+    options?: CallOptions,
+  ): AsyncIterable<PutResult> {
+    return this.client.doPut(request, options);
+  }
+
+  // /** Open a bidirectional data channel for a given descriptor. */
+  // doExchange(
+  //   request: AsyncIterable<proto.arrow_flight.FlightData>,
+  //   options?: ClientCallOptions,
+  // ): AsyncIterable<proto.arrow_flight.FlightData>;
+
+  // /** Execute a specific action against the flight service. */
+  // doAction(
+  //   request: proto.arrow_flight.Action,
+  //   options?: ClientCallOptions,
+  // ): AsyncIterable<proto.arrow_flight.Result>;
+
+  // /** Get all available action types. */
+  // listActions(
+  //   request: proto.arrow_flight.Empty,
+  //   options?: ClientCallOptions,
+  // ): AsyncIterable<proto.arrow_flight.ActionType>;
+}

package/src/arrow-utils.ts

@@ -0,0 +1,30 @@
+import { Message, type Schema } from "apache-arrow";
+import type { FlightData, FlightInfo } from "./proto/Flight";
+import { RecordBatchStreamReaderFromFlightData } from "./record-batch-decoder";
+
+export function decodeSchemaFromFlightInfo(
+  info: FlightInfo,
+): Schema | undefined {
+  // Notice that the `info.schema` field has the following format:
+  // The schema of the dataset in its IPC form:
+  //   4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+  //   4 bytes - the byte length of the payload
+  //   a flatbuffer Message whose header is the Schema
+  const message = Message.decode(info.schema.slice(8));
+  return getMessageSchema(message);
+}
+
+export function getMessageSchema(message: Message): Schema | undefined {
+  if (message.isSchema()) {
+    return message.header();
+  }
+  return undefined;
+}
+
+export function decodeFlightDataStream(
+  stream: AsyncIterable<FlightData>,
+  { expectedSchema: _expectedSchema }: { expectedSchema: Schema },
+) {
+  // TODO: we want to validate the schema of the stream?
+  return new RecordBatchStreamReaderFromFlightData(stream);
+}

package/src/flight-data-encoder.ts

@@ -0,0 +1,108 @@
+import { Message, type RecordBatch, type Schema } from "apache-arrow";
+import * as metadata from "apache-arrow/ipc/metadata/message";
+import { VectorAssembler } from "apache-arrow/visitor/vectorassembler";
+import { FlightData, type FlightDescriptor } from "./proto/Flight";
+
+export const FlightDataEncoder = {
+  encodeSchema(
+    schema: Schema,
+    {
+      flightDescriptor,
+      appMetadata,
+    }: { flightDescriptor: FlightDescriptor; appMetadata?: Uint8Array },
+  ): FlightData {
+    const message = Message.from(schema);
+    return FlightData.create({
+      dataHeader: Message.encode(message),
+      appMetadata,
+      flightDescriptor,
+    });
+  },
+  encodeBatch(
+    batch: RecordBatch,
+    {
+      appMetadata,
+    }: {
+      appMetadata?: (args: {
+        index: number;
+        length: number;
+      }) => Uint8Array | undefined;
+    } = {},
+  ): ReadonlyArray<FlightData> {
+    const { byteLength, nodes, bufferRegions, buffers } =
+      VectorAssembler.assemble(batch);
+
+    const metadataRecordBatch = new metadata.RecordBatch(
+      batch.numRows,
+      nodes,
+      bufferRegions,
+      null,
+    );
+
+    const message = Message.from(metadataRecordBatch, byteLength);
+
+    const flightData = FlightData.create({
+      dataHeader: Message.encode(message),
+      appMetadata: appMetadata?.({ index: 0, length: 1 }),
+      dataBody: encodeRecordBatchContent(buffers, byteLength, null),
+    });
+
+    return [flightData];
+  },
+};
+
+// Write the content of the record batch to the output buffer.
+//
+// This code is taken from the arrow-js ipc module.
+// https://github.com/apache/arrow-js/blob/870e27eb3e467a6f2936e8d17c5e021c5eb07ad7/src/ipc/writer.ts
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// 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.
+function encodeRecordBatchContent(
+  buffers: ArrayBufferView<ArrayBufferLike>[],
+  byteLength: number,
+  compression: metadata.BodyCompression | null = null,
+): Uint8Array {
+  const out = new Uint8Array(byteLength);
+  const bufGroupSize = compression != null ? 2 : 1;
+  const bufs = new Array(bufGroupSize);
+  let pos = 0;
+
+  for (let i = 0; i < buffers.length; i += bufGroupSize) {
+    let size = 0;
+    for (let j = -1; ++j < bufGroupSize; ) {
+      bufs[j] = buffers[i + j];
+      size += bufs[j].byteLength;
+    }
+
+    if (size === 0) {
+      continue;
+    }
+
+    for (const buf of bufs) {
+      out.set(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength), pos);
+      pos += buf.byteLength;
+    }
+
+    const padding = ((size + 7) & ~7) - size;
+
+    if (padding > 0) {
+      out.set(new Uint8Array(padding), pos);
+      pos += padding;
+    }
+  }
+
+  return out;
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+export { Metadata } from "nice-grpc";
+export { ArrowFlightClient } from "./arrow-flight";
+export { ArrowFlightSqlClient } from "./arrow-flight-sql";
+export { FlightDataEncoder } from "./flight-data-encoder";
+export {
+  FlightData,
+  FlightDescriptor,
+  FlightDescriptor_DescriptorType,
+  PutResult,
+  Ticket,
+} from "./proto/Flight";
+export {
+  type ClientOptions,
+  createChannelFromConfig,
+  type HostOrChannel,
+} from "./proto-utils";