@useairfoil/flight 0.4.0 → 0.4.1

package/dist/chunk-Bp6m_JJh.js

@@ -0,0 +1,13 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+
+//#endregion
+export { __export as t };

package/dist/index.d.ts

@@ -1,8 +1,48 @@
-import { CallOptions, Channel, ChannelCredentials, ChannelOptions, CompatServiceDefinition, DefaultCallOptions, Metadata, NormalizedServiceDefinition } from "nice-grpc";
-import * as apache_arrow0 from "apache-arrow";
-import { RecordBatch, Schema } from "apache-arrow";
+import { Config, Context, Effect, Layer, Scope, Stream } from "effect";
+import { CallOptions, CallOptions as CallOptions$1, Channel, ChannelCredentials, ChannelOptions, CompatServiceDefinition, DefaultCallOptions, NormalizedServiceDefinition } from "nice-grpc";
+import { RecordBatch, RecordBatch as RecordBatch$1, Schema, TypeMap } from "apache-arrow";
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import * as effect_Types0 from "effect/Types";
+import * as effect_Cause0 from "effect/Cause";
 
+//#region src/record-batch-with-metadata.d.ts
+type RecordBatchWithMetadata<T extends TypeMap = any> = {
+  readonly batch: RecordBatch<T>;
+  readonly appMetadata: Uint8Array;
+};
+declare namespace flight_client_error_d_exports {
+  export { FlightClientError, FlightClientErrorLike, FlightDecodeError, FlightProtocolError, FlightTransportError };
+}
+declare const FlightClientError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
+  readonly _tag: "FlightClientError";
+} & Readonly<A>;
+declare class FlightClientError extends FlightClientError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+declare const FlightTransportError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
+  readonly _tag: "FlightTransportError";
+} & Readonly<A>;
+declare class FlightTransportError extends FlightTransportError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+declare const FlightDecodeError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
+  readonly _tag: "FlightDecodeError";
+} & Readonly<A>;
+declare class FlightDecodeError extends FlightDecodeError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+declare const FlightProtocolError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => effect_Cause0.YieldableError & {
+  readonly _tag: "FlightProtocolError";
+} & Readonly<A>;
+declare class FlightProtocolError extends FlightProtocolError_base<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+type FlightClientErrorLike = FlightClientError | FlightTransportError | FlightDecodeError | FlightProtocolError;
+//#endregion
 //#region src/proto-utils.d.ts
 type RemoveTypeUrl<T> = Omit<T, "$type">;
 type ClientOptions<S extends CompatServiceDefinition> = {
@@ -20,7 +60,6 @@ type HostOrChannel = {
 declare function createChannelFromConfig(config: HostOrChannel): Channel;
 //#endregion
 //#region src/proto/Flight.d.ts
-
 /** The request that a client provides to a server on handshake. */
 interface HandshakeRequest {
   $type: "arrow.flight.protocol.HandshakeRequest";
@@ -494,7 +533,7 @@ type DeepPartial$1<T> = T extends Builtin$1 ? T : T extends globalThis.Array<inf
   readonly $case: T["$case"];
 } : T extends {} ? { [K in Exclude<keyof T, "$type">]?: DeepPartial$1<T[K]> } : Partial<T>;
 type KeysOfUnion$1<T> = T extends T ? keyof T : never;
-type Exact$1<P, I extends P> = P extends Builtin$1 ? P : P & { [K in keyof P]: Exact$1<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion$1<P> | "$type">]: never };
+type Exact$1<P$1, I extends P$1> = P$1 extends Builtin$1 ? P$1 : P$1 & { [K in keyof P$1]: Exact$1<P$1[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion$1<P$1> | "$type">]: never };
 interface MessageFns$1<T, V extends string> {
   readonly $type: V;
   encode(message: T, writer?: BinaryWriter): BinaryWriter;
@@ -504,41 +543,26 @@ interface MessageFns$1<T, V extends string> {
   create<I extends Exact$1<DeepPartial$1<T>, I>>(base?: I): T;
   fromPartial<I extends Exact$1<DeepPartial$1<T>, I>>(object: I): T;
 }
-//#endregion
-//#region src/arrow-flight.d.ts
-declare class ArrowFlightClient {
-  private client;
-  constructor(config: HostOrChannel, options?: ClientOptions<FlightServiceDefinition>);
-  executeFlightInfo(info: FlightInfo, options?: CallOptions): AsyncGenerator<RecordBatch>;
-  /**
-   * 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>;
-  /** Get a list of available streams given a particular criteria. */
-  getFlightInfo(request: FlightDescriptor, options?: CallOptions): Promise<FlightInfo>;
-  /**
-   * 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>;
-  /**
-   * 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>;
+declare namespace arrow_flight_client_d_exports {
+  export { ArrowFlightClient, ArrowFlightClientOptions, ArrowFlightClientService, CallOptions$1 as CallOptions, ClientOptions, HostOrChannel, RecordBatch$1 as RecordBatch, RecordBatchWithMetadata, layer$1 as layer, layerConfig$1 as layerConfig, make$1 as make };
 }
+type ArrowFlightClientOptions = HostOrChannel & {
+  readonly defaultCallOptions?: DefaultCallOptions<NormalizedServiceDefinition<FlightServiceDefinition>>;
+};
+interface ArrowFlightClientService {
+  readonly handshake: (request: AsyncIterable<HandshakeRequest>, options?: CallOptions$1) => Stream.Stream<HandshakeResponse, FlightClientErrorLike>;
+  readonly getFlightInfo: (request: FlightDescriptor, options?: CallOptions$1) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
+  readonly doGet: (request: Ticket, options: {
+    readonly schema: Schema;
+  } & CallOptions$1) => Stream.Stream<RecordBatchWithMetadata, FlightClientErrorLike>;
+  readonly doPut: (request: AsyncIterable<FlightData>, options?: CallOptions$1) => AsyncIterable<PutResult>;
+  readonly executeFlightInfo: (info: FlightInfo, options?: CallOptions$1) => Stream.Stream<RecordBatchWithMetadata, FlightClientErrorLike>;
+}
+declare const ArrowFlightClient_base: Context.ServiceClass<ArrowFlightClient, "@useairfoil/flight/ArrowFlightClient", ArrowFlightClientService>;
+declare class ArrowFlightClient extends ArrowFlightClient_base {}
+declare const make$1: (options: ArrowFlightClientOptions) => Effect.Effect<ArrowFlightClientService, never, Scope.Scope>;
+declare const layer$1: (options: ArrowFlightClientOptions) => Layer.Layer<ArrowFlightClient>;
+declare const layerConfig$1: (options: Config.Wrap<ArrowFlightClientOptions>) => Layer.Layer<ArrowFlightClient, Config.ConfigError, never>;
 //#endregion
 //#region src/proto/FlightSql.d.ts
 
@@ -703,7 +727,7 @@ type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U
   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;
-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 };
+type Exact<P$1, I extends P$1> = P$1 extends Builtin ? P$1 : P$1 & { [K in keyof P$1]: Exact<P$1[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P$1> | "$type">]: never };
 interface MessageFns<T, V extends string> {
   readonly $type: V;
   encode(message: T, writer?: BinaryWriter): BinaryWriter;
@@ -713,18 +737,23 @@ interface MessageFns<T, V extends string> {
   create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
   fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
 }
-//#endregion
-//#region src/arrow-flight-sql.d.ts
-declare class ArrowFlightSqlClient {
-  private inner;
-  constructor(config: HostOrChannel, options?: ClientOptions<FlightServiceDefinition>);
-  executeFlightInfo(request: FlightInfo, options?: CallOptions): AsyncGenerator<apache_arrow0.RecordBatch<any>, any, any>;
-  getCatalogs(request: RemoveTypeUrl<CommandGetCatalogs>, options?: CallOptions): Promise<FlightInfo>;
-  getDbSchemas(request: RemoveTypeUrl<CommandGetDbSchemas>, options?: CallOptions): Promise<FlightInfo>;
-  getTables(request: RemoveTypeUrl<CommandGetTables>, options?: CallOptions): Promise<FlightInfo>;
-  getTableTypes(request: RemoveTypeUrl<CommandGetTableTypes>, options?: CallOptions): Promise<FlightInfo>;
-  executeQuery(request: RemoveTypeUrl<CommandStatementQuery>, options?: CallOptions): Promise<FlightInfo>;
+declare namespace arrow_flight_sql_client_d_exports {
+  export { ArrowFlightSqlClient, ArrowFlightSqlClientOptions, ArrowFlightSqlClientService, CallOptions, FlightInfo, RecordBatchWithMetadata, layer, layerConfig, make };
+}
+type ArrowFlightSqlClientOptions = ArrowFlightClientOptions;
+interface ArrowFlightSqlClientService {
+  readonly executeFlightInfo: (info: FlightInfo, options?: CallOptions) => Stream.Stream<RecordBatchWithMetadata, FlightClientErrorLike>;
+  readonly getCatalogs: (request: RemoveTypeUrl<CommandGetCatalogs>, options?: CallOptions) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
+  readonly getDbSchemas: (request: RemoveTypeUrl<CommandGetDbSchemas>, options?: CallOptions) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
+  readonly getTables: (request: RemoveTypeUrl<CommandGetTables>, options?: CallOptions) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
+  readonly getTableTypes: (request: RemoveTypeUrl<CommandGetTableTypes>, options?: CallOptions) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
+  readonly executeQuery: (request: RemoveTypeUrl<CommandStatementQuery>, options?: CallOptions) => Effect.Effect<FlightInfo, FlightClientErrorLike>;
 }
+declare const ArrowFlightSqlClient_base: Context.ServiceClass<ArrowFlightSqlClient, "@useairfoil/flight/ArrowFlightSqlClient", ArrowFlightSqlClientService>;
+declare class ArrowFlightSqlClient extends ArrowFlightSqlClient_base {}
+declare const make: (options: ArrowFlightClientOptions) => Effect.Effect<ArrowFlightSqlClientService, never, Scope.Scope>;
+declare const layer: (options: ArrowFlightSqlClientOptions) => Layer.Layer<ArrowFlightSqlClient>;
+declare const layerConfig: (options: Config.Wrap<ArrowFlightSqlClientOptions>) => Layer.Layer<ArrowFlightSqlClient, Config.ConfigError, never>;
 //#endregion
 //#region src/flight-data-encoder.d.ts
 declare const FlightDataEncoder: {
@@ -745,5 +774,5 @@ declare const FlightDataEncoder: {
   }): ReadonlyArray<FlightData>;
 };
 //#endregion
-export { ArrowFlightClient, ArrowFlightSqlClient, type ClientOptions, FlightData, FlightDataEncoder, FlightDescriptor, FlightDescriptor_DescriptorType, type HostOrChannel, Metadata, PutResult, Ticket, createChannelFromConfig };
+export { arrow_flight_client_d_exports as ArrowFlightClient, type ArrowFlightClientOptions, type ArrowFlightClientService, arrow_flight_sql_client_d_exports as ArrowFlightSqlClient, type ArrowFlightSqlClientOptions, type ArrowFlightSqlClientService, type ClientOptions, flight_client_error_d_exports as FlightClientError, type FlightClientErrorLike, FlightData, FlightDataEncoder, FlightDescriptor, FlightDescriptor_DescriptorType, type FlightInfo, type HostOrChannel, PutResult, type RecordBatchWithMetadata, Ticket, createChannelFromConfig };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,6 @@
-import { Metadata, createChannel, createClient } from "nice-grpc";
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { Config, Context, Data, Effect, Layer, Scope, Stream } from "effect";
+import { createChannel, createClient } from "nice-grpc";
 import { Message, MessageHeader, RecordBatch, Struct, Vector, compressionRegistry, makeData } 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";
@@ -132,7 +134,10 @@ var RecordBatchStreamReaderFromFlightData = class extends RecordBatchReaderImpl
 				const header = message.header();
 				return {
 					done: false,
-					value: this._loadRecordBatch(header, flight.dataBody)
+					value: {
+						batch: this._loadRecordBatch(header, flight.dataBody),
+						appMetadata: flight.appMetadata
+					}
 				};
 			} else if (message.isDictionaryBatch()) {
 				this._dictionaryIndex++;
@@ -145,7 +150,10 @@ var RecordBatchStreamReaderFromFlightData = class extends RecordBatchReaderImpl
 			this._recordBatchIndex++;
 			return {
 				done: false,
-				value: new _InternalEmptyPlaceholderRecordBatch(this.schema)
+				value: {
+					batch: new _InternalEmptyPlaceholderRecordBatch(this.schema),
+					appMetadata: new Uint8Array(0)
+				}
 			};
 		}
 		return ITERATOR_DONE;
@@ -174,6 +182,19 @@ function decodeFlightDataStream(stream, { expectedSchema: _expectedSchema }) {
 	return new RecordBatchStreamReaderFromFlightData(stream);
 }
 
+//#endregion
+//#region src/flight-client-error.ts
+var flight_client_error_exports = /* @__PURE__ */ __export({
+	FlightClientError: () => FlightClientError,
+	FlightDecodeError: () => FlightDecodeError,
+	FlightProtocolError: () => FlightProtocolError,
+	FlightTransportError: () => FlightTransportError
+});
+var FlightClientError = class extends Data.TaggedError("FlightClientError") {};
+var FlightTransportError = class extends Data.TaggedError("FlightTransportError") {};
+var FlightDecodeError = class extends Data.TaggedError("FlightDecodeError") {};
+var FlightProtocolError = class extends Data.TaggedError("FlightProtocolError") {};
+
 //#endregion
 //#region src/proto-utils.ts
 function createChannelFromConfig(config) {
@@ -1668,62 +1689,60 @@ function isSet$2(value) {
 }
 
 //#endregion
-//#region src/arrow-flight.ts
-var ArrowFlightClient = class {
-	client;
-	constructor(config, options = {}) {
-		this.client = createClient(FlightServiceDefinition, createChannelFromConfig(config), options.defaultCallOptions);
+//#region src/arrow-flight-client.ts
+var arrow_flight_client_exports = /* @__PURE__ */ __export({
+	ArrowFlightClient: () => ArrowFlightClient,
+	layer: () => layer$1,
+	layerConfig: () => layerConfig$1,
+	make: () => make
+});
+var ArrowFlightClient = class extends Context.Service()("@useairfoil/flight/ArrowFlightClient") {};
+const mapTransportError = (message, cause) => new FlightTransportError({
+	message,
+	cause
+});
+const mapDecodeError = (message, cause) => new FlightDecodeError({
+	message,
+	cause
+});
+const streamFromAsyncIterable = (iterable, message) => Stream.fromAsyncIterable(iterable, (cause) => mapTransportError(message, cause));
+const make = Effect.fnUntraced(function* (options) {
+	const ownsChannel = "host" in options;
+	const channel = createChannelFromConfig(options);
+	const client = createClient(FlightServiceDefinition, channel, options.defaultCallOptions);
+	if (ownsChannel) {
+		const scope = yield* Scope.Scope;
+		yield* Scope.addFinalizer(scope, Effect.sync(() => {
+			channel.close();
+		}));
 	}
-	executeFlightInfo(info, options) {
+	const doGet = (request, options$1) => {
+		const { schema: expectedSchema } = options$1;
+		return Stream.fromAsyncIterable(decodeFlightDataStream(client.doGet(request, options$1), { expectedSchema }), (cause) => mapDecodeError("Flight batch decoding failed", cause));
+	};
+	const executeFlightInfo = (info, options$1) => {
 		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 === void 0) 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, options) {
-		return this.client.handshake(request, options);
-	}
-	/** Get a list of available streams given a particular criteria. */
-	getFlightInfo(request, options) {
-		return this.client.getFlightInfo(request, options);
-	}
-	/**
-	* 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, options) {
-		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, options) {
-		return this.client.doPut(request, options);
-	}
-};
+		if (!schema) return Stream.fail(new FlightProtocolError({ message: "FlightInfo must include a schema" }));
+		return Stream.fromIterable(info.endpoint).pipe(Stream.flatMap((endpoint) => endpoint.ticket === void 0 ? Stream.empty : doGet(endpoint.ticket, {
+			schema,
+			...options$1
+		})));
+	};
+	return ArrowFlightClient.of({
+		handshake: (request, options$1) => streamFromAsyncIterable(client.handshake(request, options$1), "Flight handshake failed"),
+		getFlightInfo: (request, options$1) => Effect.tryPromise({
+			try: () => client.getFlightInfo(request, options$1),
+			catch: (cause) => mapTransportError("Flight getFlightInfo failed", cause)
+		}),
+		doGet,
+		doPut: (request, options$1) => client.doPut(request, options$1),
+		executeFlightInfo
+	});
+});
+const layer$1 = (options) => Layer.effect(ArrowFlightClient, make(options));
+const layerConfig$1 = (options) => Layer.effect(ArrowFlightClient, Effect.gen(function* () {
+	return yield* make(yield* Config.unwrap(options));
+}));
 
 //#endregion
 //#region src/proto/any.ts
@@ -4022,51 +4041,44 @@ function isSet(value) {
 }
 
 //#endregion
-//#region src/arrow-flight-sql.ts
-var ArrowFlightSqlClient = class {
-	inner;
-	constructor(config, options = {}) {
-		this.inner = new ArrowFlightClient(config, options);
-	}
-	executeFlightInfo(request, options) {
-		return this.inner.executeFlightInfo(request, options);
-	}
-	async getCatalogs(request, options) {
-		const descriptor = createCommandDescriptor(CommandGetCatalogs.$type, CommandGetCatalogs.encode({
+//#region src/arrow-flight-sql-client.ts
+var arrow_flight_sql_client_exports = /* @__PURE__ */ __export({
+	ArrowFlightSqlClient: () => ArrowFlightSqlClient,
+	layer: () => layer,
+	layerConfig: () => layerConfig,
+	make: () => make$1
+});
+var ArrowFlightSqlClient = class extends Context.Service()("@useairfoil/flight/ArrowFlightSqlClient") {};
+const make$1 = Effect.fnUntraced(function* (options) {
+	const inner = yield* make(options);
+	return ArrowFlightSqlClient.of({
+		executeFlightInfo: (info, options$1) => inner.executeFlightInfo(info, options$1),
+		getCatalogs: (request, options$1) => inner.getFlightInfo(createCommandDescriptor(CommandGetCatalogs.$type, CommandGetCatalogs.encode({
 			$type: CommandGetCatalogs.$type,
 			...request
-		}).finish());
-		return this.inner.getFlightInfo(descriptor, options);
-	}
-	async getDbSchemas(request, options) {
-		const descriptor = createCommandDescriptor(CommandGetDbSchemas.$type, CommandGetDbSchemas.encode({
+		}).finish()), options$1),
+		getDbSchemas: (request, options$1) => inner.getFlightInfo(createCommandDescriptor(CommandGetDbSchemas.$type, CommandGetDbSchemas.encode({
 			$type: CommandGetDbSchemas.$type,
 			...request
-		}).finish());
-		return this.inner.getFlightInfo(descriptor, options);
-	}
-	async getTables(request, options) {
-		const descriptor = createCommandDescriptor(CommandGetTables.$type, CommandGetTables.encode({
+		}).finish()), options$1),
+		getTables: (request, options$1) => inner.getFlightInfo(createCommandDescriptor(CommandGetTables.$type, CommandGetTables.encode({
 			$type: CommandGetTables.$type,
 			...request
-		}).finish());
-		return this.inner.getFlightInfo(descriptor, options);
-	}
-	async getTableTypes(request, options) {
-		const descriptor = createCommandDescriptor(CommandGetTableTypes.$type, CommandGetTableTypes.encode({
+		}).finish()), options$1),
+		getTableTypes: (request, options$1) => inner.getFlightInfo(createCommandDescriptor(CommandGetTableTypes.$type, CommandGetTableTypes.encode({
 			$type: CommandGetTableTypes.$type,
 			...request
-		}).finish());
-		return this.inner.getFlightInfo(descriptor, options);
-	}
-	async executeQuery(request, options) {
-		const descriptor = createCommandDescriptor(CommandStatementQuery.$type, CommandStatementQuery.encode({
+		}).finish()), options$1),
+		executeQuery: (request, options$1) => inner.getFlightInfo(createCommandDescriptor(CommandStatementQuery.$type, CommandStatementQuery.encode({
 			$type: CommandStatementQuery.$type,
 			...request
-		}).finish());
-		return this.inner.getFlightInfo(descriptor, options);
-	}
-};
+		}).finish()), options$1)
+	});
+});
+const layer = (options) => Layer.effect(ArrowFlightSqlClient, make$1(options));
+const layerConfig = (options) => Layer.effect(ArrowFlightSqlClient, Effect.gen(function* () {
+	return yield* make$1(yield* Config.unwrap(options));
+}));
 function createCommandDescriptor(typeUrl, value) {
 	const cmd = Any.create({
 		typeUrl: `type.googleapis.com/${typeUrl}`,
@@ -4129,5 +4141,5 @@ function encodeRecordBatchContent(buffers, byteLength, compression = null) {
 }
 
 //#endregion
-export { ArrowFlightClient, ArrowFlightSqlClient, FlightData, FlightDataEncoder, FlightDescriptor, FlightDescriptor_DescriptorType, Metadata, PutResult, Ticket, createChannelFromConfig };
+export { arrow_flight_client_exports as ArrowFlightClient, arrow_flight_sql_client_exports as ArrowFlightSqlClient, flight_client_error_exports as FlightClientError, FlightData, FlightDataEncoder, FlightDescriptor, FlightDescriptor_DescriptorType, FlightInfo, PutResult, Ticket, createChannelFromConfig };
 //# sourceMappingURL=index.js.map