sqlscope-rs 0.0.0-stage → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dcalsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,109 @@
-# Temporary Holding Version
+# sqlscope-rs
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Scope-aware SQL analysis and rewriting for TypeScript and JavaScript: row
+filters, CTE injection, table rewrites and column lineage over 30+ SQL
+dialects. It runs [sqlscope](https://github.com/dcalsky/sqlscope) (Rust, built
+on the [polyglot](https://github.com/tobilg/polyglot) SQL engine) as a
+WebAssembly module bundled in the package: no native library, no install
+scripts.
+
+```bash
+npm install sqlscope-rs
+```
+
+| Function | Purpose |
+| --- | --- |
+| `applyRowFilter` | Filter every in-scope table by a predicate (row-level security). |
+| `injectCtes` | Prepend CTE definitions to a query's root `WITH`. |
+| `rewriteTables` | Replace table references with derived tables. |
+| `columnOrigins` | Source columns whose values reach the result (column lineage). |
+| `outputColumns` | Names of the columns a statement outputs. |
+| `referencedColumns` | Columns referenced anywhere (filters included), per table. |
+| `columnUsages` | Column references together with the clause they appear in. |
+
+## Usage
+
+```ts
+import { applyRowFilter, columnOrigins, columnUsages, injectCtes, rewriteTables } from "sqlscope-rs";
+
+applyRowFilter("SELECT id FROM orders", "tenant_id = 7", { dialect: "postgres" });
+// 'SELECT id FROM (SELECT * FROM orders WHERE tenant_id = 7) AS orders'
+
+applyRowFilter("SELECT * FROM a JOIN b ON a.id = b.id", "tenant_id = 7", { tableNames: ["a"] });
+
+columnOrigins(
+  "SELECT o.id, p.amount FROM orders o JOIN payments p ON o.id = p.order_id WHERE o.status = 'PAID'",
+);
+// { orders: ['id'], payments: ['amount'] }
+
+columnOrigins("SELECT * FROM orders", { schema: { orders: ["id", "status"] } });
+// { orders: ['id', 'status'] }
+
+columnUsages("SELECT id FROM orders WHERE status = 'PAID'");
+// [{ table: 'orders', column: 'id', clause: 'SELECT' },
+//  { table: 'orders', column: 'status', clause: 'WHERE' }]
+
+injectCtes("SELECT * FROM foo", [{ name: "foo", query: "SELECT id FROM t" }]);
+// 'WITH foo AS (SELECT id FROM t) SELECT * FROM foo'
+
+rewriteTables("SELECT col1 FROM myschema.mytable", [
+  { matchKey: "myschema.mytable", inline: { table: "view1", schema: "vsch" } },
+]);
+// 'SELECT col1 FROM (SELECT * FROM vsch.view1) AS mytable'
+```
+
+Every function is synchronous. Options:
+
+| Option | Read by |
+| --- | --- |
+| `dialect` | all (default `"trino"`; `"postgres"`, `"mysql"`, `"spark"`, `"snowflake"`, `"bigquery"`, ...) |
+| `schema` | `columnOrigins`, `outputColumns`, `referencedColumns`, `columnUsages` |
+| `tableNames`, `tablePatterns`, `defaultDb` | `applyRowFilter` |
+| `stripCatalogs` | `rewriteTables` |
+
+`schema` maps table names (bare, `schema.table` or `catalog.schema.table`) to
+their ordered columns, as an object or a `Map`.
+
+Errors are thrown as `InvalidArgumentError`, `ParseError`, `UnsupportedError`
+or `InternalError`, all subclasses of `SqlscopeError`.
+
+The [sqlscope README](https://github.com/dcalsky/sqlscope#operations)
+describes each operation in detail.
+
+## Runtimes
+
+**Node.js (≥ 20.19), Deno and Bun** load the WebAssembly module when the
+package is imported (`import` or `require`); just call the functions.
+
+**Browsers, workers and edge runtimes** load it asynchronously: `await init()`
+once before calling anything else.
+
+```ts
+import { init, outputColumns } from "sqlscope-rs";
+
+await init(); // fetches sqlscope.wasm next to the package
+outputColumns("SELECT a, b FROM t");
+```
+
+`init()` resolves `sqlscope.wasm` with `new URL(..., import.meta.url)`, which
+webpack, Rollup and esbuild handle. With Vite, import the module's URL
+explicitly:
+
+```ts
+import { init } from "sqlscope-rs";
+import wasmUrl from "sqlscope-rs/sqlscope.wasm?url";
+
+await init(wasmUrl);
+```
+
+`init` also accepts a `Response`, the bytes, or a compiled
+`WebAssembly.Module`; `initSync(bytes)` loads synchronously. Calling `init()`
+under Node.js is harmless, so the same code runs everywhere.
+
+The module is about 9 MB (2.5 MB gzipped). V8 compiles it lazily; under
+sustained load its optimizing compiler can hold several hundred MB of
+optimized code. Run Node.js with `--liftoff-only` to trade speed for memory.
+
+## License
+
+MIT

package/dist/api.d.ts

@@ -0,0 +1,126 @@
+/** Table name (bare, `schema.table` or `catalog.schema.table`) -> ordered column names. */
+export type Schema = Readonly<Record<string, readonly string[]>> | ReadonlyMap<string, readonly string[]>;
+/** One name, or several. */
+export type Names = string | Iterable<string>;
+/** Options accepted by every operation. */
+export interface DialectOptions {
+    /**
+     * The SQL dialect: "trino" (the default), "postgres", "mysql", "starrocks",
+     * "spark", "hive", "snowflake", "bigquery", "duckdb", ...
+     */
+    dialect?: string;
+}
+/** Options of the analysis operations. */
+export interface SchemaOptions extends DialectOptions {
+    /**
+     * Table schemas. They expand wildcards and attribute unqualified columns.
+     * A table listed with no columns has zero columns; an absent table is
+     * unknown.
+     */
+    schema?: Schema;
+}
+/** Options of {@link applyRowFilter}. */
+export interface RowFilterOptions extends DialectOptions {
+    /**
+     * Filter only these tables: bare (`orders`), schema-qualified
+     * (`sales.orders`) or catalog-qualified (`iceberg.sales.orders`), matched
+     * case-insensitively. Composes additively with `tablePatterns`.
+     */
+    tableNames?: Names;
+    /** Filter only tables whose bare or fully qualified name matches one of these regular expressions. */
+    tablePatterns?: Names;
+    /** The schema of unqualified table references, matched against schema-qualified `tableNames`. */
+    defaultDb?: string;
+}
+/** Options of {@link rewriteTables}. */
+export interface RewriteOptions extends DialectOptions {
+    /**
+     * Catalogs that are transparent while matching: with `["hive"]`,
+     * `hive.sales.orders` matches the match key `sales.orders`.
+     */
+    stripCatalogs?: Names;
+}
+/**
+ * A common table expression `name AS (query)`.
+ *
+ * `name` is an identifier value, not SQL text; it is quoted as needed.
+ */
+export interface CteDef {
+    name: string;
+    query: string;
+}
+/** A table name, optionally schema- and catalog-qualified. */
+export interface TableRef {
+    table: string;
+    schema?: string;
+    catalog?: string;
+}
+/** A derived table backed by `UNION DISTINCT` over `branches`. */
+export interface UnionRewrite {
+    /** The alias used for references without an alias of their own. */
+    tableAlias: string;
+    columns: readonly string[];
+    branches: readonly TableRef[];
+}
+/**
+ * Replaces references to `matchKey` (`schema.table`). Set exactly one of
+ * `inline`, which becomes `(SELECT * FROM inline)`, or `union`.
+ */
+export interface TableRewrite {
+    matchKey: string;
+    inline?: TableRef;
+    union?: UnionRewrite;
+}
+/** The SQL clause that contains a column reference. */
+export type Clause = "SELECT" | "FROM" | "JOIN_ON" | "JOIN_USING" | "WHERE" | "GROUP_BY" | "HAVING" | "QUALIFY" | "WINDOW" | "ORDER_BY" | "SORT_BY" | "DISTRIBUTE_BY" | "CLUSTER_BY" | "CONNECT_BY" | "LATERAL_VIEW" | "UPDATE_SET_TARGET" | "UPDATE_SET_VALUE" | "MERGE_ON" | "MERGE_WHEN";
+/** One distinct use of a root table column in a clause. */
+export interface ColumnUsage {
+    table: string;
+    column: string;
+    clause: Clause;
+}
+/**
+ * Wrap every in-scope table of a query in a derived table filtered by `predicate`.
+ *
+ * `SELECT * FROM a` becomes `SELECT * FROM (SELECT * FROM a WHERE <predicate>) AS a`.
+ * By default every physical table is filtered; `tableNames`, `tablePatterns`
+ * and `defaultDb` restrict the scope. CTE references, table functions and
+ * `DUAL` are never wrapped. `predicate` is parsed as one boolean expression;
+ * bind or escape its values before calling. Returns the input unchanged when
+ * no table is in scope.
+ */
+export declare function applyRowFilter(sql: string, predicate: string, options?: RowFilterOptions): string;
+/**
+ * Add CTE definitions to the root `WITH` of a query, before existing CTEs.
+ *
+ * Definitions keep their order, so each may use earlier ones. A name that
+ * repeats another definition or an existing root CTE is rejected.
+ */
+export declare function injectCtes(sql: string, ctes: Iterable<CteDef | readonly [name: string, query: string]>, options?: DialectOptions): string;
+/**
+ * Replace physical table references according to `rewrites`.
+ *
+ * Matched references become derived tables that keep their alias (or bare
+ * name); qualified column references are rebound onto it. Returns the input
+ * unchanged when nothing matches.
+ */
+export declare function rewriteTables(sql: string, rewrites: Iterable<TableRewrite>, options?: RewriteOptions): string;
+/**
+ * Source columns whose values flow into the result, keyed by root table.
+ *
+ * Filter-only positions (WHERE, JOIN ON, GROUP BY, HAVING, ORDER BY) and the
+ * right side of INTERSECT / EXCEPT are excluded. Every table read is present,
+ * possibly with an empty list.
+ */
+export declare function columnOrigins(sql: string, options?: SchemaOptions): Record<string, string[]>;
+/**
+ * Names of the columns a statement outputs, in order.
+ *
+ * Unaliased expressions are named `_col{i}`; `*` expands from `schema` or
+ * stays `"*"`. Returns `null` for statements without columns.
+ */
+export declare function outputColumns(sql: string, options?: SchemaOptions): string[] | null;
+/** Columns referenced anywhere in a statement (including filters), keyed by root table. */
+export declare function referencedColumns(sql: string, options?: SchemaOptions): Record<string, string[]>;
+/** Every distinct `(table, column, clause)` use in a statement, sorted. */
+export declare function columnUsages(sql: string, options?: SchemaOptions): ColumnUsage[];

package/dist/api.js

@@ -0,0 +1,96 @@
+// The sqlscope operations.
+import { call } from "./engine.js";
+function names(values) {
+    if (values === undefined)
+        return undefined;
+    return typeof values === "string" ? [values] : Array.from(values);
+}
+function schema(value) {
+    if (value === undefined)
+        return undefined;
+    return value instanceof Map ? Object.fromEntries(value) : value;
+}
+function table(ref) {
+    return { table: ref.table, schema: ref.schema, catalog: ref.catalog };
+}
+/** Calls `operation`; undefined fields and options are omitted. */
+function run(operation, sql, fields, options) {
+    return call(operation, { sql, ...fields, options });
+}
+/**
+ * Wrap every in-scope table of a query in a derived table filtered by `predicate`.
+ *
+ * `SELECT * FROM a` becomes `SELECT * FROM (SELECT * FROM a WHERE <predicate>) AS a`.
+ * By default every physical table is filtered; `tableNames`, `tablePatterns`
+ * and `defaultDb` restrict the scope. CTE references, table functions and
+ * `DUAL` are never wrapped. `predicate` is parsed as one boolean expression;
+ * bind or escape its values before calling. Returns the input unchanged when
+ * no table is in scope.
+ */
+export function applyRowFilter(sql, predicate, options = {}) {
+    return run("apply_row_filter", sql, { predicate }, {
+        dialect: options.dialect,
+        tableNames: names(options.tableNames),
+        tablePatterns: names(options.tablePatterns),
+        defaultDb: options.defaultDb,
+    });
+}
+/**
+ * Add CTE definitions to the root `WITH` of a query, before existing CTEs.
+ *
+ * Definitions keep their order, so each may use earlier ones. A name that
+ * repeats another definition or an existing root CTE is rejected.
+ */
+export function injectCtes(sql, ctes, options = {}) {
+    const defs = Array.from(ctes, (cte) => "name" in cte ? { name: cte.name, query: cte.query } : { name: cte[0], query: cte[1] });
+    return run("inject_ctes", sql, { ctes: defs }, { dialect: options.dialect });
+}
+/**
+ * Replace physical table references according to `rewrites`.
+ *
+ * Matched references become derived tables that keep their alias (or bare
+ * name); qualified column references are rebound onto it. Returns the input
+ * unchanged when nothing matches.
+ */
+export function rewriteTables(sql, rewrites, options = {}) {
+    const plan = Array.from(rewrites, (rewrite) => ({
+        matchKey: rewrite.matchKey,
+        inline: rewrite.inline && table(rewrite.inline),
+        union: rewrite.union && {
+            tableAlias: rewrite.union.tableAlias,
+            columns: Array.from(rewrite.union.columns),
+            branches: Array.from(rewrite.union.branches, table),
+        },
+    }));
+    return run("rewrite_tables", sql, { rewrites: plan }, { dialect: options.dialect, stripCatalogs: names(options.stripCatalogs) });
+}
+function analyze(operation, sql, options) {
+    return run(operation, sql, {}, { dialect: options.dialect, schema: schema(options.schema) });
+}
+/**
+ * Source columns whose values flow into the result, keyed by root table.
+ *
+ * Filter-only positions (WHERE, JOIN ON, GROUP BY, HAVING, ORDER BY) and the
+ * right side of INTERSECT / EXCEPT are excluded. Every table read is present,
+ * possibly with an empty list.
+ */
+export function columnOrigins(sql, options = {}) {
+    return analyze("column_origins", sql, options);
+}
+/**
+ * Names of the columns a statement outputs, in order.
+ *
+ * Unaliased expressions are named `_col{i}`; `*` expands from `schema` or
+ * stays `"*"`. Returns `null` for statements without columns.
+ */
+export function outputColumns(sql, options = {}) {
+    return analyze("output_columns", sql, options);
+}
+/** Columns referenced anywhere in a statement (including filters), keyed by root table. */
+export function referencedColumns(sql, options = {}) {
+    return analyze("referenced_columns", sql, options);
+}
+/** Every distinct `(table, column, clause)` use in a statement, sorted. */
+export function columnUsages(sql, options = {}) {
+    return analyze("column_usages", sql, options);
+}

package/dist/engine.d.ts

@@ -0,0 +1,51 @@
+/** Base class of every sqlscope error. */
+export declare class SqlscopeError extends Error {
+    name: string;
+}
+/** An option or argument is invalid. */
+export declare class InvalidArgumentError extends SqlscopeError {
+    name: string;
+}
+/** The SQL text could not be parsed. */
+export declare class ParseError extends SqlscopeError {
+    name: string;
+}
+/** The statement shape is not supported, or the input exceeded a safety limit. */
+export declare class UnsupportedError extends SqlscopeError {
+    name: string;
+}
+/** sqlscope produced an invalid result or crashed (a bug). */
+export declare class InternalError extends SqlscopeError {
+    name: string;
+}
+/** The bytes of the WebAssembly module. */
+export type WasmBytes = ArrayBuffer | ArrayBufferView;
+/** A `Response` to the WebAssembly module, such as `fetch(url)` returns. */
+export interface WasmResponse {
+    readonly url: string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+/** A compiled `WebAssembly.Module`. */
+export type WasmModule = typeof globalThis extends {
+    WebAssembly: {
+        Module: abstract new (...args: never) => infer M;
+    };
+} ? M : never;
+/** What {@link init} accepts: a URL or response to fetch, the bytes, or a compiled module. */
+export type WasmSource = string | URL | WasmResponse | WasmBytes | WasmModule;
+/**
+ * Load the WebAssembly module. Resolves immediately when it is loaded.
+ *
+ * Under Node.js (and Deno and Bun) the module is loaded when the package is
+ * imported, so calling `init` is never needed. Elsewhere, await it once before
+ * any other call. Without `source` it fetches `sqlscope.wasm` next to the
+ * package, which bundlers resolve; pass a URL or the bytes to serve it from
+ * somewhere else.
+ */
+export declare function init(source?: WasmSource | Promise<WasmSource>): Promise<void>;
+/** Load the WebAssembly module synchronously from its bytes or a compiled module. */
+export declare function initSync(source: WasmBytes | WasmModule): void;
+/** The sqlscope version of the WebAssembly module ("X.Y.Z"). */
+export declare function version(): string;
+/** Run one operation and return its decoded result, throwing on error. */
+export declare function call(operation: string, request: object): unknown;

package/dist/engine.js

@@ -0,0 +1,88 @@
+// Runs operations on the sqlscope WebAssembly module.
+import initWasm, { call as wasmCall, initSync as initWasmSync, version as wasmVersion } from "../wasm/sqlscope_wasm.js";
+/** Base class of every sqlscope error. */
+export class SqlscopeError extends Error {
+    name = "SqlscopeError";
+}
+/** An option or argument is invalid. */
+export class InvalidArgumentError extends SqlscopeError {
+    name = "InvalidArgumentError";
+}
+/** The SQL text could not be parsed. */
+export class ParseError extends SqlscopeError {
+    name = "ParseError";
+}
+/** The statement shape is not supported, or the input exceeded a safety limit. */
+export class UnsupportedError extends SqlscopeError {
+    name = "UnsupportedError";
+}
+/** sqlscope produced an invalid result or crashed (a bug). */
+export class InternalError extends SqlscopeError {
+    name = "InternalError";
+}
+const ERRORS = {
+    invalid_argument: InvalidArgumentError,
+    parse: ParseError,
+    unsupported: UnsupportedError,
+};
+let ready = false;
+let pending;
+/**
+ * Load the WebAssembly module. Resolves immediately when it is loaded.
+ *
+ * Under Node.js (and Deno and Bun) the module is loaded when the package is
+ * imported, so calling `init` is never needed. Elsewhere, await it once before
+ * any other call. Without `source` it fetches `sqlscope.wasm` next to the
+ * package, which bundlers resolve; pass a URL or the bytes to serve it from
+ * somewhere else.
+ */
+export function init(source) {
+    if (ready)
+        return Promise.resolve();
+    const input = source === undefined ? undefined : { module_or_path: source };
+    pending ??= initWasm(input).then(() => {
+        ready = true;
+    }, (error) => {
+        pending = undefined;
+        throw error;
+    });
+    return pending;
+}
+/** Load the WebAssembly module synchronously from its bytes or a compiled module. */
+export function initSync(source) {
+    if (ready)
+        return;
+    initWasmSync({ module: source });
+    ready = true;
+}
+function engine() {
+    if (!ready) {
+        throw new SqlscopeError("sqlscope is not initialized: await init() before calling it");
+    }
+}
+/** The sqlscope version of the WebAssembly module ("X.Y.Z"). */
+export function version() {
+    engine();
+    return wasmVersion();
+}
+/** Run one operation and return its decoded result, throwing on error. */
+export function call(operation, request) {
+    engine();
+    let text;
+    try {
+        text = wasmCall(operation, JSON.stringify(request));
+    }
+    catch (error) {
+        // A panic traps; the module may be unusable afterwards.
+        if (error instanceof WebAssembly.RuntimeError) {
+            throw new InternalError(`sqlscope crashed: ${error.message}`, { cause: error });
+        }
+        throw error;
+    }
+    const response = JSON.parse(text);
+    if ("error" in response) {
+        const { kind, message } = response.error;
+        throw new (ERRORS[kind] ?? InternalError)(message);
+    }
+    return response.ok;
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Scope-aware SQL analysis and rewriting.
+ *
+ * | Function | Purpose |
+ * | --- | --- |
+ * | {@link applyRowFilter} | Filter every in-scope table by a predicate. |
+ * | {@link injectCtes} | Prepend CTE definitions to a query's root `WITH`. |
+ * | {@link rewriteTables} | Replace table references with derived tables. |
+ * | {@link columnOrigins} | Source columns whose values reach the result (lineage). |
+ * | {@link outputColumns} | Names of the columns a statement outputs. |
+ * | {@link referencedColumns} | Columns referenced anywhere, per table. |
+ * | {@link columnUsages} | Column references with the clause they appear in. |
+ *
+ * The SQL engine is a WebAssembly module shipped in this package. Node.js,
+ * Deno and Bun load it on import; browsers and other runtimes `await init()`
+ * first.
+ *
+ * @module
+ */
+export * from "./api.js";
+export { InternalError, InvalidArgumentError, ParseError, SqlscopeError, UnsupportedError, init, initSync, version, } from "./engine.js";
+export type { WasmBytes, WasmModule, WasmResponse, WasmSource } from "./engine.js";

package/dist/index.js

@@ -0,0 +1,21 @@
+/**
+ * Scope-aware SQL analysis and rewriting.
+ *
+ * | Function | Purpose |
+ * | --- | --- |
+ * | {@link applyRowFilter} | Filter every in-scope table by a predicate. |
+ * | {@link injectCtes} | Prepend CTE definitions to a query's root `WITH`. |
+ * | {@link rewriteTables} | Replace table references with derived tables. |
+ * | {@link columnOrigins} | Source columns whose values reach the result (lineage). |
+ * | {@link outputColumns} | Names of the columns a statement outputs. |
+ * | {@link referencedColumns} | Columns referenced anywhere, per table. |
+ * | {@link columnUsages} | Column references with the clause they appear in. |
+ *
+ * The SQL engine is a WebAssembly module shipped in this package. Node.js,
+ * Deno and Bun load it on import; browsers and other runtimes `await init()`
+ * first.
+ *
+ * @module
+ */
+export * from "./api.js";
+export { InternalError, InvalidArgumentError, ParseError, SqlscopeError, UnsupportedError, init, initSync, version, } from "./engine.js";

package/dist/node.d.ts

@@ -0,0 +1 @@
+export * from "./index.js";

package/dist/node.js

@@ -0,0 +1,5 @@
+// The Node.js entry point: loads the WebAssembly module on import.
+import { readFileSync } from "node:fs";
+import { initSync } from "./engine.js";
+initSync(readFileSync(new URL("../wasm/sqlscope_wasm_bg.wasm", import.meta.url)));
+export * from "./index.js";

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "sqlscope-rs",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "Scope-aware SQL analysis and rewriting: row filters, CTE injection, table rewrites, column lineage.",
+  "keywords": [
+    "sql",
+    "lineage",
+    "row-level-security",
+    "parser",
+    "wasm"
+  ],
+  "license": "MIT",
+  "author": "dcalsky <dcalsky@gmail.com>",
+  "homepage": "https://github.com/dcalsky/sqlscope",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dcalsky/sqlscope.git",
+    "directory": "typescript"
+  },
+  "bugs": "https://github.com/dcalsky/sqlscope/issues",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "node": "./dist/node.js",
+      "default": "./dist/index.js"
+    },
+    "./sqlscope.wasm": "./wasm/sqlscope_wasm_bg.wasm",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "wasm/sqlscope_wasm.js",
+    "wasm/sqlscope_wasm.d.ts",
+    "wasm/sqlscope_wasm_bg.wasm",
+    "wasm/sqlscope_wasm_bg.wasm.d.ts"
+  ],
+  "engines": {
+    "node": ">=20.19"
+  },
+  "scripts": {
+    "build:wasm": "make -C .. build-wasm",
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test \"test/*.test.ts\"",
+    "prepack": "node -e \"require('fs').accessSync('wasm/sqlscope_wasm_bg.wasm')\" && npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^24.19.1",
+    "typescript": "^5.9.3"
+  }
+}

package/wasm/sqlscope_wasm.d.ts

@@ -0,0 +1,47 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Runs `operation` on the JSON `request` and returns the JSON response.
+ */
+export function call(operation: string, request: string): string;
+
+/**
+ * The sqlscope version ("X.Y.Z").
+ */
+export function version(): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly call: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly version: () => [number, number];
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/wasm/sqlscope_wasm.js

@@ -0,0 +1,234 @@
+/* @ts-self-types="./sqlscope_wasm.d.ts" */
+
+/**
+ * Runs `operation` on the JSON `request` and returns the JSON response.
+ * @param {string} operation
+ * @param {string} request
+ * @returns {string}
+ */
+export function call(operation, request) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(request, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.call(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * The sqlscope version ("X.Y.Z").
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./sqlscope_wasm_bg.js": import0,
+    };
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('sqlscope_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/wasm/sqlscope_wasm_bg.wasm.d.ts

@@ -0,0 +1,10 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const call: (a: number, b: number, c: number, d: number) => [number, number];
+export const version: () => [number, number];
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;