@wavehouse/chtypes 0.1.0

package/dist/schema.d.ts

@@ -0,0 +1,444 @@
+/**
+ * A compiled schema — one tenant table's column list, compiled inside one
+ * version's library, plus the engine and TTL declarations that make `rows()`
+ * answer with the storage layer's verdict as well as the type layer's.
+ */
+import type { BlockHandle, FilterHandle, NativeLibrary, SchemaHandle } from './ffi.js';
+import { type Format } from './format.js';
+import { type BatchResult, type FilterResult, type RowResult } from './results.js';
+import { type Settings } from './settings.js';
+/** One declared column, as ClickHouse canonicalised it. */
+export interface ColumnInfo {
+    readonly name: string;
+    /** Canonical type — pass it through verbatim, never re-normalise whitespace. */
+    readonly type: string;
+    /** "" | "DEFAULT" | "MATERIALIZED" | "ALIAS" | "EPHEMERAL" */
+    readonly defaultKind: string;
+    readonly defaultExpr: string;
+    /** True when the DEFAULT is a literal applicable without the interpreter. */
+    readonly defaultIsLiteral: boolean;
+}
+/** Options for `Schema#setEngine` — the table's MergeTree-namespace settings. */
+export interface EngineOptions {
+    /**
+     * The `SETTINGS` clause after the engine — `allow_nullable_key` and friends,
+     * a namespace `DB::Settings` cannot carry (spec/c-abi.md §`chs_schema_engine`).
+     * Absent or empty is structurally identical to the plain engine declaration:
+     * `chs_schema_engine` takes "{}" either way. Names are validated by the
+     * server's own `MergeTreeSettings` object: an unknown name throws the
+     * server's own 115; a known name declared at a NON-default value is refused
+     * (`unsupported`, naming it) — no MergeTree setting's behaviour is modelled
+     * yet, and silently ignoring a declared value would mean the declared
+     * profile is not in force; a name declared AT its default is inert and
+     * accepted.
+     */
+    readonly mergeTreeSettings?: Settings | undefined;
+}
+/**
+ * Options for `Schema#rows` — the revision-3 export and document-flag
+ * channels (spec/c-abi.md §Rows; docs/proposals/rows-export.md). Whatever the
+ * options, `rows()` is always ONE `chs_rows` call — never a second call,
+ * never re-parsing.
+ */
+export interface RowsOptions {
+    /**
+     * A `Format` the artifact can SERIALIZE — this revision exactly
+     * `Format.JSONCompactEachRow`. Any other value answers the whole call
+     * `outcome: 'unsupported'` and processes nothing — loud, never silent.
+     * Absent = no export: today's path, byte-identical to revision 2.
+     */
+    readonly exportFormat?: Format | undefined;
+    /**
+     * A bitmask of `DOC_VALUES | DOC_TRANSFORMS | DOC_DEFAULTS` selecting the
+     * document groups; the verdict channel is always present and not a flag.
+     * Defaults: `DOC_ALL` when no `exportFormat` is given (the full document —
+     * plain `rows()` behaviour), `0` (LEAN — verdicts only: `values`,
+     * `transformed`, `substituted`, `computed` and `unknownFields` all come
+     * back empty) when one is. An explicit value always wins; a bit outside
+     * `DOC_ALL` is refused loudly by the library, never pre-validated here.
+     */
+    readonly docFlags?: number | undefined;
+}
+/**
+ * Options for `Schema#compileFilter` — the revision-4 query-parameter
+ * bindings.
+ */
+export interface CompileFilterOptions {
+    /**
+     * `{name:Type}` query-parameter bindings: name → value STRING, exactly as
+     * the server's own parameter channels carry them. Each value is
+     * deserialized by the DECLARED type's own reader and injected as a typed
+     * literal AFTER SQL parsing, so a value is never SQL text and NEVER needs
+     * hand-escaping — injection safety is by construction, not by escaping
+     * (spec/c-abi.md §Filters, Query parameters). Do not render values into
+     * the expression yourself.
+     *
+     * CHOOSE THE BRACE TYPE FOR THE VALUE'S DOMAIN: the declared type's own
+     * reader WRAPS an out-of-domain integer — `{p:UInt8}` given `"256"` binds
+     * `0` and matches every genuine zero (measured, uniform 24.8–26.7) —
+     * while the same constant as a literal PROMOTES (`x = 256` is never
+     * true). Size the brace type for the tenant-supplied domain or validate
+     * the value first; malformed spellings refuse loudly (457 for
+     * `"-1"`/`"+7"`/`"007"` as UInt8, 32 for `""`). A name bound twice at the
+     * C boundary takes the LAST binding — the server's own `insert_or_assign`
+     * rule (unreachable through this unique-keyed object, stated for
+     * completeness).
+     *
+     * The compiled handle bakes the values in: identity is per
+     * (schema, expr, params), so changing a value means compiling a new
+     * `Filter`. A caller compiling filters from tenant-influenced values MUST
+     * bound its cache (an LRU keyed on schema generation + expr + params-hash)
+     * and its compile rate per principal — the key is attacker-influencable,
+     * so an unbounded cache is a memory DoS and an unmetered compile path is a
+     * CPU DoS.
+     */
+    readonly params?: Settings | undefined;
+}
+/**
+ * A compiled schema — one tenant table's column list, compiled inside one
+ * version's library. Obtained from `Library#compileDdl`; never constructed
+ * directly. Release with `close()` (idempotent) or `using` / `Symbol.dispose`.
+ *
+ * Thread-safety: the C ABI forbids using one `chs_schema *` from two threads
+ * at once; on a single JS thread every call here is synchronous, so ordinary
+ * Node code satisfies that by construction. Do not share a `Schema` across
+ * `worker_threads`.
+ */
+export declare class Schema {
+    private readonly native;
+    /** The column-declaration list this schema was compiled from, verbatim. */
+    readonly ddl: string;
+    /**
+     * The declared columns as ClickHouse canonicalised them, in declaration
+     * order — flattened under `flatten_nested=1`, DEFAULT-rewritten types
+     * (`x Int64 DEFAULT NULL` compiles as `Nullable(Int64)`), ALIAS types
+     * inferred. A gateway detects EPHEMERAL columns here, at compile time
+     * (`defaultKind === 'EPHEMERAL'`), not per row.
+     */
+    readonly columns: readonly ColumnInfo[];
+    private handle;
+    /**
+     * Every open `Filter` compiled from this handle, so `close()` can free them
+     * FIRST — the C layer does not refcount, and freeing the schema under a
+     * live filter is use-after-free (spec/c-abi.md §Filters, handle lifetime).
+     */
+    private readonly filters;
+    /**
+     * Every open `Block` parsed from this handle — the same non-owning rule,
+     * the same free-before-schema order (spec/c-abi.md §Blocks).
+     */
+    private readonly blocks;
+    /** @internal — obtained from `Library#compileDdl`. */
+    constructor(native: NativeLibrary, handle: SchemaHandle, 
+    /** The column-declaration list this schema was compiled from, verbatim. */
+    ddl: string);
+    private live;
+    /**
+     * Declare the table engine, so `rows()` applies the engine's own insert-time
+     * merge (`optimize_on_insert = 1`): a CollapsingMergeTree refusing an invalid
+     * Sign with code 117 before anything is stored, a SummingMergeTree summing
+     * equal keys and dropping all-zero rows, a ReplacingMergeTree deduplicating.
+     *
+     * `options.mergeTreeSettings` declares the table's MergeTree-namespace
+     * settings — see `EngineOptions` for the error contract (unknown name ⇒ the
+     * server's 115; non-default declared value ⇒ `unsupported`, never silently
+     * ignored). Absent/empty is structurally the plain engine declaration:
+     * `chs_schema_engine` takes "{}" either way.
+     *
+     * The two error classes here are the refusal/decline split and MUST be
+     * handled as peers — `UnsupportedError` is deliberately NOT
+     * `instanceof SchemaError` (spec/bindings.md rule 12):
+     *
+     * @param engine - the engine expression, e.g. `"SummingMergeTree"`,
+     *   `"CollapsingMergeTree(sign)"`.
+     * @param orderBy - the sorting key, e.g. `"(day, key)"`.
+     * @param options - the MergeTree-namespace `SETTINGS` clause, if any.
+     * @throws {SchemaError} when the SERVER refused (positive code): this DDL
+     *   can never exist and the tenant has to be told. Today that is 115, an
+     *   unknown MergeTree setting name, with the server's own message verbatim.
+     * @throws {UnsupportedError} when this LIBRARY declined: an engine or
+     *   sorting key this build does not model, a known MergeTree setting
+     *   declared at a non-default value, or a guarded exception. A real server
+     *   might well have accepted it — validate cautiously, fall back to the
+     *   server, and never present the decline as a rejection.
+     */
+    setEngine(engine: string, orderBy: string, options?: EngineOptions): void;
+    /**
+     * Declare the table's rows TTL (`ts + INTERVAL 30 DAY`). An expired row is
+     * reported NOT STORED through the batch's `transformed` list.
+     *
+     * Column-level TTLs need no call: they are part of the declaration list.
+     *
+     * @param ttl - the rows-TTL expression, e.g. `"ts + INTERVAL 30 DAY"`. It is
+     *   validated under the handle's declared compile profile when one exists.
+     * @throws {UnsupportedError} for a TTL form this build refuses rather than
+     *   guesses: WHERE / GROUP BY TTLs, TO DISK/VOLUME moves, RECOMPRESS, any
+     *   clock-reading TTL expression, and guarded exceptions. Fall back to the
+     *   server; do not report a tenant error.
+     */
+    setTtl(ttl: string): void;
+    /**
+     * Validate and coerce ONE row body, answering exactly as this ClickHouse
+     * version's insert path would.
+     *
+     * There is no exception for a bad row: rejection, poisoning and declines all
+     * arrive as the `RowResult`'s `outcome` (see `Outcome` for the taxonomy and
+     * the caller's obligations per arm).
+     *
+     * @param format - the wire format code (`Format`). Binary-format support
+     *   depends on the loaded artifact — probe, don't assume.
+     * @param raw - the row's bytes, exactly as they would arrive in an INSERT
+     *   body. Always bytes, never a JS string: binary formats contain NUL bytes
+     *   and text rows can carry invalid UTF-8 on purpose.
+     * @param settings - per-call settings; they win over the compile profile and
+     *   the library defaults (except a type gate the profile declared, which the
+     *   handle has already settled, as a real server's CREATE does).
+     * @returns the `RowResult` — verdict, stored values, and every silent change.
+     * @throws {ChtypesError} when the schema is closed, or a settings value is a
+     *   JS `number`.
+     * @throws {UnsupportedError} when the artifact predates `chs_row`.
+     */
+    row(format: Format, raw: Uint8Array, settings?: Settings): RowResult;
+    /**
+     * Validate and coerce a whole request body, which may hold many rows.
+     *
+     * This is not `row()` in a loop and must never be implemented as one: row
+     * separation is format-specific (a quoted CSV field can contain a newline),
+     * `input_format_allow_errors_num` / `_ratio` decide whether a bad row is
+     * skipped or aborts the batch, and one batch is one clock instant for the
+     * volatile-DEFAULT guarantee.
+     *
+     * @param format - the wire format code (`Format`).
+     * @param body - the whole request body as bytes (never a JS string).
+     * @param settings - per-call settings; same precedence as `row`.
+     * @returns the `BatchResult`. When `engineRows` is present it — not `rows` —
+     *   is the stored truth, and batch-level storage transforms (`ttl_expired`,
+     *   `ttl_column_expired`) are folded into `transformed`.
+     * With `options.exportFormat` the same ONE call also serializes the batch's
+     * accepted rows through the vendored writer: `payload` carries the bytes
+     * (zero-length = emitted-empty, an accepted batch with zero accepted rows;
+     * `undefined` + `exportDeclined` = withheld, with the reason), and `spans`
+     * is index-aligned with `rows` — `payload.subarray(s.off, s.off + s.len)`
+     * IS row i's line. With `options.docFlags` the per-row documents are
+     * thinned to the selected groups; the verdict channel is never thinned.
+     * See `RowsOptions` for the defaults and `BatchResult` for the three
+     * payload states.
+     *
+     * @param format - the wire format code (`Format`).
+     * @param body - the whole request body as bytes (never a JS string).
+     * @param settings - per-call settings; same precedence as `row`.
+     * @param options - the revision-3 export/doc-flag channels; absent =
+     *   today's full document, byte-identical to revision 2.
+     * @returns the `BatchResult`. When `engineRows` is present it — not `rows` —
+     *   is the stored truth, and batch-level storage transforms (`ttl_expired`,
+     *   `ttl_column_expired`) are folded into `transformed`.
+     * @throws {ChtypesError} when the schema is closed, a settings value is a JS
+     *   `number`, or the artifact predates `chs_rows` (a mandatory symbol).
+     */
+    rows(format: Format, body: Uint8Array, settings?: Settings, options?: RowsOptions): BatchResult;
+    /**
+     * Compile one boolean SQL expression over this schema's PHYSICAL columns
+     * (ordinary + MATERIALIZED; naming an ALIAS/EPHEMERAL column fails with
+     * ClickHouse's own UNKNOWN_IDENTIFIER, exactly where a real CREATE fails) —
+     * the same TreeRewriter + ExpressionAnalyzer pipeline the CONSTRAINT CHECK
+     * path runs, so comparison semantics are WHERE-side by construction:
+     * `x = 256` over UInt8 promotes (false for every row), it never wraps
+     * (spec/c-abi.md §Filters).
+     *
+     * The expression may contain `{name:Type}` query parameters, bound with
+     * `options.params` (revision 4) — substitution is the server's own
+     * `ReplaceQueryParameterVisitor`, run before analysis, exactly where a
+     * real server runs it; see `CompileFilterOptions` for the injection-safety
+     * and cache-discipline contract. Close the filter when done (`close()` /
+     * `Symbol.dispose`); `schema.close()` also closes every open filter FIRST,
+     * so no caller ordering can free the schema under a live filter.
+     *
+     * ENFORCEMENT GATE: nothing may enforce read-side security on this surface
+     * until the WHERE-truth rig gates green (zero over-admit, zero over-hide);
+     * until then it is a shadow/replay surface.
+     *
+     * @param expr - one boolean expression, e.g. `"x = 256"` or
+     *   `"tenant = {t:String}"`.
+     * @param options - the `{name:Type}` bindings, if any.
+     * @returns the compiled `Filter`.
+     * @throws {SchemaError} when ClickHouse itself refuses the expression —
+     *   unknown identifier (47), unknown function, an analyzer-raised
+     *   NO_COMMON_TYPE — and, since revision 4, the server's own parameter
+     *   refusals: an UNBOUND `{name:Type}` is **456** UNKNOWN_QUERY_PARAMETER
+     *   ("Substitution `name` is not set"), a value the declared type cannot
+     *   parse completely is **457** BAD_QUERY_PARAMETER — the server's own
+     *   code and message, verbatim. A bound name the expression never uses is
+     *   ignored, as a live server ignores an unused `param_*`.
+     * @throws {UnsupportedError} when this build declines: a non-deterministic
+     *   expression (clock reads — `now() > ts` —, `rand()`, server-constants;
+     *   the scan runs AFTER substitution, so a value can never smuggle one
+     *   in), or an artifact that predates the filter trio.
+     */
+    compileFilter(expr: string, options?: CompileFilterOptions): Filter;
+    /** @internal — `Filter#close` deregisters itself here. */
+    forgetFilter(filter: Filter): void;
+    /**
+     * Parse a body ONCE into a `Block` (`chs_block_parse`) — the parse half of
+     * `Filter#rows`, exported so K filters can evaluate one event with no
+     * re-parse (`Filter#eval`; spec/c-abi.md §Blocks). Same formats and
+     * settings contract as `rows` (`settings` is the PARSE-side map: format
+     * settings, clock keys; evaluation takes none). Volatile DEFAULTs resolve
+     * against THIS call's clock instant, so
+     * `filter.eval(schema.parseBlock(...))` ≡ `filter.rows(...)` exactly when
+     * the clock is pinned (`chtypes_now_epoch_nanos`) or the schema has no
+     * volatile DEFAULT.
+     *
+     * Per-row parse failures do NOT throw — they are recorded IN the block and
+     * answer `'decline'` from every filter, with the recorded error. Release
+     * with `close()` / `Symbol.dispose`; `schema.close()` closes open blocks
+     * FIRST, the C-required order.
+     *
+     * @param format - the wire format code (`Format`).
+     * @param body - the rows as bytes (never a JS string).
+     * @param settings - parse-side settings; same precedence as `Schema#rows`.
+     * @returns the parsed `Block`.
+     * @throws {SchemaError} on a call-level failure — an unknown setting's
+     *   115, an unsplittable body, a binary decode fault, the deferred
+     *   JSONEachRow framing verdict: a malformed body yields no block and no
+     *   partial answers.
+     * @throws {UnsupportedError} when this build declines the call, or the
+     *   artifact predates the block twin.
+     */
+    parseBlock(format: Format, body: Uint8Array, settings?: Settings): Block;
+    /** @internal — `Block#close` deregisters itself here. */
+    forgetBlock(block: Block): void;
+    /**
+     * Release the native schema. Idempotent. After it, `row` / `rows` /
+     * `setEngine` / `setTtl` throw `ChtypesError` ("schema is closed").
+     * Any `Filter` or `Block` still open on this schema is closed FIRST, in
+     * the same call — the handles-before-schema free order the C layer
+     * requires, enforced here so no dispose ordering can get it backwards.
+     */
+    close(): void;
+    /** `using schema = lib.compileDdl(...)` releases it at scope exit. */
+    [Symbol.dispose](): void;
+}
+/**
+ * One boolean SQL expression compiled against a `Schema`'s columns
+ * (`chs_filter_compile`). Obtained from `Schema#compileFilter`; never
+ * constructed directly.
+ *
+ * LIFETIME: a filter REFERENCES its schema handle — the C layer does not copy
+ * and does not refcount (spec/c-abi.md §Filters). This binding enforces the
+ * free order structurally, both ways: the `Filter` holds its `Schema` (so the
+ * schema stays reachable), and `Schema#close` closes every open filter before
+ * freeing the schema. `close()` is idempotent, and `using` / `Symbol.dispose`
+ * work on both objects in any nesting — the schema's dispose runs the
+ * filter's first when the caller forgot. A filter compiled from a schema
+ * answers for THAT handle: recompile filters when the schema is recompiled.
+ *
+ * THREADS: the header's rule, verbatim — one `chs_filter` "must not be used
+ * from two threads at once, and a chs_filter call is ALSO a use of its schema
+ * handle" (two filters over ONE schema must not run concurrently either). On
+ * a single JS thread every call here is synchronous, so ordinary Node code
+ * satisfies both by construction (spec/bindings.md §Concurrency); do not
+ * share a `Filter` — or its `Schema` — across `worker_threads`.
+ *
+ * ENFORCEMENT GATE: `'error'` and `'decline'` verdicts are NOT answers — a
+ * caller enforcing visibility MUST fail closed on both — and NO caller may
+ * enforce read-side security on this surface until the WHERE-truth rig gates
+ * green; until then it is a shadow/replay surface (spec/c-abi.md §Filters).
+ */
+export declare class Filter {
+    private readonly native;
+    private readonly schema;
+    /** The expression text as compiled, for logging and cache keys. */
+    readonly expr: string;
+    private handle;
+    /** @internal — obtained from `Schema#compileFilter`. */
+    constructor(native: NativeLibrary, schema: Schema, handle: FilterHandle, 
+    /** The expression text as compiled, for logging and cache keys. */
+    expr: string);
+    /**
+     * Evaluate the filter over a body of rows (`chs_filter_rows`) — the same
+     * formats and settings contract as `Schema#rows`, ONE C call. Rows are
+     * evaluated INDEPENDENTLY (there is no INSERT to abort):
+     * `input_format_allow_errors_*` does not apply, a bad text row declines
+     * (`'decline'`) and the tail resyncs so verdict indexes keep matching input
+     * rows, and volatile DEFAULTs resolve against one clock instant per call.
+     *
+     * @param format - the wire format code (`Format`).
+     * @param body - the rows as bytes (never a JS string).
+     * @param settings - per-call settings; same precedence as `Schema#rows`.
+     * @returns the `FilterResult` — the call-level outcome, and one verdict per
+     *   row when it is `'ok'`.
+     * @throws {ChtypesError} when the filter is closed, or a settings value is
+     *   a JS `number`.
+     */
+    rows(format: Format, body: Uint8Array, settings?: Settings): FilterResult;
+    /**
+     * Evaluate this filter over an already-parsed `Block` (`chs_filter_eval`)
+     * — the SAME result document `rows` returns: same `FilterResult` fields,
+     * same verdicts, same `errors` rule (a row the parse recorded as
+     * unparseable answers `'decline'` with the recorded error). Evaluation is
+     * a pure function of (filter, block): no settings, and the block is
+     * neither consumed nor mutated, so one block can be evaluated by K filters
+     * sequentially with no re-parse — the live-SSE call shape.
+     *
+     * Filter and block MUST come from the SAME schema: a mismatched pair
+     * answers a REJECTED result (code 1002) — the C layer's loud refusal,
+     * never undefined behaviour. A pair from two different libraries throws
+     * `ChtypesError`: no handle ever crosses a dlopen'd image boundary.
+     *
+     * @param block - a `Block` from `Schema#parseBlock`.
+     * @returns the `FilterResult`, exactly as `rows` would answer it.
+     * @throws {ChtypesError} when the filter or block is closed, or they come
+     *   from two different libraries.
+     */
+    eval(block: Block): FilterResult;
+    /**
+     * Release the native filter (`chs_filter_free`). Idempotent, and also
+     * performed by the schema's own `close()` — filters first, then the schema,
+     * the C-required order.
+     */
+    close(): void;
+    /** `using filter = schema.compileFilter(...)` releases it at scope exit. */
+    [Symbol.dispose](): void;
+}
+/**
+ * One body, parsed ONCE under one schema handle and one clock instant
+ * (`chs_block_parse`). Obtained from `Schema#parseBlock`; evaluated by
+ * `Filter#eval`. The parse-once/eval-many twin of `Filter#rows`
+ * (spec/c-abi.md §Blocks): the live-SSE hot path is K filters × 1 event, and
+ * the block sheds the re-parse.
+ *
+ * LIFETIME: a block REFERENCES its schema handle exactly as a filter does —
+ * the C layer does not copy and does not refcount. This binding enforces the
+ * free order structurally, both ways: the `Block` holds its `Schema` (so the
+ * schema stays reachable), and `Schema#close` closes every open block before
+ * freeing the schema — `using` / `Symbol.dispose` work on all three objects
+ * in any nesting, and the schema's dispose runs the block's first when the
+ * caller forgot. A block may be evaluated by MANY filters, sequentially;
+ * evaluation does not consume or mutate it. Recompile blocks when the schema
+ * is recompiled.
+ *
+ * THREADS: one block must not be used from two threads at once, and an eval
+ * is a use of BOTH handles. On a single JS thread every call here is
+ * synchronous, so ordinary Node code satisfies both by construction; do not
+ * share a `Block` — or its `Schema` — across `worker_threads`.
+ */
+export declare class Block {
+    private readonly native;
+    private readonly schema;
+    private handle;
+    /** @internal — obtained from `Schema#parseBlock`. */
+    constructor(native: NativeLibrary, schema: Schema, handle: BlockHandle);
+    /** @internal — the loaded library this block's handle belongs to. */
+    get nativeLib(): NativeLibrary;
+    /** @internal — the live handle, for `Filter#eval`. */
+    liveHandle(): BlockHandle;
+    /**
+     * Release the native block (`chs_block_free`). Idempotent, and also
+     * performed by the schema's own `close()` — blocks first, then the schema,
+     * the C-required order.
+     */
+    close(): void;
+    /** `using block = schema.parseBlock(...)` releases it at scope exit. */
+    [Symbol.dispose](): void;
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

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