pqb 0.7.13 → 0.8.1

package/dist/index.js

@@ -4,168 +4,77 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var pg = require('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");
@@ -225,24 +134,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 = {
@@ -251,7 +160,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);
@@ -261,7 +170,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;
@@ -275,8 +184,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}`;
@@ -286,21 +195,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);
@@ -335,11 +244,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
     );
@@ -349,41 +258,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,
@@ -404,15 +313,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;
@@ -421,7 +330,7 @@ const processWhere = (ands, ctx, model, data, quotedAs, not) => {
         const rightColumn = quoteFullColumn(
           item[2],
           getQueryAs({
-            table: model.table,
+            table: table.table,
             query: { as: quotedAs }
           })
         );
@@ -454,7 +363,7 @@ const processWhere = (ands, ctx, model, data, quotedAs, not) => {
       joinItems.forEach((item) => {
         const { target, conditions } = processJoinItem(
           ctx,
-          model,
+          table,
           item,
           quotedAs
         );
@@ -471,7 +380,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`);
         }
@@ -519,29 +428,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 ");
@@ -581,7 +490,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])
@@ -638,6 +547,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");
 
@@ -677,10 +624,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 = [];
@@ -717,13 +664,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));
         }
       }
     });
@@ -752,7 +699,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;
     }
@@ -781,12 +728,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 "";
@@ -794,7 +741,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,
@@ -820,7 +767,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`
@@ -828,7 +775,7 @@ const havingToSql = (ctx, model, query, quotedAs) => {
                   }
                   const expression = aggregateToSql(
                     ctx,
-                    model,
+                    table,
                     {
                       function: key,
                       arg: column,
@@ -849,7 +796,7 @@ const havingToSql = (ctx, model, query, quotedAs) => {
               ands.push(
                 `${aggregateToSql(
                   ctx,
-                  model,
+                  table,
                   {
                     function: key,
                     arg: column,
@@ -915,17 +862,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)) {
@@ -944,7 +891,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) => {
@@ -974,7 +921,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) {
@@ -1029,22 +976,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}`);
@@ -1053,8 +1000,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;
@@ -1091,9 +1038,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}`);
@@ -1101,12 +1048,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);
@@ -1114,7 +1061,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) => {
@@ -1137,13 +1084,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 = [];
@@ -1173,19 +1120,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
   };
@@ -1194,56 +1141,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(
@@ -1252,7 +1199,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 = [];
@@ -1359,19 +1306,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;
 };
@@ -1390,7 +1337,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;
@@ -1418,72 +1365,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;
@@ -1682,20 +1808,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() {
@@ -1781,6 +1909,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);
@@ -1812,6 +1954,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(
@@ -1826,6 +1976,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() {
@@ -1833,12 +1986,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 {
 }
@@ -1848,12 +2007,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() {
@@ -1862,6 +2027,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() {
@@ -1870,6 +2042,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() {
@@ -1877,8 +2052,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() {
@@ -1891,12 +2096,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})`
     );
   }
 }
@@ -1905,12 +2110,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() {
@@ -1918,6 +2139,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() {
@@ -1925,6 +2149,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() {
@@ -1932,56 +2159,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 {
@@ -1990,6 +2246,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() {
@@ -1997,6 +2256,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() {
@@ -2004,6 +2266,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() {
@@ -2011,6 +2276,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) {
@@ -2019,6 +2287,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,
@@ -2033,6 +2305,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,
@@ -2046,6 +2322,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() {
@@ -2053,6 +2332,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() {
@@ -2060,6 +2342,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() {
@@ -2067,6 +2352,9 @@ class XMLColumn extends ColumnType {
     this.dataType = "xml";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.xml()`);
+  }
 }
 
 class DateBaseColumn extends ColumnType {
@@ -2083,11 +2371,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) {
@@ -2115,6 +2414,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() {
@@ -2122,12 +2429,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() {
@@ -2135,6 +2460,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) {
@@ -2143,6 +2476,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,
@@ -2159,6 +2500,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 {
@@ -2169,6 +2513,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;
   }
@@ -2307,14 +2658,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;
+        })
+      );
+    }
   });
 };
 
@@ -2337,11 +2712,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);
   },
@@ -2361,7 +2759,7 @@ const baseTypeMethods = {
     return notNullish(this);
   },
   deepPartial() {
-    return this;
+    return this.optional();
   },
   transform(fn) {
     return __spreadProps$d(__spreadValues$i({}, this), {
@@ -2369,7 +2767,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]
     });
   },
@@ -2426,13 +2824,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));
 };
@@ -2468,6 +2877,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) => {
@@ -2493,14 +2909,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})`);
+    }
   });
 };
 
@@ -2529,8 +2955,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()
       });
@@ -2540,7 +2976,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;
@@ -2567,8 +3011,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()
       });
@@ -2590,7 +3044,10 @@ const nativeEnum = (givenEnum) => {
   return constructType({
     dataType: "nativeEnum",
     enum: givenEnum,
-    options
+    options,
+    toCode(t) {
+      return toCode(this, t, `${t}.nativeEnum(enum)`);
+    }
   });
 };
 
@@ -2619,6 +3076,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)
@@ -2709,66 +3183,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 = {
@@ -2811,6 +3364,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()
@@ -2842,13 +3402,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));
 };
@@ -2877,6 +3449,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
@@ -2937,6 +3516,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() {
@@ -2944,6 +3527,9 @@ class JSONTextColumn extends ColumnType {
     this.dataType = "json";
     this.operators = Operators.text;
   }
+  toCode(t) {
+    return columnCode(this, t, `${t}.jsonText()`);
+  }
 }
 
 class ArrayColumn extends ColumnType {
@@ -2951,23 +3537,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] === "[") {
@@ -3205,6 +3811,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;
@@ -4158,9 +4767,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();
     },
@@ -4251,7 +4860,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);
@@ -4698,13 +5307,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;
   }
@@ -4845,7 +5454,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".*)), '[]')`
@@ -5251,7 +5860,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,
@@ -5500,7 +6109,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;
   }
@@ -5684,7 +6293,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,
@@ -5907,6 +6516,8 @@ exports.array = array;
 exports.arrayToEnum = arrayToEnum;
 exports.checkIfASimpleQuery = checkIfASimpleQuery;
 exports.cloneQueryArrays = cloneQueryArrays;
+exports.columnChainToCode = columnChainToCode;
+exports.columnCode = columnCode;
 exports.columnTypes = columnTypes;
 exports.columnUtils = utils;
 exports.constructType = constructType;
@@ -5969,7 +6580,9 @@ exports.resetTableData = resetTableData;
 exports.scalarTypes = scalarTypes;
 exports.set = set;
 exports.setQueryObjectValue = setQueryObjectValue;
+exports.singleQuote = singleQuote;
 exports.toArray = toArray;
+exports.toCode = toCode;
 exports.toSql = toSql;
 exports.toSqlCacheKey = toSqlCacheKey;
 exports.tuple = tuple;