@housekit/orm 0.1.1

package/dist/external.d.ts

@@ -0,0 +1,177 @@
+/**
+ * HouseKit External Data Sources - Type-Safe External Table Functions
+ *
+ * ClickHouse can query external data sources directly in SQL.
+ * These helpers create virtual table references that can be used in JOINs.
+ *
+ * Standard ORMs often lack support for this - HouseKit's Data Gravity approach
+ * moves computation to ClickHouse instead of downloading data to Node.js.
+ */
+import { type TableColumns, type TableOptions } from './table';
+/**
+ * External table that can be used in FROM/JOIN clauses
+ */
+export interface ExternalTableDefinition<TCols extends TableColumns = TableColumns> {
+    $table: string;
+    $columns: TCols;
+    $options: TableOptions & {
+        externallyManaged: true;
+        kind: 'external';
+    };
+    /**
+     * External tables don't have CREATE statements
+     */
+    toSQL(): string;
+}
+/**
+ * S3 file format options
+ */
+export type S3Format = 'CSV' | 'CSVWithNames' | 'TSV' | 'TabSeparated' | 'TabSeparatedWithNames' | 'JSONEachRow' | 'JSON' | 'JSONCompact' | 'Parquet' | 'ORC' | 'Arrow' | 'Avro' | 'Native';
+/**
+ * S3 compression options
+ */
+export type S3Compression = 'none' | 'gzip' | 'br' | 'xz' | 'zstd' | 'lz4' | 'bz2';
+/**
+ * S3 access configuration for external table functions
+ */
+export interface ExternalS3Config {
+    /** S3 bucket URL with path pattern (supports wildcards) */
+    url: string;
+    /** AWS access key (optional if using IAM roles) */
+    accessKeyId?: string;
+    /** AWS secret key (optional if using IAM roles) */
+    secretAccessKey?: string;
+    /** File format */
+    format?: S3Format;
+    /** Structure definition for the file (e.g., 'id UInt32, name String') */
+    structure?: string;
+    /** Compression type */
+    compression?: S3Compression;
+}
+/**
+ * URL source configuration (for HTTP endpoints)
+ */
+export interface ExternalURLConfig {
+    /** URL to fetch data from */
+    url: string;
+    /** File format */
+    format: S3Format;
+    /** Structure definition */
+    structure?: string;
+    /** HTTP headers */
+    headers?: Record<string, string>;
+}
+/**
+ * File source configuration (for local/mounted files)
+ */
+export interface ExternalFileConfig {
+    /** File path pattern (supports wildcards) */
+    path: string;
+    /** File format */
+    format: S3Format;
+    /** Structure definition */
+    structure?: string;
+}
+/**
+ * HDFS configuration
+ */
+export interface HDFSConfig {
+    /** HDFS URL */
+    url: string;
+    /** File format */
+    format: S3Format;
+    /** Structure definition */
+    structure?: string;
+}
+/**
+ * MySQL external table configuration
+ */
+export interface MySQLExternalConfig {
+    host: string;
+    port?: number;
+    database: string;
+    table: string;
+    user: string;
+    password: string;
+}
+/**
+ * PostgreSQL external table configuration
+ */
+export interface PostgreSQLExternalConfig {
+    host: string;
+    port?: number;
+    database: string;
+    table: string | {
+        schema: string;
+        table: string;
+    };
+    user: string;
+    password: string;
+}
+/**
+ * Create an S3 external table reference for use in queries.
+ *
+ * @example
+ * ```typescript
+ * import { s3, eq, sql } from '@housekit/orm';
+ *
+ * // Define external S3 data
+ * const externalUsers = s3({
+ *   url: 's3://my-bucket/users/*.parquet',
+ *   format: 'Parquet',
+ * });
+ *
+ * // Use in a JOIN - ClickHouse reads S3 directly!
+ * const query = db.select({
+ *   eventType: events.event_type,
+ *   userName: sql`externalUsers.name`,
+ * })
+ * .from(events)
+ * .innerJoin(externalUsers, eq(events.user_id, sql`externalUsers.id`));
+ * ```
+ */
+export declare function s3<TCols extends TableColumns = {}>(config: ExternalS3Config, columns?: TCols): ExternalTableDefinition<TCols> & TCols;
+/**
+ * Create an S3 Cluster external table (for distributed reading)
+ */
+export declare function s3Cluster<TCols extends TableColumns = {}>(clusterName: string, config: ExternalS3Config, columns?: TCols): ExternalTableDefinition<TCols> & TCols;
+/**
+ * Create a URL external table reference.
+ */
+export declare function url<TCols extends TableColumns = {}>(config: ExternalURLConfig, columns?: TCols): ExternalTableDefinition<TCols> & TCols;
+/**
+ * Create a File external table reference.
+ */
+export declare function file<TCols extends TableColumns = {}>(config: ExternalFileConfig, columns?: TCols): ExternalTableDefinition<TCols> & TCols;
+/**
+ * Create an HDFS external table reference.
+ */
+export declare function hdfs<TCols extends TableColumns = {}>(config: HDFSConfig, columns?: TCols): ExternalTableDefinition<TCols> & TCols;
+/**
+ * Create a MySQL external table reference.
+ *
+ * @warning **SECURITY WARNING**: This includes the password in plain text in the generated SQL.
+ * The password will be stored in plain text in ClickHouse's `system.query_log` unless you have
+ * configured query masking on the server. Ensure you use a read-only user with minimal permissions.
+ */
+export declare function mysql<TCols extends TableColumns = {}>(config: MySQLExternalConfig, columns?: TCols): ExternalTableDefinition<TCols> & TCols;
+/**
+ * Create a PostgreSQL external table reference.
+ *
+ * @warning **SECURITY WARNING**: This includes the password in plain text in the generated SQL.
+ * The password will be stored in plain text in ClickHouse's `system.query_log` unless you have
+ * configured query masking on the server. Ensure you use a read-only user with minimal permissions.
+ */
+export declare function postgresql<TCols extends TableColumns = {}>(config: PostgreSQLExternalConfig, columns?: TCols): ExternalTableDefinition<TCols> & TCols;
+/**
+ * Create an inline VALUES table (useful for small lookup tables in queries)
+ */
+export declare function values<T extends Record<string, any>>(data: T[], structure: string): ExternalTableDefinition;
+/**
+ * Create a Numbers table function (generates sequence of numbers)
+ */
+export declare function numbers(count: number, offset?: number): ExternalTableDefinition;
+/**
+ * Create a generateRandom table function
+ */
+export declare function generateRandom(structure: string, randomSeed?: number, maxStringLength?: number, maxArrayLength?: number): ExternalTableDefinition;

