@fjall/clickhouse 1.1.0

package/LICENSE

@@ -0,0 +1,50 @@
+Fjall Proprietary Software Licence
+
+Copyright (c) 2026 Fjall. All rights reserved.
+
+This software, including all source, object, bundled, and minified forms
+("the Software"), is the proprietary and confidential property of Fjall.
+
+1. Permitted Use. Subject to the terms of this Licence, Fjall grants you
+   a non-exclusive, non-transferable, revocable licence to install the
+   Software via the npm registry and to execute it solely for the purpose
+   of deploying, operating, and managing your own applications and
+   infrastructure on cloud providers.
+
+2. Restrictions. You may NOT, and may not permit any third party to:
+   (a) copy, redistribute, sublicense, sell, rent, lease, or otherwise
+       transfer the Software;
+   (b) modify, adapt, translate, or create derivative works of the Software;
+   (c) reverse engineer, decompile, disassemble, deminify, or otherwise
+       attempt to derive the source code, structure, or organisation of
+       the Software, except to the minimum extent expressly permitted by
+       applicable mandatory law;
+   (d) use the Software, or any portion of it, to develop, train, or
+       improve any product or service that competes with Fjall;
+   (e) remove, alter, or obscure any proprietary notices contained in
+       the Software;
+   (f) publish, share, or otherwise disclose the Software or its contents
+       to any third party.
+
+3. Ownership. All right, title, and interest in and to the Software,
+   including all intellectual property rights, remain with Fjall. No
+   rights are granted except as expressly set out in this Licence.
+
+4. Termination. This Licence terminates automatically if you breach any
+   of its terms. Upon termination you must cease all use of the Software
+   and destroy all copies in your possession.
+
+5. Disclaimer of Warranty. THE SOFTWARE IS PROVIDED "AS IS" WITHOUT
+   WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
+   THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
+   AND NON-INFRINGEMENT.
+
+6. Limitation of Liability. IN NO EVENT SHALL FJALL BE LIABLE FOR ANY
+   INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, OR PUNITIVE DAMAGES
+   ARISING OUT OF OR RELATED TO THE SOFTWARE, EVEN IF ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGES.
+
+7. Governing Law. This Licence is governed by the laws of England and
+   Wales, without regard to conflict of laws principles.
+
+For commercial licensing enquiries, contact: contact@fjall.io

package/README.md

