parquetable

A lightweight, WebAssembly Apache Parquet reader and writer with a columnar typed-array API. The default build is a compact .wasm (~150 KB, ~60 KB gzipped) with no C toolchain — a small alternative to shipping the full parquet crate to the browser.

Built on the pure-Rust parquetable crate; every type is verified against Apache Arrow / PyArrow.

Install

npm install parquetable

The package targets bundlers (webpack, Vite, Rollup, esbuild). Loading the wasm is async in those setups per your bundler's wasm integration.

Read

readParquet returns a Table of columns. Leaf values come back as typed arrays (Int32Array, BigInt64Array, Float64Array, …), strings as string[], and every column carries a validity mask (1 = present, 0 = null; null when the column has no nulls).

import { readParquet } from "parquetable";

const table = readParquet(bytes); // bytes: Uint8Array
console.log(table.numRows);

for (const col of table.columns) {
  if (col.kind === "leaf") {
    console.log(col.name, col.type, col.values, col.validity);
  } else if (col.kind === "list") {
    // row i spans col.child.values[col.offsets[i] .. col.offsets[i + 1]]
  } else if (col.kind === "struct") {
    for (const field of col.fields) console.log(field.name);
  }
}

Write

writeParquet takes the same columnar shape and returns a Uint8Array. A column is nullable iff it carries a validity mask.

import { writeParquet } from "parquetable";

const bytes = writeParquet(
  {
    columns: [
      { name: "id", kind: "leaf", type: "int64", validity: null, values: BigInt64Array.from([1n, 2n, 3n]) },
      { name: "name", kind: "leaf", type: "string", validity: Uint8Array.from([1, 0, 1]), values: ["a", "", "c"] },
      {
        name: "tags", kind: "list", logical: { name: "list" }, validity: null,
        offsets: Int32Array.from([0, 2, 2, 3]),
        child: { name: "element", kind: "leaf", type: "string", validity: null, values: ["x", "y", "z"] },
      },
    ],
  },
  { compression: "snappy" },
);

Nested types — list, struct, and map (a list with logical: { name: "map" } whose child is a struct of [key, value]) — nest arbitrarily. The read and write shapes are symmetric, so writeParquet(readParquet(bytes)) round-trips.

License

Licensed under either of Apache License, Version 2.0 or MIT license at your option.