package/dist/index.d.ts

@@ -0,0 +1,187 @@
+import { type TableDefinition, type TableColumns } from './core';
+import { createClientFromConfigObject, type ClientConfigWithSchema } from './client';
+export { ClickHouseColumn } from './column';
+export { type TableDefinition, type TableColumns, type TableOptions, type IndexDefinition, type ProjectionDefinition, index, projection, deriveTable, renderSchema } from './table';
+export { Engine, type EngineConfiguration } from './engines';
+export * from './external';
+export * from './expressions';
+export * from './builders/select';
+export * from './builders/select.types';
+export * from './builders/insert';
+export * from './builders/delete';
+export * from './builders/update';
+export * from './metadata';
+export * from './compiler';
+export * from './modules';
+export * from './relational';
+export * from './logger';
+export * from './client';
+export { t, defineTable, table, view, defineView, materializedView, defineMaterializedView, dictionary, defineDictionary, defineProjection, detectMaterializedViewDrift, extractMVQuery, createMigrationBridge, generateBlueGreenMigration, relations, type ColumnBuilder, type EnhancedTableOptions } from './schema-builder';
+export { sql } from './expressions';
+export { generateSelectSchema, generateInsertSchema } from './codegen/zod';
+export { BinaryWriter, createBinaryEncoder, serializeRowBinary, serializeRowsBinary, buildBinaryConfig, type BinaryEncoder, type BinarySerializationConfig, } from './utils/binary-serializer';
+export { SyncBinarySerializer, BinaryWorkerPool, type BinaryWorkerPoolOptions, } from './utils/binary-worker-pool';
+/**
+ * Load housekit.config.js/ts and create a client by name.
+ */
+export declare function createClientFromConfig(databaseName?: string): Promise<HousekitClient>;
+export type HousekitClient = ReturnType<typeof createClientFromConfigObject>;
+export declare function createClient(): Promise<HousekitClient>;
+export declare function createClient(config: ClientConfigWithSchema): HousekitClient;
+export declare function createClient(databaseName: string): Promise<HousekitClient>;
+export declare function tableExists(client: HousekitClient, tableName: string): Promise<boolean>;
+export declare function ensureTable<TCols extends TableColumns>(client: HousekitClient, table: TableDefinition<TCols>): Promise<void>;
+export declare function dropTable(client: HousekitClient, tableName: string, options?: {
+    ifExists?: boolean;
+}): Promise<void>;
+/**
+ * Create multiple ClickHouse clients for multi-database setups
+ * @example
+ * const clients = createClients({
+ *   analytics: { url: 'http://localhost:8123', database: 'analytics' },
+ *   logs: { url: 'http://localhost:8123', database: 'logs' }
+ * });
+ *
+ * await clients.analytics.select().from(events);
+ * await clients.logs.insert(logTable).values({...});
+ */
+export declare function createClients<T extends Record<string, ClientConfigWithSchema>>(configs: T): Record<keyof T, HousekitClient>;
+/**
+ * Close all clients in a multi-database setup
+ */
+export declare function closeAllClients(clients: Record<string, HousekitClient>): Promise<void>;
+import { defineTable, defineProjection, detectMaterializedViewDrift, extractMVQuery, createMigrationBridge, generateBlueGreenMigration, relations } from './schema-builder';
+import { sql } from './expressions';
+import { deriveTable } from './table';
+import { generateSelectSchema, generateInsertSchema } from './codegen/zod';
+/**
+ * Optional default export for users who prefer this style.
+ * Named exports are recommended for better tree-shaking.
+ *
+ * @example
+ * ```typescript
+ * // Named exports (recommended)
+ * import { table, t, Engine } from '@housekit/orm';
+ *
+ * // Default export (alternative)
+ * import housekit from '@housekit/orm';
+ * const users = housekit.table('users', { ... });
+ * ```
+ */
+declare const _default: {
+    t: {
+        int8: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        int16: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        integer: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        int32: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        int64: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        int128: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        int256: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        uint8: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        uint16: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        uint32: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        uint64: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        uint128: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        uint256: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        float32: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        float: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        float64: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        bfloat16: (name: string) => import("./column").ClickHouseColumn<number, true, false>;
+        decimal: (name: string, precision?: number, scale?: number) => import("./column").ClickHouseColumn<number, true, false>;
+        decimal32: (name: string, scale?: number) => import("./column").ClickHouseColumn<number, true, false>;
+        decimal64: (name: string, scale?: number) => import("./column").ClickHouseColumn<number, true, false>;
+        decimal128: (name: string, scale?: number) => import("./column").ClickHouseColumn<number, true, false>;
+        decimal256: (name: string, scale?: number) => import("./column").ClickHouseColumn<number, true, false>;
+        text: (name: string) => import("./column").ClickHouseColumn<string, true, false>;
+        string: (name: string) => import("./column").ClickHouseColumn<string, true, false>;
+        fixedString: (name: string, length: number) => import("./column").ClickHouseColumn<string, true, false>;
+        varchar: (name: string, opts?: {
+            length?: number;
+        }) => import("./column").ClickHouseColumn<string, true, false>;
+        date: (name: string) => import("./column").ClickHouseColumn<string | Date, true, false>;
+        date32: (name: string) => import("./column").ClickHouseColumn<string | Date, true, false>;
+        timestamp: (name: string, timezone?: string) => import("./column").ClickHouseColumn<string | Date, true, false>;
+        datetime: (name: string, timezone?: string) => import("./column").ClickHouseColumn<string | Date, true, false>;
+        datetime64: (name: string, precision?: number, timezone?: string) => import("./column").ClickHouseColumn<string | Date, true, false>;
+        boolean: (name: string) => import("./column").ClickHouseColumn<boolean, true, false>;
+        bool: (name: string) => import("./column").ClickHouseColumn<boolean, true, false>;
+        uuid: (name: string) => import("./column").ClickHouseColumn<string, true, false>;
+        ipv4: (name: string) => import("./column").ClickHouseColumn<string, true, false>;
+        ipv6: (name: string) => import("./column").ClickHouseColumn<string, true, false>;
+        array: <T>(col: import("./column").ClickHouseColumn<T>) => import("./column").ClickHouseColumn<T[], true, false>;
+        tuple: (name: string, types: string[]) => import("./column").ClickHouseColumn<any, true, false>;
+        map: (name: string, keyType?: string, valueType?: string) => import("./column").ClickHouseColumn<Record<string, any>, true, false>;
+        nested: (name: string, fields: Record<string, string>) => import("./column").ClickHouseColumn<any, true, false>;
+        json: <TSchema = Record<string, any>>(name: string) => import("./column").ClickHouseColumn<TSchema, false, false>;
+        dynamic: (name: string, maxTypes?: number) => import("./column").ClickHouseColumn<any, true, false>;
+        lowCardinality: <T, TNotNull extends boolean, TAutoGenerated extends boolean>(col: import("./column").ClickHouseColumn<T, TNotNull, TAutoGenerated>) => import("./column").ClickHouseColumn<T, TNotNull, TAutoGenerated>;
+        aggregateFunction: (name: string, funcName: string, ...argTypes: string[]) => import("./column").ClickHouseColumn<any, true, false>;
+        simpleAggregateFunction: (name: string, funcName: string, argType: string) => import("./column").ClickHouseColumn<any, true, false>;
+        point: (name: string) => import("./column").ClickHouseColumn<[number, number], true, false>;
+        ring: (name: string) => import("./column").ClickHouseColumn<[number, number][], true, false>;
+        polygon: (name: string) => import("./column").ClickHouseColumn<[number, number][][], true, false>;
+        multiPolygon: (name: string) => import("./column").ClickHouseColumn<[number, number][][][], true, false>;
+        enum: (name: string, values: readonly string[]) => import("./column").ClickHouseColumn<string, false, false>;
+    };
+    table: typeof defineTable;
+    defineTable: typeof defineTable;
+    view: typeof import("./table").chView;
+    defineView: typeof import("./table").chView;
+    materializedView: typeof import("./materialized-views").chMaterializedView;
+    defineMaterializedView: typeof import("./materialized-views").chMaterializedView;
+    dictionary: typeof import("./dictionary").chDictionary;
+    defineDictionary: typeof import("./dictionary").chDictionary;
+    defineProjection: typeof defineProjection;
+    relations: typeof relations;
+    createClient: typeof createClient;
+    createClients: typeof createClients;
+    closeAllClients: typeof closeAllClients;
+    Engine: {
+        MergeTree: (options?: Omit<import("./engines").MergeTreeConfig, "type">) => import("./engines").MergeTreeConfig;
+        ReplacingMergeTree: (versionColumn?: string, isDeletedColumn?: string, options?: Omit<import("./engines").ReplacingMergeTreeConfig, "type" | "versionColumn" | "isDeletedColumn">) => import("./engines").ReplacingMergeTreeConfig;
+        SummingMergeTree: (columns?: string[], options?: Omit<import("./engines").SummingMergeTreeConfig, "type" | "columns">) => import("./engines").SummingMergeTreeConfig;
+        AggregatingMergeTree: (options?: Omit<import("./engines").AggregatingMergeTreeConfig, "type">) => import("./engines").AggregatingMergeTreeConfig;
+        CollapsingMergeTree: (signColumn: string, options?: Omit<import("./engines").CollapsingMergeTreeConfig, "type" | "signColumn">) => import("./engines").CollapsingMergeTreeConfig;
+        VersionedCollapsingMergeTree: (signColumn: string, versionColumn: string, options?: Omit<import("./engines").VersionedCollapsingMergeTreeConfig, "type" | "signColumn" | "versionColumn">) => import("./engines").VersionedCollapsingMergeTreeConfig;
+        GraphiteMergeTree: (configSection: string, options?: Omit<import("./engines").GraphiteMergeTreeConfig, "type" | "configSection">) => import("./engines").GraphiteMergeTreeConfig;
+        ReplicatedMergeTree: (config?: Omit<import("./engines").ReplicatedMergeTreeConfig, "type">) => import("./engines").ReplicatedMergeTreeConfig;
+        Buffer: <T extends TableColumns>(targetTable: TableDefinition<T>, opts: {
+            minRows: number;
+            maxRows: number;
+            layers?: number;
+            minTime?: number;
+            maxTime?: number;
+            minBytes?: number;
+            maxBytes?: number;
+        }) => import("./engines").BufferConfig;
+        BufferExplicit: (config: Omit<import("./engines").BufferConfig, "type">) => import("./engines").BufferConfig;
+        Distributed: (config: Omit<import("./engines").DistributedConfig, "type">) => import("./engines").DistributedConfig;
+        Null: () => import("./engines").NullConfig;
+        Log: () => import("./engines").LogConfig;
+        TinyLog: () => import("./engines").TinyLogConfig;
+        Memory: (config?: Omit<import("./engines").MemoryConfig, "type">) => import("./engines").MemoryConfig;
+        Join: (strictness: import("./engines").JoinConfig["strictness"], joinType: import("./engines").JoinConfig["joinType"], keys: string[]) => import("./engines").JoinConfig;
+        Dictionary: (dictionaryName: string) => import("./engines").DictionaryConfig;
+        File: (format: string, compression?: import("./engines").FileConfig["compression"]) => import("./engines").FileConfig;
+        URL: (url: string, format: string, compression?: import("./engines").URLConfig["compression"]) => import("./engines").URLConfig;
+        S3: (config: Omit<import("./engines").S3Config, "type">) => import("./engines").S3Config;
+        Kafka: (config: Omit<import("./engines").KafkaConfig, "type">) => import("./engines").KafkaConfig;
+        PostgreSQL: (config: Omit<import("./engines").PostgreSQLConfig, "type">) => import("./engines").PostgreSQLConfig;
+        MySQL: (config: Omit<import("./engines").MySQLConfig, "type">) => import("./engines").MySQLConfig;
+    };
+    sql: typeof sql;
+    index: (name: string) => {
+        on: (...cols: import("./column").ClickHouseColumn[]) => {
+            type: (type: import("./table").IndexDefinition["type"], granularity?: number) => import("./table").IndexDefinition;
+        };
+    };
+    projection: (name: string, query: string) => import("./table").ProjectionDefinition;
+    deriveTable: typeof deriveTable;
+    detectMaterializedViewDrift: typeof detectMaterializedViewDrift;
+    extractMVQuery: typeof extractMVQuery;
+    createMigrationBridge: typeof createMigrationBridge;
+    generateBlueGreenMigration: typeof generateBlueGreenMigration;
+    generateSelectSchema: typeof generateSelectSchema;
+    generateInsertSchema: typeof generateInsertSchema;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,222 @@
+// src/index.ts
+import { resolve, join } from "path";
+import { existsSync, readdirSync } from "fs";
+import { createClientFromConfigObject } from "./client";
+import { ClickHouseColumn } from "./column";
+import {
+  index,
+  projection,
+  deriveTable,
+  renderSchema
+} from "./table";
+import { Engine } from "./engines";
+
+export * from "./external";
+export * from "./expressions";
+export * from "./builders/select";
+export * from "./builders/select.types";
+export * from "./builders/insert";
+export * from "./builders/delete";
+export * from "./builders/update";
+export * from "./metadata";
+export * from "./compiler";
+export * from "./modules";
+export * from "./relational";
+export * from "./logger";
+export * from "./client";
+import {
+  t,
+  defineTable,
+  table,
+  view,
+  defineView,
+  materializedView,
+  defineMaterializedView,
+  dictionary,
+  defineDictionary,
+  defineProjection,
+  detectMaterializedViewDrift,
+  extractMVQuery,
+  createMigrationBridge,
+  generateBlueGreenMigration,
+  relations
+} from "./schema-builder";
+import { sql } from "./expressions";
+import { generateSelectSchema, generateInsertSchema } from "./codegen/zod";
+import {
+  BinaryWriter,
+  createBinaryEncoder,
+  serializeRowBinary,
+  serializeRowsBinary,
+  buildBinaryConfig
+} from "./utils/binary-serializer";
+import {
+  SyncBinarySerializer,
+  BinaryWorkerPool
+} from "./utils/binary-worker-pool";
+import {
+  t as t2,
+  defineTable as defineTable2,
+  table as table2,
+  view as view2,
+  defineView as defineView2,
+  materializedView as materializedView2,
+  defineMaterializedView as defineMaterializedView2,
+  dictionary as dictionary2,
+  defineDictionary as defineDictionary2,
+  defineProjection as defineProjection2,
+  detectMaterializedViewDrift as detectMaterializedViewDrift2,
+  extractMVQuery as extractMVQuery2,
+  createMigrationBridge as createMigrationBridge2,
+  generateBlueGreenMigration as generateBlueGreenMigration2,
+  relations as relations2
+} from "./schema-builder";
+import { sql as sql2 } from "./expressions";
+import { Engine as Engine2 } from "./engines";
+import { index as index2, projection as projection2, deriveTable as deriveTable2 } from "./table";
+import { generateSelectSchema as generateSelectSchema2, generateInsertSchema as generateInsertSchema2 } from "./codegen/zod";
+async function createClientFromConfig(databaseName = "default") {
+  const config = await loadConfig();
+  const dbConfig = config.databases[databaseName];
+  if (!dbConfig) {
+    throw new Error(`Database "${databaseName}" not found in housekit.config.js. Available databases: ${Object.keys(config.databases).join(", ")}`);
+  }
+  const clientConfig = {
+    url: dbConfig.url || (dbConfig.host ? `http://${dbConfig.host}${dbConfig.port ? `:${dbConfig.port}` : ""}` : "http://localhost:8123"),
+    database: dbConfig.database,
+    username: dbConfig.username || "default",
+    password: dbConfig.password || ""
+  };
+  return createClientFromConfigObject(clientConfig);
+}
+async function loadConfig() {
+  const root = process.cwd();
+  const extensions = ["ts", "js", "mjs", "cjs"];
+  function findConfigFile(dir, depth = 0) {
+    if (depth > 10)
+      return null;
+    if (dir.includes("node_modules") || dir.includes(".git"))
+      return null;
+    for (const ext of extensions) {
+      const configPath2 = join(dir, `housekit.config.${ext}`);
+      if (existsSync(configPath2)) {
+        return configPath2;
+      }
+    }
+    if (depth < 3) {
+      try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+            const found = findConfigFile(join(dir, entry.name), depth + 1);
+            if (found)
+              return found;
+          }
+        }
+      } catch {}
+    }
+    return null;
+  }
+  const configPath = findConfigFile(root);
+  if (configPath) {
+    const module = await import(resolve(configPath));
+    return module.default;
+  }
+  throw new Error("housekit.config.{ts,js,mjs,cjs} not found in workspace.");
+}
+function createClient(configOrName) {
+  if (configOrName === undefined) {
+    return createClientFromConfig("default");
+  }
+  if (typeof configOrName === "string") {
+    return createClientFromConfig(configOrName);
+  }
+  return createClientFromConfigObject(configOrName);
+}
+async function tableExists(client2, tableName) {
+  return client2.tableExists(tableName);
+}
+async function ensureTable(client2, table3) {
+  return client2.ensureTable(table3);
+}
+async function dropTable(client2, tableName, options) {
+  return client2.dropTable(tableName, options);
+}
+function createClients(configs) {
+  const clients = {};
+  for (const [name, config] of Object.entries(configs)) {
+    clients[name] = createClientFromConfigObject(config);
+  }
+  return clients;
+}
+async function closeAllClients(clients) {
+  await Promise.all(Object.values(clients).map((client2) => client2.close()));
+}
+var src_default = {
+  t: t2,
+  table: table2,
+  defineTable: defineTable2,
+  view: view2,
+  defineView: defineView2,
+  materializedView: materializedView2,
+  defineMaterializedView: defineMaterializedView2,
+  dictionary: dictionary2,
+  defineDictionary: defineDictionary2,
+  defineProjection: defineProjection2,
+  relations: relations2,
+  createClient,
+  createClients,
+  closeAllClients,
+  Engine: Engine2,
+  sql: sql2,
+  index: index2,
+  projection: projection2,
+  deriveTable: deriveTable2,
+  detectMaterializedViewDrift: detectMaterializedViewDrift2,
+  extractMVQuery: extractMVQuery2,
+  createMigrationBridge: createMigrationBridge2,
+  generateBlueGreenMigration: generateBlueGreenMigration2,
+  generateSelectSchema: generateSelectSchema2,
+  generateInsertSchema: generateInsertSchema2
+};
+export {
+  view,
+  tableExists,
+  table,
+  t,
+  sql,
+  serializeRowsBinary,
+  serializeRowBinary,
+  renderSchema,
+  relations,
+  projection,
+  materializedView,
+  index,
+  generateSelectSchema,
+  generateInsertSchema,
+  generateBlueGreenMigration,
+  extractMVQuery,
+  ensureTable,
+  dropTable,
+  dictionary,
+  detectMaterializedViewDrift,
+  deriveTable,
+  defineView,
+  defineTable,
+  defineProjection,
+  defineMaterializedView,
+  defineDictionary,
+  src_default as default,
+  createMigrationBridge,
+  createClients,
+  createClientFromConfig,
+  createClient,
+  createBinaryEncoder,
+  closeAllClients,
+  buildBinaryConfig,
+  SyncBinarySerializer,
+  Engine,
+  ClickHouseColumn,
+  BinaryWriter,
+  BinaryWorkerPool
+};

package/dist/logger.d.ts

@@ -0,0 +1,8 @@
+export interface HousekitLogger {
+    logQuery(query: string, params: any, durationMs: number, stats?: {
+        readRows: number;
+        readBytes: number;
+    }): void;
+    logError(error: Error, query: string): void;
+}
+export declare function wrapClientWithLogger(client: any, logger?: HousekitLogger): any;