pqb 0.7.13 → 0.8.1

package/dist/index.esm.js

@@ -1,167 +1,76 @@
 import { types, Pool, DatabaseError } from 'pg';
 
-var __defProp$q = Object.defineProperty;
-var __defProps$k = Object.defineProperties;
-var __getOwnPropDescs$k = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$r = Object.getOwnPropertySymbols;
-var __hasOwnProp$r = Object.prototype.hasOwnProperty;
-var __propIsEnum$r = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$q = (obj, key, value) => key in obj ? __defProp$q(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$q = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$r.call(b, prop))
-      __defNormalProp$q(a, prop, b[prop]);
-  if (__getOwnPropSymbols$r)
-    for (var prop of __getOwnPropSymbols$r(b)) {
-      if (__propIsEnum$r.call(b, prop))
-        __defNormalProp$q(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$k = (a, b) => __defProps$k(a, __getOwnPropDescs$k(b));
-const addColumnData = (q, key, value) => {
-  const cloned = Object.create(q);
-  cloned.data = __spreadProps$k(__spreadValues$q({}, q.data), { [key]: value });
-  return cloned;
+const defaultsKey = Symbol("defaults");
+const queryTypeWithLimitOne = {
+  one: true,
+  oneOrThrow: true
 };
-class ColumnType {
-  constructor() {
-    this.data = {};
-    this.isPrimaryKey = false;
-    this.isHidden = false;
-    this.isNullable = false;
-    this.hasDefault = false;
-    this.chain = [];
+const isQueryReturnsAll = (q) => !q.query.returnType || q.query.returnType === "all";
+
+const raw = (sql, values) => ({
+  __raw: sql,
+  __values: values
+});
+const isRaw = (obj) => "__raw" in obj;
+const keys = [];
+const getRaw = (raw2, valuesArray) => {
+  if (raw2.__values === false) {
+    return raw2.__raw;
   }
-  primaryKey() {
-    return Object.assign(this, { isPrimaryKey: true });
+  const arr = raw2.__raw.split("'");
+  const values = raw2.__values || emptyObject;
+  const len = arr.length;
+  keys.length = 0;
+  for (let i = 0; i < len; i += 2) {
+    arr[i] = arr[i].replace(/\$(\w+)/g, (_, key) => {
+      const value = values[key];
+      if (value === void 0) {
+        throw new Error(`Query variable \`${key}\` is not provided`);
+      }
+      keys.push(key);
+      valuesArray.push(value);
+      return `$${valuesArray.length}`;
+    });
   }
-  foreignKey(fnOrTable, column, options = {}) {
-    const cloned = Object.create(this);
-    if (typeof fnOrTable === "string") {
-      cloned.data = __spreadProps$k(__spreadValues$q({}, this.data), {
-        foreignKey: __spreadValues$q({ table: fnOrTable, columns: [column] }, options)
-      });
-    } else {
-      cloned.data = __spreadProps$k(__spreadValues$q({}, this.data), {
-        foreignKey: __spreadValues$q({ fn: fnOrTable, columns: [column] }, options)
-      });
+  if (keys.length > 0 && keys.length < Object.keys(values).length) {
+    for (const key in values) {
+      if (!keys.includes(key)) {
+        throw new Error(`Query variable \`${key}\` is unused`);
+      }
     }
-    return cloned;
-  }
-  hidden() {
-    return Object.assign(this, { isHidden: true });
-  }
-  nullable() {
-    this.isNullable = true;
-    return this;
-  }
-  encode(fn) {
-    const self = this;
-    self.encodeFn = fn;
-    return self;
-  }
-  parse(fn) {
-    this.parseFn = fn;
-    this.parseItem = fn;
-    return this;
-  }
-  as(column) {
-    return addColumnData(this, "as", column);
-  }
-  toSQL() {
-    return this.dataType;
   }
-  default(value) {
-    return addColumnData(this, "default", value);
-  }
-  index(options = {}) {
-    return addColumnData(this, "index", options);
-  }
-  unique(options = {}) {
-    return addColumnData(this, "index", __spreadProps$k(__spreadValues$q({}, options), { unique: true }));
-  }
-  comment(comment) {
-    return addColumnData(this, "comment", comment);
-  }
-  validationDefault(value) {
-    return addColumnData(this, "validationDefault", value);
-  }
-  compression(compression) {
-    return addColumnData(this, "compression", compression);
-  }
-  collate(collate) {
-    return addColumnData(this, "collate", collate);
-  }
-  modifyQuery(cb) {
-    return addColumnData(this, "modifyQuery", cb);
-  }
-  transform(fn) {
-    const cloned = Object.create(this);
-    cloned.chain = [...this.chain, ["transform", fn]];
-    return cloned;
-  }
-  to(fn, type) {
-    const cloned = Object.create(type);
-    cloned.chain = [...this.chain, ["to", fn, type], ...cloned.chain];
-    return cloned;
-  }
-  refine(check) {
-    const cloned = Object.create(this);
-    cloned.chain = [...this.chain, ["refine", check]];
-    return cloned;
-  }
-  superRefine(check) {
-    const cloned = Object.create(this);
-    cloned.chain = [...this.chain, ["superRefine", check]];
-    return cloned;
-  }
-}
-
-const singleQuoteRegex = /'/g;
-const doubleQuoteRegex = /"/g;
-const quoteValue$1 = (value) => {
-  const type = typeof value;
-  if (type === "number")
-    return String(value);
-  else if (type === "string")
-    return `"${value.replace(doubleQuoteRegex, '\\"').replace(singleQuoteRegex, "''")}"`;
-  else if (type === "boolean")
-    return value ? "true" : "false";
-  else if (value instanceof Date)
-    return `"${value.toISOString()}"`;
-  else if (Array.isArray(value))
-    return quoteArray(value);
-  else if (type === null || type === void 0)
-    return "NULL";
-  else
-    return `"${JSON.stringify(value).replace(doubleQuoteRegex, '\\"').replace(singleQuoteRegex, "''")}"`;
+  return arr.join("'");
 };
-const quoteArray = (array) => `'{${array.map(quoteValue$1).join(",")}}'`;
-const quote = (value) => {
-  const type = typeof value;
-  if (type === "number")
-    return `${value}`;
-  else if (type === "string")
-    return `'${value.replace(singleQuoteRegex, "''")}'`;
-  else if (type === "boolean")
-    return value ? "true" : "false";
-  else if (value instanceof Date)
-    return `'${value.toISOString()}'`;
-  else if (Array.isArray(value))
-    return quoteArray(value);
-  else if (value === null || value === void 0)
-    return "NULL";
-  else
-    return `'${JSON.stringify(value).replace(singleQuoteRegex, "''")}'`;
+const getRawSql = (raw2) => {
+  return raw2.__raw;
+};
+const EMPTY_OBJECT = {};
+const getQueryParsers = (q) => {
+  return q.query.parsers || q.columnsParsers;
 };
 
-const defaultsKey = Symbol("defaults");
-const queryTypeWithLimitOne = {
-  one: true,
-  oneOrThrow: true
+const q = (sql) => `"${sql}"`;
+const qc = (column, quotedAs) => quotedAs ? `${quotedAs}.${q(column)}` : column;
+const quoteFullColumn = (fullColumn, quotedAs) => {
+  const index = fullColumn.indexOf(".");
+  if (index !== -1) {
+    return `${q(fullColumn.slice(0, index))}.${q(fullColumn.slice(index + 1))}`;
+  } else if (quotedAs) {
+    return `${quotedAs}.${q(fullColumn)}`;
+  } else {
+    return q(fullColumn);
+  }
+};
+const expressionToSql = (expr, values, quotedAs) => {
+  return typeof expr === "object" && isRaw(expr) ? getRaw(expr, values) : quoteFullColumn(expr, quotedAs);
+};
+const quoteSchemaAndTable = (schema, table) => {
+  return schema ? `${q(schema)}.${q(table)}` : q(table);
+};
+const addValue = (values, value) => {
+  values.push(value);
+  return `$${values.length}`;
 };
-const isQueryReturnsAll = (q) => !q.query.returnType || q.query.returnType === "all";
 
 const pushDistinctSql = (ctx, distinct, quotedAs) => {
   ctx.sql.push("DISTINCT");
@@ -221,24 +130,24 @@ const windowToSql = (window, values, quotedAs) => {
   }
 };
 
-const processJoinItem = (ctx, model, args, quotedAs) => {
+const processJoinItem = (ctx, table, args, quotedAs) => {
   let target;
   let conditions;
   const [first] = args;
   if (typeof first === "string") {
-    if (first in model.relations) {
+    if (first in table.relations) {
       const {
         key,
         query: toQuery,
         joinQuery
-      } = model.relations[first];
-      const jq = joinQuery(model, toQuery);
+      } = table.relations[first];
+      const jq = joinQuery(table, toQuery);
       const { query } = jq;
-      const table = typeof query.from === "string" ? query.from : jq.table;
-      target = quoteSchemaAndTable(query.schema, table);
+      const tableName = typeof query.from === "string" ? query.from : jq.table;
+      target = quoteSchemaAndTable(query.schema, tableName);
       const as = query.as || key;
       const joinAs = q(as);
-      if (as !== table) {
+      if (as !== tableName) {
         target += ` AS ${joinAs}`;
       }
       const queryData = {
@@ -247,7 +156,7 @@ const processJoinItem = (ctx, model, args, quotedAs) => {
       };
       if (args[1]) {
         const arg = args[1](
-          new ctx.onQueryBuilder(jq, jq.shape, model)
+          new ctx.onQueryBuilder(jq, jq.shape, table)
         ).query;
         if (arg.and)
           queryData.and.push(...arg.and);
@@ -257,7 +166,7 @@ const processJoinItem = (ctx, model, args, quotedAs) => {
       conditions = whereToSql(ctx, jq, queryData, joinAs);
     } else {
       target = q(first);
-      conditions = processArgs(args, ctx, model, first, target, quotedAs);
+      conditions = processArgs(args, ctx, table, first, target, quotedAs);
     }
   } else {
     const query = first.query;
@@ -271,8 +180,8 @@ const processJoinItem = (ctx, model, args, quotedAs) => {
         target += ` AS ${quoted}`;
       }
     }
-    conditions = processArgs(args, ctx, model, first, joinAs, quotedAs);
-    const whereSql = whereToSql(ctx, model, query, joinAs);
+    conditions = processArgs(args, ctx, table, first, joinAs, quotedAs);
+    const whereSql = whereToSql(ctx, table, query, joinAs);
     if (whereSql) {
       if (conditions)
         conditions += ` AND ${whereSql}`;
@@ -282,21 +191,21 @@ const processJoinItem = (ctx, model, args, quotedAs) => {
   }
   return { target, conditions };
 };
-const processArgs = (args, ctx, model, first, joinAs, quotedAs) => {
+const processArgs = (args, ctx, table, first, joinAs, quotedAs) => {
   var _a;
   if (args.length === 2) {
     const arg = args[1];
     if (typeof arg === "function") {
       let shape;
       if (typeof first === "string") {
-        shape = (_a = model.query.withShapes) == null ? void 0 : _a[first];
+        shape = (_a = table.query.withShapes) == null ? void 0 : _a[first];
         if (!shape) {
           throw new Error("Cannot get shape of `with` statement");
         }
       } else {
         shape = first.shape;
       }
-      const jq = arg(new ctx.onQueryBuilder(first, shape, model));
+      const jq = arg(new ctx.onQueryBuilder(first, shape, table));
       return whereToSql(ctx, jq, jq.query, joinAs);
     } else {
       return getObjectOrRawConditions(arg, ctx.values, quotedAs, joinAs);
@@ -331,11 +240,11 @@ const getObjectOrRawConditions = (data, values, quotedAs, joinAs) => {
     return pairs.join(", ");
   }
 };
-const pushJoinSql = (ctx, model, query, quotedAs) => {
+const pushJoinSql = (ctx, table, query, quotedAs) => {
   query.join.forEach((item) => {
     const { target, conditions } = processJoinItem(
       ctx,
-      model,
+      table,
       item.args,
       quotedAs
     );
@@ -345,41 +254,41 @@ const pushJoinSql = (ctx, model, query, quotedAs) => {
   });
 };
 
-const pushWhereStatementSql = (ctx, model, query, quotedAs) => {
-  const res = whereToSql(ctx, model, query, quotedAs, false);
+const pushWhereStatementSql = (ctx, table, query, quotedAs) => {
+  const res = whereToSql(ctx, table, query, quotedAs, false);
   if (res) {
     ctx.sql.push("WHERE", res);
   }
 };
-const pushWhereToSql = (sql, ctx, model, query, quotedAs, not) => {
-  const res = whereToSql(ctx, model, query, quotedAs, not);
+const pushWhereToSql = (sql, ctx, table, query, quotedAs, not) => {
+  const res = whereToSql(ctx, table, query, quotedAs, not);
   if (res) {
     sql.push(res);
   }
 };
-const whereToSql = (ctx, model, query, quotedAs, not) => {
+const whereToSql = (ctx, table, query, quotedAs, not) => {
   if (query.or) {
     const ors = query.and ? [query.and, ...query.or] : query.or;
-    return ors.map((and) => processAnds(and, ctx, model, quotedAs, not)).join(" OR ");
+    return ors.map((and) => processAnds(and, ctx, table, quotedAs, not)).join(" OR ");
   } else if (query.and) {
-    return processAnds(query.and, ctx, model, quotedAs, not);
+    return processAnds(query.and, ctx, table, quotedAs, not);
   } else {
     return void 0;
   }
 };
-const processAnds = (and, ctx, model, quotedAs, not) => {
+const processAnds = (and, ctx, table, quotedAs, not) => {
   const ands = [];
-  and.forEach((data) => processWhere(ands, ctx, model, data, quotedAs, not));
+  and.forEach((data) => processWhere(ands, ctx, table, data, quotedAs, not));
   return ands.join(" AND ");
 };
-const processWhere = (ands, ctx, model, data, quotedAs, not) => {
+const processWhere = (ands, ctx, table, data, quotedAs, not) => {
   const prefix = not ? "NOT " : "";
   if (typeof data === "function") {
-    const qb = data(new ctx.whereQueryBuilder(model, model.shape));
+    const qb = data(new ctx.whereQueryBuilder(table, table.shape));
     pushWhereToSql(ands, ctx, qb, qb.query, quotedAs, not);
     return;
   }
-  if ("prototype" in data || "__model" in data) {
+  if ("prototype" in data || "__table" in data) {
     const query = data;
     const sql = whereToSql(
       ctx,
@@ -400,15 +309,15 @@ const processWhere = (ands, ctx, model, data, quotedAs, not) => {
     const value = data[key];
     if (key === "AND") {
       const arr = toArray(value);
-      ands.push(processAnds(arr, ctx, model, quotedAs, not));
+      ands.push(processAnds(arr, ctx, table, quotedAs, not));
     } else if (key === "OR") {
       const arr = value.map(toArray);
       ands.push(
-        arr.map((and) => processAnds(and, ctx, model, quotedAs, not)).join(" OR ")
+        arr.map((and) => processAnds(and, ctx, table, quotedAs, not)).join(" OR ")
       );
     } else if (key === "NOT") {
       const arr = toArray(value);
-      ands.push(processAnds(arr, ctx, model, quotedAs, !not));
+      ands.push(processAnds(arr, ctx, table, quotedAs, !not));
     } else if (key === "ON") {
       if (Array.isArray(value)) {
         const item = value;
@@ -417,7 +326,7 @@ const processWhere = (ands, ctx, model, data, quotedAs, not) => {
         const rightColumn = quoteFullColumn(
           item[2],
           getQueryAs({
-            table: model.table,
+            table: table.table,
             query: { as: quotedAs }
           })
         );
@@ -450,7 +359,7 @@ const processWhere = (ands, ctx, model, data, quotedAs, not) => {
       joinItems.forEach((item) => {
         const { target, conditions } = processJoinItem(
           ctx,
-          model,
+          table,
           item,
           quotedAs
         );
@@ -467,7 +376,7 @@ const processWhere = (ands, ctx, model, data, quotedAs, not) => {
           )}`
         );
       } else {
-        const column = model.shape[key];
+        const column = table.shape[key];
         if (!column) {
           throw new Error(`Unknown column ${key} provided to condition`);
         }
@@ -515,29 +424,29 @@ const pushIn = (ands, prefix, quotedAs, values, arg) => {
   );
 };
 
-var __defProp$p = Object.defineProperty;
-var __defProps$j = Object.defineProperties;
-var __getOwnPropDescs$j = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$q = Object.getOwnPropertySymbols;
-var __hasOwnProp$q = Object.prototype.hasOwnProperty;
-var __propIsEnum$q = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$p = (obj, key, value) => key in obj ? __defProp$p(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$p = (a, b) => {
+var __defProp$q = Object.defineProperty;
+var __defProps$k = Object.defineProperties;
+var __getOwnPropDescs$k = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$r = Object.getOwnPropertySymbols;
+var __hasOwnProp$r = Object.prototype.hasOwnProperty;
+var __propIsEnum$r = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$q = (obj, key, value) => key in obj ? __defProp$q(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$q = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$q.call(b, prop))
-      __defNormalProp$p(a, prop, b[prop]);
-  if (__getOwnPropSymbols$q)
-    for (var prop of __getOwnPropSymbols$q(b)) {
-      if (__propIsEnum$q.call(b, prop))
-        __defNormalProp$p(a, prop, b[prop]);
+    if (__hasOwnProp$r.call(b, prop))
+      __defNormalProp$q(a, prop, b[prop]);
+  if (__getOwnPropSymbols$r)
+    for (var prop of __getOwnPropSymbols$r(b)) {
+      if (__propIsEnum$r.call(b, prop))
+        __defNormalProp$q(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$j = (a, b) => __defProps$j(a, __getOwnPropDescs$j(b));
-const aggregateToSql = (ctx, model, item, quotedAs) => {
+var __spreadProps$k = (a, b) => __defProps$k(a, __getOwnPropDescs$k(b));
+const aggregateToSql = (ctx, table, item, quotedAs) => {
   var _a;
   const sql = [`${item.function}(`];
-  ctx = __spreadProps$j(__spreadValues$p({}, ctx), { sql });
+  ctx = __spreadProps$k(__spreadValues$q({}, ctx), { sql });
   const options = item.options || EMPTY_OBJECT;
   if (options.distinct && !options.withinGroup)
     sql.push("DISTINCT ");
@@ -577,7 +486,7 @@ const aggregateToSql = (ctx, model, item, quotedAs) => {
   if (options.filter || options.filterOr) {
     const whereSql = whereToSql(
       ctx,
-      model,
+      table,
       {
         and: options.filter ? [options.filter] : void 0,
         or: (_a = options.filterOr) == null ? void 0 : _a.map((item2) => [item2])
@@ -634,6 +543,44 @@ class UnhandledTypeError extends PormInternalError {
   }
 }
 
+const singleQuoteRegex = /'/g;
+const doubleQuoteRegex = /"/g;
+const quoteValue$1 = (value) => {
+  const type = typeof value;
+  if (type === "number")
+    return String(value);
+  else if (type === "string")
+    return `"${value.replace(doubleQuoteRegex, '\\"').replace(singleQuoteRegex, "''")}"`;
+  else if (type === "boolean")
+    return value ? "true" : "false";
+  else if (value instanceof Date)
+    return `"${value.toISOString()}"`;
+  else if (Array.isArray(value))
+    return quoteArray(value);
+  else if (type === null || type === void 0)
+    return "NULL";
+  else
+    return `"${JSON.stringify(value).replace(doubleQuoteRegex, '\\"').replace(singleQuoteRegex, "''")}"`;
+};
+const quoteArray = (array) => `'{${array.map(quoteValue$1).join(",")}}'`;
+const quote = (value) => {
+  const type = typeof value;
+  if (type === "number")
+    return `${value}`;
+  else if (type === "string")
+    return `'${value.replace(singleQuoteRegex, "''")}'`;
+  else if (type === "boolean")
+    return value ? "true" : "false";
+  else if (value instanceof Date)
+    return `'${value.toISOString()}'`;
+  else if (Array.isArray(value))
+    return quoteArray(value);
+  else if (value === null || value === void 0)
+    return "NULL";
+  else
+    return `'${JSON.stringify(value).replace(singleQuoteRegex, "''")}'`;
+};
+
 const relationQueryKey = Symbol("relationQuery");
 const isRequiredRelationKey = Symbol("isRequiredRelation");
 
@@ -673,10 +620,10 @@ const jsonToSql = (item, values, quotedAs) => {
   }
   return "";
 };
-const pushSelectSql = (ctx, model, query, quotedAs) => {
-  ctx.sql.push(selectToSql(ctx, model, query, quotedAs));
+const pushSelectSql = (ctx, table, query, quotedAs) => {
+  ctx.sql.push(selectToSql(ctx, table, query, quotedAs));
 };
-const selectToSql = (ctx, model, query, quotedAs) => {
+const selectToSql = (ctx, table, query, quotedAs) => {
   var _a;
   if (query.select) {
     const list = [];
@@ -713,13 +660,13 @@ const selectToSql = (ctx, model, query, quotedAs) => {
           list.push(
             `${item.function}(${selectToSql(
               ctx,
-              model,
+              table,
               { select: item.arguments },
               quotedAs
             )})${item.as ? ` AS ${q(item.as)}` : ""}`
           );
         } else {
-          list.push(aggregateToSql(ctx, model, item, quotedAs));
+          list.push(aggregateToSql(ctx, table, item, quotedAs));
         }
       }
     });
@@ -748,7 +695,7 @@ const pushSubQuerySql = (query, as, values, list) => {
       }
       select.length = 0;
       select[0] = { selectAs: { c: first } };
-      query = query._wrap(query.__model.clone());
+      query = query._wrap(query.__table.clone());
       query._getOptional(raw(`COALESCE(json_agg("c"), '[]')`));
       break;
     }
@@ -777,12 +724,12 @@ const aggregateOptionNames = [
   "filterOr",
   "withinGroup"
 ];
-const pushHavingSql = (ctx, model, query, quotedAs) => {
-  const conditions = havingToSql(ctx, model, query, quotedAs);
+const pushHavingSql = (ctx, table, query, quotedAs) => {
+  const conditions = havingToSql(ctx, table, query, quotedAs);
   if (conditions.length)
     ctx.sql.push("HAVING", conditions);
 };
-const havingToSql = (ctx, model, query, quotedAs) => {
+const havingToSql = (ctx, table, query, quotedAs) => {
   const or = query.having && query.havingOr ? [query.having, ...query.havingOr] : query.having ? [query.having] : query.havingOr;
   if (!(or == null ? void 0 : or.length))
     return "";
@@ -790,7 +737,7 @@ const havingToSql = (ctx, model, query, quotedAs) => {
   or.forEach((and) => {
     const ands = [];
     and.forEach((item) => {
-      if ("prototype" in item || "__model" in item) {
+      if ("prototype" in item || "__table" in item) {
         const query2 = item;
         const sql = havingToSql(
           ctx,
@@ -816,7 +763,7 @@ const havingToSql = (ctx, model, query, quotedAs) => {
                 if (!aggregateOptionNames.includes(
                   op
                 )) {
-                  const operator = model.shape[column].operators[op];
+                  const operator = table.shape[column].operators[op];
                   if (!operator) {
                     throw new Error(
                       `Unknown operator ${op} provided to condition`
@@ -824,7 +771,7 @@ const havingToSql = (ctx, model, query, quotedAs) => {
                   }
                   const expression = aggregateToSql(
                     ctx,
-                    model,
+                    table,
                     {
                       function: key,
                       arg: column,
@@ -845,7 +792,7 @@ const havingToSql = (ctx, model, query, quotedAs) => {
               ands.push(
                 `${aggregateToSql(
                   ctx,
-                  model,
+                  table,
                   {
                     function: key,
                     arg: column,
@@ -911,17 +858,17 @@ const queryKeysOfNotSimpleQuery = [
   "for"
 ];
 
-const pushFromAndAs = (ctx, model, query, quotedAs) => {
+const pushFromAndAs = (ctx, table, query, quotedAs) => {
   ctx.sql.push("FROM");
   if (query.fromOnly)
     ctx.sql.push("ONLY");
-  const from = getFrom(model, query, ctx.values);
+  const from = getFrom(table, query, ctx.values);
   ctx.sql.push(from);
   if (query.as && quotedAs && quotedAs !== from) {
     ctx.sql.push("AS", quotedAs);
   }
 };
-const getFrom = (model, query, values) => {
+const getFrom = (table, query, values) => {
   if (query.from) {
     if (typeof query.from === "object") {
       if (isRaw(query.from)) {
@@ -940,7 +887,7 @@ const getFrom = (model, query, values) => {
     }
     return quoteSchemaAndTable(query.schema, query.from);
   }
-  return quoteSchemaAndTable(query.schema, model.table);
+  return quoteSchemaAndTable(query.schema, table.table);
 };
 
 const pushQueryArray = (q, key, value) => {
@@ -970,7 +917,7 @@ const setQueryObjectValue = (q, object, key, value) => {
   return q;
 };
 
-const pushInsertSql = (ctx, model, query, quotedAs) => {
+const pushInsertSql = (ctx, table, query, quotedAs) => {
   const quotedColumns = query.columns.map(q);
   ctx.sql.push(`INSERT INTO ${quotedAs}(${quotedColumns.join(", ")})`);
   if (query.fromQuery) {
@@ -1025,22 +972,22 @@ const pushInsertSql = (ctx, model, query, quotedAs) => {
       ctx.sql.push("DO UPDATE SET", set);
     }
   }
-  pushWhereStatementSql(ctx, model, query, quotedAs);
-  pushReturningSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
+  pushReturningSql(ctx, table, query, quotedAs);
 };
 const encodeRow = (ctx, row) => {
   return row.map(
     (value) => value === void 0 ? "DEFAULT" : addValue(ctx.values, value)
   ).join(", ");
 };
-const pushReturningSql = (ctx, model, query, quotedAs) => {
+const pushReturningSql = (ctx, table, query, quotedAs) => {
   if (query.select) {
-    ctx.sql.push(`RETURNING ${selectToSql(ctx, model, query, quotedAs)}`);
+    ctx.sql.push(`RETURNING ${selectToSql(ctx, table, query, quotedAs)}`);
   }
 };
 
-const pushUpdateSql = (ctx, model, query, quotedAs) => {
-  const quotedTable = quoteSchemaAndTable(query.schema, model.table);
+const pushUpdateSql = (ctx, table, query, quotedAs) => {
+  const quotedTable = quoteSchemaAndTable(query.schema, table.table);
   ctx.sql.push(`UPDATE ${quotedTable}`);
   if (quotedTable !== quotedAs) {
     ctx.sql.push(`AS ${quotedAs}`);
@@ -1049,8 +996,8 @@ const pushUpdateSql = (ctx, model, query, quotedAs) => {
   const set = [];
   processData(ctx, set, query.updateData);
   ctx.sql.push(set.join(", "));
-  pushWhereStatementSql(ctx, model, query, quotedAs);
-  pushReturningSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
+  pushReturningSql(ctx, table, query, quotedAs);
 };
 const processData = (ctx, set, data) => {
   let append;
@@ -1087,9 +1034,9 @@ const processValue = (values, key, value) => {
   return addValue(values, value);
 };
 
-const pushDeleteSql = (ctx, model, query, quotedAs) => {
+const pushDeleteSql = (ctx, table, query, quotedAs) => {
   var _a, _b, _c;
-  const from = q(model.table);
+  const from = q(table.table);
   ctx.sql.push(`DELETE FROM ${from}`);
   if (from !== quotedAs) {
     ctx.sql.push(`AS ${quotedAs}`);
@@ -1097,12 +1044,12 @@ const pushDeleteSql = (ctx, model, query, quotedAs) => {
   let conditions;
   if ((_a = query.join) == null ? void 0 : _a.length) {
     const items = query.join.map(
-      (item) => processJoinItem(ctx, model, item.args, quotedAs)
+      (item) => processJoinItem(ctx, table, item.args, quotedAs)
     );
     ctx.sql.push(`USING ${items.map((item) => item.target).join(", ")}`);
     conditions = items.map((item) => item.conditions).filter(Boolean).join(" AND ");
   }
-  pushWhereStatementSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
   if (conditions == null ? void 0 : conditions.length) {
     if (((_b = query.and) == null ? void 0 : _b.length) || ((_c = query.or) == null ? void 0 : _c.length)) {
       ctx.sql.push("AND", conditions);
@@ -1110,7 +1057,7 @@ const pushDeleteSql = (ctx, model, query, quotedAs) => {
       ctx.sql.push("WHERE", conditions);
     }
   }
-  pushReturningSql(ctx, model, query, quotedAs);
+  pushReturningSql(ctx, table, query, quotedAs);
 };
 
 const pushTruncateSql = (ctx, table, query) => {
@@ -1133,13 +1080,13 @@ const pushColumnInfoSql = (ctx, table, query) => {
   }
 };
 
-const pushCopySql = (ctx, model, query, quotedAs) => {
+const pushCopySql = (ctx, table, query, quotedAs) => {
   const { sql } = ctx;
   const { copy } = query;
   const columns = copy.columns ? `(${copy.columns.map(q).join(", ")})` : "";
   const target = "from" in copy ? copy.from : copy.to;
   sql.push(
-    `COPY ${q(model.table)}${columns} ${"from" in copy ? "FROM" : "TO"} ${typeof target === "string" ? quote(target) : `PROGRAM ${quote(target.program)}`}`
+    `COPY ${q(table.table)}${columns} ${"from" in copy ? "FROM" : "TO"} ${typeof target === "string" ? quote(target) : `PROGRAM ${quote(target.program)}`}`
   );
   if (Object.keys(copy).length > (copy.columns ? 2 : 1)) {
     const options = [];
@@ -1169,19 +1116,19 @@ const pushCopySql = (ctx, model, query, quotedAs) => {
       options.push(`ENCODING ${quote(copy.encoding)}`);
     sql.push(`WITH (${options.join(", ")})`);
   }
-  pushWhereStatementSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
 };
 
 const toSqlCacheKey = Symbol("toSqlCache");
-const toSql = (model, options) => {
-  return !(options == null ? void 0 : options.clearCache) && model.query[toSqlCacheKey] || (model.query[toSqlCacheKey] = makeSql(model, options));
+const toSql = (table, options) => {
+  return !(options == null ? void 0 : options.clearCache) && table.query[toSqlCacheKey] || (table.query[toSqlCacheKey] = makeSql(table, options));
 };
-const makeSql = (model, { values = [] } = {}) => {
-  const query = model.query;
+const makeSql = (table, { values = [] } = {}) => {
+  const query = table.query;
   const sql = [];
   const ctx = {
-    whereQueryBuilder: model.whereQueryBuilder,
-    onQueryBuilder: model.onQueryBuilder,
+    whereQueryBuilder: table.whereQueryBuilder,
+    onQueryBuilder: table.onQueryBuilder,
     sql,
     values
   };
@@ -1190,56 +1137,56 @@ const makeSql = (model, { values = [] } = {}) => {
   }
   if (query.type) {
     if (query.type === "truncate") {
-      if (!model.table)
+      if (!table.table)
         throw new Error("Table is missing for truncate");
-      pushTruncateSql(ctx, model.table, query);
+      pushTruncateSql(ctx, table.table, query);
       return { text: sql.join(" "), values };
     }
     if (query.type === "columnInfo") {
-      if (!model.table)
+      if (!table.table)
         throw new Error("Table is missing for truncate");
-      pushColumnInfoSql(ctx, model.table, query);
+      pushColumnInfoSql(ctx, table.table, query);
       return { text: sql.join(" "), values };
     }
-    if (!model.table)
+    if (!table.table)
       throw new Error(`Table is missing for ${query.type}`);
-    const quotedAs2 = q(query.as || model.table);
+    const quotedAs2 = q(query.as || table.table);
     if (query.type === "insert") {
-      pushInsertSql(ctx, model, query, q(model.table));
+      pushInsertSql(ctx, table, query, q(table.table));
       return { text: sql.join(" "), values };
     }
     if (query.type === "update") {
-      pushUpdateSql(ctx, model, query, quotedAs2);
+      pushUpdateSql(ctx, table, query, quotedAs2);
       return { text: sql.join(" "), values };
     }
     if (query.type === "delete") {
-      pushDeleteSql(ctx, model, query, quotedAs2);
+      pushDeleteSql(ctx, table, query, quotedAs2);
       return { text: sql.join(" "), values };
     }
     if (query.type === "copy") {
-      pushCopySql(ctx, model, query, quotedAs2);
+      pushCopySql(ctx, table, query, quotedAs2);
       return { text: sql.join(" "), values };
     }
   }
-  const quotedAs = model.table && q(query.as || model.table);
+  const quotedAs = table.table && q(query.as || table.table);
   sql.push("SELECT");
   if (query.distinct) {
     pushDistinctSql(ctx, query.distinct, quotedAs);
   }
-  pushSelectSql(ctx, model, query, quotedAs);
-  if (model.table || query.from) {
-    pushFromAndAs(ctx, model, query, quotedAs);
+  pushSelectSql(ctx, table, query, quotedAs);
+  if (table.table || query.from) {
+    pushFromAndAs(ctx, table, query, quotedAs);
   }
   if (query.join) {
     pushJoinSql(
       ctx,
-      model,
+      table,
       query,
       quotedAs
     );
   }
   if (query.and || query.or) {
-    pushWhereStatementSql(ctx, model, query, quotedAs);
+    pushWhereStatementSql(ctx, table, query, quotedAs);
   }
   if (query.group) {
     const group = query.group.map(
@@ -1248,7 +1195,7 @@ const makeSql = (model, { values = [] } = {}) => {
     sql.push(`GROUP BY ${group.join(", ")}`);
   }
   if (query.having || query.havingOr) {
-    pushHavingSql(ctx, model, query, quotedAs);
+    pushHavingSql(ctx, table, query, quotedAs);
   }
   if (query.window) {
     const window = [];
@@ -1355,19 +1302,19 @@ const cloneQueryArrays = (q) => {
   }
 };
 
-var __defProp$o = Object.defineProperty;
-var __getOwnPropSymbols$p = Object.getOwnPropertySymbols;
-var __hasOwnProp$p = Object.prototype.hasOwnProperty;
-var __propIsEnum$p = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$o = (obj, key, value) => key in obj ? __defProp$o(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$o = (a, b) => {
+var __defProp$p = Object.defineProperty;
+var __getOwnPropSymbols$q = Object.getOwnPropertySymbols;
+var __hasOwnProp$q = Object.prototype.hasOwnProperty;
+var __propIsEnum$q = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$p = (obj, key, value) => key in obj ? __defProp$p(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$p = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$p.call(b, prop))
-      __defNormalProp$o(a, prop, b[prop]);
-  if (__getOwnPropSymbols$p)
-    for (var prop of __getOwnPropSymbols$p(b)) {
-      if (__propIsEnum$p.call(b, prop))
-        __defNormalProp$o(a, prop, b[prop]);
+    if (__hasOwnProp$q.call(b, prop))
+      __defNormalProp$p(a, prop, b[prop]);
+  if (__getOwnPropSymbols$q)
+    for (var prop of __getOwnPropSymbols$q(b)) {
+      if (__propIsEnum$q.call(b, prop))
+        __defNormalProp$p(a, prop, b[prop]);
     }
   return a;
 };
@@ -1386,7 +1333,7 @@ const joinTruthy = (...strings) => {
   return strings.filter((string) => string).join("");
 };
 const getClonedQueryData = (query) => {
-  const cloned = __spreadValues$o({}, query);
+  const cloned = __spreadValues$p({}, query);
   delete cloned[toSqlCacheKey];
   cloneQueryArrays(cloned);
   return cloned;
@@ -1414,72 +1361,251 @@ const pushOrNewArray = (arr, value) => {
   } else {
     return [value];
   }
-};
-
-const raw = (sql, values) => ({
-  __raw: sql,
-  __values: values
-});
-const isRaw = (obj) => "__raw" in obj;
-const keys = [];
-const getRaw = (raw2, valuesArray) => {
-  if (raw2.__values === false) {
-    return raw2.__raw;
+};
+const singleQuote = (s) => `'${s.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+
+var __defProp$o = Object.defineProperty;
+var __defProps$j = Object.defineProperties;
+var __getOwnPropDescs$j = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$p = Object.getOwnPropertySymbols;
+var __hasOwnProp$p = Object.prototype.hasOwnProperty;
+var __propIsEnum$p = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$o = (obj, key, value) => key in obj ? __defProp$o(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$o = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$p.call(b, prop))
+      __defNormalProp$o(a, prop, b[prop]);
+  if (__getOwnPropSymbols$p)
+    for (var prop of __getOwnPropSymbols$p(b)) {
+      if (__propIsEnum$p.call(b, prop))
+        __defNormalProp$o(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$j = (a, b) => __defProps$j(a, __getOwnPropDescs$j(b));
+const addColumnData = (q, key, value) => {
+  const cloned = Object.create(q);
+  cloned.data = __spreadProps$j(__spreadValues$o({}, q.data), { [key]: value });
+  return cloned;
+};
+const columnChainToCode = (chain, t, code, append) => {
+  const result = toArray(code);
+  if (typeof append === "string") {
+    if (append) {
+      if (result.length === 1 && typeof result[0] === "string") {
+        result[0] += append;
+      } else {
+        result.push(append);
+      }
+    }
+  } else {
+    if (append.length)
+      result.push(...append);
+  }
+  for (const item of chain) {
+    if (item[0] === "transform") {
+      result.push(`.transform(${item[1].toString()})`);
+    } else if (item[0] === "to") {
+      const type = toArray(item[2].toCode(t));
+      result.push(`.to(${item[1].toString()}, `, ...type, ")");
+    } else if (item[0] === "refine") {
+      result.push(`.refine(${item[1].toString()})`);
+    } else if (item[0] === "superRefine") {
+      result.push(`.superRefine(${item[1].toString()})`);
+    }
+  }
+  return result.length === 1 && typeof result[0] === "string" ? result[0] : result;
+};
+const columnCode = (type, t, code) => {
+  const append = [];
+  const { foreignKey, index, validationDefault } = type.data;
+  if (type.isPrimaryKey)
+    append.push(".primaryKey()");
+  if (foreignKey) {
+    append.push(`.foreignKey(`);
+    if ("fn" in foreignKey) {
+      append.push(foreignKey.fn.toString());
+    } else {
+      append.push(singleQuote(foreignKey.table));
+    }
+    append.push(`, ${singleQuote(foreignKey.columns[0])}`);
+    const hasOptions = foreignKey.name || foreignKey.match || foreignKey.onUpdate || foreignKey.onDelete;
+    if (hasOptions) {
+      const arr = [];
+      if (foreignKey.name)
+        arr.push(`name: ${singleQuote(foreignKey.name)},`);
+      if (foreignKey.match)
+        arr.push(`match: ${singleQuote(foreignKey.match)},`);
+      if (foreignKey.onUpdate)
+        arr.push(`onUpdate: ${singleQuote(foreignKey.onUpdate)},`);
+      if (foreignKey.onDelete)
+        arr.push(`onDelete: ${singleQuote(foreignKey.onDelete)},`);
+      append.push(", {", arr, "}");
+    }
+    append.push(")");
+  }
+  if (type.isHidden)
+    append.push(".hidden()");
+  if (type.isNullable)
+    append.push(".nullable()");
+  if ("isNonEmpty" in type.data)
+    append.push(".nonEmpty()");
+  if (type.encodeFn)
+    append.push(`.encode(${type.encodeFn.toString()})`);
+  if (type.parseFn && !("hideFromCode" in type.parseFn))
+    append.push(`.parse(${type.parseFn.toString()})`);
+  if (type.data.as)
+    append.push(`.as(${type.data.as.toCode(t)})`);
+  if (type.data.default)
+    append.push(`.default(${JSON.stringify(type.data.default)})`);
+  if (index) {
+    append.push(`.${index.unique ? "unique" : "index"}(`);
+    for (const key in index) {
+      if (key === "unique")
+        continue;
+      const arr = [];
+      if (index.expression)
+        arr.push(
+          `expression: ${typeof index.expression === "string" ? singleQuote(index.expression) : index.expression},`
+        );
+      if (index.collate)
+        arr.push(`collate: ${singleQuote(index.collate)},`);
+      if (index.operator)
+        arr.push(`operator: ${singleQuote(index.operator)},`);
+      if (index.order)
+        arr.push(`order: ${singleQuote(index.order)},`);
+      if (index.name)
+        arr.push(`name: ${singleQuote(index.name)},`);
+      if (index.unique)
+        arr.push(`unique: true,`);
+      if (index.using)
+        arr.push(`using: ${singleQuote(index.using)},`);
+      if (index.include)
+        arr.push(
+          `include: ${typeof index.include === "string" ? singleQuote(index.include) : `[${index.include.map(singleQuote).join(", ")}]`},`
+        );
+      if (index.with)
+        arr.push(`with: ${singleQuote(index.with)},`);
+      if (index.tablespace)
+        arr.push(`tablespace: ${singleQuote(index.tablespace)},`);
+      if (index.where)
+        arr.push(`where: ${singleQuote(index.where)},`);
+      append.push("{", arr, "}");
+      break;
+    }
+    append.push(")");
+  }
+  if (type.data.comment)
+    append.push(`.comment(${singleQuote(type.data.comment)})`);
+  if (validationDefault) {
+    append.push(
+      `.validationDefault(${typeof validationDefault === "function" ? validationDefault.toString() : typeof validationDefault === "string" ? singleQuote(validationDefault) : JSON.stringify(validationDefault)})`
+    );
+  }
+  if (type.data.compression)
+    append.push(`.compression(${singleQuote(type.data.compression)})`);
+  if (type.data.collate)
+    append.push(`.collate(${singleQuote(type.data.collate)})`);
+  if (type.data.modifyQuery)
+    append.push(`.modifyQuery(${type.data.modifyQuery.toString()})`);
+  return columnChainToCode(type.chain, t, code, append);
+};
+class ColumnType {
+  constructor() {
+    this.data = {};
+    this.isPrimaryKey = false;
+    this.isHidden = false;
+    this.isNullable = false;
+    this.hasDefault = false;
+    this.chain = [];
+  }
+  primaryKey() {
+    const cloned = Object.create(this);
+    return Object.assign(cloned, { isPrimaryKey: true });
+  }
+  foreignKey(fnOrTable, column, options = {}) {
+    const cloned = Object.create(this);
+    if (typeof fnOrTable === "string") {
+      cloned.data = __spreadProps$j(__spreadValues$o({}, this.data), {
+        foreignKey: __spreadValues$o({ table: fnOrTable, columns: [column] }, options)
+      });
+    } else {
+      cloned.data = __spreadProps$j(__spreadValues$o({}, this.data), {
+        foreignKey: __spreadValues$o({ fn: fnOrTable, columns: [column] }, options)
+      });
+    }
+    return cloned;
+  }
+  hidden() {
+    return Object.assign(Object.create(this), { isHidden: true });
   }
-  const arr = raw2.__raw.split("'");
-  const values = raw2.__values || emptyObject;
-  const len = arr.length;
-  keys.length = 0;
-  for (let i = 0; i < len; i += 2) {
-    arr[i] = arr[i].replace(/\$(\w+)/g, (_, key) => {
-      const value = values[key];
-      if (value === void 0) {
-        throw new Error(`Query variable \`${key}\` is not provided`);
-      }
-      keys.push(key);
-      valuesArray.push(value);
-      return `$${valuesArray.length}`;
+  nullable() {
+    return Object.assign(Object.create(this), {
+      isNullable: true
     });
   }
-  if (keys.length > 0 && keys.length < Object.keys(values).length) {
-    for (const key in values) {
-      if (!keys.includes(key)) {
-        throw new Error(`Query variable \`${key}\` is unused`);
-      }
-    }
+  encode(fn) {
+    return Object.assign(Object.create(this), {
+      encodeFn: fn
+    });
   }
-  return arr.join("'");
-};
-const getRawSql = (raw2) => {
-  return raw2.__raw;
-};
-const EMPTY_OBJECT = {};
-const getQueryParsers = (q) => {
-  return q.query.parsers || q.columnsParsers;
-};
-
-const q = (sql) => `"${sql}"`;
-const qc = (column, quotedAs) => quotedAs ? `${quotedAs}.${q(column)}` : column;
-const quoteFullColumn = (fullColumn, quotedAs) => {
-  const index = fullColumn.indexOf(".");
-  if (index !== -1) {
-    return `${q(fullColumn.slice(0, index))}.${q(fullColumn.slice(index + 1))}`;
-  } else if (quotedAs) {
-    return `${quotedAs}.${q(fullColumn)}`;
-  } else {
-    return q(fullColumn);
+  parse(fn) {
+    return Object.assign(Object.create(this), {
+      parseFn: fn,
+      parseItem: fn
+    });
   }
-};
-const expressionToSql = (expr, values, quotedAs) => {
-  return typeof expr === "object" && isRaw(expr) ? getRaw(expr, values) : quoteFullColumn(expr, quotedAs);
-};
-const quoteSchemaAndTable = (schema, table) => {
-  return schema ? `${q(schema)}.${q(table)}` : q(table);
-};
-const addValue = (values, value) => {
-  values.push(value);
-  return `$${values.length}`;
-};
+  as(column) {
+    return addColumnData(this, "as", column);
+  }
+  toSQL() {
+    return this.dataType;
+  }
+  default(value) {
+    return addColumnData(this, "default", value);
+  }
+  index(options = {}) {
+    return addColumnData(this, "index", options);
+  }
+  unique(options = {}) {
+    return addColumnData(this, "index", __spreadProps$j(__spreadValues$o({}, options), { unique: true }));
+  }
+  comment(comment) {
+    return addColumnData(this, "comment", comment);
+  }
+  validationDefault(value) {
+    return addColumnData(this, "validationDefault", value);
+  }
+  compression(compression) {
+    return addColumnData(this, "compression", compression);
+  }
+  collate(collate) {
+    return addColumnData(this, "collate", collate);
+  }
+  modifyQuery(cb) {
+    return addColumnData(this, "modifyQuery", cb);
+  }
+  transform(fn) {
+    const cloned = Object.create(this);
+    cloned.chain = [...this.chain, ["transform", fn]];
+    return cloned;
+  }
+  to(fn, type) {
+    const cloned = Object.create(this);
+    cloned.chain = [...this.chain, ["to", fn, type], ...cloned.chain];
+    return cloned;
+  }
+  refine(check) {
+    const cloned = Object.create(this);
+    cloned.chain = [...this.chain, ["refine", check]];
+    return cloned;
+  }
+  superRefine(check) {
+    const cloned = Object.create(this);
+    cloned.chain = [...this.chain, ["superRefine", check]];
+    return cloned;
+  }
+}
 
 var __defProp$n = Object.defineProperty;
 var __defProps$i = Object.defineProperties;
@@ -1678,20 +1804,22 @@ function length(value) {
 function size(value) {
   return setDataValue(this, "size", value);
 }
-function nonempty() {
-  return setDataValue(this, "min", 1);
+function nonEmpty() {
+  const cloned = setDataValue(this, "min", 1);
+  cloned.data.isNonEmpty = true;
+  return cloned;
 }
 const arrayMethods = {
   min,
   max,
   length,
-  nonempty
+  nonEmpty
 };
 const setMethods = {
   min,
   max,
   size,
-  nonempty
+  nonEmpty
 };
 const stringTypeMethods = () => __spreadProps$h(__spreadValues$m({}, arrayMethods), {
   email() {
@@ -1777,6 +1905,20 @@ const dateTypeMethods = {
   }
 };
 
+const numberDataToCode = (data) => {
+  let code = "";
+  if (data.gte !== void 0)
+    code += `.min(${data.gte})`;
+  if (data.gt !== void 0)
+    code += `.gt(${data.gt})`;
+  if (data.lte !== void 0)
+    code += `.max(${data.lte})`;
+  if (data.lt !== void 0)
+    code += `.lt(${data.lt})`;
+  if (data.multipleOf !== void 0)
+    code += `.step(${data.multipleOf})`;
+  return code;
+};
 class NumberBaseColumn extends ColumnType {
   constructor() {
     super(...arguments);
@@ -1808,6 +1950,14 @@ class DecimalBaseColumn extends ColumnType {
       scale
     };
   }
+  toCode(t) {
+    const { precision, scale } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.decimal(${precision || ""}${scale ? `, ${scale}` : ""})`
+    );
+  }
   toSQL() {
     const { precision, scale } = this.data;
     return joinTruthy(
@@ -1822,6 +1972,9 @@ class SmallIntColumn extends IntegerBaseColumn {
     this.dataType = "smallint";
     this.parseItem = parseInt;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.smallint()${numberDataToCode(this.data)}`);
+  }
 }
 class IntegerColumn extends IntegerBaseColumn {
   constructor() {
@@ -1829,12 +1982,18 @@ class IntegerColumn extends IntegerBaseColumn {
     this.dataType = "integer";
     this.parseItem = parseInt;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.integer()${numberDataToCode(this.data)}`);
+  }
 }
 class BigIntColumn extends NumberAsStringBaseColumn {
   constructor() {
     super(...arguments);
     this.dataType = "bigint";
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.bigint()`);
+  }
 }
 class DecimalColumn extends DecimalBaseColumn {
 }
@@ -1844,12 +2003,18 @@ class RealColumn extends NumberBaseColumn {
     this.dataType = "real";
     this.parseItem = parseFloat;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.real()${numberDataToCode(this.data)}`);
+  }
 }
 class DoublePrecisionColumn extends NumberAsStringBaseColumn {
   constructor() {
     super(...arguments);
     this.dataType = "double precision";
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.doublePrecision()`);
+  }
 }
 class SmallSerialColumn extends IntegerBaseColumn {
   constructor() {
@@ -1858,6 +2023,13 @@ class SmallSerialColumn extends IntegerBaseColumn {
     this.parseItem = parseInt;
     this.hasDefault = true;
   }
+  toCode(t) {
+    return columnCode(
+      this,
+      t,
+      `${t}.smallSerial()${numberDataToCode(this.data)}`
+    );
+  }
 }
 class SerialColumn extends IntegerBaseColumn {
   constructor() {
@@ -1866,6 +2038,9 @@ class SerialColumn extends IntegerBaseColumn {
     this.parseItem = parseInt;
     this.hasDefault = true;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.serial()${numberDataToCode(this.data)}`);
+  }
 }
 class BigSerialColumn extends NumberAsStringBaseColumn {
   constructor() {
@@ -1873,8 +2048,38 @@ class BigSerialColumn extends NumberAsStringBaseColumn {
     this.dataType = "bigserial";
     this.hasDefault = true;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.bigSerial()`);
+  }
 }
 
+const stringDataToCode = (data) => {
+  let code = "";
+  const { min, isNonEmpty } = data;
+  if (min !== void 0 && (!isNonEmpty || isNonEmpty && min !== 1))
+    code += `.min(${min})`;
+  if (data.max !== void 0)
+    code += `.max(${data.max})`;
+  if (data.length !== void 0)
+    code += `.length(${data.length})`;
+  if (data.email !== void 0)
+    code += `.email()`;
+  if (data.url !== void 0)
+    code += `.url()`;
+  if (data.uuid !== void 0)
+    code += `.uuid()`;
+  if (data.cuid !== void 0)
+    code += `.cuid()`;
+  if (data.regex)
+    code += `.regex(${data.regex.toString()})`;
+  if (data.startsWith !== void 0)
+    code += `.startsWith(${singleQuote(data.startsWith)})`;
+  if (data.endsWith !== void 0)
+    code += `.endsWith(${singleQuote(data.endsWith)})`;
+  if (data.cuid !== void 0)
+    code += `.trim()`;
+  return code;
+};
 const textMethods = stringTypeMethods();
 class TextBaseColumn extends ColumnType {
   constructor() {
@@ -1887,12 +2092,12 @@ assignMethodsToClass(TextBaseColumn, textMethods);
 class LimitedTextBaseColumn extends TextBaseColumn {
   constructor(limit) {
     super();
-    this.data = { max: limit };
+    this.data = { arg: limit };
   }
   toSQL() {
     return joinTruthy(
       this.dataType,
-      this.data.max !== void 0 && `(${this.data.max})`
+      this.data.arg !== void 0 && `(${this.data.arg})`
     );
   }
 }
@@ -1901,12 +2106,28 @@ class VarCharColumn extends LimitedTextBaseColumn {
     super(...arguments);
     this.dataType = "varchar";
   }
+  toCode(t) {
+    const { arg } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.varchar(${arg != null ? arg : ""})${stringDataToCode(this.data)}`
+    );
+  }
 }
 class CharColumn extends LimitedTextBaseColumn {
   constructor() {
     super(...arguments);
     this.dataType = "char";
   }
+  toCode(t) {
+    const { arg } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.char(${arg != null ? arg : ""})${stringDataToCode(this.data)}`
+    );
+  }
 }
 class TextColumn extends TextBaseColumn {
   constructor() {
@@ -1914,6 +2135,9 @@ class TextColumn extends TextBaseColumn {
     this.dataType = "text";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.text()${stringDataToCode(this.data)}`);
+  }
 }
 class ByteaColumn extends ColumnType {
   constructor() {
@@ -1921,6 +2145,9 @@ class ByteaColumn extends ColumnType {
     this.dataType = "bytea";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.bytea()`);
+  }
 }
 class PointColumn extends ColumnType {
   constructor() {
@@ -1928,56 +2155,85 @@ class PointColumn extends ColumnType {
     this.dataType = "point";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.point()`);
+  }
 }
 class LineColumn extends ColumnType {
   constructor() {
     super(...arguments);
-    this.dataType = "point";
+    this.dataType = "line";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.line()`);
+  }
 }
 class LsegColumn extends ColumnType {
   constructor() {
     super(...arguments);
-    this.dataType = "point";
+    this.dataType = "lseg";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.lseg()`);
+  }
 }
 class BoxColumn extends ColumnType {
   constructor() {
     super(...arguments);
-    this.dataType = "point";
+    this.dataType = "box";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.box()`);
+  }
 }
 class PathColumn extends ColumnType {
   constructor() {
     super(...arguments);
-    this.dataType = "point";
+    this.dataType = "path";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.path()`);
+  }
 }
 class PolygonColumn extends ColumnType {
   constructor() {
     super(...arguments);
-    this.dataType = "point";
+    this.dataType = "polygon";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.polygon()`);
+  }
 }
 class CircleColumn extends ColumnType {
   constructor() {
     super(...arguments);
-    this.dataType = "point";
+    this.dataType = "circle";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.circle()`);
+  }
 }
 class MoneyColumn extends NumberBaseColumn {
   constructor() {
     super(...arguments);
     this.dataType = "money";
-    this.parseFn = (input) => {
-      return parseFloat(input.replace(/,/g, "").replace(/\$/g, ""));
-    };
+    this.parseFn = Object.assign(
+      function(input) {
+        return parseFloat(input.replace(/,/g, "").replace(/\$/g, ""));
+      },
+      {
+        hideFromCode: true
+      }
+    );
+  }
+  toCode(t) {
+    return columnCode(this, t, `${t}.money()`);
   }
 }
 class CidrColumn extends ColumnType {
@@ -1986,6 +2242,9 @@ class CidrColumn extends ColumnType {
     this.dataType = "cidr";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.cidr()`);
+  }
 }
 class InetColumn extends ColumnType {
   constructor() {
@@ -1993,6 +2252,9 @@ class InetColumn extends ColumnType {
     this.dataType = "inet";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.inet()`);
+  }
 }
 class MacAddrColumn extends ColumnType {
   constructor() {
@@ -2000,6 +2262,9 @@ class MacAddrColumn extends ColumnType {
     this.dataType = "macaddr";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.macaddr()`);
+  }
 }
 class MacAddr8Column extends ColumnType {
   constructor() {
@@ -2007,6 +2272,9 @@ class MacAddr8Column extends ColumnType {
     this.dataType = "macaddr8";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.macaddr8()`);
+  }
 }
 class BitColumn extends ColumnType {
   constructor(length) {
@@ -2015,6 +2283,10 @@ class BitColumn extends ColumnType {
     this.operators = Operators.text;
     this.data = { length };
   }
+  toCode(t) {
+    const { length } = this.data;
+    return columnCode(this, t, `${t}.bit(${length})`);
+  }
   toSQL() {
     return joinTruthy(
       this.dataType,
@@ -2029,6 +2301,10 @@ class BitVaryingColumn extends ColumnType {
     this.operators = Operators.text;
     this.data = { length };
   }
+  toCode(t) {
+    const { length } = this.data;
+    return columnCode(this, t, `${t}.bitVarying(${length != null ? length : ""})`);
+  }
   toSQL() {
     return joinTruthy(
       this.dataType,
@@ -2042,6 +2318,9 @@ class TsVectorColumn extends ColumnType {
     this.dataType = "tsvector";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.tsvector()`);
+  }
 }
 class TsQueryColumn extends ColumnType {
   constructor() {
@@ -2049,6 +2328,9 @@ class TsQueryColumn extends ColumnType {
     this.dataType = "tsquery";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.tsquery()`);
+  }
 }
 class UUIDColumn extends ColumnType {
   constructor() {
@@ -2056,6 +2338,9 @@ class UUIDColumn extends ColumnType {
     this.dataType = "uuid";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.uuid()`);
+  }
 }
 class XMLColumn extends ColumnType {
   constructor() {
@@ -2063,6 +2348,9 @@ class XMLColumn extends ColumnType {
     this.dataType = "xml";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.xml()`);
+  }
 }
 
 class DateBaseColumn extends ColumnType {
@@ -2079,11 +2367,22 @@ class DateBaseColumn extends ColumnType {
   }
 }
 assignMethodsToClass(DateBaseColumn, dateTypeMethods);
+const dateDataToCode = (data) => {
+  let code = "";
+  if (data.min)
+    code += `.min(new Date('${data.min.toISOString()}'))`;
+  if (data.max)
+    code += `.max(new Date('${data.max.toISOString()}'))`;
+  return code;
+};
 class DateColumn extends DateBaseColumn {
   constructor() {
     super(...arguments);
     this.dataType = "date";
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.date()${dateDataToCode(this.data)}`);
+  }
 }
 class DateTimeBaseClass extends DateBaseColumn {
   constructor(precision) {
@@ -2111,6 +2410,14 @@ class TimestampColumn extends DateTimeBaseClass {
     super(...arguments);
     this.dataType = "timestamp";
   }
+  toCode(t) {
+    const { precision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.timestamp(${precision || ""})${dateDataToCode(this.data)}`
+    );
+  }
 }
 class TimestampWithTimeZoneColumn extends DateTimeWithTimeZoneBaseClass {
   constructor() {
@@ -2118,12 +2425,30 @@ class TimestampWithTimeZoneColumn extends DateTimeWithTimeZoneBaseClass {
     this.dataType = "timestamp with time zone";
     this.baseDataType = "timestamp";
   }
+  toCode(t) {
+    const { precision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.timestampWithTimeZone(${precision || ""})${dateDataToCode(
+        this.data
+      )}`
+    );
+  }
 }
 class TimeColumn extends DateTimeBaseClass {
   constructor() {
     super(...arguments);
     this.dataType = "time";
   }
+  toCode(t) {
+    const { precision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.time(${precision || ""})${dateDataToCode(this.data)}`
+    );
+  }
 }
 class TimeWithTimeZoneColumn extends DateTimeWithTimeZoneBaseClass {
   constructor() {
@@ -2131,6 +2456,14 @@ class TimeWithTimeZoneColumn extends DateTimeWithTimeZoneBaseClass {
     this.dataType = "time with time zone";
     this.baseDataType = "time";
   }
+  toCode(t) {
+    const { precision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.timeWithTimeZone(${precision || ""})${dateDataToCode(this.data)}`
+    );
+  }
 }
 class IntervalColumn extends ColumnType {
   constructor(fields, precision) {
@@ -2139,6 +2472,14 @@ class IntervalColumn extends ColumnType {
     this.operators = Operators.date;
     this.data = { fields, precision };
   }
+  toCode(t) {
+    const { fields, precision } = this.data;
+    return columnCode(
+      this,
+      t,
+      `${t}.interval(${[fields && `'${fields}'`, precision && String(precision)].filter((part) => part).join(", ")})`
+    );
+  }
   toSQL() {
     return joinTruthy(
       this.dataType,
@@ -2155,6 +2496,9 @@ class BooleanColumn extends ColumnType {
     this.operators = Operators.boolean;
     this.parseItem = (input) => input[0] === "t";
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.boolean()`);
+  }
 }
 
 class EnumColumn extends ColumnType {
@@ -2165,6 +2509,13 @@ class EnumColumn extends ColumnType {
     this.operators = Operators.any;
     this.dataType = "enum";
   }
+  toCode(t) {
+    return columnCode(
+      this,
+      t,
+      `${t}.enum('${this.enumName}', [${this.options.map((option) => `'${option}'`).join(", ")}])`
+    );
+  }
   toSql() {
     return this.enumName;
   }
@@ -2303,14 +2654,38 @@ const intersection = (left, right) => {
   return constructType({
     dataType: "intersection",
     left,
-    right
+    right,
+    toCode(t) {
+      return toCode(this, t, [
+        this.left.toCode(t),
+        ".and(",
+        this.right.toCode(t),
+        ")"
+      ]);
+    }
   });
 };
 
 const union = (types) => {
   return constructType({
     dataType: "union",
-    types
+    types,
+    toCode(t) {
+      const last = this.types.length - 1;
+      return toCode(
+        this,
+        t,
+        this.types.flatMap((type, i) => {
+          const item = [...toArray(type.toCode(t))];
+          if (i < last) {
+            item.push(`${i > 0 ? ")" : ""}.or(`);
+          } else {
+            item.push(")");
+          }
+          return item;
+        })
+      );
+    }
   });
 };
 
@@ -2333,11 +2708,34 @@ var __spreadValues$i = (a, b) => {
   return a;
 };
 var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
+const toCode = (type, t, code) => {
+  let append = "";
+  if (type.data.nullable && type.data.optional) {
+    append += ".nullish()";
+  } else if (type.data.nullable) {
+    append += ".nullable()";
+  } else if (type.data.optional) {
+    append += ".optional()";
+  }
+  if (type.data.isDeepPartial) {
+    append += ".deepPartial()";
+  }
+  if (type.data.isNonEmpty) {
+    append += ".nonEmpty()";
+  }
+  if (type.data.default) {
+    append += `.default(${JSON.stringify(type.data.default)})`;
+  }
+  return columnChainToCode(type.chain, t, code, append);
+};
 const baseTypeMethods = {
   type: void 0,
   data: {},
   dataType: "any",
   chain: [],
+  toCode() {
+    throw new Error("toCode is not implemented");
+  },
   optional() {
     return optional(this);
   },
@@ -2357,7 +2755,7 @@ const baseTypeMethods = {
     return notNullish(this);
   },
   deepPartial() {
-    return this;
+    return this.optional();
   },
   transform(fn) {
     return __spreadProps$d(__spreadValues$i({}, this), {
@@ -2365,7 +2763,7 @@ const baseTypeMethods = {
     });
   },
   to(fn, type) {
-    return __spreadProps$d(__spreadValues$i({}, type), {
+    return __spreadProps$d(__spreadValues$i({}, this), {
       chain: [...this.chain, ["to", fn, type], ...type.chain]
     });
   },
@@ -2422,13 +2820,24 @@ const array = (element) => {
   return constructType(__spreadValues$h({
     dataType: "array",
     element,
+    toCode(t) {
+      let code = ".array()";
+      const { min, max, length, isNonEmpty } = this.data;
+      if (min !== void 0 && (!isNonEmpty || isNonEmpty && min !== 1))
+        code += `.min(${min})`;
+      if (max !== void 0)
+        code += `.max(${max})`;
+      if (length !== void 0)
+        code += `.length(${length})`;
+      return toCode(this, t, [...toArray(this.element.toCode(t)), code]);
+    },
     deepPartial() {
       return __spreadProps$c(__spreadValues$h({}, this), {
-        element: this.element.deepPartial()
+        element: this.element.deepPartial(),
+        data: __spreadProps$c(__spreadValues$h({}, this.data), {
+          isDeepPartial: true
+        })
       });
-    },
-    nonEmpty() {
-      return this.min(1);
     }
   }, arrayMethods));
 };
@@ -2464,6 +2873,13 @@ const discriminatedUnion = (discriminator, options) => {
     discriminatorValue: void 0,
     options: optionsMap,
     _option: void 0,
+    toCode(t) {
+      return toCode(this, t, [
+        `${t}.discriminatedUnion(${singleQuote(this.discriminator)}, [`,
+        options.flatMap((option) => option.toCode(t)),
+        "])"
+      ]);
+    },
     deepPartial() {
       const newOptionsMap = /* @__PURE__ */ new Map();
       optionsMap.forEach((option, key) => {
@@ -2489,14 +2905,24 @@ const enumType = (options) => {
   return constructType({
     dataType: "enum",
     enum: arrayToEnum(options),
-    options
+    options,
+    toCode(t) {
+      return toCode(
+        this,
+        t,
+        `${t}.enum([${options.map(singleQuote).join(", ")}])`
+      );
+    }
   });
 };
 
 const instanceOf = (cls) => {
   return constructType({
     dataType: "instanceOf",
-    class: cls
+    class: cls,
+    toCode(t) {
+      return toCode(this, t, `${t}.instanceOf(${this.class.name})`);
+    }
   });
 };
 
@@ -2525,8 +2951,18 @@ const lazy = (fn) => {
     getter() {
       return this.typeCache || (this.typeCache = fn());
     },
+    toCode(t) {
+      return toCode(this, t, [
+        `${t}.lazy(() => `,
+        ...toArray(this.getter().toCode(t)),
+        ")"
+      ]);
+    },
     deepPartial() {
       return __spreadProps$a(__spreadValues$f({}, this), {
+        data: __spreadProps$a(__spreadValues$f({}, this.data), {
+          isDeepPartial: true
+        }),
         typeCache: void 0,
         getter: () => this.getter().deepPartial()
       });
@@ -2536,7 +2972,15 @@ const lazy = (fn) => {
 
 const literal = (value) => constructType({
   dataType: "literal",
-  value
+  value,
+  toCode(t) {
+    const { value: value2 } = this;
+    return toCode(
+      this,
+      t,
+      `${t}.literal(${typeof value2 === "string" ? singleQuote(value2) : value2})`
+    );
+  }
 });
 
 var __defProp$e = Object.defineProperty;
@@ -2563,8 +3007,18 @@ const map = (keyType, valueType) => {
     dataType: "map",
     keyType,
     valueType,
+    toCode(t) {
+      return toCode(
+        this,
+        t,
+        `${t}.map(${this.keyType.toCode(t)}, ${this.valueType.toCode(t)})`
+      );
+    },
     deepPartial() {
       return __spreadProps$9(__spreadValues$e({}, this), {
+        data: __spreadProps$9(__spreadValues$e({}, this.data), {
+          isDeepPartial: true
+        }),
         keyType: this.keyType.deepPartial(),
         valueType: this.valueType.deepPartial()
       });
@@ -2586,7 +3040,10 @@ const nativeEnum = (givenEnum) => {
   return constructType({
     dataType: "nativeEnum",
     enum: givenEnum,
-    options
+    options,
+    toCode(t) {
+      return toCode(this, t, `${t}.nativeEnum(enum)`);
+    }
   });
 };
 
@@ -2615,6 +3072,23 @@ const object = (shape) => {
     shape,
     unknownKeys: "strip",
     catchAllType: void 0,
+    toCode(t) {
+      const { shape: shape2 } = this;
+      const arr = [];
+      for (const key in shape2) {
+        arr.push(`${key}: ${shape2[key].toCode(t)},`);
+      }
+      let lastLine = "})";
+      if (this.unknownKeys === "passthrough") {
+        lastLine += ".passthrough()";
+      } else if (this.unknownKeys === "strict") {
+        lastLine += ".strict()";
+      }
+      if (this.catchAllType) {
+        lastLine += `.catchAll(${this.catchAllType.toCode(t)})`;
+      }
+      return toCode(this, t, [`${t}.object({`, arr, lastLine]);
+    },
     extend(add) {
       return object(
         Object.assign(__spreadValues$d({}, this.shape), add)
@@ -2705,66 +3179,145 @@ var __spreadValues$c = (a, b) => {
 var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
 const any = () => {
   return constructType({
-    dataType: "any"
+    dataType: "any",
+    toCode(t) {
+      return toCode(this, t, `${t}.any()`);
+    }
   });
 };
-const bigIntMethods = __spreadValues$c({
+const bigIntMethods = __spreadProps$7(__spreadValues$c({
   dataType: "bigint"
-}, numberTypeMethods);
+}, numberTypeMethods), {
+  toCode(t) {
+    return toCode(this, t, `${t}.bigint()`);
+  }
+});
 const bigint = () => {
   return constructType(bigIntMethods);
 };
 const boolean = () => {
   return constructType({
-    dataType: "boolean"
+    dataType: "boolean",
+    toCode(t) {
+      return toCode(this, t, `${t}.boolean()`);
+    }
   });
 };
 const nan = () => {
   return constructType({
-    dataType: "nan"
+    dataType: "nan",
+    toCode(t) {
+      return toCode(this, t, `${t}.nan()`);
+    }
   });
 };
 const never = () => {
   return constructType({
-    dataType: "never"
+    dataType: "never",
+    toCode(t) {
+      return toCode(this, t, `${t}.never()`);
+    }
   });
 };
 const nullType = () => {
   return constructType({
-    dataType: "null"
+    dataType: "null",
+    toCode(t) {
+      return toCode(this, t, `${t}.null()`);
+    }
   });
 };
 const numberMethods = __spreadProps$7(__spreadValues$c({}, numberTypeMethods), {
-  dataType: "number"
+  dataType: "number",
+  toCode(t) {
+    let code = `${t}.number()`;
+    if (this.data.gte !== void 0)
+      code += `.min(${this.data.gte})`;
+    if (this.data.gt !== void 0)
+      code += `.gt(${this.data.gt})`;
+    if (this.data.lte !== void 0)
+      code += `.max(${this.data.lte})`;
+    if (this.data.lt !== void 0)
+      code += `.lt(${this.data.lt})`;
+    if (this.data.multipleOf !== void 0)
+      code += `.step(${this.data.multipleOf})`;
+    if (this.data.int)
+      code += `.int()`;
+    return toCode(this, t, code);
+  }
 });
 const number = () => {
   return constructType(numberMethods);
 };
 const dateMethods = __spreadProps$7(__spreadValues$c({}, dateTypeMethods), {
-  dataType: "date"
+  dataType: "date",
+  toCode(t) {
+    let code = `${t}.date()`;
+    if (this.data.min)
+      code += `.min(new Date('${this.data.min.toISOString()}'))`;
+    if (this.data.max)
+      code += `.max(new Date('${this.data.max.toISOString()}'))`;
+    return toCode(this, t, code);
+  }
 });
 const date = () => {
   return constructType(dateMethods);
 };
 const stringMethods = __spreadProps$7(__spreadValues$c({}, stringTypeMethods()), {
-  dataType: "string"
+  dataType: "string",
+  toCode(t) {
+    let code = `${t}.string()`;
+    const { min, isNonEmpty } = this.data;
+    if (min !== void 0 && (!isNonEmpty || isNonEmpty && min !== 1))
+      code += `.min(${min})`;
+    if (this.data.max !== void 0)
+      code += `.max(${this.data.max})`;
+    if (this.data.length !== void 0)
+      code += `.length(${this.data.length})`;
+    if (this.data.email !== void 0)
+      code += `.email()`;
+    if (this.data.url !== void 0)
+      code += `.url()`;
+    if (this.data.uuid !== void 0)
+      code += `.uuid()`;
+    if (this.data.cuid !== void 0)
+      code += `.cuid()`;
+    if (this.data.regex)
+      code += `.regex(${this.data.regex.toString()})`;
+    if (this.data.startsWith !== void 0)
+      code += `.startsWith(${singleQuote(this.data.startsWith)})`;
+    if (this.data.endsWith !== void 0)
+      code += `.endsWith(${singleQuote(this.data.endsWith)})`;
+    if (this.data.cuid !== void 0)
+      code += `.trim()`;
+    return toCode(this, t, code);
+  }
 });
 const string = () => {
   return constructType(stringMethods);
 };
 const undefinedType = () => {
   return constructType({
-    dataType: "undefined"
+    dataType: "undefined",
+    toCode(t) {
+      return toCode(this, t, `${t}.undefined()`);
+    }
   });
 };
 const unknown = () => {
   return constructType({
-    dataType: "unknown"
+    dataType: "unknown",
+    toCode(t) {
+      return toCode(this, t, `${t}.unknown()`);
+    }
   });
 };
 const voidType = () => {
   return constructType({
-    dataType: "void"
+    dataType: "void",
+    toCode(t) {
+      return toCode(this, t, `${t}.void()`);
+    }
   });
 };
 const scalarTypes = {
@@ -2807,6 +3360,13 @@ function record(...args) {
     dataType: "record",
     keyType,
     valueType,
+    toCode(t) {
+      return toCode(
+        this,
+        t,
+        `${t}.record(${args.length === 1 ? this.valueType.toCode(t) : `${this.keyType.toCode(t)}, ${this.valueType.toCode(t)}`})`
+      );
+    },
     deepPartial() {
       return __spreadProps$6(__spreadValues$b({}, this), {
         valueType: this.valueType.deepPartial()
@@ -2838,13 +3398,25 @@ const set = (valueType) => {
   return constructType(__spreadValues$a({
     dataType: "set",
     valueType,
+    toCode(t) {
+      let append = ")";
+      const { min, max, size, isNonEmpty } = this.data;
+      if (min !== void 0 && (!isNonEmpty || isNonEmpty && min !== 1))
+        append += `.min(${min})`;
+      if (max !== void 0)
+        append += `.max(${max})`;
+      if (size !== void 0)
+        append += `.size(${size})`;
+      return toCode(this, t, [
+        `${t}.set(`,
+        ...toArray(this.valueType.toCode(t)),
+        append
+      ]);
+    },
     deepPartial() {
       return __spreadProps$5(__spreadValues$a({}, this), {
         valueType: this.valueType.deepPartial()
       });
-    },
-    nonEmpty() {
-      return this.min(1);
     }
   }, setMethods));
 };
@@ -2873,6 +3445,13 @@ const tuple = (items, rest = null) => {
     dataType: "tuple",
     items,
     restType: rest,
+    toCode(t) {
+      return toCode(
+        this,
+        t,
+        `${t}.tuple([${this.items.map((item) => item.toCode(t)).join(", ")}]${this.restType ? `, ${this.restType.toCode(t)}` : ""})`
+      );
+    },
     rest(rest2) {
       return __spreadProps$4(__spreadValues$9({}, this), {
         restType: rest2
@@ -2933,6 +3512,10 @@ class JSONColumn extends ColumnType {
     const schema = typeof schemaOrFn === "function" ? schemaOrFn(jsonTypes) : schemaOrFn;
     this.data = { schema };
   }
+  toCode(t) {
+    const { schema } = this.data;
+    return columnCode(this, t, `${t}.json((t) => ${schema.toCode("t")})`);
+  }
 }
 class JSONTextColumn extends ColumnType {
   constructor() {
@@ -2940,6 +3523,9 @@ class JSONTextColumn extends ColumnType {
     this.dataType = "json";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.jsonText()`);
+  }
 }
 
 class ArrayColumn extends ColumnType {
@@ -2947,23 +3533,43 @@ class ArrayColumn extends ColumnType {
     super();
     this.dataType = "array";
     this.operators = Operators.array;
-    this.parseFn = (input) => {
-      const entries = [];
-      parseArray(
-        input,
-        0,
-        input.length,
-        entries,
-        false,
-        this.data.item
-      );
-      return entries;
-    };
+    this.parseFn = Object.assign(
+      (input) => {
+        const entries = [];
+        parseArray(
+          input,
+          0,
+          input.length,
+          entries,
+          false,
+          this.data.item
+        );
+        return entries;
+      },
+      {
+        hideFromCode: true
+      }
+    );
     this.data = { item };
   }
   toSQL() {
     return `${this.data.item.toSQL()}[]`;
   }
+  toCode(t) {
+    let code = ")";
+    const { min, max, length, isNonEmpty } = this.data;
+    if (min !== void 0 && (!isNonEmpty || isNonEmpty && min !== 1))
+      code += `.min(${min})`;
+    if (max !== void 0)
+      code += `.max(${max})`;
+    if (length !== void 0)
+      code += `.length(${length})`;
+    return columnCode(this, t, [
+      "t.array(",
+      ...toArray(this.data.item.toCode(t)),
+      code
+    ]);
+  }
 }
 const parseArray = (input, pos, len, entries, nested, item) => {
   if (input[0] === "[") {
@@ -3201,6 +3807,9 @@ class VirtualColumn extends ColumnType {
     this.dataType = "";
     this.operators = Operators.any;
   }
+  toCode() {
+    throw new Error(`toCode is not implemented for virtual column`);
+  }
 }
 
 var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
@@ -4154,9 +4763,9 @@ class Delete {
 
 const forQueryBuilder = (q, type, tableNames) => {
   q.query.for = { type, tableNames };
-  q.__model = Object.create(q.__model);
-  q.__model.__model = q.__model;
-  Object.assign(q.__model, {
+  q.__table = Object.create(q.__table);
+  q.__table.__table = q.__table;
+  Object.assign(q.__table, {
     noWait() {
       return this.clone()._noWait();
     },
@@ -4247,7 +4856,7 @@ var __spreadValues$5 = (a, b) => {
   return a;
 };
 const processHavingArg = (arg) => {
-  if ("__model" in arg || isRaw(arg)) {
+  if ("__table" in arg || isRaw(arg)) {
     return arg;
   } else {
     const processed = __spreadValues$5({}, arg);
@@ -4694,13 +5303,13 @@ class WhereQueryBuilder extends Where {
     this.withData = {};
     this.table = typeof q === "object" ? q.table : q;
     this.shape = shape;
-    this.__model = this;
+    this.__table = this;
     if (typeof q === "object" && q.query.as) {
       this.query.as = q.query.as;
     }
   }
   clone() {
-    const cloned = Object.create(this.__model);
+    const cloned = Object.create(this.__table);
     cloned.query = getClonedQueryData(this.query);
     return cloned;
   }
@@ -4841,7 +5450,7 @@ class Json {
     return this.clone()._json();
   }
   _json() {
-    const q = this._wrap(this.__model.clone());
+    const q = this._wrap(this.__table.clone());
     q._getOptional(
       raw(
         queryTypeWithLimitOne[this.query.returnType] ? `row_to_json("t".*)` : `COALESCE(json_agg(row_to_json("t".*)), '[]')`
@@ -5247,7 +5856,7 @@ class Update {
         ctx.resultAll = await handleResult(q, queryResult);
         if (ctx.updateLater) {
           await Promise.all(ctx.updateLaterPromises);
-          const t = this.__model.clone().transacting(q);
+          const t = this.__table.clone().transacting(q);
           const keys = this.primaryKeys;
           t._whereIn(
             keys,
@@ -5496,7 +6105,7 @@ class QueryMethods {
     return this;
   }
   clone() {
-    const cloned = Object.create(this.__model);
+    const cloned = Object.create(this.__table);
     cloned.query = getClonedQueryData(this.query);
     return cloned;
   }
@@ -5680,7 +6289,7 @@ class Db {
     this.whereQueryBuilder = WhereQueryBuilder;
     this.onQueryBuilder = OnQueryBuilder;
     var _a, _b;
-    this.__model = this;
+    this.__table = this;
     const logger = options.logger || console;
     this.query = {
       adapter,
@@ -5792,5 +6401,5 @@ const createDb = (_a) => {
   return db;
 };
 
-export { Adapter, Aggregate, ArrayColumn, ArrayOfColumnsObjects, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, Clear, ColumnInfoMethods, ColumnType, ColumnsObject, Create, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeWithTimeZoneBaseClass, Db, DecimalBaseColumn, DecimalColumn, Delete, DoublePrecisionColumn, EMPTY_OBJECT, EnumColumn, For, From, Having, InetColumn, IntegerBaseColumn, IntegerColumn, IntervalColumn, JSONColumn, JSONTextColumn, Join, Json, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, OnConflictQueryBuilder, OnQueryBuilder, Operators, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, PormError, PormInternalError, QueryCallbacks, QueryError, QueryGet, QueryLog, QueryMethods, QueryUpsert, RawMethods, RealColumn, Select, SerialColumn, SmallIntColumn, SmallSerialColumn, TextBaseColumn, TextColumn, Then, TimeColumn, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, Transaction, TransactionAdapter, TsQueryColumn, TsVectorColumn, UUIDColumn, UnhandledTypeError, Union, Update, VarCharColumn, VirtualColumn, Where, WhereQueryBuilder, With, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addParserToQuery, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, anyShape, applyMixins, array, arrayToEnum, checkIfASimpleQuery, cloneQueryArrays, columnTypes, utils as columnUtils, constructType, createDb, createOperator, defaultsKey, discriminatedUnion, emptyObject, enumType, getClonedQueryData, getColumnTypes, getQueryAs, getQueryParsers, getRaw, getRawSql, getTableData, getValidEnumValues, getValueKey, handleResult, instanceOf, intersection, isQueryReturnsAll, isRaw, isRequiredRelationKey, joinTruthy, jsonTypes, lazy, literal, logColors, logParamToLogObject, makeRegexToFindInSql, makeSql, map, nativeEnum, newTableData, noop, notNullable, notNullish, nullable, nullish, object, optional, parseRecord, parseResult, processSelectArg, pushOrNewArray, pushOrNewArrayToObject, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, raw, record, relationQueryKey, required, resetTableData, scalarTypes, set, setQueryObjectValue, toArray, toSql, toSqlCacheKey, tuple, union };
+export { Adapter, Aggregate, ArrayColumn, ArrayOfColumnsObjects, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, Clear, ColumnInfoMethods, ColumnType, ColumnsObject, Create, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeWithTimeZoneBaseClass, Db, DecimalBaseColumn, DecimalColumn, Delete, DoublePrecisionColumn, EMPTY_OBJECT, EnumColumn, For, From, Having, InetColumn, IntegerBaseColumn, IntegerColumn, IntervalColumn, JSONColumn, JSONTextColumn, Join, Json, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, OnConflictQueryBuilder, OnQueryBuilder, Operators, PathColumn, PluckResultColumnType, PointColumn, PolygonColumn, PormError, PormInternalError, QueryCallbacks, QueryError, QueryGet, QueryLog, QueryMethods, QueryUpsert, RawMethods, RealColumn, Select, SerialColumn, SmallIntColumn, SmallSerialColumn, TextBaseColumn, TextColumn, Then, TimeColumn, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, Transaction, TransactionAdapter, TsQueryColumn, TsVectorColumn, UUIDColumn, UnhandledTypeError, Union, Update, VarCharColumn, VirtualColumn, Where, WhereQueryBuilder, With, XMLColumn, addOr, addOrNot, addParserForRawExpression, addParserForSelectItem, addParserToQuery, addQueryOn, addQueryOrOn, addWhere, addWhereIn, addWhereNot, aggregate1FunctionNames, anyShape, applyMixins, array, arrayToEnum, checkIfASimpleQuery, cloneQueryArrays, columnChainToCode, columnCode, columnTypes, utils as columnUtils, constructType, createDb, createOperator, defaultsKey, discriminatedUnion, emptyObject, enumType, getClonedQueryData, getColumnTypes, getQueryAs, getQueryParsers, getRaw, getRawSql, getTableData, getValidEnumValues, getValueKey, handleResult, instanceOf, intersection, isQueryReturnsAll, isRaw, isRequiredRelationKey, joinTruthy, jsonTypes, lazy, literal, logColors, logParamToLogObject, makeRegexToFindInSql, makeSql, map, nativeEnum, newTableData, noop, notNullable, notNullish, nullable, nullish, object, optional, parseRecord, parseResult, processSelectArg, pushOrNewArray, pushOrNewArrayToObject, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryMethodByReturnType, queryTypeWithLimitOne, quote, raw, record, relationQueryKey, required, resetTableData, scalarTypes, set, setQueryObjectValue, singleQuote, toArray, toCode, toSql, toSqlCacheKey, tuple, union };
 //# sourceMappingURL=index.esm.js.map