@housekit/orm 0.1.17 → 0.1.21

package/dist/index.js

@@ -192,8 +192,8 @@ class BinaryReader {
     return new Date(Number(ms));
   }
   readNullable(reader) {
-    const isNull = this.readUInt8();
-    if (isNull === 1)
+    const isNull2 = this.readUInt8();
+    if (isNull2 === 1)
       return null;
     return reader();
   }
@@ -2157,6 +2157,144 @@ function generateRandom(structure, randomSeed, maxStringLength = 10, maxArrayLen
   };
 }
 
+// src/modules/conditional.ts
+function ifNull(col, alt) {
+  return sql`ifNull(${col}, ${alt})`;
+}
+function sqlIf(condition, trueVal, falseVal) {
+  return sql`if(${condition}, ${trueVal}, ${falseVal})`;
+}
+function multiIf(...args) {
+  if (args.length < 3) {
+    throw new Error("multiIf requires at least 3 arguments: condition, value, default");
+  }
+  if (args.length % 2 === 0) {
+    throw new Error("multiIf requires an odd number of arguments: condition-value pairs plus a default value");
+  }
+  const params = args.map((arg) => sql`${arg}`).join(", ");
+  return sql`multiIf(${params})`;
+}
+function caseWhen() {
+  return new CaseWhenBuilder;
+}
+
+class CaseWhenBuilder {
+  conditions = [];
+  values = [];
+  defaultValue;
+  when(condition, value) {
+    this.conditions.push(condition);
+    this.values.push(value);
+    return this;
+  }
+  otherwise(value) {
+    this.defaultValue = value;
+    return this.build();
+  }
+  build() {
+    if (!this.defaultValue) {
+      throw new Error("CaseWhenBuilder requires a default value via .otherwise()");
+    }
+    const args = [];
+    for (let i = 0;i < this.conditions.length; i++) {
+      args.push(this.conditions[i]);
+      args.push(this.values[i]);
+    }
+    args.push(this.defaultValue);
+    return multiIf(...args);
+  }
+}
+function coalesce(...args) {
+  const chunks = ["coalesce("];
+  const params = [];
+  args.forEach((arg, i) => {
+    params.push(arg);
+    if (i < args.length - 1) {
+      chunks.push(", ");
+    }
+  });
+  chunks.push(")");
+  return new SQL(chunks, params);
+}
+function greatest(...args) {
+  const chunks = ["greatest("];
+  const params = [];
+  args.forEach((arg, i) => {
+    params.push(arg);
+    if (i < args.length - 1) {
+      chunks.push(", ");
+    }
+  });
+  chunks.push(")");
+  return new SQL(chunks, params);
+}
+function least(...args) {
+  const chunks = ["least("];
+  const params = [];
+  args.forEach((arg, i) => {
+    params.push(arg);
+    if (i < args.length - 1) {
+      chunks.push(", ");
+    }
+  });
+  chunks.push(")");
+  return new SQL(chunks, params);
+}
+function isNull(col) {
+  return sql`${col} IS NULL`;
+}
+function isNotNull(col) {
+  return sql`${col} IS NOT NULL`;
+}
+function nullIf(condition, col) {
+  return sql`nullIf(${col}, ${condition})`;
+}
+function nullIfEqual(col, value) {
+  return sql`nullIf(${col}, ${value})`;
+}
+function not(expr) {
+  return sql`NOT (${expr})`;
+}
+function and(...exprs) {
+  const filtered = exprs.filter((e) => !!e);
+  if (filtered.length === 0)
+    return;
+  if (filtered.length === 1)
+    return filtered[0];
+  const finalChunks = ["("];
+  const finalParams = [];
+  filtered.forEach((e, i) => {
+    finalParams.push(e);
+    if (i < filtered.length - 1) {
+      finalChunks.push(") AND (");
+    } else {
+      finalChunks.push(")");
+    }
+  });
+  return new SQL(finalChunks, finalParams);
+}
+function or(...exprs) {
+  const filtered = exprs.filter((e) => !!e);
+  if (filtered.length === 0)
+    return;
+  if (filtered.length === 1)
+    return filtered[0];
+  const finalChunks = ["("];
+  const finalParams = [];
+  filtered.forEach((e, i) => {
+    finalParams.push(e);
+    if (i < filtered.length - 1) {
+      finalChunks.push(") OR (");
+    } else {
+      finalChunks.push(")");
+    }
+  });
+  return new SQL(finalChunks, finalParams);
+}
+function xor(expr1, expr2) {
+  return sql`xor(${expr1}, ${expr2})`;
+}
+
 // src/utils/lru-cache.ts
 class LRUCache {
   map = new Map;
@@ -2731,6 +2869,7 @@ class QueryCompiler {
 class ClickHouseQueryBuilder {
   client;
   _select = null;
+  _selectResolver = null;
   _table = null;
   _prewhere = null;
   _sample = null;
@@ -2753,7 +2892,17 @@ class ClickHouseQueryBuilder {
   }
   select(fields) {
     if (fields) {
+      if (typeof fields === "function") {
+        if (!this._table) {
+          this._selectResolver = fields;
+          return this;
+        }
+        this._select = fields(this._table.$columns);
+        this._selectResolver = null;
+        return this;
+      }
       this._select = fields;
+      this._selectResolver = null;
       return this;
     }
     return this;
@@ -2767,16 +2916,48 @@ class ClickHouseQueryBuilder {
     if (defaultFinal !== undefined) {
       this._final = Boolean(defaultFinal);
     }
+    this.resolveSelect();
     return this;
   }
   fromSubquery(subquery, alias) {
     this._table = this.createSubqueryTable(alias, subquery);
     this._final = false;
+    this.resolveSelect();
     return this;
   }
+  resolveSelect() {
+    if (!this._selectResolver)
+      return;
+    if (!this._table) {
+      throw new Error("Call .from() before using callback select");
+    }
+    this._select = this._selectResolver(this._table.$columns);
+    this._selectResolver = null;
+  }
   where(expression) {
-    if (expression) {
+    if (!expression)
+      return this;
+    if (typeof expression === "object" && "toSQL" in expression) {
       this._where = expression;
+      return this;
+    }
+    if (typeof expression === "object") {
+      const table = this._table;
+      if (!table)
+        return this;
+      const chunks = [];
+      const columns = table.$columns || table;
+      for (const [key, value] of Object.entries(expression)) {
+        const column = table[key] || columns?.[key];
+        if (column) {
+          chunks.push(eq(column, value));
+        }
+      }
+      if (chunks.length > 0) {
+        const combined = chunks.length === 1 ? chunks[0] : and(...chunks);
+        if (combined)
+          this._where = combined;
+      }
     }
     return this;
   }
@@ -3012,6 +3193,7 @@ class ClickHouseQueryBuilder {
     return buildTable(alias);
   }
   getState() {
+    this.resolveSelect();
     return {
       select: this._select,
       table: this._table,
@@ -3728,8 +3910,8 @@ class BinaryWriter {
     const ticks = typeof value === "number" ? BigInt(Math.round(value * multiplier)) : BigInt(Math.round(value.getTime() * multiplier / 1000));
     this.writeInt64(ticks);
   }
-  writeNullable(isNull) {
-    this.writeUInt8(isNull ? 1 : 0);
+  writeNullable(isNull2) {
+    this.writeUInt8(isNull2 ? 1 : 0);
   }
   writeArrayLength(length) {
     this.writeUInt64(length);
@@ -4329,7 +4511,7 @@ var globalBatcher = (client) => {
 };
 
 // src/builders/insert.ts
-import { v4 as uuidv42, v7 as uuidv7 } from "uuid";
+import { v1 as uuidv1, v4 as uuidv42, v6 as uuidv6, v7 as uuidv7 } from "uuid";
 
 class BinaryTransform extends Transform2 {
   serializer;
@@ -4379,6 +4561,7 @@ class ClickHouseInsertBuilder {
   _batchSize = 1000;
   _batchConfig = null;
   _forceJson = false;
+  _returning = false;
   constructor(client, table) {
     this.client = client;
     this.table = table;
@@ -4394,6 +4577,13 @@ class ClickHouseInsertBuilder {
     this._values = value;
     return this;
   }
+  async insert(data) {
+    return this.values(data);
+  }
+  returning() {
+    this._returning = true;
+    return this;
+  }
   syncInsert() {
     this._async = false;
     return this;
@@ -4459,6 +4649,23 @@ class ClickHouseInsertBuilder {
       throw new Error("❌ No values to insert");
     }
     const plan = buildInsertPlan(this.table);
+    if (this._returning) {
+      if (this._batchConfig) {
+        throw new Error("❌ returning() cannot be used with background batching");
+      }
+      const { processedRows, resultRows } = await this.collectReturningRows(plan);
+      const stream = Readable.from(processedRows, { objectMode: true });
+      await this.client.insert({
+        table: this.table.$table,
+        values: stream,
+        format: "JSONEachRow",
+        clickhouse_settings: {
+          async_insert: this._async ? 1 : 0,
+          wait_for_async_insert: this._waitForAsync ? 1 : 0
+        }
+      });
+      return resultRows;
+    }
     if (this._batchConfig && !this._forceJson) {
       const batcher = globalBatcher(this.client);
       const rowIterator = this.processRows(plan);
@@ -4474,6 +4681,7 @@ class ClickHouseInsertBuilder {
     } else {
       await this.executeJsonInsert(plan, tableName, format);
     }
+    return;
   }
   resolveFormat(plan) {
     if (this._format !== "auto") {
@@ -4566,13 +4774,73 @@ class ClickHouseInsertBuilder {
       yield processedRow;
     }
   }
+  async collectReturningRows(plan) {
+    const processedRows = [];
+    const resultRows = [];
+    const values2 = this._values;
+    const iterable = values2 instanceof Readable ? values2 : Array.isArray(values2) ? values2 : isIterable(values2) ? values2 : isAsyncIterable(values2) ? values2 : [values2];
+    for await (const row of iterable) {
+      const processed = processRowWithPlan(row, plan, "json");
+      for (const col of plan.columns) {
+        if (processed[col.columnName] !== undefined)
+          continue;
+        const expr = col.column.meta?.defaultExpr;
+        if (!expr)
+          continue;
+        const resolved = this.resolveClientDefaultExpr(expr);
+        if (resolved !== undefined) {
+          processed[col.columnName] = col.transform(resolved);
+        }
+      }
+      this.assertReturningRow(row, processed, plan);
+      processedRows.push(processed);
+      const resultRow = {};
+      for (const col of plan.columns) {
+        const value = processed[col.columnName];
+        resultRow[col.propKey] = value;
+      }
+      resultRows.push(resultRow);
+    }
+    return { processedRows, resultRows };
+  }
+  assertReturningRow(rawRow, processed, plan) {
+    for (const col of plan.columns) {
+      const hasValue = rawRow[col.propKey] !== undefined || rawRow[col.columnName] !== undefined;
+      if (hasValue)
+        continue;
+      if (processed[col.columnName] !== undefined) {
+        continue;
+      }
+      if (col.defaultFn || col.autoUUIDVersion !== null && !col.useServerUUID || col.hasDefault) {
+        continue;
+      }
+      if (col.useServerUUID || col.column.meta?.defaultExpr) {
+        throw new Error(`❌ returning() cannot infer column '${col.columnName}' because it uses a server-side default. Provide a value or remove the default expression.`);
+      }
+    }
+  }
+  resolveClientDefaultExpr(expr) {
+    const normalized = expr.replace(/\s+/g, "").toLowerCase();
+    if (normalized === "now()" || normalized === "now64()" || normalized.startsWith("now64(")) {
+      return new Date;
+    }
+    if (normalized === "generateuuidv4()")
+      return uuidv42();
+    if (normalized === "generateuuidv7()")
+      return uuidv7();
+    if (normalized === "generateuuidv1()")
+      return uuidv1();
+    if (normalized === "generateuuidv6()")
+      return uuidv6();
+    return;
+  }
   async then(onfulfilled, onrejected) {
     try {
-      await this.execute();
+      const result = await this.execute();
       if (onfulfilled) {
-        return Promise.resolve(onfulfilled());
+        return Promise.resolve(onfulfilled(result));
       }
-      return Promise.resolve();
+      return Promise.resolve(result);
     } catch (error) {
       if (onrejected) {
         return Promise.resolve(onrejected(error));
@@ -4833,159 +5101,21 @@ function wrapClientWithLogger(client, logger) {
   return wrapped;
 }
 
-// src/modules/conditional.ts
-function ifNull(col, alt) {
-  return sql`ifNull(${col}, ${alt})`;
-}
-function sqlIf(condition, trueVal, falseVal) {
-  return sql`if(${condition}, ${trueVal}, ${falseVal})`;
-}
-function multiIf(...args) {
-  if (args.length < 3) {
-    throw new Error("multiIf requires at least 3 arguments: condition, value, default");
-  }
-  if (args.length % 2 === 0) {
-    throw new Error("multiIf requires an odd number of arguments: condition-value pairs plus a default value");
-  }
-  const params = args.map((arg) => sql`${arg}`).join(", ");
-  return sql`multiIf(${params})`;
-}
-function caseWhen() {
-  return new CaseWhenBuilder;
+// src/relational.ts
+function buildJoinCondition(fields, references) {
+  if (!fields || !references || fields.length === 0 || references.length === 0)
+    return null;
+  const pairs = fields.map((f, i) => sql`${f} = ${references[i]}`);
+  const filtered = pairs.filter((p) => Boolean(p));
+  if (filtered.length === 0)
+    return null;
+  if (filtered.length === 1)
+    return filtered[0];
+  return and(...filtered) || null;
 }
-
-class CaseWhenBuilder {
-  conditions = [];
-  values = [];
-  defaultValue;
-  when(condition, value) {
-    this.conditions.push(condition);
-    this.values.push(value);
-    return this;
-  }
-  otherwise(value) {
-    this.defaultValue = value;
-    return this.build();
-  }
-  build() {
-    if (!this.defaultValue) {
-      throw new Error("CaseWhenBuilder requires a default value via .otherwise()");
-    }
-    const args = [];
-    for (let i = 0;i < this.conditions.length; i++) {
-      args.push(this.conditions[i]);
-      args.push(this.values[i]);
-    }
-    args.push(this.defaultValue);
-    return multiIf(...args);
-  }
-}
-function coalesce(...args) {
-  const chunks = ["coalesce("];
-  const params = [];
-  args.forEach((arg, i) => {
-    params.push(arg);
-    if (i < args.length - 1) {
-      chunks.push(", ");
-    }
-  });
-  chunks.push(")");
-  return new SQL(chunks, params);
-}
-function greatest(...args) {
-  const chunks = ["greatest("];
-  const params = [];
-  args.forEach((arg, i) => {
-    params.push(arg);
-    if (i < args.length - 1) {
-      chunks.push(", ");
-    }
-  });
-  chunks.push(")");
-  return new SQL(chunks, params);
-}
-function least(...args) {
-  const chunks = ["least("];
-  const params = [];
-  args.forEach((arg, i) => {
-    params.push(arg);
-    if (i < args.length - 1) {
-      chunks.push(", ");
-    }
-  });
-  chunks.push(")");
-  return new SQL(chunks, params);
-}
-function isNull(col) {
-  return sql`${col} IS NULL`;
-}
-function isNotNull(col) {
-  return sql`${col} IS NOT NULL`;
-}
-function nullIf(condition, col) {
-  return sql`nullIf(${col}, ${condition})`;
-}
-function nullIfEqual(col, value) {
-  return sql`nullIf(${col}, ${value})`;
-}
-function not(expr) {
-  return sql`NOT (${expr})`;
-}
-function and(...exprs) {
-  const filtered = exprs.filter((e) => !!e);
-  if (filtered.length === 0)
-    return;
-  if (filtered.length === 1)
-    return filtered[0];
-  const finalChunks = ["("];
-  const finalParams = [];
-  filtered.forEach((e, i) => {
-    finalParams.push(e);
-    if (i < filtered.length - 1) {
-      finalChunks.push(") AND (");
-    } else {
-      finalChunks.push(")");
-    }
-  });
-  return new SQL(finalChunks, finalParams);
-}
-function or(...exprs) {
-  const filtered = exprs.filter((e) => !!e);
-  if (filtered.length === 0)
-    return;
-  if (filtered.length === 1)
-    return filtered[0];
-  const finalChunks = ["("];
-  const finalParams = [];
-  filtered.forEach((e, i) => {
-    finalParams.push(e);
-    if (i < filtered.length - 1) {
-      finalChunks.push(") OR (");
-    } else {
-      finalChunks.push(")");
-    }
-  });
-  return new SQL(finalChunks, finalParams);
-}
-function xor(expr1, expr2) {
-  return sql`xor(${expr1}, ${expr2})`;
-}
-
-// src/relational.ts
-function buildJoinCondition(fields, references) {
-  if (!fields || !references || fields.length === 0 || references.length === 0)
-    return null;
-  const pairs = fields.map((f, i) => sql`${f} = ${references[i]}`);
-  const filtered = pairs.filter((p) => Boolean(p));
-  if (filtered.length === 0)
-    return null;
-  if (filtered.length === 1)
-    return filtered[0];
-  return and(...filtered) || null;
-}
-function isDistributedTable(tableDef) {
-  const options = tableDef.$options;
-  return !!(options?.onCluster || options?.shardKey);
+function isDistributedTable(tableDef) {
+  const options = tableDef.$options;
+  return !!(options?.onCluster || options?.shardKey);
 }
 function buildRelationalAPI(client, schema) {
   if (!schema)
@@ -5207,7 +5337,7 @@ function createHousekitClient(config) {
       const builder = new ClickHouseQueryBuilder(client);
       if (!fieldsOrTable)
         return builder.select();
-      if (typeof fieldsOrTable === "object" && fieldsOrTable !== null && "$table" in fieldsOrTable && "$columns" in fieldsOrTable) {
+      if (typeof fieldsOrTable === "object" && fieldsOrTable !== null && "$table" in fieldsOrTable) {
         return builder.select().from(fieldsOrTable);
       }
       return builder.select(fieldsOrTable);
@@ -5260,6 +5390,105 @@ function createHousekitClient(config) {
   return baseClient;
 }
 var createClientFromConfigObject = createHousekitClient;
+
+// src/codegen/zod.ts
+import { z } from "zod";
+function mapClickHouseTypeToZod(column) {
+  const type = column.type.toLowerCase();
+  let zodType;
+  if (type.startsWith("nullable(")) {
+    const innerType = column.type.slice("nullable(".length, -1);
+    const innerColumn = new ClickHouseColumn(column.name, innerType);
+    zodType = mapClickHouseTypeToZod(innerColumn).nullable();
+  } else if (type.startsWith("array(")) {
+    const innerType = column.type.slice("array(".length, -1);
+    const innerColumn = new ClickHouseColumn(column.name, innerType);
+    zodType = z.array(mapClickHouseTypeToZod(innerColumn));
+  } else if (type.startsWith("fixedstring")) {
+    zodType = z.string();
+  } else if (type.startsWith("enum")) {
+    if (column.meta?.enumValues) {
+      zodType = z.enum(column.meta.enumValues);
+    } else {
+      zodType = z.string();
+    }
+  } else if (type.startsWith("datetime64")) {
+    zodType = z.date();
+  } else if (type.startsWith("decimal")) {
+    zodType = z.string().refine((val) => !isNaN(parseFloat(val)), {
+      message: "Must be a valid decimal number string"
+    });
+  } else {
+    switch (type) {
+      case "uuid":
+      case "string":
+      case "json":
+      case "ipv4":
+      case "ipv6":
+        zodType = z.string();
+        break;
+      case "int8":
+      case "uint8":
+      case "int16":
+      case "uint16":
+      case "int32":
+      case "uint32":
+      case "float32":
+      case "float64":
+        zodType = z.number();
+        break;
+      case "int64":
+      case "uint64":
+      case "int128":
+      case "uint128":
+      case "int256":
+      case "uint256":
+        zodType = z.bigint();
+        break;
+      case "boolean":
+      case "bool":
+        zodType = z.boolean();
+        break;
+      case "date":
+      case "datetime":
+        zodType = z.date();
+        break;
+      default:
+        zodType = z.string();
+        break;
+    }
+  }
+  if (column.isNull && !type.startsWith("nullable(")) {
+    zodType = zodType.nullable();
+  }
+  return zodType;
+}
+function generateSelectSchema(table) {
+  const shape = {};
+  for (const key in table.$columns) {
+    if (Object.prototype.hasOwnProperty.call(table.$columns, key)) {
+      const column = table.$columns[key];
+      shape[key] = mapClickHouseTypeToZod(column);
+    }
+  }
+  return z.object(shape);
+}
+function generateInsertSchema(table) {
+  const shape = {};
+  for (const key in table.$columns) {
+    if (Object.prototype.hasOwnProperty.call(table.$columns, key)) {
+      const column = table.$columns[key];
+      let zodType = mapClickHouseTypeToZod(column);
+      const isOptionalBySchema = !column.isNull && (column.meta?.default !== undefined || column.meta?.defaultFn !== undefined || column.meta?.defaultExpr !== undefined || column.meta?.autoGenerate !== undefined);
+      const isOptionalByNullable = column.isNull;
+      if (isOptionalBySchema || isOptionalByNullable) {
+        zodType = zodType.optional();
+      } else {}
+      shape[key] = zodType;
+    }
+  }
+  return z.object(shape);
+}
 // src/modules/array.ts
 function arrayJoin(separator, col) {
   if (col) {
@@ -6266,7 +6495,21 @@ var t = {
   ring: (name) => new ClickHouseColumn(name, "Ring"),
   polygon: (name) => new ClickHouseColumn(name, "Polygon"),
   multiPolygon: (name) => new ClickHouseColumn(name, "MultiPolygon"),
-  enum: (name, values2) => new ClickHouseColumn(name, "String", true, { enumValues: values2 })
+  enum: (name, values2) => new ClickHouseColumn(name, "String", true, { enumValues: values2 }),
+  timestamps: () => ({
+    created_at: new ClickHouseColumn("created_at", "DateTime").default("now()"),
+    updated_at: new ClickHouseColumn("updated_at", "DateTime").default("now()")
+  }),
+  primaryUuid: (name) => {
+    const colName = name ?? "id";
+    return {
+      [colName]: new ClickHouseColumn(colName, "UUID").autoGenerate().primaryKey().default("generateUUIDv4()")
+    };
+  },
+  softDeletes: () => ({
+    is_deleted: new ClickHouseColumn("is_deleted", "Bool").default(false),
+    deleted_at: new ClickHouseColumn("deleted_at", "DateTime").nullable()
+  })
 };
 function defineTable(tableName, columnsOrCallback, options) {
   const columns = typeof columnsOrCallback === "function" ? columnsOrCallback(t) : columnsOrCallback;
@@ -6303,104 +6546,6 @@ function relations(table2, relationsBuilder) {
   table2.$relations = rels;
   return rels;
 }
-// src/codegen/zod.ts
-import { z } from "zod";
-function mapClickHouseTypeToZod(column) {
-  const type = column.type.toLowerCase();
-  let zodType;
-  if (type.startsWith("nullable(")) {
-    const innerType = column.type.slice("nullable(".length, -1);
-    const innerColumn = new ClickHouseColumn(column.name, innerType);
-    zodType = mapClickHouseTypeToZod(innerColumn).nullable();
-  } else if (type.startsWith("array(")) {
-    const innerType = column.type.slice("array(".length, -1);
-    const innerColumn = new ClickHouseColumn(column.name, innerType);
-    zodType = z.array(mapClickHouseTypeToZod(innerColumn));
-  } else if (type.startsWith("fixedstring")) {
-    zodType = z.string();
-  } else if (type.startsWith("enum")) {
-    if (column.meta?.enumValues) {
-      zodType = z.enum(column.meta.enumValues);
-    } else {
-      zodType = z.string();
-    }
-  } else if (type.startsWith("datetime64")) {
-    zodType = z.date();
-  } else if (type.startsWith("decimal")) {
-    zodType = z.string().refine((val) => !isNaN(parseFloat(val)), {
-      message: "Must be a valid decimal number string"
-    });
-  } else {
-    switch (type) {
-      case "uuid":
-      case "string":
-      case "json":
-      case "ipv4":
-      case "ipv6":
-        zodType = z.string();
-        break;
-      case "int8":
-      case "uint8":
-      case "int16":
-      case "uint16":
-      case "int32":
-      case "uint32":
-      case "float32":
-      case "float64":
-        zodType = z.number();
-        break;
-      case "int64":
-      case "uint64":
-      case "int128":
-      case "uint128":
-      case "int256":
-      case "uint256":
-        zodType = z.bigint();
-        break;
-      case "boolean":
-      case "bool":
-        zodType = z.boolean();
-        break;
-      case "date":
-      case "datetime":
-        zodType = z.date();
-        break;
-      default:
-        zodType = z.string();
-        break;
-    }
-  }
-  if (column.isNull && !type.startsWith("nullable(")) {
-    zodType = zodType.nullable();
-  }
-  return zodType;
-}
-function generateSelectSchema(table2) {
-  const shape = {};
-  for (const key in table2.$columns) {
-    if (Object.prototype.hasOwnProperty.call(table2.$columns, key)) {
-      const column = table2.$columns[key];
-      shape[key] = mapClickHouseTypeToZod(column);
-    }
-  }
-  return z.object(shape);
-}
-function generateInsertSchema(table2) {
-  const shape = {};
-  for (const key in table2.$columns) {
-    if (Object.prototype.hasOwnProperty.call(table2.$columns, key)) {
-      const column = table2.$columns[key];
-      let zodType = mapClickHouseTypeToZod(column);
-      const isOptionalBySchema = !column.isNull && (column.meta?.default !== undefined || column.meta?.defaultFn !== undefined || column.meta?.defaultExpr !== undefined || column.meta?.autoGenerate !== undefined);
-      const isOptionalByNullable = column.isNull;
-      if (isOptionalBySchema || isOptionalByNullable) {
-        zodType = zodType.optional();
-      } else {}
-      shape[key] = zodType;
-    }
-  }
-  return z.object(shape);
-}
 // src/index.ts
 async function createClientFromConfig(databaseName = "default") {
   const config = await loadConfig();
@@ -6416,6 +6561,18 @@ async function createClientFromConfig(databaseName = "default") {
   };
   return createClientFromConfigObject(clientConfig);
 }
+function housekit(config, options) {
+  return createHousekitClient({
+    ...config,
+    schema: options?.schema
+  });
+}
+function createSchema(table2) {
+  return {
+    select: generateSelectSchema(table2),
+    insert: generateInsertSchema(table2)
+  };
+}
 async function loadConfig() {
   const root = process.cwd();
   const extensions = ["ts", "js", "mjs", "cjs"];
@@ -6725,6 +6882,7 @@ export {
   htmlEscape,
   housekitMetadataSchemas,
   housekitMetadataDefaults,
+  housekit,
   hdfs,
   hasAny,
   hasAll,
@@ -6794,6 +6952,7 @@ export {
   dateDiff,
   dateAdd,
   createdAt,
+  createSchema,
   createMigrationBridge,
   createHousekitClient,
   createClients,