@procwire/codec-arrow 0.1.3 → 0.2.0

package/dist/codec.js

@@ -0,0 +1,598 @@
+/**
+ * Apache Arrow IPC codec implementation for @procwire/transport.
+ *
+ * @remarks
+ * This is an internal module. Import from `@procwire/codec-arrow` instead.
+ *
+ * @internal
+ */
+import { tableFromIPC, tableToIPC } from "apache-arrow";
+import { SerializationError } from "@procwire/transport";
+/**
+ * High-performance Apache Arrow IPC serialization codec.
+ *
+ * Implements the {@link SerializationCodec} interface for use with
+ * @procwire/transport channels. Optimized for columnar data transfer,
+ * analytics workloads, and interoperability with data science tools.
+ *
+ * @remarks
+ * This codec uses zero-copy optimization where possible, wrapping the
+ * underlying ArrayBuffer instead of copying data. For maximum performance
+ * in trusted environments, disable input validation with `validateInput: false`.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { tableFromArrays } from 'apache-arrow';
+ * import { ArrowCodec } from '@procwire/codec-arrow';
+ *
+ * const codec = new ArrowCodec();
+ *
+ * // Create a table with typed columns
+ * const table = tableFromArrays({
+ *   id: Int32Array.from([1, 2, 3, 4, 5]),
+ *   name: ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
+ *   score: Float64Array.from([95.5, 87.3, 92.1, 88.7, 91.2]),
+ *   active: [true, false, true, true, false]
+ * });
+ *
+ * // Serialize to Arrow IPC format
+ * const buffer = codec.serialize(table);
+ * console.log(`Serialized ${table.numRows} rows to ${buffer.length} bytes`);
+ *
+ * // Deserialize back to Table
+ * const decoded = codec.deserialize(buffer);
+ * console.log(decoded.numRows);    // 5
+ * console.log(decoded.numCols);    // 4
+ * console.log(decoded.schema.fields.map(f => f.name)); // ['id', 'name', 'score', 'active']
+ * ```
+ *
+ * @example With configuration options
+ * ```ts
+ * const codec = new ArrowCodec({
+ *   format: 'stream',       // Streaming format for IPC
+ *   validateInput: false,   // Skip validation for performance
+ *   collectMetrics: true,   // Track throughput
+ * });
+ *
+ * // Process batches
+ * for (const batch of batches) {
+ *   channel.send(codec.serialize(batch));
+ * }
+ *
+ * // Check metrics
+ * console.log(`Processed ${codec.metrics?.rowsSerialized} rows`);
+ * ```
+ *
+ * @example File format for random access
+ * ```ts
+ * import { writeFileSync, readFileSync } from 'fs';
+ *
+ * const codec = new ArrowCodec({ format: 'file' });
+ *
+ * // Write to file
+ * const buffer = codec.serialize(table);
+ * writeFileSync('data.arrow', buffer);
+ *
+ * // Read from file (supports random access)
+ * const fileBuffer = readFileSync('data.arrow');
+ * const loadedTable = codec.deserialize(fileBuffer);
+ * ```
+ *
+ * @example Cross-language interoperability
+ * ```ts
+ * // Node.js side
+ * const codec = new ArrowCodec();
+ * const buffer = codec.serialize(table);
+ * socket.write(buffer);
+ *
+ * // Python side (PyArrow)
+ * // import pyarrow as pa
+ * // reader = pa.ipc.open_stream(buffer)
+ * // table = reader.read_all()
+ * ```
+ *
+ * @example Integration with @procwire/transport
+ * ```ts
+ * import { ArrowCodec } from '@procwire/codec-arrow';
+ * import { StreamChannel } from '@procwire/transport/channel';
+ *
+ * const codec = new ArrowCodec({ collectMetrics: true });
+ *
+ * const channel = new StreamChannel({
+ *   transport,
+ *   framing,
+ *   serialization: codec,
+ *   protocol
+ * });
+ *
+ * // Send Arrow tables through the channel
+ * channel.send(table);
+ * ```
+ *
+ * @see {@link ArrowCodecOptions} for configuration options
+ * @see {@link ArrowCodecMetrics} for metrics structure
+ * @see {@link createFastArrowCodec} for maximum performance
+ * @see {@link createMonitoredArrowCodec} for monitoring
+ * @see {@link createFileArrowCodec} for file format
+ */
+export class ArrowCodec {
+    /**
+     * Unique identifier for this codec.
+     *
+     * Used by codec registries to identify and lookup codecs by name.
+     * The value `"arrow"` identifies this as an Apache Arrow codec.
+     *
+     * @readonly
+     */
+    name = "arrow";
+    /**
+     * MIME type for Arrow IPC encoded data.
+     *
+     * The content type varies based on the format:
+     * - Stream format: `application/vnd.apache.arrow.stream`
+     * - File format: `application/vnd.apache.arrow.file`
+     *
+     * Used in HTTP Content-Type headers and content negotiation.
+     *
+     * @readonly
+     * @see {@link https://arrow.apache.org/docs/format/IPC.html | Apache Arrow IPC specification}
+     */
+    contentType;
+    format;
+    validateInput;
+    collectMetrics;
+    _metrics = null;
+    /**
+     * Creates a new ArrowCodec instance.
+     *
+     * @param options - Optional configuration for serialization behavior.
+     *                  See {@link ArrowCodecOptions} for available options.
+     *
+     * @example Default configuration
+     * ```ts
+     * const codec = new ArrowCodec();
+     * ```
+     *
+     * @example With options
+     * ```ts
+     * const codec = new ArrowCodec({
+     *   format: 'file',
+     *   validateInput: true,
+     *   collectMetrics: true,
+     * });
+     * ```
+     */
+    constructor(options) {
+        this.format = options?.format ?? "stream";
+        this.validateInput = options?.validateInput ?? true;
+        this.collectMetrics = options?.collectMetrics ?? false;
+        // Set content type based on format
+        this.contentType =
+            this.format === "file"
+                ? "application/vnd.apache.arrow.file"
+                : "application/vnd.apache.arrow.stream";
+        if (this.collectMetrics) {
+            this._metrics = {
+                serializeCount: 0,
+                deserializeCount: 0,
+                bytesSerialised: 0,
+                bytesDeserialized: 0,
+                rowsSerialized: 0,
+                rowsDeserialized: 0,
+                serializeErrors: 0,
+                deserializeErrors: 0,
+            };
+        }
+    }
+    /**
+     * Returns current metrics if `collectMetrics` is enabled.
+     *
+     * Returns a copy of the metrics object to prevent external modification.
+     * Returns `null` if metrics collection is disabled.
+     *
+     * @returns A readonly copy of metrics, or `null` if metrics are disabled.
+     *
+     * @example
+     * ```ts
+     * const codec = new ArrowCodec({ collectMetrics: true });
+     *
+     * // Process some data
+     * codec.serialize(table1);
+     * codec.serialize(table2);
+     *
+     * const metrics = codec.metrics;
+     * if (metrics) {
+     *   console.log(`Serialized ${metrics.serializeCount} tables`);
+     *   console.log(`Total rows: ${metrics.rowsSerialized}`);
+     *   console.log(`Total bytes: ${metrics.bytesSerialised}`);
+     * }
+     * ```
+     *
+     * @see {@link ArrowCodecMetrics} for the metrics structure
+     * @see {@link resetMetrics} to reset all metrics to zero
+     */
+    get metrics() {
+        return this._metrics ? { ...this._metrics } : null;
+    }
+    /**
+     * Resets all metrics to zero.
+     *
+     * Use this method to start fresh measurement periods, for example
+     * at the beginning of a new batch processing run or time window.
+     * Has no effect if metrics collection is disabled.
+     *
+     * @example
+     * ```ts
+     * const codec = new ArrowCodec({ collectMetrics: true });
+     *
+     * // Process batch 1
+     * for (const table of batch1) {
+     *   codec.serialize(table);
+     * }
+     * console.log('Batch 1:', codec.metrics);
+     *
+     * // Reset for batch 2
+     * codec.resetMetrics();
+     *
+     * // Process batch 2
+     * for (const table of batch2) {
+     *   codec.serialize(table);
+     * }
+     * console.log('Batch 2:', codec.metrics);
+     * ```
+     */
+    resetMetrics() {
+        if (this._metrics) {
+            this._metrics.serializeCount = 0;
+            this._metrics.deserializeCount = 0;
+            this._metrics.bytesSerialised = 0;
+            this._metrics.bytesDeserialized = 0;
+            this._metrics.rowsSerialized = 0;
+            this._metrics.rowsDeserialized = 0;
+            this._metrics.serializeErrors = 0;
+            this._metrics.deserializeErrors = 0;
+        }
+    }
+    /**
+     * Serializes an Apache Arrow Table to IPC format.
+     *
+     * Converts the input Table to Arrow IPC binary format using the configured
+     * format (stream or file). Uses zero-copy optimization to avoid unnecessary
+     * memory allocations.
+     *
+     * @param value - Apache Arrow Table to serialize. Must be a valid Table
+     *                instance with at least one column.
+     * @returns Buffer containing the Arrow IPC encoded data.
+     *
+     * @throws {SerializationError} When input is not a valid Arrow Table
+     *         (if validation is enabled).
+     * @throws {SerializationError} When encoding fails due to internal
+     *         Arrow library errors.
+     *
+     * @example Basic serialization
+     * ```ts
+     * import { tableFromArrays } from 'apache-arrow';
+     *
+     * const codec = new ArrowCodec();
+     * const table = tableFromArrays({
+     *   id: [1, 2, 3],
+     *   name: ['Alice', 'Bob', 'Charlie']
+     * });
+     *
+     * const buffer = codec.serialize(table);
+     * console.log(`Serialized to ${buffer.length} bytes`);
+     * ```
+     *
+     * @example Error handling
+     * ```ts
+     * const codec = new ArrowCodec();
+     *
+     * try {
+     *   codec.serialize({ notATable: true } as any);
+     * } catch (error) {
+     *   if (error instanceof SerializationError) {
+     *     console.error('Invalid input:', error.message);
+     *   }
+     * }
+     * ```
+     *
+     * @see {@link deserialize} for the reverse operation
+     */
+    serialize(value) {
+        // Input validation (can be disabled for performance)
+        if (this.validateInput) {
+            if (!this.isTable(value)) {
+                if (this._metrics)
+                    this._metrics.serializeErrors++;
+                throw new SerializationError("Invalid input: expected Apache Arrow Table", new TypeError("Input is not an Arrow Table"));
+            }
+        }
+        try {
+            // Serialize to IPC format
+            const uint8array = tableToIPC(value, this.format);
+            // ZERO-COPY: Wrap underlying ArrayBuffer without copying
+            const buffer = Buffer.from(uint8array.buffer, uint8array.byteOffset, uint8array.byteLength);
+            // Update metrics
+            if (this._metrics) {
+                this._metrics.serializeCount++;
+                this._metrics.bytesSerialised += buffer.length;
+                this._metrics.rowsSerialized += value.numRows;
+            }
+            return buffer;
+        }
+        catch (error) {
+            if (this._metrics)
+                this._metrics.serializeErrors++;
+            throw new SerializationError(`Failed to encode Arrow table: ${error instanceof Error ? error.message : String(error)}`, error);
+        }
+    }
+    /**
+     * Deserializes Arrow IPC data back to an Apache Arrow Table.
+     *
+     * Parses the binary Arrow IPC data and reconstructs the Table with
+     * its full schema and column data.
+     *
+     * @param buffer - Buffer or Uint8Array containing Arrow IPC encoded data.
+     *                 Must be valid Arrow IPC format (stream or file).
+     * @returns The deserialized Apache Arrow Table.
+     *
+     * @throws {SerializationError} When input is null, undefined, empty,
+     *         or not a Buffer/Uint8Array (if validation is enabled).
+     * @throws {SerializationError} When the buffer contains invalid or
+     *         corrupted Arrow IPC data.
+     *
+     * @example Basic deserialization
+     * ```ts
+     * const codec = new ArrowCodec();
+     *
+     * // Roundtrip
+     * const original = tableFromArrays({ id: [1, 2, 3], name: ['A', 'B', 'C'] });
+     * const buffer = codec.serialize(original);
+     * const decoded = codec.deserialize(buffer);
+     *
+     * console.log(decoded.numRows);    // 3
+     * console.log(decoded.numCols);    // 2
+     * console.log(decoded.getChild('id')?.toArray()); // Int32Array [1, 2, 3]
+     * ```
+     *
+     * @example Accessing column data
+     * ```ts
+     * const table = codec.deserialize(buffer);
+     *
+     * // Get column by name
+     * const idColumn = table.getChild('id');
+     * const ids = idColumn?.toArray();
+     *
+     * // Iterate rows
+     * for (const row of table) {
+     *   console.log(row.id, row.name);
+     * }
+     *
+     * // Access schema
+     * for (const field of table.schema.fields) {
+     *   console.log(`${field.name}: ${field.type}`);
+     * }
+     * ```
+     *
+     * @example Error handling
+     * ```ts
+     * const codec = new ArrowCodec();
+     *
+     * try {
+     *   codec.deserialize(Buffer.from('invalid data'));
+     * } catch (error) {
+     *   if (error instanceof SerializationError) {
+     *     console.error('Decode failed:', error.message);
+     *   }
+     * }
+     * ```
+     *
+     * @see {@link serialize} for the reverse operation
+     */
+    deserialize(buffer) {
+        // Input validation (can be disabled for performance)
+        if (this.validateInput) {
+            // Use unknown to allow runtime type checking
+            const input = buffer;
+            if (input === null || input === undefined) {
+                if (this._metrics)
+                    this._metrics.deserializeErrors++;
+                throw new SerializationError(`Invalid input: expected Buffer or Uint8Array, got ${input === null ? "null" : "undefined"}`, new TypeError("Invalid input type"));
+            }
+            if (!Buffer.isBuffer(input) && !(input instanceof Uint8Array)) {
+                if (this._metrics)
+                    this._metrics.deserializeErrors++;
+                throw new SerializationError(`Invalid input: expected Buffer or Uint8Array, got ${typeof input}`, new TypeError("Invalid input type"));
+            }
+            if (buffer.length === 0) {
+                if (this._metrics)
+                    this._metrics.deserializeErrors++;
+                throw new SerializationError("Invalid input: buffer is empty", new Error("Empty buffer"));
+            }
+        }
+        try {
+            const table = tableFromIPC(buffer);
+            // Update metrics
+            if (this._metrics) {
+                this._metrics.deserializeCount++;
+                this._metrics.bytesDeserialized += buffer.length;
+                this._metrics.rowsDeserialized += table.numRows;
+            }
+            return table;
+        }
+        catch (error) {
+            if (this._metrics)
+                this._metrics.deserializeErrors++;
+            throw new SerializationError(`Failed to decode Arrow table: ${error instanceof Error ? error.message : String(error)}`, error);
+        }
+    }
+    /**
+     * Checks if value is an Apache Arrow Table.
+     *
+     * Uses duck-typing for performance, avoiding instanceof checks that
+     * can fail across module boundaries or different package versions.
+     *
+     * @param value - Value to check.
+     * @returns `true` if value appears to be an Arrow Table.
+     *
+     * @internal
+     */
+    isTable(value) {
+        if (!value || typeof value !== "object")
+            return false;
+        const table = value;
+        return (typeof table.numRows === "number" &&
+            typeof table.numCols === "number" &&
+            typeof table.schema === "object" &&
+            table.schema !== null &&
+            typeof table.getChild === "function");
+    }
+}
+/**
+ * Creates an ArrowCodec optimized for maximum throughput.
+ *
+ * Returns a codec with input validation disabled for use in trusted
+ * environments where input is guaranteed to be valid. This provides
+ * the best possible performance but will produce unclear errors or
+ * undefined behavior if given invalid input.
+ *
+ * @param format - IPC format to use. Defaults to `'stream'`.
+ *
+ * @returns A configured ArrowCodec with validation disabled.
+ *
+ * @example
+ * ```ts
+ * // For trusted internal IPC between your own processes
+ * const codec = createFastArrowCodec('stream');
+ *
+ * // Maximum performance - no validation overhead
+ * const buffer = codec.serialize(table);
+ * ```
+ *
+ * @remarks
+ * Only use this in trusted environments where:
+ * - Input always comes from your own code
+ * - Tables are guaranteed to be valid Arrow Tables
+ * - Buffers are guaranteed to be valid Arrow IPC data
+ *
+ * @see {@link ArrowCodec} for the full codec with validation
+ * @see {@link createMonitoredArrowCodec} for monitoring support
+ */
+export function createFastArrowCodec(format = "stream") {
+    return new ArrowCodec({
+        format,
+        validateInput: false,
+        collectMetrics: false,
+    });
+}
+/**
+ * Creates an ArrowCodec with metrics collection enabled.
+ *
+ * Returns a codec that tracks serialize/deserialize counts, bytes processed,
+ * rows processed, and error counts. Useful for monitoring throughput,
+ * debugging issues, and capacity planning.
+ *
+ * @param options - Additional codec options. The `collectMetrics` option
+ *                  will always be set to `true`.
+ *
+ * @returns A configured ArrowCodec with metrics collection enabled.
+ *
+ * @example Basic monitoring
+ * ```ts
+ * const codec = createMonitoredArrowCodec();
+ *
+ * // Process data
+ * for (const table of tables) {
+ *   codec.serialize(table);
+ * }
+ *
+ * // Check throughput
+ * const metrics = codec.metrics!;
+ * console.log(`Tables: ${metrics.serializeCount}`);
+ * console.log(`Rows: ${metrics.rowsSerialized}`);
+ * console.log(`Bytes: ${metrics.bytesSerialised}`);
+ * console.log(`Errors: ${metrics.serializeErrors}`);
+ * ```
+ *
+ * @example With additional options
+ * ```ts
+ * const codec = createMonitoredArrowCodec({
+ *   format: 'file',
+ *   validateInput: false, // Trust input for performance
+ * });
+ * ```
+ *
+ * @example Periodic reporting
+ * ```ts
+ * const codec = createMonitoredArrowCodec();
+ *
+ * setInterval(() => {
+ *   const m = codec.metrics;
+ *   if (m) {
+ *     console.log(`Throughput: ${m.rowsSerialized} rows, ${m.bytesSerialised} bytes`);
+ *     codec.resetMetrics(); // Reset for next interval
+ *   }
+ * }, 60000); // Report every minute
+ * ```
+ *
+ * @see {@link ArrowCodecMetrics} for the metrics structure
+ * @see {@link ArrowCodec.metrics} for accessing metrics
+ * @see {@link ArrowCodec.resetMetrics} for resetting metrics
+ */
+export function createMonitoredArrowCodec(options) {
+    return new ArrowCodec({
+        ...options,
+        collectMetrics: true,
+    });
+}
+/**
+ * Creates an ArrowCodec configured for file format.
+ *
+ * Returns a codec using the Arrow file format, which includes a footer
+ * with schema and record batch offsets for random access. Use this when
+ * you need to write Arrow data to disk or when random access to record
+ * batches is required.
+ *
+ * @param options - Additional codec options. The `format` option
+ *                  will always be set to `'file'`.
+ *
+ * @returns A configured ArrowCodec for file format.
+ *
+ * @example Writing to disk
+ * ```ts
+ * import { writeFileSync, readFileSync } from 'fs';
+ *
+ * const codec = createFileArrowCodec();
+ *
+ * // Serialize with file format (includes footer)
+ * const buffer = codec.serialize(table);
+ * writeFileSync('data.arrow', buffer);
+ *
+ * // Read back
+ * const loaded = codec.deserialize(readFileSync('data.arrow'));
+ * ```
+ *
+ * @example With additional options
+ * ```ts
+ * const codec = createFileArrowCodec({
+ *   validateInput: true,
+ *   collectMetrics: true,
+ * });
+ * ```
+ *
+ * @remarks
+ * The file format is larger than stream format due to the footer,
+ * but enables random access to record batches without reading the
+ * entire file. For IPC where you read data sequentially, prefer
+ * the default stream format.
+ *
+ * @see {@link ArrowCodec} for stream format (default)
+ * @see {@link ArrowIPCFormat} for format differences
+ */
+export function createFileArrowCodec(options) {
+    return new ArrowCodec({
+        ...options,
+        format: "file",
+    });
+}
+//# sourceMappingURL=codec.js.map

package/dist/codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.js","sourceRoot":"","sources":["../src/codec.ts"],"names":[],"mappings":"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"}