@@ -0,0 +1,71 @@
+# @fjall/clickhouse
+
+Runtime helpers for ClickHouse migration containers. Consumes the user manifest published by `@fjall/components-infrastructure` `ClickHouseDatabase` and provisions workload users in writable `users_local` storage. Also ships a generic SQL-file runner and a connection-retry helper.
+
+## Installation
+
+```bash
+npm install @fjall/clickhouse @clickhouse/client
+```
+
+`@clickhouse/client` is a peer dependency — the consumer supplies the runtime client.
+
+## Env-var contract
+
+The framework's commitment is the env-var shape, not this package's API. A customer rolling their own consumer reads the same env vars.
+
+| Env var                    | Shape                                   | Producer                                                  |
+| -------------------------- | --------------------------------------- | --------------------------------------------------------- |
+| `CLICKHOUSE_MANAGED_USERS` | JSON `Array<string>` of user names      | `ClickHouseDatabase.getMigrationContributions()`          |
+| `USER_<NAME>_PASSWORD`     | plaintext (one per managed-users entry) | ECS executionRole + Secrets Manager (no runtime SDK call) |
+
+The manifest carries names only — the schema admin (XML-defined) is NOT included, and profile binding is the customer SQL's job (`ALTER USER <name> SETTINGS PROFILE '<profile>'`).
+
+The constant name + env-name helper + schema live in `@fjall/util/migration`:
+
+```typescript
+import {
+  CLICKHOUSE_MANAGED_USERS_ENV,
+  ManagedUserNamesSchema,
+  userPasswordEnvName,
+} from "@fjall/util/migration";
+```
+
+This package re-exports them for convenience so consumers don't need two imports.
+
+## Usage
+
+```typescript
+import {
+  connectWithRetry,
+  createConsoleMigrationLogger,
+  provisionUsersFromEnv,
+  runSqlMigrations,
+} from "@fjall/clickhouse";
+import { createClient } from "@clickhouse/client";
+
+const logger = createConsoleMigrationLogger("migration-runner");
+const client = createClient({ url, username, password, database });
+
+await connectWithRetry(client, { label: "user-provision", logger });
+await provisionUsersFromEnv({ client, logger });
+await runSqlMigrations({ client, dir: "./clickhouse-init", logger });
+```
+
+`provisionUsersFromEnv` is idempotent — it issues `CREATE USER IF NOT EXISTS` then `ALTER USER` for every manifest entry, so repeated invocations are safe.
+
+## Rolling your own consumer
+
+The env-var contract above is stable. A customer who prefers their own provisioner reads the same env vars; this package's helpers are convenience wrappers. The framework commits to the env shape, not to this package.
+
+If rolling your own, you'll want to replicate:
+
+- single-quote-escape the password literal (`'` → `''`) before string-interpolating into `IDENTIFIED WITH … BY '…'`
+- mask passwords in any log output (use `maskSensitiveOutput` from `@fjall/util`)
+- order `CREATE USER IF NOT EXISTS` before `ALTER USER` so re-provisioning realigns drifted credentials
+- place provisioning BEFORE any migration-hash idempotency gate
+- regex-validate user names before string-interpolating into SQL (CH doesn't bind identifier parameters)
+
+## Licence
+
+Proprietary — see [LICENSE](./LICENSE).

package/dist/.minified

@@ -0,0 +1 @@
+10 files minified at 2026-05-23T21:29:47.546Z

package/dist/connectWithRetry.d.ts

@@ -0,0 +1,9 @@
+import type { ClickHouseClient } from "@clickhouse/client";
+import type { MigrationLogger } from "./logger.js";
+export interface ConnectWithRetryOpts {
+    label: string;
+    signal?: AbortSignal;
+    delays?: readonly number[];
+    logger?: MigrationLogger;
+}
+export declare function connectWithRetry(client: ClickHouseClient, opts: ConnectWithRetryOpts): Promise<void>;

package/dist/connectWithRetry.js

@@ -0,0 +1 @@
+import{getErrorMessage as f,maskSensitiveOutput as _}from"@fjall/util";import{sleepAbortable as g}from"./sleepAbortable.js";const p=[5e3,1e4,2e4,4e4,6e4],y=3,A=516,h=["ECONNREFUSED","ETIMEDOUT","ENOTFOUND"];async function u(E,a){const{label:n,signal:c,logger:i}=a,r=a.delays??p;let s;for(let t=0;t<r.length;t++){if(c?.aborted)throw new Error(`connectWithRetry: ${n} aborted by signal before attempt ${t+1}`);try{await E.ping(),t>0&&i?.info("connect succeeded after retry",{label:n,attempt:t+1});return}catch(e){s=e;const o=typeof e=="object"&&e!==null&&"code"in e?e.code:void 0,l=o===A;if(!(typeof o=="string"&&h.includes(o)||l&&t<y))throw e;i?.warn("connect attempt failed; retrying",{label:n,attempt:t+1,attempts:r.length,delayMs:r[t],code:l?"AUTH_FAILED":o??""}),await g(r[t],c)}}const d=_(f(s));throw new Error(`connectWithRetry: ${n} failed after ${r.length} attempts: ${d}`)}export{u as connectWithRetry};

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export { CLICKHOUSE_MANAGED_USERS_ENV, userPasswordEnvName, } from "@fjall/util/migration";

package/dist/constants.js

@@ -0,0 +1 @@
+import{CLICKHOUSE_MANAGED_USERS_ENV as e,userPasswordEnvName as o}from"@fjall/util/migration";export{e as CLICKHOUSE_MANAGED_USERS_ENV,o as userPasswordEnvName};

package/dist/createClient.d.ts

@@ -0,0 +1,44 @@
+import { type ClickHouseClient, type ClickHouseClientConfigOptions } from "@clickhouse/client";
+/**
+ * Construction options for {@link createFjallClickHouseClient}.
+ *
+ * Every field is optional. `url` falls back to `process.env.CLICKHOUSE_URL`;
+ * `caCert` falls back to `process.env.CLICKHOUSE_CA_CERT`. Empty strings
+ * are treated identically to `undefined` on both — dev compose without a
+ * CA cert injected boots transparently in plaintext, while prod ECS
+ * containers receive the CA PEM via the secret-block on `secretsImport`
+ * and run on `https://`.
+ */
+export interface CreateFjallClickHouseClientOptions {
+    /** Defaults to env CLICKHOUSE_URL. Empty/undefined throws. */
+    readonly url?: string;
+    /**
+     * Defaults to env CLICKHOUSE_CA_CERT (PEM string injected by the ECS
+     * `secrets:` block from `ClickHouseDatabase.tlsCaSecret`). Absent/empty
+     * disables the `tls:` config (plaintext fallback for dev compose).
+     */
+    readonly caCert?: string;
+    readonly username?: string;
+    readonly password?: string;
+    /** Optional database name override. */
+    readonly database?: string;
+    /** Pass-through to `@clickhouse/client`. */
+    readonly clickhouse_settings?: ClickHouseClientConfigOptions["clickhouse_settings"];
+    readonly compression?: ClickHouseClientConfigOptions["compression"];
+    readonly request_timeout?: number;
+    readonly max_open_connections?: number;
+    readonly keep_alive?: ClickHouseClientConfigOptions["keep_alive"];
+}
+/**
+ * Sync factory wrapping `@clickhouse/client`'s `createClient`. No AWS SDK
+ * call, no `await`, no module-level cache — the CA PEM is already on
+ * `process.env` when the container's user code runs because ECS resolves
+ * the `secrets:` block during container bring-up.
+ *
+ * `tls.ca_cert` MUST be a `Buffer` per the `@clickhouse/client` contract.
+ * Passing a raw string type-checks (the field accepts `Buffer | string`
+ * structurally) but the underlying TLS stack silently skips the
+ * trust-store add and the handshake fails downstream. Wrap explicitly
+ * with `Buffer.from(pem, "utf8")`.
+ */
+export declare function createFjallClickHouseClient(opts?: CreateFjallClickHouseClientOptions): ClickHouseClient;

package/dist/createClient.js

@@ -0,0 +1 @@
+import{createClient as d}from"@clickhouse/client";function c(e={}){const n=process.env.CLICKHOUSE_URL,i=e.url!==void 0&&e.url!==""?e.url:n!==void 0&&n!==""?n:void 0;if(i===void 0)throw new Error("createFjallClickHouseClient: CLICKHOUSE_URL must be set (env or opts.url)");const r=process.env.CLICKHOUSE_CA_CERT,u=e.caCert!==void 0&&e.caCert!==""?e.caCert:r!==void 0&&r!==""?r:void 0;return d({url:i,...e.username!==void 0&&{username:e.username},...e.password!==void 0&&{password:e.password},...e.database!==void 0&&{database:e.database},...e.clickhouse_settings!==void 0&&{clickhouse_settings:e.clickhouse_settings},...e.compression!==void 0&&{compression:e.compression},...e.request_timeout!==void 0&&{request_timeout:e.request_timeout},...e.max_open_connections!==void 0&&{max_open_connections:e.max_open_connections},...e.keep_alive!==void 0&&{keep_alive:e.keep_alive},...u!==void 0&&{tls:{ca_cert:Buffer.from(u,"utf8")}}})}export{c as createFjallClickHouseClient};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { CLICKHOUSE_MANAGED_USERS_ENV, userPasswordEnvName, } from "./constants.js";
+export { ManagedUserNameSchema, ManagedUserNamesSchema, type ManagedUserName, type ManagedUserNames, } from "./schemas.js";
+export { type MigrationLogger, createConsoleMigrationLogger, } from "./logger.js";
+export { type ConnectWithRetryOpts, connectWithRetry, } from "./connectWithRetry.js";
+export { type ProvisionUsersFromEnvOpts, type ProvisionUsersFromEnvResult, provisionUsersFromEnv, } from "./provisionUsers.js";
+export { type RunSqlMigrationsOpts, type RunSqlMigrationsResult, runSqlMigrations, } from "./runSqlMigrations.js";
+export { type VerifyExpectedClickHouseSchemaVersionOpts, type VerifyExpectedClickHouseSchemaVersionResult, verifyExpectedClickHouseSchemaVersion, } from "./verifyExpectedClickHouseSchemaVersion.js";
+export { type CreateFjallClickHouseClientOptions, createFjallClickHouseClient, } from "./createClient.js";

package/dist/index.js

@@ -0,0 +1 @@
+import{CLICKHOUSE_MANAGED_USERS_ENV as o,userPasswordEnvName as t}from"./constants.js";import{ManagedUserNameSchema as m,ManagedUserNamesSchema as s}from"./schemas.js";import{createConsoleMigrationLogger as i}from"./logger.js";import{connectWithRetry as p}from"./connectWithRetry.js";import{provisionUsersFromEnv as x}from"./provisionUsers.js";import{runSqlMigrations as E}from"./runSqlMigrations.js";import{verifyExpectedClickHouseSchemaVersion as g}from"./verifyExpectedClickHouseSchemaVersion.js";import{createFjallClickHouseClient as M}from"./createClient.js";export{o as CLICKHOUSE_MANAGED_USERS_ENV,m as ManagedUserNameSchema,s as ManagedUserNamesSchema,p as connectWithRetry,i as createConsoleMigrationLogger,M as createFjallClickHouseClient,x as provisionUsersFromEnv,E as runSqlMigrations,t as userPasswordEnvName,g as verifyExpectedClickHouseSchemaVersion};

package/dist/logger.d.ts

@@ -0,0 +1,5 @@
+export interface MigrationLogger {
+    info(msg: string, ctx?: Record<string, unknown>): void;
+    warn(msg: string, ctx?: Record<string, unknown>): void;
+}
+export declare function createConsoleMigrationLogger(namespace: string): MigrationLogger;

package/dist/logger.js

@@ -0,0 +1,3 @@
+function r(n){return{info(t,e){process.stdout.write(JSON.stringify({level:"info",namespace:n,msg:t,ctx:e??{},ts:new Date().toISOString()})+`
+`)},warn(t,e){process.stdout.write(JSON.stringify({level:"warn",namespace:n,msg:t,ctx:e??{},ts:new Date().toISOString()})+`
+`)}}}export{r as createConsoleMigrationLogger};

package/dist/provisionUsers.d.ts

@@ -0,0 +1,12 @@
+import type { ClickHouseClient } from "@clickhouse/client";
+import type { MigrationLogger } from "./logger.js";
+export interface ProvisionUsersFromEnvOpts {
+    client: ClickHouseClient;
+    signal?: AbortSignal;
+    logger?: MigrationLogger;
+    env?: NodeJS.ProcessEnv;
+}
+export interface ProvisionUsersFromEnvResult {
+    provisioned: readonly string[];
+}
+export declare function provisionUsersFromEnv(opts: ProvisionUsersFromEnvOpts): Promise<ProvisionUsersFromEnvResult>;

package/dist/provisionUsers.js

@@ -0,0 +1 @@
+import{CLICKHOUSE_MANAGED_USERS_ENV as i,userPasswordEnvName as w}from"./constants.js";import{ManagedUserNamesSchema as S}from"./schemas.js";function g(r){return r.replace(/\\/g,"\\\\").replace(/'/g,"''")}async function N(r){const{client:t,signal:v,logger:s}=r,m=r.env??process.env,o=m[i];if(o===void 0||o==="")return s?.info("no managed users to provision (manifest env absent)",{}),{provisioned:[]};let c;try{c=JSON.parse(o)}catch(e){throw new Error(`provisionUsersFromEnv: malformed ${i} \u2014 JSON parse failed`,{cause:e})}const n=S.safeParse(c);if(!n.success)throw new Error(`provisionUsersFromEnv: malformed ${i} \u2014 ${n.error.message}`);const p=n.data;if(p.length===0)return s?.info("no managed users to provision (manifest empty)",{}),{provisioned:[]};const d=[];for(const e of p){if(v?.aborted)throw new Error(`provisionUsersFromEnv: aborted by signal before user '${e}'`);const f=w(e),a=m[f];if(a===void 0||a==="")throw new Error(`provisionUsersFromEnv: required env ${f} is missing or empty`);const E=g(a),u=`CREATE USER IF NOT EXISTS ${e} IDENTIFIED WITH sha256_password BY '${E}'`,l=`ALTER USER ${e} IDENTIFIED WITH sha256_password BY '${E}'`;await t.command({query:u}),await t.command({query:l}),s?.info("clickhouse user provisioned",{name:e}),d.push(e)}return{provisioned:d}}export{N as provisionUsersFromEnv};

package/dist/runSqlMigrations.d.ts

@@ -0,0 +1,14 @@
+import type { ClickHouseClient } from "@clickhouse/client";
+import type { MigrationLogger } from "./logger.js";
+export declare function hasSqlContent(chunk: string): boolean;
+export interface RunSqlMigrationsOpts {
+    client: ClickHouseClient;
+    dir: string;
+    skipFilesMatching?: RegExp;
+    signal?: AbortSignal;
+    logger?: MigrationLogger;
+}
+export interface RunSqlMigrationsResult {
+    applied: readonly string[];
+}
+export declare function runSqlMigrations(opts: RunSqlMigrationsOpts): Promise<RunSqlMigrationsResult>;

package/dist/runSqlMigrations.js

@@ -0,0 +1,2 @@
+import{readFileSync as S,readdirSync as E}from"node:fs";import{join as w}from"node:path";import{getErrorMessage as q,maskSensitiveOutput as M}from"@fjall/util";import{CLICKHOUSE_MIGRATION_SKIP_RE as y}from"@fjall/util/migration";const R=y,l=400;function b(e){return e.split(`
+`).some(r=>{const n=r.trim();return n.length>0&&!n.startsWith("--")})}function _(e){return e.split(/;\s*\n/).map(r=>r.trim()).filter(r=>r.length>0&&b(r))}async function P(e){const{client:r,dir:n,signal:s,logger:c}=e,m=e.skipFilesMatching??R,f=E(n).filter(t=>t.endsWith(".sql")).filter(t=>!m.test(t)).sort(),a=[];for(const t of f){if(s?.aborted)throw new Error(`runSqlMigrations: aborted by signal before applying '${t}'`);const p=w(n,t),g=S(p,"utf8"),u=_(g);try{for(const o of u){if(s?.aborted)throw new Error(`runSqlMigrations: aborted by signal while applying '${t}'`);await r.command({query:o})}}catch(o){const d=q(o).replace(/'(?:[^']|'')*'/g,"'<REDACTED>'"),i=M(d),h=i.length>l?i.slice(0,l)+"\u2026":i;throw new Error(`runSqlMigrations: ${t}: ${h}`,{cause:o})}c?.info("sql migration applied",{file:t}),a.push(t)}return{applied:a}}export{b as hasSqlContent,P as runSqlMigrations};

package/dist/schemas.d.ts

@@ -0,0 +1 @@
+export { ManagedUserNameSchema, ManagedUserNamesSchema, type ManagedUserName, type ManagedUserNames, } from "@fjall/util/migration";

package/dist/schemas.js

@@ -0,0 +1 @@
+import{ManagedUserNameSchema as m,ManagedUserNamesSchema as r}from"@fjall/util/migration";export{m as ManagedUserNameSchema,r as ManagedUserNamesSchema};

package/dist/sleepAbortable.d.ts

@@ -0,0 +1 @@
+export declare function sleepAbortable(ms: number, signal?: AbortSignal): Promise<void>;

package/dist/sleepAbortable.js

@@ -0,0 +1 @@
+function b(o,e){return e?.aborted?Promise.resolve():new Promise(r=>{const t=()=>{clearTimeout(n),e?.removeEventListener("abort",t),r()},n=setTimeout(()=>{e?.removeEventListener("abort",t),r()},o);e?.addEventListener("abort",t,{once:!0})})}export{b as sleepAbortable};

package/dist/verifyExpectedClickHouseSchemaVersion.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Boot-time gate: verify the ClickHouse `_schema_migrations` audit table's
+ * most recently applied row matches the expected version baked into the
+ * deployed image. Companion to the SQL-side helper
+ * `verifyExpectedSchemaVersion` from `@fjall/util/migration` — together they
+ * close the asymmetry where a webapp's boot gate checks Postgres but blindly
+ * trusts ClickHouse.
+ *
+ * The audit table is owned by the migration runner: see the canonical DDL
+ * recorded by `ensureSchemaMigrationsTable` in the webapp's migration-runner
+ * (columns `version`, `applied_at`, `snapshot_arn`, `prisma_version`,
+ * `ch_version`). This helper reads a single configurable column (default
+ * `ch_version`) so callers can pin to whichever the image's expected env
+ * carries (overall migration hash via `version`, Prisma-side via
+ * `prisma_version`, or ClickHouse-side via `ch_version`).
+ *
+ * Returns `{ matches, expected, actual }` rather than throwing on mismatch:
+ * the consumer's boot script owns the exit-code / log shape.
+ */
+import type { ClickHouseClient } from "@clickhouse/client";
+import type { MigrationLogger } from "./logger.js";
+declare const ALLOWED_FIELDS: readonly ["version", "ch_version", "prisma_version"];
+type AllowedField = (typeof ALLOWED_FIELDS)[number];
+export interface VerifyExpectedClickHouseSchemaVersionOpts {
+    client: ClickHouseClient;
+    /** Expected version (typically read from an env var baked into the image). */
+    expected: string;
+    /** Database holding the audit table. Defaults to `"analytics"`. */
+    database?: string;
+    /** Audit-table name. Defaults to `"_schema_migrations"`. */
+    table?: string;
+    /** Column whose latest value to compare. Defaults to `"ch_version"`. */
+    field?: AllowedField;
+    signal?: AbortSignal;
+    logger?: MigrationLogger;
+}
+export interface VerifyExpectedClickHouseSchemaVersionResult {
+    matches: boolean;
+    expected: string;
+    /** `null` when the audit table is empty (no migrations applied yet). */
+    actual: string | null;
+}
+export declare function verifyExpectedClickHouseSchemaVersion(opts: VerifyExpectedClickHouseSchemaVersionOpts): Promise<VerifyExpectedClickHouseSchemaVersionResult>;
+export {};

package/dist/verifyExpectedClickHouseSchemaVersion.js

@@ -0,0 +1 @@
+const s=/^[A-Za-z_][A-Za-z0-9_]*$/,n=["version","ch_version","prisma_version"],l="analytics",u="_schema_migrations",E="ch_version";async function h(e){if(e.signal?.aborted)throw new Error("verifyExpectedClickHouseSchemaVersion: aborted by signal before query");const t=e.database??l,c=e.table??u,a=e.field??E;if(!s.test(t))throw new Error(`verifyExpectedClickHouseSchemaVersion: unsafe database identifier '${t}'`);if(!s.test(c))throw new Error(`verifyExpectedClickHouseSchemaVersion: unsafe table identifier '${c}'`);if(!n.includes(a))throw new Error(`verifyExpectedClickHouseSchemaVersion: field must be one of ${n.join("|")} (got '${a}')`);const i=(await(await e.client.query({query:`SELECT ${a} AS value FROM ${t}.${c} ORDER BY applied_at DESC LIMIT 1`,format:"JSONEachRow"})).json())[0]?.value,o=typeof i=="string"?i:null,r={matches:o===e.expected,expected:e.expected,actual:o};return e.logger?.info("ClickHouse schema-version check complete",{matches:r.matches,expected:r.expected,actual:r.actual,database:t,table:c,field:a}),r}export{h as verifyExpectedClickHouseSchemaVersion};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@fjall/clickhouse",
+  "version": "1.1.0",
+  "description": "Runtime helpers for ClickHouse migration containers — user provisioning, SQL file application, connection retry. Consumes the manifest contract published by @fjall/components-infrastructure ClickHouseDatabase.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rm -rf ./dist ./sourcemaps",
+    "clean:node": "rm -rf ./node_modules",
+    "build": "npm run clean && npx tsc && node ../scripts/minify-dist.mjs dist",
+    "watch": "npm run build && npx tsc-watch",
+    "watch:only": "npx tsc-watch",
+    "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,tsx,js,jsx,json}\"",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "test": "vitest run",
+    "typecheck": "npx tsc --noEmit"
+  },
+  "author": "",
+  "license": "SEE LICENSE IN LICENSE",
+  "devDependencies": {
+    "@clickhouse/client": "^1.18.0",
+    "@types/node": "^25.6.0",
+    "prettier": "^3.8.3",
+    "tsc-watch": "^7.2.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "peerDependencies": {
+    "@clickhouse/client": "^1.18.0"
+  },
+  "dependencies": {
+    "@fjall/util": "^1.1.0",
+    "zod": "^4.4.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "gitHead": "437ec726425bd7610b83a57c12c1a4e1980bbb01"
+}