pqb 0.57.0 → 0.57.2

package/dist/index.js

@@ -1,10 +1,1053 @@
 'use strict';
 
-var orchidCore = require('orchid-core');
+var url = require('url');
+var path = require('node:path');
+var promises = require('timers/promises');
 var node_util = require('node:util');
 var node_async_hooks = require('node:async_hooks');
 var pqb = require('pqb');
 
+const colors = {
+  yellow: (s) => `\x1B[33m${s}\x1B[0m`,
+  green: (s) => `\x1B[32m${s}\x1B[0m`,
+  red: (s) => `\x1B[31m${s}\x1B[0m`,
+  blue: (s) => `\x1B[34m${s}\x1B[0m`,
+  bright: (s) => `\x1B[1m${s}\x1B[0m`,
+  blueBold: (s) => `\x1B[1m\x1B[34m${s}\x1B[0m`,
+  yellowBold: (s) => `\x1B[1m\x1B[33m${s}\x1B[0m`,
+  greenBold: (s) => `\x1B[1m\x1B[32m${s}\x1B[0m`,
+  pale: (s) => `\x1B[2m${s}\x1B[0m`
+};
+
+function applyMixins(derivedCtor, constructors) {
+  constructors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      Object.defineProperty(
+        derivedCtor.prototype,
+        name,
+        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || /* @__PURE__ */ Object.create(null)
+      );
+    });
+  });
+}
+const joinTruthy = (...strings) => {
+  return strings.filter((string) => string).join("");
+};
+const toArray = (item) => Array.isArray(item) ? item : [item];
+const noop = () => {
+};
+const returnArg = (a) => a;
+const emptyObject = {};
+const emptyArray = [];
+const pushOrNewArrayToObjectImmutable = (obj, key, value) => {
+  obj[key] = obj[key] ? [...obj[key], value] : [value];
+};
+const setObjectValueImmutable = (q, object, key, value) => {
+  q[object] = {
+    ...q[object],
+    [key]: value
+  };
+  return q;
+};
+const spreadObjectValues = (q, object, value) => {
+  q[object] = {
+    ...q[object],
+    ...value
+  };
+};
+const pushOrNewArray = (arr, value) => {
+  if (arr) {
+    arr.push(value);
+    return arr;
+  } else {
+    return [value];
+  }
+};
+const singleQuote = (s) => {
+  return `'${s.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+};
+const backtickQuote = (s) => {
+  return `\`${s.replaceAll("\\", "\\\\").replaceAll("`", "\\`")}\``;
+};
+const singleQuoteArray = (arr) => {
+  return `[${arr.map(singleQuote).join(", ")}]`;
+};
+const quoteObjectKey = (key, toCamel) => {
+  if (toCamel) key = toCamelCase(key);
+  return /^[a-zA-Z_$][\w$]*$/.test(key) ? key : singleQuote(key);
+};
+const isObjectEmpty = (obj) => !objectHasValues(obj);
+const objectHasValues = (obj) => {
+  if (!obj) return false;
+  for (const key in obj) {
+    if (obj[key] !== void 0) return true;
+  }
+  return false;
+};
+const pathToLog = (path2) => {
+  return process.platform === "win32" ? path2 : url.pathToFileURL(path2).toString();
+};
+const toCamelCase = (str) => {
+  return str.replace(/^_+/g, "").replace(/_+./g, (a) => a[a.length - 1].toUpperCase()).replace(/_+$/g, "");
+};
+const toPascalCase = (str) => {
+  const camel = toCamelCase(str);
+  return camel[0].toUpperCase() + camel.slice(1);
+};
+const toSnakeCase = (str) => {
+  return str.replace(/[A-Z]/g, (a) => `_${a.toLowerCase()}`);
+};
+const deepCompare = (a, b) => {
+  if (a === b) return true;
+  if (typeof a !== typeof b) {
+    if (a === void 0 && typeof b === "object") {
+      a = emptyObject;
+    } else if (typeof a === "object" && b === void 0) {
+      b = emptyObject;
+    } else {
+      return false;
+    }
+  }
+  if (typeof a === "object") {
+    if (a === null) return b === null;
+    if (Array.isArray(a)) {
+      if (!Array.isArray(b) || a.length !== b.length) return false;
+      return a.every((item, i) => deepCompare(item, b[i]));
+    }
+    for (const key in a) {
+      if (!deepCompare(a[key], b[key]))
+        return false;
+    }
+    for (const key in b) {
+      if (!(key in a) && b[key] !== void 0) return false;
+    }
+    return true;
+  }
+  return a === b;
+};
+const getImportPath = (from, to) => {
+  const rel = path.relative(path.dirname(from), to).split(path.sep).join(path.posix.sep);
+  const importPath = rel.startsWith("./") || rel.startsWith("../") ? rel : `./${rel}`;
+  return importPath.replace(/\.[tj]s$/, "");
+};
+const getStackTrace = () => {
+  let stack;
+  const original = Error.prepareStackTrace;
+  Error.prepareStackTrace = (_, s) => stack = s;
+  new Error().stack;
+  Error.prepareStackTrace = original;
+  return stack;
+};
+const getCallerFilePath = (stack = getStackTrace()) => {
+  if (stack) {
+    const coreLibFile = stack[0]?.getFileName();
+    let i = 1;
+    if (stack[1]?.getFileName() === coreLibFile) {
+      i++;
+    }
+    const libFile = stack[i]?.getFileName();
+    const libDir = libFile && path.dirname(libFile);
+    for (; i < stack.length; i++) {
+      const item = stack[i];
+      let file = item.getFileName();
+      if (!file || // skip files in the caller orchid library
+      path.dirname(file) === libDir || // skip any files in the node_modules
+      /\bnode_modules\b/.test(file)) {
+        continue;
+      }
+      if (/file:\/\/\/\w+:\//.test(file)) {
+        file = decodeURI(file.slice(8));
+      } else {
+        try {
+          file = new URL(file).pathname;
+        } catch (_) {
+        }
+      }
+      return file;
+    }
+  }
+  return;
+};
+const callWithThis = function(cb) {
+  return cb(this);
+};
+const pick = (obj, keys) => {
+  const res = {};
+  for (const key of keys) {
+    res[key] = obj[key];
+  }
+  return res;
+};
+const omit = (obj, keys) => {
+  const res = { ...obj };
+  for (const key of keys) {
+    delete res[key];
+  }
+  return res;
+};
+const addValue = (values, value) => {
+  values.push(value);
+  return `$${values.length}`;
+};
+const getFreeAlias = (obj, as) => {
+  if (obj?.[as]) {
+    let suffix = 2;
+    let name;
+    while (obj[name = as + suffix]) {
+      suffix++;
+    }
+    as = name;
+  }
+  return as;
+};
+const getFreeSetAlias = (set, as, start = 2) => {
+  if (set.has(as)) {
+    let suffix = start;
+    let name;
+    while (set.has(name = as + suffix)) {
+      suffix++;
+    }
+    as = name;
+  }
+  return as;
+};
+const exhaustive = (_) => {
+  throw new Error("Condition was not exhaustive");
+};
+const pluralize = (w, count, append = "s") => {
+  return count === 1 ? w : w + append;
+};
+const isIterable = (x) => !!(x && typeof x === "object" && typeof x[Symbol.iterator] === "function");
+
+const setConnectRetryConfig = (adapter, config) => {
+  adapter.connectRetryConfig = {
+    attempts: config.attempts ?? 10,
+    strategy: typeof config.strategy === "function" ? config.strategy : defaultConnectRetryStrategy(config.strategy ?? emptyObject)
+  };
+};
+const wrapAdapterFnWithConnectRetry = (adapter, fn) => {
+  return async function(...args) {
+    let attempt = 1;
+    for (; ; ) {
+      try {
+        return await fn.call(this, ...args);
+      } catch (err) {
+        const config = adapter.connectRetryConfig;
+        if (!err || typeof err !== "object" || err.code !== "ECONNREFUSED" || !config || attempt >= config.attempts) {
+          throw err;
+        }
+        await config.strategy(attempt, config.attempts);
+        attempt++;
+      }
+    }
+  };
+};
+const defaultConnectRetryStrategy = (param) => {
+  return (attempt) => promises.setTimeout((param.factor ?? 1.5) ** (attempt - 1) * (param.delay ?? 50));
+};
+
+const getValueKey = Symbol("get");
+const applyTransforms = (queryData, returnType, fns, result) => {
+  for (const fn of fns) {
+    if ("map" in fn) {
+      if (!returnType || returnType === "all" || returnType === "pluck") {
+        result = result.map(fn.map, fn.thisArg);
+      } else if (result !== void 0) {
+        result = result === null ? null : fn.map.call(fn.thisArg, result, 0, result);
+      }
+    } else {
+      result = fn(result, queryData);
+    }
+  }
+  return result;
+};
+const pushQueryValueImmutable = (q, key, value) => {
+  pushOrNewArrayToObjectImmutable(
+    q.q,
+    key,
+    value
+  );
+  return q;
+};
+
+const numberMethodNames = ["gt", "gte", "lt", "lte", "step", "int", "finite", "safe"];
+const stringMethodNames = [
+  "nonEmpty",
+  "min",
+  "max",
+  "length",
+  "email",
+  "url",
+  "emoji",
+  "uuid",
+  "cuid",
+  "cuid2",
+  "ulid",
+  "regex",
+  "includes",
+  "startsWith",
+  "endsWith",
+  "datetime",
+  "ipv4",
+  "ipv6",
+  "trim",
+  "toLowerCase",
+  "toUpperCase"
+];
+const dateMethodNames = ["min", "max"];
+const arrayMethodNames = [
+  "min",
+  "max",
+  "length",
+  "nonEmpty"
+];
+
+class Expression {
+  // Produce SQL string by calling `makeSQL` and applying operators from the `q.chain`, push query variables into given `values` array.
+  toSQL(ctx, quotedAs) {
+    let sql = this.makeSQL(ctx, quotedAs);
+    if (this.q.chain) {
+      const { chain } = this.q;
+      for (let i = 0, len = chain.length; i < len; i += 2) {
+        sql = chain[i](
+          sql,
+          chain[i + 1],
+          ctx,
+          quotedAs
+        );
+      }
+    }
+    return sql;
+  }
+}
+const isExpression = (arg) => arg instanceof Expression;
+const isTemplateLiteralArgs = (args) => Array.isArray(args[0]) && "raw" in args[0] && Array.isArray(args[0].raw);
+class ExpressionTypeMethod {
+  // Define the resulting column type for the raw SQL.
+  type(fn) {
+    const column = fn(this.columnTypes);
+    this.q.expr.result.value = column;
+    Object.assign(
+      "baseQuery" in this ? this.baseQuery : this,
+      column.operators
+    );
+    return this;
+  }
+}
+class RawSQLBase extends Expression {
+  constructor(_sql, _values) {
+    super();
+    this._sql = _sql;
+    this._values = _values;
+    this.q = { expr: this };
+  }
+  // Attach query variables to the raw SQL.
+  values(values) {
+    this._values = values;
+    return this;
+  }
+  // Convert raw SQL to code for a code generator.
+  toCode(t) {
+    const { _sql: sql, _values: values } = this;
+    let code = `${t}.sql`;
+    code += typeof sql === "string" ? `({ raw: '${sql.replace(/'/g, "\\'")}' })` : templateLiteralSQLToCode(sql);
+    if (values) {
+      code += `.values(${JSON.stringify(values)})`;
+    }
+    return code;
+  }
+}
+const templateLiteralSQLToCode = (sql) => {
+  let code = "`";
+  const parts = sql[0];
+  let i = 0;
+  for (let last = parts.length - 1; i < last; i++) {
+    code += parts[i] + `\${${sql[i + 1]}}`;
+  }
+  code += parts[i];
+  return code + "`";
+};
+RawSQLBase.prototype.type = ExpressionTypeMethod.prototype.type;
+const isRawSQL = (arg) => arg instanceof RawSQLBase;
+class ValExpression extends Expression {
+  constructor(value) {
+    super();
+    this.value = value;
+    // TODO: move unknown column to core and use it here
+    this.result = { value: emptyObject };
+    this.q = { expr: this };
+  }
+  makeSQL(ctx) {
+    return addValue(ctx.values, this.value);
+  }
+}
+
+const addCode = (code, add) => {
+  if (typeof add === "object") {
+    code.push(add);
+  } else {
+    const last = code.length - 1;
+    if (typeof code[last] === "string") {
+      code[last] = code[last] + add;
+    } else {
+      code.push(add);
+    }
+  }
+};
+const codeToString = (code, tabs, shift) => {
+  if (typeof code === "string") return `${tabs}${code}`;
+  const lines = [];
+  for (const item of code) {
+    if (typeof item === "string") {
+      lines.push(`${tabs}${item}`);
+    } else {
+      lines.push(codeToString(item, tabs + shift, shift));
+    }
+  }
+  return lines.length ? lines.join("\n") : "";
+};
+const columnDefaultArgumentToCode = (t, value) => {
+  if (typeof value === "object" && value && isRawSQL(value)) {
+    return value.toCode(t);
+  } else if (typeof value === "function") {
+    return value.toString();
+  } else if (typeof value === "string") {
+    return singleQuote(value);
+  } else {
+    return JSON.stringify(value);
+  }
+};
+const columnMethodsToCode = (methodNames, skip, aliases) => {
+  return (data, migration, skipLocal) => {
+    return migration ? "" : methodNames.map(
+      (key) => (skipLocal || skip)?.[key] || key === "min" && data.nonEmpty && data.min === 1 ? "" : columnMethodToCode(data, key, aliases?.[key])
+    ).join("");
+  };
+};
+const columnMethodToCode = (data, key, name = key) => {
+  const param = data[key];
+  if (param === void 0) return "";
+  const error = data.errors?.[key];
+  let params;
+  if (typeof param === "object" && param && param?.constructor === Object) {
+    const props = [];
+    for (const key2 in param) {
+      if (key2 === "message") continue;
+      const value = param[key2];
+      if (value !== void 0) {
+        props.push(
+          `${key2}: ${typeof value === "string" ? singleQuote(value) : value}`
+        );
+      }
+    }
+    if (error) props.push(`message: ${singleQuote(error)}`);
+    params = props.length ? `{ ${props.join(", ")} }` : "";
+  } else {
+    params = param === true ? "" : typeof param === "string" ? singleQuote(param) : param instanceof Date ? `new Date('${param.toISOString()}')` : param;
+    if (error) {
+      if (param !== true) params += ", ";
+      params += singleQuote(error);
+    }
+  }
+  return `.${name}(${params})`;
+};
+const stringDataToCode = columnMethodsToCode(stringMethodNames);
+const numberDataToCode = columnMethodsToCode(
+  numberMethodNames,
+  void 0,
+  { lte: "max", gte: "min" }
+);
+const dateDataToCode = columnMethodsToCode(dateMethodNames);
+const arrayDataToCode = columnMethodsToCode(arrayMethodNames);
+const columnErrorMessagesToCode = (errors) => {
+  const props = [];
+  if (errors.required) {
+    props.push(`required: ${singleQuote(errors.required)},`);
+  }
+  if (errors.invalidType) {
+    props.push(`invalidType: ${singleQuote(errors.invalidType)},`);
+  }
+  const code = [];
+  if (!props.length) return code;
+  addCode(code, ".error({");
+  code.push(props);
+  addCode(code, "})");
+  return code;
+};
+
+function makeColumnNullable(column, inputSchema, outputSchema, querySchema) {
+  const c = setColumnData(column, "isNullable", true);
+  c.inputSchema = inputSchema;
+  c.outputSchema = outputSchema;
+  c.querySchema = querySchema;
+  return c;
+}
+const setColumnData = (q, key, value) => {
+  const cloned = Object.create(q);
+  cloned.data = { ...q.data, [key]: value };
+  return cloned;
+};
+const pushColumnData = (q, key, value) => {
+  const arr = q.data[key];
+  return setColumnData(
+    q,
+    key,
+    arr ? [...arr, value] : [value]
+  );
+};
+const setDataValue = (item, key, value, params) => {
+  var _a;
+  const cloned = Object.create(item);
+  cloned.data = { ...item.data, [key]: value };
+  if (params && (typeof params === "string" || params.message)) {
+    ((_a = cloned.data).errors ?? (_a.errors = {}))[key] = typeof params === "string" ? params : params.message;
+  }
+  return cloned;
+};
+let currentName;
+function setCurrentColumnName(name) {
+  currentName = name;
+}
+const consumeColumnName = () => {
+  const name = currentName;
+  currentName = void 0;
+  return name;
+};
+const defaultNowFn = "now()";
+let currentNowFn = defaultNowFn;
+const setDefaultNowFn = (sql) => {
+  currentNowFn = `(${sql})`;
+};
+const getDefaultNowFn = () => currentNowFn;
+let defaultLanguage = "english";
+const setDefaultLanguage = (lang) => {
+  defaultLanguage = lang || "english";
+};
+const getDefaultLanguage = () => defaultLanguage;
+class ColumnTypeBase {
+  constructor(schema, inputSchema, outputSchema = inputSchema, querySchema = inputSchema) {
+    this.inputSchema = inputSchema;
+    this.outputSchema = outputSchema;
+    this.querySchema = querySchema;
+    this.parse = schema.parse;
+    this.parseNull = schema.parseNull;
+    this.encode = schema.encode;
+    this.asType = schema.asType;
+    this.narrowType = schema.narrowType;
+    this.narrowAllTypes = schema.narrowAllTypes;
+    this.nullable = schema.nullable;
+    this.error = schema.error;
+    const name = consumeColumnName();
+    this.data = name ? { name } : {};
+  }
+  /**
+   * Set a default value to a column. Columns that have defaults become optional when creating a record.
+   *
+   * If you provide a value or a raw SQL, such default should be set on the column in migration to be applied on a database level.
+   *
+   * Or you can specify a callback that returns a value. This function will be called for each creating record. Such a default won't be applied to a database.
+   *
+   * ```ts
+   * export class Table extends BaseTable {
+   *   readonly table = 'table';
+   *   columns = this.setColumns((t) => ({
+   *     // values as defaults:
+   *     int: t.integer().default(123),
+   *     text: t.text().default('text'),
+   *
+   *     // raw SQL default:
+   *     timestamp: t.timestamp().default(t.sql`now()`),
+   *
+   *     // runtime default, each new records gets a new random value:
+   *     random: t.numeric().default(() => Math.random()),
+   *   }));
+   * }
+   * ```
+   *
+   * @param value - default value or a function returning a value
+   */
+  default(value) {
+    return setColumnData(this, "default", value);
+  }
+  /**
+   * Use `hasDefault` to let the column be omitted when creating records.
+   *
+   * It's better to use {@link default} instead so the value is explicit and serves as a hint.
+   */
+  hasDefault() {
+    return this;
+  }
+  /**
+   * Set a database-level validation check to a column. `check` accepts a raw SQL.
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.createTable('table', (t) => ({
+   *     // validate rank to be from 1 to 10
+   *     rank: t.integer().check(t.sql`1 >= "rank" AND "rank" <= 10`),
+   *     // constraint name can be passed as a second argument
+   *     column: t.integer().check(t.sql`...`, 'check_name'),
+   *     // a single column can have multiple checks
+   *     multiChecksColumn: t
+   *       .integer()
+   *       .check(t.sql`...`)
+   *       .check(t.sql`...`, 'optional_name'),
+   *   }));
+   * });
+   * ```
+   *
+   * @param sql - raw SQL expression
+   * @param name - to specify a constraint name
+   */
+  check(sql, name) {
+    return pushColumnData(this, "checks", { sql, name });
+  }
+  /**
+   * This method changes a column type without modifying its behavior.
+   * This is needed when converting columns to a validation schema, the converter will pick a different type specified by `.as`.
+   *
+   * Before calling `.as` need to use `.encode` with the input of the same type as the input of the target column,
+   * and `.parse` which returns the correct type.
+   *
+   * ```ts
+   * // column has the same type as t.integer()
+   * const column = t
+   *   .string()
+   *   .encode((input: number) => input)
+   *   .parse((text) => parseInt(text))
+   *   .as(t.integer());
+   * ```
+   *
+   * @param column - other column type to inherit from
+   */
+  as(column) {
+    return setColumnData(
+      this,
+      "as",
+      column
+    );
+  }
+  input(fn) {
+    const cloned = Object.create(this);
+    cloned.inputSchema = fn(this.inputSchema);
+    return cloned;
+  }
+  output(fn) {
+    const cloned = Object.create(this);
+    cloned.outputSchema = fn(this.outputSchema);
+    return cloned;
+  }
+  query(fn) {
+    const cloned = Object.create(this);
+    cloned.querySchema = fn(this.querySchema);
+    return cloned;
+  }
+  /**
+   * Set a database column name.
+   *
+   * @param name - name of the column in database.
+   */
+  name(name) {
+    return setColumnData(this, "name", name);
+  }
+  /**
+   * Append `select(false)` to a column to exclude it from the default selection.
+   * It won't be selected with `selectAll` or `select('*')` as well.
+   *
+   * ```ts
+   * export class UserTable extends BaseTable {
+   *   readonly table = 'user';
+   *   columns = this.setColumns((t) => ({
+   *     id: t.identity().primaryKey(),
+   *     name: t.string(),
+   *     password: t.string().select(false),
+   *   }));
+   * }
+   *
+   * // only id and name are selected, without password
+   * const user = await db.user.find(123);
+   *
+   * // password is still omitted, even with the wildcard
+   * const same = await db.user.find(123).select('*');
+   *
+   * const comment = await db.comment.find(123).select({
+   *   // password is omitted in the sub-selects as well
+   *   author: (q) => q.author,
+   * });
+   *
+   * // password is omitted here as well
+   * const created = await db.user.create(userData);
+   * ```
+   *
+   * Such a column can only be selected explicitly.
+   *
+   * ```ts
+   * const userWithPassword = await db.user.find(123).select('*', 'password');
+   * ```
+   */
+  select(value) {
+    return setColumnData(this, "explicitSelect", !value);
+  }
+  /**
+   * Forbid the column to be used in [create](/guide/create-update-delete.html#create-insert) and [update](/guide/create-update-delete.html#update) methods.
+   *
+   * `readOnly` column is still can be set from a [hook](http://localhost:5173/guide/hooks.html#set-values-before-create-or-update).
+   *
+   * `readOnly` column can be used together with a `default`.
+   *
+   * ```ts
+   * export class Table extends BaseTable {
+   *   readonly table = 'table';
+   *   columns = this.setColumns((t) => ({
+   *     id: t.identity().primaryKey(),
+   *     column: t.string().default(() => 'default value'),
+   *     another: t.string().readOnly(),
+   *   }));
+   *
+   *   init(orm: typeof db) {
+   *     this.beforeSave(({ set }) => {
+   *       set({ another: 'value' });
+   *     });
+   *   }
+   * }
+   *
+   * // later in the code
+   * db.table.create({ column: 'value' }); // TS error, runtime error
+   * ```
+   */
+  readOnly() {
+    return setColumnData(this, "appReadOnly", true);
+  }
+  /**
+   * Set a column value when creating a record.
+   * This works for [readOnly](#readonly) columns as well.
+   *
+   * If no value or undefined is returned, the hook won't have any effect.
+   *
+   * ```ts
+   * export class Table extends BaseTable {
+   *   readonly table = 'table';
+   *   columns = this.setColumns((t) => ({
+   *     id: t.identity().primaryKey(),
+   *     column: t.string().setOnCreate(() => 'value'),
+   *   }));
+   * }
+   * ```
+   */
+  setOnCreate(fn) {
+    return setColumnData(this, "setOnCreate", fn);
+  }
+  /**
+   * Set a column value when updating a record.
+   * This works for [readOnly](#readonly) columns as well.
+   *
+   * If no value or undefined is returned, the hook won't have any effect.
+   *
+   * ```ts
+   * export class Table extends BaseTable {
+   *   readonly table = 'table';
+   *   columns = this.setColumns((t) => ({
+   *     id: t.identity().primaryKey(),
+   *     column: t.string().setOnUpdate(() => 'value'),
+   *   }));
+   * }
+   * ```
+   */
+  setOnUpdate(fn) {
+    return setColumnData(this, "setOnUpdate", fn);
+  }
+  /**
+   * Set a column value when creating or updating a record.
+   * This works for [readOnly](#readonly) columns as well.
+   *
+   * If no value or undefined is returned, the hook won't have any effect.
+   *
+   * ```ts
+   * export class Table extends BaseTable {
+   *   readonly table = 'table';
+   *   columns = this.setColumns((t) => ({
+   *     id: t.identity().primaryKey(),
+   *     column: t.string().setOnSave(() => 'value'),
+   *   }));
+   * }
+   * ```
+   */
+  setOnSave(fn) {
+    return setColumnData(this, "setOnSave", fn);
+  }
+}
+
+const snakeCaseKey = Symbol("snakeCase");
+
+class SimpleRawSQL extends RawSQLBase {
+  // Simply returning SQL provided in the constructor.
+  makeSQL() {
+    return this._sql;
+  }
+}
+const raw$1 = (sql) => new SimpleRawSQL(sql);
+const makeTimestamps = (timestamp) => {
+  const now = getDefaultNowFn();
+  const nowRaw = raw$1(now);
+  const updatedAt = timestamp().default(nowRaw);
+  let updater;
+  updatedAt.data.modifyQuery = (q, column) => {
+    if (!updater) {
+      const key = column.data.key;
+      updater = (data) => {
+        if (data.some((item) => {
+          return typeof item !== "function" && item[key];
+        }))
+          return;
+        return { [column.data.key]: nowRaw };
+      };
+    }
+    pushOrNewArrayToObjectImmutable(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      q.q,
+      "updateData",
+      updater
+    );
+  };
+  updatedAt.data.defaultTimestamp = "updatedAt";
+  const createdAt = timestamp().default(nowRaw);
+  createdAt.data.defaultTimestamp = "createdAt";
+  return {
+    createdAt,
+    updatedAt
+  };
+};
+const timestampHelpers = {
+  timestamps() {
+    return makeTimestamps(this.timestamp);
+  },
+  timestampsNoTZ() {
+    return makeTimestamps(this.timestampNoTZ);
+  }
+};
+
+const logColors = {
+  boldCyanBright: (message) => `\x1B[1m\x1B[96m${message}\x1B[39m\x1B[22m`,
+  boldBlue: (message) => `\x1B[1m\x1B[34m${message}\x1B[39m\x1B[22m`,
+  boldYellow: (message) => `\x1B[1m\x1B[33m${message}\x1B[39m\x1B[22m`,
+  boldMagenta: (message) => `\x1B[1m\x1B[33m${message}\x1B[39m\x1B[22m`,
+  boldRed: (message) => `\x1B[1m\x1B[31m${message}\x1B[39m\x1B[22m`
+};
+
+class QueryHookUtils {
+  constructor(query, columns, key) {
+    this.query = query;
+    this.columns = columns;
+    this.key = key;
+    this.set = (data) => {
+      const set = {};
+      for (const key in data) {
+        if (data[key] !== void 0) {
+          set[key] = data[key];
+        }
+      }
+      pushQueryValueImmutable(this.query, this.key, set);
+    };
+  }
+}
+
+const queryColumnNameToKey = (q, name) => {
+  let map = q.internal.columnNameToKeyMap;
+  if (!map) {
+    q.internal.columnNameToKeyMap = map = /* @__PURE__ */ new Map();
+    const { shape } = q;
+    for (const key in q.shape) {
+      const column = shape[key];
+      map.set(column.data.name ?? key, key);
+    }
+  }
+  return map.get(name);
+};
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var _query, _query2;
+class OrchidOrmError extends Error {
+}
+class NotFoundError extends OrchidOrmError {
+  constructor(query, message = "Record is not found") {
+    super(message);
+    // `#query` is private to prevent it from serializing to not cause problems to test runner reports
+    __privateAdd(this, _query);
+    __privateSet(this, _query, query);
+  }
+  get query() {
+    return __privateGet(this, _query);
+  }
+}
+_query = new WeakMap();
+class OrchidOrmInternalError extends Error {
+  constructor(query, message, data) {
+    super(message);
+    this.data = data;
+    // `#query` is private to prevent it from serializing to not cause problems to test runner reports
+    __privateAdd(this, _query2);
+    __privateSet(this, _query2, query);
+  }
+  get query() {
+    return __privateGet(this, _query2);
+  }
+}
+_query2 = new WeakMap();
+class QueryError extends OrchidOrmInternalError {
+  get isUnique() {
+    return this.code === "23505";
+  }
+  get columns() {
+    if (this.columnsCache) return this.columnsCache;
+    const columns = {};
+    if (this.detail) {
+      const list = this.detail.match(/\((.*)\)=/)?.[1];
+      if (list) {
+        list.split(", ").forEach((item) => {
+          const column = item.startsWith('"') ? item.slice(1, -1) : item;
+          const key = queryColumnNameToKey(this.query, column) ?? column;
+          columns[key] = true;
+        });
+      }
+    }
+    return this.columnsCache = columns;
+  }
+}
+class MoreThanOneRowError extends OrchidOrmInternalError {
+  constructor(query, message) {
+    super(query, message);
+  }
+}
+class UnhandledTypeError extends OrchidOrmInternalError {
+  constructor(query, value) {
+    super(query, `Unhandled type: ${JSON.stringify(value)} received`);
+  }
+}
+
+const getPrimaryKeys = (q) => {
+  var _a;
+  return (_a = q.internal).primaryKeys ?? (_a.primaryKeys = collectPrimaryKeys(q));
+};
+const requirePrimaryKeys = (q, message) => {
+  const primaryKeys = getPrimaryKeys(q);
+  if (!primaryKeys.length) {
+    throw new OrchidOrmInternalError(q, message);
+  }
+  return primaryKeys;
+};
+const collectPrimaryKeys = (q) => {
+  const primaryKeys = [];
+  const { shape } = q.q;
+  for (const key in shape) {
+    if (shape[key].data.primaryKey) {
+      primaryKeys.push(key);
+    }
+  }
+  const pkey = q.internal.tableData.primaryKey;
+  if (pkey) {
+    primaryKeys.push(...pkey.columns);
+  }
+  return primaryKeys;
+};
+
+const newDelayedRelationSelect = (query) => ({
+  query
+});
+const setDelayedRelation = (d, as, value) => {
+  (d.value ?? (d.value = {}))[as] = value;
+};
+
+const isRelationQuery = (q) => "joinQuery" in q;
+
+const _getQueryAs = (q) => q.q.as;
+const _getQueryFreeAlias = (q, as) => q.aliases ? getFreeAlias(q.aliases, as) : as;
+const _checkIfAliased = (q, as, name) => {
+  return q.q.aliases?.[as] === name;
+};
+const _getQueryAliasOrName = (q, as) => {
+  return q.aliases?.[as] || as;
+};
+const _getQueryOuterAliases = (q) => {
+  return q.outerAliases;
+};
+const _setQueryAs = (self, as) => {
+  const { q } = self;
+  q.as = as;
+  q.aliases = {
+    ...q.aliases,
+    [as]: _getQueryFreeAlias(q, as)
+  };
+  return self;
+};
+const _setQueryAlias = (q, name, as) => {
+  q.q.aliases = { ...q.q.aliases, [as]: name };
+};
+const _setSubQueryAliases = (q) => {
+  q.q.outerAliases = q.q.aliases;
+};
+const _applyRelationAliases = (query, relQueryData) => {
+  const aliases = query.q.as ? { ...query.q.aliases } : { ...query.q.aliases, [query.table]: query.table };
+  const relAliases = relQueryData.aliases;
+  for (const as in relAliases) {
+    aliases[as] = getFreeAlias(aliases, as);
+  }
+  relQueryData.as = aliases[relQueryData.as];
+  relQueryData.aliases = aliases;
+};
+const _copyQueryAliasToQuery = (fromQuery, toQuery, key) => {
+  const name = _getQueryAliasOrName(fromQuery.q, key);
+  if (name !== key) {
+    _setQueryAlias(toQuery, name, key);
+  }
+  return name;
+};
+
+const setParserToQuery = (query, key, parser) => {
+  if (query.parsers) query.parsers[key] = parser;
+  else query.parsers = { [key]: parser };
+};
+const getQueryParsers = (q, hookSelect) => {
+  if (hookSelect) {
+    const parsers = { ...q.q.parsers };
+    const { defaultParsers } = q.q;
+    if (defaultParsers) {
+      for (const [key, value] of hookSelect) {
+        const parser = defaultParsers[key];
+        if (parser) {
+          parsers[value.as || key] = parser;
+        }
+      }
+    }
+    return parsers;
+  }
+  return q.q.select ? q.q.parsers : q.q.defaultParsers;
+};
+
+const _addToHookSelect = (query, selects) => {
+  const map = query.q.hookSelect = new Map(
+    query.q.hookSelect
+  );
+  for (const key of selects) {
+    map.set(key, { select: key });
+  }
+};
+const _addToHookSelectWithTable = (query, selects, table) => {
+  const map = query.q.hookSelect = new Map(
+    query.q.hookSelect
+  );
+  for (const column of selects) {
+    map.set(column, { select: `${table}.${column}` });
+  }
+};
+
 const used = [];
 const literalValues = [];
 const templateLiteralToSQL = (template, ctx, quotedAs) => {
@@ -16,7 +1059,7 @@ const templateLiteralToSQL = (template, ctx, quotedAs) => {
   for (let last = parts.length - 1; i < last; i++) {
     sql += parts[i];
     const value = template[i + 1];
-    if (value instanceof orchidCore.Expression) {
+    if (value instanceof Expression) {
       sql += value.toSQL(ctx, quotedAs);
     } else {
       values.push(value);
@@ -26,7 +1069,7 @@ const templateLiteralToSQL = (template, ctx, quotedAs) => {
   }
   return sql + parts[i];
 };
-class RawSQL extends orchidCore.RawSQLBase {
+class RawSQL extends RawSQLBase {
   constructor(sql, values, type) {
     super(sql, values);
     this.result = { value: type };
@@ -84,11 +1127,11 @@ class RawSQL extends orchidCore.RawSQLBase {
     return arr.join("'");
   }
 }
-class DynamicRawSQL extends orchidCore.Expression {
+class DynamicRawSQL extends Expression {
   constructor(fn) {
     super();
     this.fn = fn;
-    this.result = orchidCore.emptyObject;
+    this.result = emptyObject;
     this.q = { expr: this };
   }
   // Calls the given function to get SQL from it.
@@ -96,9 +1139,9 @@ class DynamicRawSQL extends orchidCore.Expression {
     return this.fn(raw).toSQL(ctx, quotedAs);
   }
 }
-DynamicRawSQL.prototype.type = orchidCore.ExpressionTypeMethod.prototype.type;
+DynamicRawSQL.prototype.type = ExpressionTypeMethod.prototype.type;
 function raw(...args) {
-  return orchidCore.isTemplateLiteralArgs(args) ? new RawSQL(args) : typeof args[0] === "function" ? new DynamicRawSQL(args[0]) : new RawSQL(args[0].raw, args[0].values);
+  return isTemplateLiteralArgs(args) ? new RawSQL(args) : typeof args[0] === "function" ? new DynamicRawSQL(args[0]) : new RawSQL(args[0].raw, args[0].values);
 }
 const countSelect = [new RawSQL("count(*)")];
 function sqlQueryArgsToExpression(args) {
@@ -118,7 +1161,7 @@ const sqlFn = (...args) => {
   return (...args2) => new RawSQL(args2, arg);
 };
 
-class ColumnType extends orchidCore.ColumnTypeBase {
+class ColumnType extends ColumnTypeBase {
   /**
    * Mark the column as a primary key.
    * This column type becomes an argument of the `.find` method.
@@ -144,10 +1187,10 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    * @param name - to specify a constraint name
    */
   primaryKey(name) {
-    return orchidCore.setColumnData(this, "primaryKey", name ?? true);
+    return setColumnData(this, "primaryKey", name ?? true);
   }
-  foreignKey(fnOrTable, column, options = orchidCore.emptyObject) {
-    return orchidCore.pushColumnData(this, "foreignKeys", {
+  foreignKey(fnOrTable, column, options = emptyObject) {
+    return pushColumnData(this, "foreignKeys", {
       fnOrTable,
       foreignColumns: [column],
       options
@@ -206,8 +1249,8 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    */
   index(...args) {
     const a = args;
-    return orchidCore.pushColumnData(this, "indexes", {
-      options: (typeof a[0] === "string" ? { ...a[1], name: a[0] } : a[0]) ?? orchidCore.emptyObject
+    return pushColumnData(this, "indexes", {
+      options: (typeof a[0] === "string" ? { ...a[1], name: a[0] } : a[0]) ?? emptyObject
     });
   }
   /**
@@ -314,7 +1357,7 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    */
   searchIndex(...args) {
     const a = args;
-    return orchidCore.pushColumnData(this, "indexes", {
+    return pushColumnData(this, "indexes", {
       options: {
         ...typeof a[0] === "string" ? { ...a[1], name: a[0] } : a[0],
         ...this.dataType === "tsvector" ? { using: "GIN" } : { tsVector: true }
@@ -323,7 +1366,7 @@ class ColumnType extends orchidCore.ColumnTypeBase {
   }
   unique(...args) {
     const a = args;
-    return orchidCore.pushColumnData(this, "indexes", {
+    return pushColumnData(this, "indexes", {
       options: {
         ...typeof a[0] === "string" ? { ...a[1], name: a[0] } : a[0],
         unique: true
@@ -377,22 +1420,22 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    */
   exclude(op, ...args) {
     const a = args;
-    return orchidCore.pushColumnData(this, "excludes", {
+    return pushColumnData(this, "excludes", {
       with: op,
-      options: (typeof a[0] === "string" ? { ...a[1], name: a[0] } : a[0]) ?? orchidCore.emptyObject
+      options: (typeof a[0] === "string" ? { ...a[1], name: a[0] } : a[0]) ?? emptyObject
     });
   }
   comment(comment) {
-    return orchidCore.setColumnData(this, "comment", comment);
+    return setColumnData(this, "comment", comment);
   }
   compression(compression) {
-    return orchidCore.setColumnData(this, "compression", compression);
+    return setColumnData(this, "compression", compression);
   }
   collate(collate) {
-    return orchidCore.setColumnData(this, "collate", collate);
+    return setColumnData(this, "collate", collate);
   }
   modifyQuery(cb) {
-    return orchidCore.setColumnData(
+    return setColumnData(
       this,
       "modifyQuery",
       cb
@@ -415,14 +1458,14 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    */
   generated(...args) {
     const sql = raw(...args);
-    const column = orchidCore.setColumnData(this, "generated", {
+    const column = setColumnData(this, "generated", {
       toSQL(ctx, quoted) {
         return sql.toSQL(ctx, quoted);
       },
       toCode() {
         let sql2 = ".generated";
         if (Array.isArray(args[0])) {
-          sql2 += orchidCore.templateLiteralSQLToCode(args);
+          sql2 += templateLiteralSQLToCode(args);
         } else {
           const { raw: raw2, values } = args[0];
           sql2 += `({ raw: '${raw2.replace(/'/g, "\\'")}'${values ? `, values: ${JSON.stringify(values)}` : ""} })`;
@@ -464,7 +1507,7 @@ const assignDbDataToColumn = (column, params) => {
 const isDefaultTimeStamp = (item) => {
   if (item.dataType !== "timestamptz") return false;
   const def = item.data.default;
-  if (!(def instanceof orchidCore.RawSQLBase)) return false;
+  if (!(def instanceof RawSQLBase)) return false;
   return typeof def._sql === "string" && def._sql.startsWith("now()");
 };
 const combineCodeElements = (input) => {
@@ -494,8 +1537,8 @@ const columnsShapeToCode = (ctx, shape) => {
     if (name === key) column.data.name = void 0;
     code.push(
       ...combineCodeElements([
-        `${orchidCore.quoteObjectKey(key, ctx.snakeCase)}: `,
-        ...orchidCore.toArray(shape[key].toCode(ctx, key)),
+        `${quoteObjectKey(key, ctx.snakeCase)}: `,
+        ...toArray(shape[key].toCode(ctx, key)),
         ","
       ])
     );
@@ -509,9 +1552,9 @@ const columnsShapeToCode = (ctx, shape) => {
 const pushTableDataCode = (code, ast) => {
   const lines = [
     ast.primaryKey && [primaryKeyInnerToCode(ast.primaryKey, "t") + ","],
-    ...ast.indexes?.map((x) => indexToCode(x, "t")) || orchidCore.emptyArray,
-    ...ast.excludes?.map((x) => excludeToCode(x, "t")) || orchidCore.emptyArray,
-    ...ast.constraints?.map((x) => constraintToCode(x, "t", true)) || orchidCore.emptyArray
+    ...ast.indexes?.map((x) => indexToCode(x, "t")) || emptyArray,
+    ...ast.excludes?.map((x) => excludeToCode(x, "t")) || emptyArray,
+    ...ast.constraints?.map((x) => constraintToCode(x, "t", true)) || emptyArray
   ].filter((x) => !!x);
   if (lines.length > 1) {
     code.push("(t) => [", ...lines, "],");
@@ -524,13 +1567,13 @@ const pushTableDataCode = (code, ast) => {
 };
 const primaryKeyInnerToCode = (primaryKey, t) => {
   const name = primaryKey.name;
-  return `${t}.primaryKey([${primaryKey.columns.map(orchidCore.singleQuote).join(", ")}]${name ? `, ${orchidCore.singleQuote(name)}` : ""})`;
+  return `${t}.primaryKey([${primaryKey.columns.map(singleQuote).join(", ")}]${name ? `, ${singleQuote(name)}` : ""})`;
 };
 const indexOrExcludeToCode = (innerToCode) => (item, t, prefix) => {
   const code = innerToCode(item, t);
   if (prefix) code[0] = prefix + code[0];
   const last = code[code.length - 1];
-  if (typeof last === "string" && !last.endsWith(",")) orchidCore.addCode(code, ",");
+  if (typeof last === "string" && !last.endsWith(",")) addCode(code, ",");
   return code;
 };
 const indexInnerToCode = (index, t) => {
@@ -570,17 +1613,17 @@ const indexInnerToCode = (index, t) => {
         }
       }
       if (!hasOptions2) {
-        objects.push(`${orchidCore.singleQuote(expr)},`);
+        objects.push(`${singleQuote(expr)},`);
       } else {
         const props = [
-          `${"expression" in column ? "expression" : "column"}: ${orchidCore.singleQuote(
+          `${"expression" in column ? "expression" : "column"}: ${singleQuote(
             expr
           )},`
         ];
         for (const key of columnOptions) {
           const value = column[key];
           if (value !== void 0) {
-            props.push(`${key}: ${orchidCore.singleQuote(value)},`);
+            props.push(`${key}: ${singleQuote(value)},`);
           }
         }
         objects.push("{", props, "},");
@@ -588,16 +1631,16 @@ const indexInnerToCode = (index, t) => {
     }
     code.push(["[", objects, hasOptions ? "]," : "]"]);
   } else {
-    orchidCore.addCode(
+    addCode(
       code,
-      `[${index.columns.map((it) => orchidCore.singleQuote(it.column)).join(", ")}]`
+      `[${index.columns.map((it) => singleQuote(it.column)).join(", ")}]`
     );
   }
   if (hasOptions) {
     if (columnsMultiline) {
       code.push(["{"]);
     } else {
-      orchidCore.addCode(code, ", {");
+      addCode(code, ", {");
     }
     const options = [];
     for (const key of indexOptionsKeys) {
@@ -605,20 +1648,20 @@ const indexInnerToCode = (index, t) => {
       const value = index.options[key];
       if (value === null || value === void 0) continue;
       options.push(
-        `${key}: ${Array.isArray(value) ? orchidCore.singleQuoteArray(value) : typeof value === "string" ? orchidCore.singleQuote(value) : value},`
+        `${key}: ${Array.isArray(value) ? singleQuoteArray(value) : typeof value === "string" ? singleQuote(value) : value},`
       );
     }
     if (columnsMultiline) {
       code.push([options, "},"]);
     } else {
       code.push(options);
-      orchidCore.addCode(code, "}");
+      addCode(code, "}");
     }
   }
   if (columnsMultiline) {
     code.push("),");
   } else {
-    orchidCore.addCode(code, ")");
+    addCode(code, ")");
   }
   return code;
 };
@@ -640,14 +1683,14 @@ const excludeInnerToCode = (item, t) => {
   for (const column of item.columns) {
     const expr = "expression" in column ? column.expression : column.column;
     const props = [
-      `${"expression" in column ? "expression" : "column"}: ${orchidCore.singleQuote(
+      `${"expression" in column ? "expression" : "column"}: ${singleQuote(
         expr
       )},`
     ];
     for (const key of columnOptions) {
       const value = column[key];
       if (value !== void 0) {
-        props.push(`${key}: ${orchidCore.singleQuote(value)},`);
+        props.push(`${key}: ${singleQuote(value)},`);
       }
     }
     objects.push("{", props, "},");
@@ -661,7 +1704,7 @@ const excludeInnerToCode = (item, t) => {
       const value = item.options[key];
       if (value === null || value === void 0) continue;
       options.push(
-        `${key}: ${Array.isArray(value) ? orchidCore.singleQuoteArray(value) : typeof value === "string" ? orchidCore.singleQuote(value) : value},`
+        `${key}: ${Array.isArray(value) ? singleQuoteArray(value) : typeof value === "string" ? singleQuote(value) : value},`
       );
     }
     code.push([options, "},"]);
@@ -687,7 +1730,7 @@ const constraintInnerToCode = (item, t, m) => {
     ];
   }
   return [
-    `${t}.check(${item.check.toCode(t)}${item.name ? `, ${orchidCore.singleQuote(item.name)}` : ""})`
+    `${t}.check(${item.check.toCode(t)}${item.name ? `, ${singleQuote(item.name)}` : ""})`
   ];
 };
 const referencesArgsToCode = ({
@@ -697,22 +1740,22 @@ const referencesArgsToCode = ({
   options
 }, name = options?.name || false, m) => {
   const args = [];
-  args.push(`${orchidCore.singleQuoteArray(columns)},`);
+  args.push(`${singleQuoteArray(columns)},`);
   if (m && typeof fnOrTable !== "string") {
     const { schema, table } = new (fnOrTable())();
     fnOrTable = schema ? `${schema}.${table}` : table;
   }
   args.push(
-    `${typeof fnOrTable === "string" ? orchidCore.singleQuote(fnOrTable) : fnOrTable.toString()},`
+    `${typeof fnOrTable === "string" ? singleQuote(fnOrTable) : fnOrTable.toString()},`
   );
-  args.push(`${orchidCore.singleQuoteArray(foreignColumns)},`);
-  if (orchidCore.objectHasValues(options) || name) {
+  args.push(`${singleQuoteArray(foreignColumns)},`);
+  if (objectHasValues(options) || name) {
     const lines = [];
-    if (name) lines.push(`name: ${orchidCore.singleQuote(name)},`);
+    if (name) lines.push(`name: ${singleQuote(name)},`);
     for (const key in options) {
       if (key === "name") continue;
       const value = options[key];
-      if (value) lines.push(`${key}: ${orchidCore.singleQuote(value)},`);
+      if (value) lines.push(`${key}: ${singleQuote(value)},`);
     }
     args.push("{", lines, "},");
   }
@@ -721,18 +1764,18 @@ const referencesArgsToCode = ({
 const columnForeignKeysToCode = (foreignKeys, migration) => {
   const code = [];
   for (const foreignKey of foreignKeys) {
-    orchidCore.addCode(code, `.foreignKey(`);
+    addCode(code, `.foreignKey(`);
     for (const part of foreignKeyArgumentToCode(foreignKey, migration)) {
-      orchidCore.addCode(code, part);
+      addCode(code, part);
     }
-    orchidCore.addCode(code, ")");
+    addCode(code, ")");
   }
   return code;
 };
 const foreignKeyArgumentToCode = ({
   fnOrTable,
   foreignColumns,
-  options = orchidCore.emptyObject
+  options = emptyObject
 }, migration) => {
   const code = [];
   if (migration && typeof fnOrTable !== "string") {
@@ -740,70 +1783,70 @@ const foreignKeyArgumentToCode = ({
     fnOrTable = schema ? `${schema}.${table}` : table;
   }
   code.push(
-    typeof fnOrTable === "string" ? orchidCore.singleQuote(fnOrTable) : fnOrTable.toString()
+    typeof fnOrTable === "string" ? singleQuote(fnOrTable) : fnOrTable.toString()
   );
-  orchidCore.addCode(code, `, ${orchidCore.singleQuote(foreignColumns[0])}`);
+  addCode(code, `, ${singleQuote(foreignColumns[0])}`);
   const hasOptions = options.name || options.match || options.onUpdate || options.onDelete;
   if (hasOptions) {
     const arr = [];
-    if (options.name) arr.push(`name: ${orchidCore.singleQuote(options.name)},`);
-    if (options.match) arr.push(`match: ${orchidCore.singleQuote(options.match)},`);
+    if (options.name) arr.push(`name: ${singleQuote(options.name)},`);
+    if (options.match) arr.push(`match: ${singleQuote(options.match)},`);
     if (options.onUpdate)
-      arr.push(`onUpdate: ${orchidCore.singleQuote(options.onUpdate)},`);
+      arr.push(`onUpdate: ${singleQuote(options.onUpdate)},`);
     if (options.onDelete)
-      arr.push(`onDelete: ${orchidCore.singleQuote(options.onDelete)},`);
-    orchidCore.addCode(code, ", {");
+      arr.push(`onDelete: ${singleQuote(options.onDelete)},`);
+    addCode(code, ", {");
     code.push(arr);
-    orchidCore.addCode(code, "}");
+    addCode(code, "}");
   }
   return code;
 };
 const columnIndexesToCode = (items) => {
   const code = [];
   for (const { options } of items) {
-    orchidCore.addCode(code, `.${options.unique ? "unique" : "index"}(`);
+    addCode(code, `.${options.unique ? "unique" : "index"}(`);
     const arr = [
-      options.name && `name: ${orchidCore.singleQuote(options.name)},`,
-      options.collate && `collate: ${orchidCore.singleQuote(options.collate)},`,
-      options.opclass && `opclass: ${orchidCore.singleQuote(options.opclass)},`,
-      options.order && `order: ${orchidCore.singleQuote(options.order)},`,
-      options.using && `using: ${orchidCore.singleQuote(options.using)},`,
-      options.include && `include: ${typeof options.include === "string" ? orchidCore.singleQuote(options.include) : `[${options.include.map(orchidCore.singleQuote).join(", ")}]`},`,
+      options.name && `name: ${singleQuote(options.name)},`,
+      options.collate && `collate: ${singleQuote(options.collate)},`,
+      options.opclass && `opclass: ${singleQuote(options.opclass)},`,
+      options.order && `order: ${singleQuote(options.order)},`,
+      options.using && `using: ${singleQuote(options.using)},`,
+      options.include && `include: ${typeof options.include === "string" ? singleQuote(options.include) : `[${options.include.map(singleQuote).join(", ")}]`},`,
       options.nullsNotDistinct && `nullsNotDistinct: true,`,
-      options.with && `with: ${orchidCore.singleQuote(options.with)},`,
-      options.tablespace && `tablespace: ${orchidCore.singleQuote(options.tablespace)},`,
-      options.where && `where: ${orchidCore.singleQuote(options.where)},`
+      options.with && `with: ${singleQuote(options.with)},`,
+      options.tablespace && `tablespace: ${singleQuote(options.tablespace)},`,
+      options.where && `where: ${singleQuote(options.where)},`
     ].filter((x) => !!x);
     if (arr.length) {
-      orchidCore.addCode(code, "{");
-      orchidCore.addCode(code, arr);
-      orchidCore.addCode(code, "}");
+      addCode(code, "{");
+      addCode(code, arr);
+      addCode(code, "}");
     }
-    orchidCore.addCode(code, ")");
+    addCode(code, ")");
   }
   return code;
 };
 const columnExcludesToCode = (items) => {
   const code = [];
   for (const { options, with: w } of items) {
-    orchidCore.addCode(code, `.exclude('${w}'`);
+    addCode(code, `.exclude('${w}'`);
     const arr = [
-      options.name && `name: ${orchidCore.singleQuote(options.name)},`,
-      options.collate && `collate: ${orchidCore.singleQuote(options.collate)},`,
-      options.opclass && `opclass: ${orchidCore.singleQuote(options.opclass)},`,
-      options.order && `order: ${orchidCore.singleQuote(options.order)},`,
-      options.using && `using: ${orchidCore.singleQuote(options.using)},`,
-      options.include && `include: ${typeof options.include === "string" ? orchidCore.singleQuote(options.include) : `[${options.include.map(orchidCore.singleQuote).join(", ")}]`},`,
-      options.with && `with: ${orchidCore.singleQuote(options.with)},`,
-      options.tablespace && `tablespace: ${orchidCore.singleQuote(options.tablespace)},`,
-      options.where && `where: ${orchidCore.singleQuote(options.where)},`
+      options.name && `name: ${singleQuote(options.name)},`,
+      options.collate && `collate: ${singleQuote(options.collate)},`,
+      options.opclass && `opclass: ${singleQuote(options.opclass)},`,
+      options.order && `order: ${singleQuote(options.order)},`,
+      options.using && `using: ${singleQuote(options.using)},`,
+      options.include && `include: ${typeof options.include === "string" ? singleQuote(options.include) : `[${options.include.map(singleQuote).join(", ")}]`},`,
+      options.with && `with: ${singleQuote(options.with)},`,
+      options.tablespace && `tablespace: ${singleQuote(options.tablespace)},`,
+      options.where && `where: ${singleQuote(options.where)},`
     ].filter((x) => !!x);
     if (arr.length) {
-      orchidCore.addCode(code, ", {");
-      orchidCore.addCode(code, arr);
-      orchidCore.addCode(code, "}");
+      addCode(code, ", {");
+      addCode(code, arr);
+      addCode(code, "}");
     }
-    orchidCore.addCode(code, ")");
+    addCode(code, ")");
   }
   return code;
 };
@@ -831,20 +1874,20 @@ const identityToCode = (identity, dataType) => {
     props.push(`cache: ${identity.cache},`);
   if (identity.cycle) props.push(`cycle: true,`);
   if (props.length) {
-    orchidCore.addCode(code, "{");
+    addCode(code, "{");
     code.push(props, "}");
   }
-  orchidCore.addCode(code, ")");
+  addCode(code, ")");
   return code;
 };
 const columnCode = (type, ctx, key, code) => {
   const { data } = type;
-  code = orchidCore.toArray(code);
+  code = toArray(code);
   let prepend = `${ctx.t}.`;
-  const keyName = ctx.snakeCase ? orchidCore.toSnakeCase(key) : key;
+  const keyName = ctx.snakeCase ? toSnakeCase(key) : key;
   const name = data.name ?? keyName;
   if (name !== keyName) {
-    prepend += `name(${orchidCore.singleQuote(name)}).`;
+    prepend += `name(${singleQuote(name)}).`;
   }
   if (typeof code[0] === "string") {
     code[0] = `${prepend}${code[0]}`;
@@ -852,12 +1895,12 @@ const columnCode = (type, ctx, key, code) => {
     code[0].unshift(prepend);
   }
   if (data.generated) {
-    orchidCore.addCode(code, data.generated.toCode());
+    addCode(code, data.generated.toCode());
   }
   if (data.primaryKey) {
-    orchidCore.addCode(
+    addCode(
       code,
-      `.primaryKey(${data.primaryKey === true ? "" : orchidCore.singleQuote(data.primaryKey)})`
+      `.primaryKey(${data.primaryKey === true ? "" : singleQuote(data.primaryKey)})`
     );
   }
   if (data.foreignKeys) {
@@ -865,51 +1908,51 @@ const columnCode = (type, ctx, key, code) => {
       data.foreignKeys,
       ctx.migration
     )) {
-      orchidCore.addCode(code, part);
+      addCode(code, part);
     }
   }
-  if (data.explicitSelect) orchidCore.addCode(code, ".select(false)");
-  if (data.isNullable) orchidCore.addCode(code, ".nullable()");
+  if (data.explicitSelect) addCode(code, ".select(false)");
+  if (data.isNullable) addCode(code, ".nullable()");
   if (data.as && !ctx.migration) {
-    orchidCore.addCode(code, `.as(${data.as.toCode(ctx, key)})`);
+    addCode(code, `.as(${data.as.toCode(ctx, key)})`);
   }
   if (data.default !== void 0 && data.default !== data.defaultDefault && (!ctx.migration || typeof data.default !== "function")) {
-    orchidCore.addCode(
+    addCode(
       code,
-      `.default(${orchidCore.columnDefaultArgumentToCode(ctx.t, data.default)})`
+      `.default(${columnDefaultArgumentToCode(ctx.t, data.default)})`
     );
   }
   if (data.indexes) {
     for (const part of columnIndexesToCode(data.indexes)) {
-      orchidCore.addCode(code, part);
+      addCode(code, part);
     }
   }
   if (data.excludes) {
     for (const part of columnExcludesToCode(data.excludes)) {
-      orchidCore.addCode(code, part);
+      addCode(code, part);
     }
   }
-  if (data.comment) orchidCore.addCode(code, `.comment(${orchidCore.singleQuote(data.comment)})`);
+  if (data.comment) addCode(code, `.comment(${singleQuote(data.comment)})`);
   if (data.checks) {
-    orchidCore.addCode(code, columnCheckToCode(ctx, data.checks));
+    addCode(code, columnCheckToCode(ctx, data.checks));
   }
   if (data.errors) {
-    for (const part of orchidCore.columnErrorMessagesToCode(data.errors)) {
-      orchidCore.addCode(code, part);
+    for (const part of columnErrorMessagesToCode(data.errors)) {
+      addCode(code, part);
     }
   }
   const { validationDefault } = data;
   if (validationDefault) {
-    orchidCore.addCode(
+    addCode(
       code,
-      `.validationDefault(${typeof validationDefault === "function" ? validationDefault.toString() : typeof validationDefault === "string" ? orchidCore.singleQuote(validationDefault) : JSON.stringify(validationDefault)})`
+      `.validationDefault(${typeof validationDefault === "function" ? validationDefault.toString() : typeof validationDefault === "string" ? singleQuote(validationDefault) : JSON.stringify(validationDefault)})`
     );
   }
   if (data.compression)
-    orchidCore.addCode(code, `.compression(${orchidCore.singleQuote(data.compression)})`);
-  if (data.collate) orchidCore.addCode(code, `.collate(${orchidCore.singleQuote(data.collate)})`);
+    addCode(code, `.compression(${singleQuote(data.compression)})`);
+  if (data.collate) addCode(code, `.collate(${singleQuote(data.collate)})`);
   if (data.modifyQuery)
-    orchidCore.addCode(code, `.modifyQuery(${data.modifyQuery.toString()})`);
+    addCode(code, `.modifyQuery(${data.modifyQuery.toString()})`);
   return code.length === 1 && typeof code[0] === "string" ? code[0] : code;
 };
 
@@ -942,13 +1985,13 @@ class CustomTypeColumn extends ColumnType {
       this,
       ctx,
       key,
-      `type(${orchidCore.singleQuote(
+      `type(${singleQuote(
         (dataType.startsWith(ctx.currentSchema) ? dataType.slice(ctx.currentSchema.length + 1) : dataType) + (typmod !== void 0 && typmod !== -1 && !dataType.includes("(") ? `(${typmod})` : "")
       )})`
     );
   }
   as(column) {
-    const c = orchidCore.setColumnData(
+    const c = setColumnData(
       this,
       "as",
       column
@@ -961,7 +2004,7 @@ class CustomTypeColumn extends ColumnType {
 }
 class DomainColumn extends CustomTypeColumn {
   toCode(ctx, key) {
-    return columnCode(this, ctx, key, `domain(${orchidCore.singleQuote(this.dataType)})`);
+    return columnCode(this, ctx, key, `domain(${singleQuote(this.dataType)})`);
   }
 }
 
@@ -987,7 +2030,7 @@ class EnumColumn extends ColumnType {
 
 const addColumnParserToQuery = (q, key, column) => {
   if (column._parse) {
-    orchidCore.setObjectValueImmutable(
+    setObjectValueImmutable(
       q,
       "parsers",
       key,
@@ -1039,8 +2082,8 @@ const make = (_op) => {
     function(value) {
       const { q } = this;
       (q.chain ?? (q.chain = [])).push(_op, value);
-      if (q.parsers?.[orchidCore.getValueKey]) {
-        orchidCore.setObjectValueImmutable(q, "parsers", orchidCore.getValueKey, void 0);
+      if (q.parsers?.[getValueKey]) {
+        setObjectValueImmutable(q, "parsers", getValueKey, void 0);
       }
       return setQueryOperators(this, boolean);
     },
@@ -1057,8 +2100,8 @@ const makeVarArg = (_op) => {
     function(...args) {
       const { q } = this;
       (q.chain ?? (q.chain = [])).push(_op, args);
-      if (q.parsers?.[orchidCore.getValueKey]) {
-        orchidCore.setObjectValueImmutable(q, "parsers", orchidCore.getValueKey, void 0);
+      if (q.parsers?.[getValueKey]) {
+        setObjectValueImmutable(q, "parsers", getValueKey, void 0);
       }
       return setQueryOperators(this, boolean);
     },
@@ -1071,10 +2114,10 @@ const makeVarArg = (_op) => {
 };
 const quoteValue = (arg, ctx, quotedAs, IN) => {
   if (arg && typeof arg === "object") {
-    if (IN && orchidCore.isIterable(arg)) {
-      return `(${(Array.isArray(arg) ? arg : [...arg]).map((value) => orchidCore.addValue(ctx.values, value)).join(", ")})`;
+    if (IN && isIterable(arg)) {
+      return `(${(Array.isArray(arg) ? arg : [...arg]).map((value) => addValue(ctx.values, value)).join(", ")})`;
     }
-    if (orchidCore.isExpression(arg)) {
+    if (isExpression(arg)) {
       return arg.toSQL(ctx, quotedAs);
     }
     if ("toSQL" in arg) {
@@ -1084,14 +2127,14 @@ const quoteValue = (arg, ctx, quotedAs, IN) => {
       arg = JSON.stringify(arg);
     }
   }
-  return orchidCore.addValue(ctx.values, arg);
+  return addValue(ctx.values, arg);
 };
 const quoteLikeValue = (arg, ctx, quotedAs, jsonArray) => {
   if (arg && typeof arg === "object") {
     if (Array.isArray(arg)) {
-      return `(${arg.map((value) => orchidCore.addValue(ctx.values, value)).join(", ")})`;
+      return `(${arg.map((value) => addValue(ctx.values, value)).join(", ")})`;
     }
-    if (orchidCore.isExpression(arg)) {
+    if (isExpression(arg)) {
       return arg.toSQL(ctx, quotedAs);
     }
     if ("toSQL" in arg) {
@@ -1100,7 +2143,7 @@ const quoteLikeValue = (arg, ctx, quotedAs, jsonArray) => {
       )}), '%', '\\\\%'), '_', '\\\\_')`;
     }
   }
-  return orchidCore.addValue(ctx.values, arg.replace(/[%_]/g, "\\$&"));
+  return addValue(ctx.values, arg.replace(/[%_]/g, "\\$&"));
 };
 const base = {
   equals: make(
@@ -1172,32 +2215,32 @@ const ordinalText = {
   ...ord,
   ...text
 };
-const encodeJsonPath = (ctx, path) => orchidCore.addValue(ctx.values, `{${Array.isArray(path) ? path.join(", ") : path}}`);
-const jsonPathQueryOp = (key, [path, options], ctx) => `jsonb_path_query_first(${key}, ${orchidCore.addValue(ctx.values, path)}${options?.vars ? `, ${orchidCore.addValue(ctx.values, JSON.stringify(options.vars))}${options.silent ? ", true" : ""}` : options?.silent ? ", NULL, true" : ""})`;
+const encodeJsonPath = (ctx, path) => addValue(ctx.values, `{${Array.isArray(path) ? path.join(", ") : path}}`);
+const jsonPathQueryOp = (key, [path, options], ctx) => `jsonb_path_query_first(${key}, ${addValue(ctx.values, path)}${options?.vars ? `, ${addValue(ctx.values, JSON.stringify(options.vars))}${options.silent ? ", true" : ""}` : options?.silent ? ", NULL, true" : ""})`;
 const quoteJsonValue = (arg, ctx, quotedAs, IN) => {
   if (arg && typeof arg === "object") {
     if (IN && Array.isArray(arg)) {
-      return `(${arg.map((value) => orchidCore.addValue(ctx.values, JSON.stringify(value)) + "::jsonb").join(", ")})`;
+      return `(${arg.map((value) => addValue(ctx.values, JSON.stringify(value)) + "::jsonb").join(", ")})`;
     }
-    if (orchidCore.isExpression(arg)) {
+    if (isExpression(arg)) {
       return "to_jsonb(" + arg.toSQL(ctx, quotedAs) + ")";
     }
     if ("toSQL" in arg) {
       return `to_jsonb((${getSqlText(arg.toSQL(ctx))}))`;
     }
   }
-  return orchidCore.addValue(ctx.values, JSON.stringify(arg)) + "::jsonb";
+  return addValue(ctx.values, JSON.stringify(arg)) + "::jsonb";
 };
 const serializeJsonValue = (arg, ctx, quotedAs) => {
   if (arg && typeof arg === "object") {
-    if (orchidCore.isExpression(arg)) {
+    if (isExpression(arg)) {
       return "to_jsonb(" + arg.toSQL(ctx, quotedAs) + ")";
     }
     if ("toSQL" in arg) {
       return `to_jsonb((${getSqlText(arg.toSQL(ctx))}))`;
     }
   }
-  return orchidCore.addValue(ctx.values, JSON.stringify(arg));
+  return addValue(ctx.values, JSON.stringify(arg));
 };
 const json = {
   ...ord,
@@ -1218,15 +2261,15 @@ const json = {
       const { q, columnTypes } = this;
       const chain = q.chain ?? (q.chain = []);
       chain.push(jsonPathQueryOp, [path, options]);
-      if (q.parsers?.[orchidCore.getValueKey]) {
-        orchidCore.setObjectValueImmutable(q, "parsers", orchidCore.getValueKey, void 0);
+      if (q.parsers?.[getValueKey]) {
+        setObjectValueImmutable(q, "parsers", getValueKey, void 0);
       }
       if (options?.type) {
         const type = options.type(columnTypes);
-        addColumnParserToQuery(q, orchidCore.getValueKey, type);
+        addColumnParserToQuery(q, getValueKey, type);
         chain.push = (...args) => {
           chain.push = Array.prototype.push;
-          chain.push((s) => `${s}::${type.dataType}`, orchidCore.emptyArray);
+          chain.push((s) => `${s}::${type.dataType}`, emptyArray);
           return chain.push(...args);
         };
         return setQueryOperators(this, type.operators);
@@ -1329,7 +2372,7 @@ class DateColumn extends DateBaseColumn {
       this,
       ctx,
       key,
-      `date()${orchidCore.dateDataToCode(this.data, ctx.migration)}`
+      `date()${dateDataToCode(this.data, ctx.migration)}`
     );
   }
 }
@@ -1339,7 +2382,7 @@ class DateTimeBaseClass extends DateBaseColumn {
     this.data.dateTimePrecision = dateTimePrecision;
   }
   toSQL() {
-    return orchidCore.joinTruthy(
+    return joinTruthy(
       this.dataType,
       this.data.dateTimePrecision !== void 0 && `(${this.data.dateTimePrecision})`
     );
@@ -1347,7 +2390,7 @@ class DateTimeBaseClass extends DateBaseColumn {
 }
 class DateTimeTzBaseClass extends DateTimeBaseClass {
   toSQL() {
-    return orchidCore.joinTruthy(
+    return joinTruthy(
       this.baseDataType,
       this.data.dateTimePrecision !== void 0 && `(${this.data.dateTimePrecision})`,
       " with time zone"
@@ -1367,7 +2410,7 @@ const timestampToCode = (self, ctx, key) => {
       self,
       ctx,
       key,
-      `timestamps${noTz}(${p && p !== 6 ? p : ""}).${defaultTimestamp}${orchidCore.dateDataToCode(self.data, ctx.migration)}`
+      `timestamps${noTz}(${p && p !== 6 ? p : ""}).${defaultTimestamp}${dateDataToCode(self.data, ctx.migration)}`
     );
     self.data.default = def;
     self.data.modifyQuery = modifyQuery;
@@ -1377,7 +2420,7 @@ const timestampToCode = (self, ctx, key) => {
       self,
       ctx,
       key,
-      `${self instanceof TimestampColumn ? "timestampNoTZ" : "timestamp"}(${p && p !== 6 ? p : ""})${orchidCore.dateDataToCode(self.data, ctx.migration)}`
+      `${self instanceof TimestampColumn ? "timestampNoTZ" : "timestamp"}(${p && p !== 6 ? p : ""})${dateDataToCode(self.data, ctx.migration)}`
     );
   }
 };
@@ -1413,7 +2456,7 @@ class TimeColumn extends ColumnType {
       this,
       ctx,
       key,
-      `time(${dateTimePrecision || ""})${orchidCore.dateDataToCode(
+      `time(${dateTimePrecision || ""})${dateDataToCode(
         this.data,
         ctx.migration
       )}`
@@ -1438,7 +2481,7 @@ class IntervalColumn extends ColumnType {
     );
   }
   toSQL() {
-    return orchidCore.joinTruthy(
+    return joinTruthy(
       this.dataType,
       this.data.fields && ` ${this.data.fields}`,
       this.data.precision !== void 0 && ` (${this.data.precision})`
@@ -1471,9 +2514,9 @@ class ArrayColumn extends ColumnType {
     const { item } = this.data;
     const { isNullable } = item.data;
     delete item.data.isNullable;
-    orchidCore.addCode(code, item.toCode(ctx, key));
+    addCode(code, item.toCode(ctx, key));
     item.data.isNullable = isNullable;
-    orchidCore.addCode(code, `${close}${orchidCore.arrayDataToCode(this.data, ctx.migration)}`);
+    addCode(code, `${close}${arrayDataToCode(this.data, ctx.migration)}`);
     return columnCode(this, ctx, key, code);
   }
 }
@@ -1601,7 +2644,7 @@ class DecimalColumn extends NumberAsStringBaseColumn {
   }
   toSQL() {
     const { numericPrecision, numericScale } = this.data;
-    return orchidCore.joinTruthy(
+    return joinTruthy(
       this.dataType,
       numericPrecision ? numericScale ? `(${numericPrecision}, ${numericScale})` : `(${numericPrecision})` : void 0
     );
@@ -1615,9 +2658,9 @@ const intToCode = (column, ctx, key, alias) => {
   } else {
     code = [`${alias}()`];
   }
-  orchidCore.addCode(
+  addCode(
     code,
-    orchidCore.numberDataToCode(column.data, ctx.migration, skipNumberMethods)
+    numberDataToCode(column.data, ctx.migration, skipNumberMethods)
   );
   return columnCode(column, ctx, key, code);
 };
@@ -1632,7 +2675,7 @@ class SmallIntColumn extends IntegerBaseColumn {
     return intToCode(this, ctx, key, "smallint");
   }
   identity(options = {}) {
-    return orchidCore.setColumnData(this, "identity", options);
+    return setColumnData(this, "identity", options);
   }
 }
 class IntegerColumn extends IntegerBaseColumn {
@@ -1646,7 +2689,7 @@ class IntegerColumn extends IntegerBaseColumn {
     return intToCode(this, ctx, key, "integer");
   }
   identity(options = {}) {
-    return orchidCore.setColumnData(this, "identity", options);
+    return setColumnData(this, "identity", options);
   }
 }
 class BigIntColumn extends NumberAsStringBaseColumn {
@@ -1659,7 +2702,7 @@ class BigIntColumn extends NumberAsStringBaseColumn {
     return intToCode(this, ctx, key, "bigint");
   }
   identity(options = {}) {
-    return orchidCore.setColumnData(this, "identity", options);
+    return setColumnData(this, "identity", options);
   }
 }
 class RealColumn extends NumberBaseColumn {
@@ -1674,7 +2717,7 @@ class RealColumn extends NumberBaseColumn {
       this,
       ctx,
       key,
-      `real()${orchidCore.numberDataToCode(this.data, ctx.migration)}`
+      `real()${numberDataToCode(this.data, ctx.migration)}`
     );
   }
 }
@@ -1704,7 +2747,7 @@ class SmallSerialColumn extends IntegerBaseColumn {
       this,
       ctx,
       key,
-      `smallSerial()${orchidCore.numberDataToCode(
+      `smallSerial()${numberDataToCode(
         this.data,
         ctx.migration,
         skipNumberMethods
@@ -1728,7 +2771,7 @@ class SerialColumn extends IntegerBaseColumn {
       this,
       ctx,
       key,
-      `serial()${orchidCore.numberDataToCode(
+      `serial()${numberDataToCode(
         this.data,
         ctx.migration,
         skipNumberMethods
@@ -1761,7 +2804,7 @@ const defaultSchemaConfig = {
   },
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   encode(fn) {
-    return orchidCore.setColumnData(this, "encode", fn);
+    return setColumnData(this, "encode", fn);
   },
   asType() {
     return this;
@@ -1784,27 +2827,27 @@ const defaultSchemaConfig = {
   array(item) {
     return new ArrayColumn(defaultSchemaConfig, item, void 0);
   },
-  boolean: orchidCore.noop,
-  buffer: orchidCore.noop,
-  unknown: orchidCore.noop,
-  never: orchidCore.noop,
-  stringSchema: orchidCore.noop,
-  stringMin: orchidCore.noop,
-  stringMax: orchidCore.noop,
-  stringMinMax: orchidCore.noop,
-  number: orchidCore.noop,
-  int: orchidCore.noop,
-  stringNumberDate: orchidCore.noop,
-  timeInterval: orchidCore.noop,
-  bit: orchidCore.noop,
-  uuid: orchidCore.noop,
+  boolean: noop,
+  buffer: noop,
+  unknown: noop,
+  never: noop,
+  stringSchema: noop,
+  stringMin: noop,
+  stringMax: noop,
+  stringMinMax: noop,
+  number: noop,
+  int: noop,
+  stringNumberDate: noop,
+  timeInterval: noop,
+  bit: noop,
+  uuid: noop,
   nullable() {
-    return orchidCore.setColumnData(this, "isNullable", true);
+    return setColumnData(this, "isNullable", true);
   },
   json() {
     return new JSONColumn(defaultSchemaConfig, void 0);
   },
-  setErrors: orchidCore.noop,
+  setErrors: noop,
   smallint: () => new SmallIntColumn(defaultSchemaConfig),
   integer: () => new IntegerColumn(defaultSchemaConfig),
   real: () => new RealColumn(defaultSchemaConfig),
@@ -1822,7 +2865,7 @@ const defaultSchemaConfig = {
   date: () => new DateColumn(defaultSchemaConfig),
   timestampNoTZ: (precision) => new TimestampColumn(defaultSchemaConfig, precision),
   timestamp: (precision) => new TimestampTZColumn(defaultSchemaConfig, precision),
-  geographyPointSchema: orchidCore.noop
+  geographyPointSchema: noop
 };
 
 class TextBaseColumn extends ColumnType {
@@ -1841,7 +2884,7 @@ class LimitedTextBaseColumn extends TextBaseColumn {
     this.data.maxChars = limit;
   }
   toSQL() {
-    return orchidCore.joinTruthy(
+    return joinTruthy(
       this.dataType,
       this.data.maxChars !== void 0 && `(${this.data.maxChars})`
     );
@@ -1858,7 +2901,7 @@ class VarCharColumn extends LimitedTextBaseColumn {
       this,
       ctx,
       key,
-      `varchar(${maxChars ?? ""})${orchidCore.stringDataToCode(this.data, ctx.migration)}`
+      `varchar(${maxChars ?? ""})${stringDataToCode(this.data, ctx.migration)}`
     );
   }
 }
@@ -1873,7 +2916,7 @@ class StringColumn extends VarCharColumn {
       this,
       ctx,
       key,
-      `string(${max ?? ""})${orchidCore.stringDataToCode(this.data, ctx.migration)}`
+      `string(${max ?? ""})${stringDataToCode(this.data, ctx.migration)}`
     );
   }
 }
@@ -1897,7 +2940,7 @@ const textColumnToCode = (column, ctx, key) => {
     column,
     ctx,
     key,
-    `${column.dataType}(${args})${orchidCore.stringDataToCode(data, ctx.migration)}`
+    `${column.dataType}(${args})${stringDataToCode(data, ctx.migration)}`
   );
 };
 class TextColumn extends TextBaseColumn {
@@ -2066,7 +3109,7 @@ class BitColumn extends ColumnType {
     return columnCode(this, ctx, key, `bit(${length})`);
   }
   toSQL() {
-    return orchidCore.joinTruthy(
+    return joinTruthy(
       this.dataType,
       this.data.length !== void 0 && `(${this.data.length})`
     );
@@ -2085,14 +3128,14 @@ class BitVaryingColumn extends ColumnType {
     return columnCode(this, ctx, key, `bitVarying(${length ?? ""})`);
   }
   toSQL() {
-    return orchidCore.joinTruthy(
+    return joinTruthy(
       this.dataType,
       this.data.length !== void 0 && `(${this.data.length})`
     );
   }
 }
 class TsVectorColumn extends ColumnType {
-  constructor(schema, defaultLanguage = orchidCore.getDefaultLanguage()) {
+  constructor(schema, defaultLanguage = getDefaultLanguage()) {
     super(schema, schema.stringSchema());
     this.defaultLanguage = defaultLanguage;
     this.dataType = "tsvector";
@@ -2137,13 +3180,13 @@ class TsVectorColumn extends ColumnType {
       const { snakeCase } = ctx;
       let sql;
       if (Array.isArray(target)) {
-        const columns = target.length === 1 ? `"${snakeCase ? orchidCore.toSnakeCase(target[0]) : target[0]}"` : target.map(
-          (column2) => `coalesce("${snakeCase ? orchidCore.toSnakeCase(column2) : column2}", '')`
+        const columns = target.length === 1 ? `"${snakeCase ? toSnakeCase(target[0]) : target[0]}"` : target.map(
+          (column2) => `coalesce("${snakeCase ? toSnakeCase(column2) : column2}", '')`
         ).join(` || ' ' || `);
         sql = `to_tsvector('${language}', ${columns})`;
       } else {
         for (const key in target) {
-          sql = (sql ? sql + " || " : "(") + `setweight(to_tsvector('${language}', coalesce("${snakeCase ? orchidCore.toSnakeCase(key) : key}", '')), '${target[key]}')`;
+          sql = (sql ? sql + " || " : "(") + `setweight(to_tsvector('${language}', coalesce("${snakeCase ? toSnakeCase(key) : key}", '')), '${target[key]}')`;
         }
         if (sql) {
           sql += ")";
@@ -2169,14 +3212,14 @@ class TsVectorColumn extends ColumnType {
         const pairs = [];
         for (const key in target) {
           pairs.push(
-            `${orchidCore.quoteObjectKey(key, false)}: '${target[key]}'`
+            `${quoteObjectKey(key, false)}: '${target[key]}'`
           );
         }
         code += `{ ${pairs.join(", ")} }`;
       }
       return code + ")";
     };
-    const column = orchidCore.setColumnData(this, "generated", {
+    const column = setColumnData(this, "generated", {
       toSQL,
       toCode
     });
@@ -2356,8 +3399,8 @@ function uint8ArrToHex(arr) {
 }
 
 const getColumnTypes = (types, fn, nowSQL, language) => {
-  if (nowSQL) orchidCore.setDefaultNowFn(nowSQL);
-  if (language) orchidCore.setDefaultLanguage(language);
+  if (nowSQL) setDefaultNowFn(nowSQL);
+  if (language) setDefaultLanguage(language);
   return fn(types);
 };
 const makeColumnTypes = (schema) => {
@@ -2366,7 +3409,7 @@ const makeColumnTypes = (schema) => {
     enum: schema.enum,
     array: schema.array,
     name(name) {
-      orchidCore.setCurrentColumnName(name);
+      setCurrentColumnName(name);
       return this;
     },
     sql: sqlFn,
@@ -2471,7 +3514,7 @@ const makeColumnTypes = (schema) => {
         return new PostgisGeographyPointColumn(schema);
       }
     },
-    ...orchidCore.timestampHelpers
+    ...timestampHelpers
   };
 };
 RawSQL.prototype.columnTypes = makeColumnTypes;
@@ -2560,7 +3603,7 @@ const makeColumnsByType = (schema) => {
   };
 };
 
-const anyShape = new Proxy(orchidCore.emptyObject, {
+const anyShape = new Proxy(emptyObject, {
   get() {
     return UnknownColumn.instance;
   }
@@ -2628,7 +3671,7 @@ const columnWithDotToSql = (ctx, data, shape, column, index, quotedAs, select) =
     const shape2 = data.joinedShapes?.[table];
     return shape2 ? select ? makeRowToJson(table, shape2, true) : `"${table}".*` : column;
   }
-  const tableName = orchidCore._getQueryAliasOrName(data, table);
+  const tableName = _getQueryAliasOrName(data, table);
   const quoted = `"${table}"`;
   const col = quoted === quotedAs ? shape[key] : data.joinedShapes?.[tableName]?.[key];
   if (col) {
@@ -2667,7 +3710,7 @@ const tableColumnToSqlWithAs = (ctx, data, column, table, key, as, quotedAs, sel
     }
     return column;
   }
-  const tableName = orchidCore._getQueryAliasOrName(data, table);
+  const tableName = _getQueryAliasOrName(data, table);
   const quoted = `"${table}"`;
   const col = quoted === quotedAs ? data.shape[key] : data.joinedShapes?.[tableName][key];
   if (jsonList) jsonList[as] = col;
@@ -2799,7 +3842,7 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
     }
     return;
   }
-  if (orchidCore.isExpression(data)) {
+  if (isExpression(data)) {
     ands.push(`(${data.toSQL(ctx, quotedAs)})`);
     return;
   }
@@ -2807,11 +3850,11 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
     const value = data[key];
     if (value === void 0) continue;
     if (key === "AND") {
-      const arr = orchidCore.toArray(value);
+      const arr = toArray(value);
       const sql = processAnds(arr, ctx, table, query, quotedAs);
       if (sql) ands.push(sql);
     } else if (key === "OR") {
-      const arr = value.map(orchidCore.toArray);
+      const arr = value.map(toArray);
       const sqls = arr.reduce((acc, and) => {
         const sql = processAnds(and, ctx, table, query, quotedAs);
         if (sql) acc.push(sql);
@@ -2819,7 +3862,7 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
       }, []);
       if (sqls.length) ands.push(`(${sqls.join(" OR ")})`);
     } else if (key === "NOT") {
-      const arr = orchidCore.toArray(value);
+      const arr = toArray(value);
       ands.push(`NOT ${processAnds(arr, ctx, table, query, quotedAs, true)}`);
     } else if (key === "ON") {
       if (Array.isArray(value)) {
@@ -2841,10 +3884,10 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
         );
         const rightPath = item[3];
         ands.push(
-          `jsonb_path_query_first(${leftColumn}, ${orchidCore.addValue(
+          `jsonb_path_query_first(${leftColumn}, ${addValue(
             ctx.values,
             leftPath
-          )}) = jsonb_path_query_first(${rightColumn}, ${orchidCore.addValue(
+          )}) = jsonb_path_query_first(${rightColumn}, ${addValue(
             ctx.values,
             rightPath
           )})`
@@ -2854,7 +3897,7 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
         const joinAs = `"${getJoinItemSource(item.joinFrom)}"`;
         const q = item.useOuterAliases ? {
           joinedShapes: query.joinedShapes,
-          aliases: orchidCore._getQueryOuterAliases(query),
+          aliases: _getQueryOuterAliases(query),
           shape: query.shape
         } : query;
         ands.push(
@@ -2862,7 +3905,7 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
         );
       }
     } else if (key === "IN") {
-      orchidCore.toArray(value).forEach((item) => {
+      toArray(value).forEach((item) => {
         pushIn(ctx, query, ands, quotedAs, item);
       });
     } else if (key === "EXISTS") {
@@ -2887,7 +3930,7 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
       const search = value;
       ands.push(`${search.vectorSQL} @@ "${search.as}"`);
     } else if (typeof value === "object" && value && !(value instanceof Date) && !Array.isArray(value)) {
-      if (orchidCore.isExpression(value)) {
+      if (isExpression(value)) {
         ands.push(
           `${columnToSql(
             ctx,
@@ -2947,7 +3990,7 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
         ands.push(`${column} = ${expr.toSQL(ctx, quotedAs)}`);
       } else {
         ands.push(
-          `${column} ${value === null ? "IS NULL" : `= ${orchidCore.addValue(ctx.values, value)}`}`
+          `${column} ${value === null ? "IS NULL" : `= ${addValue(ctx.values, value)}`}`
         );
       }
     }
@@ -2962,10 +4005,10 @@ const pushIn = (ctx, query, ands, quotedAs, arg) => {
   let value;
   if (Array.isArray(arg.values)) {
     value = `${arg.values.map(
-      multiple ? (arr) => `(${arr.map((value2) => orchidCore.addValue(ctx.values, value2)).join(", ")})` : (arr) => `${arr.map((value2) => orchidCore.addValue(ctx.values, value2)).join(", ")}`
+      multiple ? (arr) => `(${arr.map((value2) => addValue(ctx.values, value2)).join(", ")})` : (arr) => `${arr.map((value2) => addValue(ctx.values, value2)).join(", ")}`
     ).join(", ")}`;
     value = `(${value})`;
-  } else if (orchidCore.isExpression(arg.values)) {
+  } else if (isExpression(arg.values)) {
     value = arg.values.toSQL(ctx, quotedAs);
   } else {
     value = `(${getSqlText(toSQL(arg.values, ctx))})`;
@@ -2981,7 +4024,7 @@ const processJoinItem = (ctx, table, query, args, quotedAs) => {
   if ("l" in args) {
     const { aliasValue } = ctx;
     ctx.aliasValue = true;
-    target = `(${getSqlText(args.l.toSQL(ctx))}) "${orchidCore._getQueryAliasOrName(
+    target = `(${getSqlText(args.l.toSQL(ctx))}) "${_getQueryAliasOrName(
       query,
       args.a
     )}"`;
@@ -3028,7 +4071,7 @@ const processJoinItem = (ctx, table, query, args, quotedAs) => {
     target = `(VALUES ${args.d.map((x) => {
       return "(" + Object.entries(shape).map(([key, column]) => {
         const value = x[key];
-        return orchidCore.addValue(
+        return addValue(
           values,
           value === null || value === void 0 ? null : column.data.encode ? column.data.encode(value) : value
         ) + "::" + column.dataType;
@@ -3135,7 +4178,7 @@ const getConditionsFor3Or4LengthItem = (ctx, query, target, quotedAs, args, join
 const getObjectOrRawConditions = (ctx, query, data, quotedAs, joinAs, joinShape) => {
   if (data === true) {
     return "true";
-  } else if (orchidCore.isExpression(data)) {
+  } else if (isExpression(data)) {
     return data.toSQL(ctx, quotedAs);
   } else {
     const pairs = [];
@@ -3276,7 +4319,7 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery, shape, whereExists,
       };
     }
   }
-  const args0 = args.length ? args[0] : orchidCore.returnArg;
+  const args0 = args.length ? args[0] : returnArg;
   if (typeof args0 === "function") {
     let q = first;
     if (q.joinQueryAfterCallback) {
@@ -3357,7 +4400,7 @@ const noneResult = (q, queryData, type) => {
   } else if (type === "valueOrThrow" && queryData.returning) {
     return 0;
   } else {
-    throw new orchidCore.NotFoundError(q);
+    throw new NotFoundError(q);
   }
 };
 const noneMethods = {
@@ -3367,7 +4410,7 @@ const noneMethods = {
     try {
       let result = noneResult(this, this.q, this.q.returnType);
       if (this.q.transform) {
-        result = orchidCore.applyTransforms(
+        result = applyTransforms(
           this.q,
           this.q.returnType,
           this.q.transform,
@@ -3386,8 +4429,8 @@ const noneMethods = {
 const _queryNone = (q) => {
   if (isQueryNone(q)) return q;
   q = extendQuery(q, noneMethods);
-  orchidCore.pushQueryValueImmutable(q, "and", new RawSQL("false"));
-  orchidCore.pushQueryValueImmutable(
+  pushQueryValueImmutable(q, "and", new RawSQL("false"));
+  pushQueryValueImmutable(
     q,
     "transform",
     (_, queryData) => noneResult(q, queryData, queryData.returnType)
@@ -3404,7 +4447,7 @@ const resolveCallbacksInArgs = (q, args) => {
       qb.q = getClonedQueryData(q.q);
       qb.q.and = qb.q.or = qb.q.scopes = void 0;
       qb.q.subQuery = 1;
-      orchidCore._setSubQueryAliases(qb);
+      _setSubQueryAliases(qb);
       args[i] = resolveSubQueryCallbackV2(qb, arg);
     }
   }
@@ -3426,21 +4469,21 @@ const validateFindBy = (q, arg, method) => {
   for (const key in arg) {
     nonEmpty = true;
     if (arg[key] === void 0) {
-      throw new orchidCore.OrchidOrmInternalError(
+      throw new OrchidOrmInternalError(
         q,
         `${method} was called with undefined value`
       );
     }
   }
   if (!nonEmpty) {
-    throw new orchidCore.OrchidOrmInternalError(
+    throw new OrchidOrmInternalError(
       q,
       `${method} was called with empty object`
     );
   }
 };
 const _queryWhereSql = (q, args) => {
-  return orchidCore.pushQueryValueImmutable(
+  return pushQueryValueImmutable(
     q,
     "and",
     sqlQueryArgsToExpression(args)
@@ -3448,24 +4491,24 @@ const _queryWhereSql = (q, args) => {
 };
 const _queryWhereNot = (q, args) => {
   resolveCallbacksInArgs(q, args);
-  return orchidCore.pushQueryValueImmutable(q, "and", {
+  return pushQueryValueImmutable(q, "and", {
     NOT: args
   });
 };
 const _queryWhereNotSql = (q, args) => {
-  return orchidCore.pushQueryValueImmutable(q, "and", {
+  return pushQueryValueImmutable(q, "and", {
     NOT: sqlQueryArgsToExpression(args)
   });
 };
 const _queryWhereOneOf = (q, args) => {
   resolveCallbacksInArgs(q, args);
-  return orchidCore.pushQueryValueImmutable(q, "and", {
+  return pushQueryValueImmutable(q, "and", {
     OR: args
   });
 };
 const _queryWhereNotOneOf = (q, args) => {
   resolveCallbacksInArgs(q, args);
-  return orchidCore.pushQueryValueImmutable(q, "and", {
+  return pushQueryValueImmutable(q, "and", {
     NOT: { OR: args }
   });
 };
@@ -3490,7 +4533,7 @@ const _queryOrNot = (q, args) => {
 const _queryWhereIn = (q, and, arg, values, not) => {
   let item;
   if (values) {
-    if (orchidCore.isIterable(values)) values = [...values];
+    if (isIterable(values)) values = [...values];
     if ("length" in values && !values.length) {
       return _queryNone(q);
     }
@@ -3516,9 +4559,9 @@ const _queryWhereIn = (q, and, arg, values, not) => {
   }
   if (not) item = { NOT: item };
   if (and) {
-    orchidCore.pushQueryValueImmutable(q, "and", item);
+    pushQueryValueImmutable(q, "and", item);
   } else {
-    orchidCore.pushQueryValueImmutable(q, "or", [item]);
+    pushQueryValueImmutable(q, "or", [item]);
   }
   return q;
 };
@@ -4227,7 +5270,7 @@ const _chain = (fromQuery, toQuery, rel) => {
   } else {
     q.relChain = [{ query: self, rel }];
   }
-  orchidCore._applyRelationAliases(self, q);
+  _applyRelationAliases(self, q);
   q.joinedShapes = {
     [getQueryAs(self)]: self.q.shape,
     ...self.q.joinedShapes
@@ -4269,10 +5312,10 @@ const resolveSubQueryCallbackV2 = (q, cb) => {
   arg.q = getClonedQueryData(q.q);
   arg.q.subQuery = 1;
   arg.q.with = arg.q.relChain = void 0;
-  orchidCore._setSubQueryAliases(arg);
+  _setSubQueryAliases(arg);
   return cb(arg);
 };
-const joinSubQuery = (q, sub) => orchidCore.isRelationQuery(sub) ? sub.joinQuery(sub, q) : sub;
+const joinSubQuery = (q, sub) => isRelationQuery(sub) ? sub.joinQuery(sub, q) : sub;
 
 const _clone = (q) => q.clone();
 const pushQueryArrayImmutable = (q, key, value) => {
@@ -4289,7 +5332,7 @@ const setQueryObjectValueImmutable = (q, object, key, value) => {
 };
 const throwIfNoWhere = (q, method) => {
   if (!q.q.or && !q.q.and && !q.q.scopes && !q.q.all) {
-    throw new orchidCore.OrchidOrmInternalError(
+    throw new OrchidOrmInternalError(
       q,
       `Dangerous ${method} without conditions`
     );
@@ -4297,7 +5340,7 @@ const throwIfNoWhere = (q, method) => {
 };
 const throwIfJoinLateral = (q, method) => {
   if (q.q.join?.some((x) => Array.isArray(x) || "s" in x.args && x.args.s)) {
-    throw new orchidCore.OrchidOrmInternalError(
+    throw new OrchidOrmInternalError(
       q,
       `Cannot join a complex query in ${method}`
     );
@@ -4305,8 +5348,8 @@ const throwIfJoinLateral = (q, method) => {
 };
 const saveAliasedShape = (q, as, key) => {
   const shapes = q.q[key];
-  as = orchidCore.getFreeAlias(shapes, as);
-  setQueryObjectValueImmutable(q, key, as, orchidCore.emptyObject);
+  as = getFreeAlias(shapes, as);
+  setQueryObjectValueImmutable(q, key, as, emptyObject);
   return as;
 };
 const extendQuery = (q, methods) => {
@@ -4366,7 +5409,7 @@ const _queryRows = (q) => {
 };
 const getFullColumnTable = (q, column, index, as) => {
   const table = column.slice(0, index);
-  return as && table !== as && orchidCore._checkIfAliased(q, table, as) ? as : table;
+  return as && table !== as && _checkIfAliased(q, table, as) ? as : table;
 };
 
 const _joinReturningArgs = (query, require, first, args, forbidLateral) => {
@@ -4393,7 +5436,7 @@ const _joinReturningArgs = (query, require, first, args, forbidLateral) => {
     joinKey = q.q.as || q.table;
     if (joinKey) {
       shape = getShapeFromSelect(q, joinSubQuery && !!q.q.select);
-      parsers = orchidCore.getQueryParsers(q);
+      parsers = getQueryParsers(q);
       batchParsers = q.q.batchParsers;
       computeds = q.q.runtimeComputeds;
       if (joinSubQuery) {
@@ -4407,7 +5450,7 @@ const _joinReturningArgs = (query, require, first, args, forbidLateral) => {
     if (relation) {
       shape = getShapeFromSelect(relation.query);
       const r = relation.query;
-      parsers = orchidCore.getQueryParsers(r);
+      parsers = getQueryParsers(r);
       batchParsers = r.q.batchParsers;
       computeds = r.q.runtimeComputeds;
     } else {
@@ -4442,17 +5485,17 @@ const _joinReturningArgs = (query, require, first, args, forbidLateral) => {
       if ("r" in joinArgs && joinArgs.r) {
         joinArgs.c = shape = getShapeFromSelect(j, true);
       }
-      orchidCore.setObjectValueImmutable(q, "joinedShapes", joinKey, shape);
-      orchidCore.setObjectValueImmutable(q, "joinedParsers", joinKey, orchidCore.getQueryParsers(j));
+      setObjectValueImmutable(q, "joinedShapes", joinKey, shape);
+      setObjectValueImmutable(q, "joinedParsers", joinKey, getQueryParsers(j));
       if (jq.batchParsers) {
-        orchidCore.setObjectValueImmutable(
+        setObjectValueImmutable(
           jq,
           "joinedBatchParsers",
           joinKey,
           jq.batchParsers
         );
       }
-      orchidCore.setObjectValueImmutable(
+      setObjectValueImmutable(
         q,
         "joinedComputeds",
         joinKey,
@@ -4485,7 +5528,7 @@ const _join = (query, require, type, first, args) => {
   if (!joinArgs) {
     return _queryNone(query);
   }
-  orchidCore.pushQueryValueImmutable(query, "join", {
+  pushQueryValueImmutable(query, "join", {
     type,
     args: joinArgs
   });
@@ -4500,12 +5543,12 @@ const _join = (query, require, type, first, args) => {
 const addAllShapesAndParsers = (query, joinKey, shape, parsers, batchParsers, computeds) => {
   if (!joinKey) return;
   const { q } = query;
-  orchidCore.setObjectValueImmutable(q, "joinedShapes", joinKey, shape);
-  orchidCore.setObjectValueImmutable(q, "joinedParsers", joinKey, parsers);
+  setObjectValueImmutable(q, "joinedShapes", joinKey, shape);
+  setObjectValueImmutable(q, "joinedParsers", joinKey, parsers);
   if (batchParsers) {
-    orchidCore.setObjectValueImmutable(q, "joinedBatchParsers", joinKey, batchParsers);
+    setObjectValueImmutable(q, "joinedBatchParsers", joinKey, batchParsers);
   }
-  orchidCore.setObjectValueImmutable(q, "joinedComputeds", joinKey, computeds);
+  setObjectValueImmutable(q, "joinedComputeds", joinKey, computeds);
 };
 const _joinLateralProcessArg = (q, arg, cb) => {
   let relation;
@@ -4545,19 +5588,19 @@ const _joinLateral = (self, type, arg, as, innerJoinLateral) => {
   const q = self;
   arg.q.joinTo = q;
   const joinedAs = getQueryAs(q);
-  orchidCore.setObjectValueImmutable(arg.q, "joinedShapes", joinedAs, q.q.shape);
+  setObjectValueImmutable(arg.q, "joinedShapes", joinedAs, q.q.shape);
   const joinKey = as || arg.q.as || arg.table;
   if (joinKey) {
     const shape = getShapeFromSelect(arg, true);
-    orchidCore.setObjectValueImmutable(q.q, "joinedShapes", joinKey, shape);
-    orchidCore.setObjectValueImmutable(
+    setObjectValueImmutable(q.q, "joinedShapes", joinKey, shape);
+    setObjectValueImmutable(
       q.q,
       "joinedParsers",
       joinKey,
-      orchidCore.getQueryParsers(arg)
+      getQueryParsers(arg)
     );
     if (arg.q.batchParsers) {
-      orchidCore.setObjectValueImmutable(
+      setObjectValueImmutable(
         q.q,
         "joinedBatchParsers",
         joinKey,
@@ -4566,7 +5609,7 @@ const _joinLateral = (self, type, arg, as, innerJoinLateral) => {
     }
   }
   as || (as = getQueryAs(arg));
-  orchidCore.setObjectValueImmutable(q.q, "joinedComputeds", as, arg.q.runtimeComputeds);
+  setObjectValueImmutable(q.q, "joinedComputeds", as, arg.q.runtimeComputeds);
   const joinArgs = {
     l: arg,
     a: as,
@@ -4594,7 +5637,7 @@ const _joinLateral = (self, type, arg, as, innerJoinLateral) => {
       map.set(dedupKey, { q: arg, a: as });
     }
   }
-  orchidCore.pushQueryValueImmutable(q, "join", {
+  pushQueryValueImmutable(q, "join", {
     type: `${type} LATERAL`,
     args: joinArgs
   });
@@ -4638,11 +5681,11 @@ const logParamToLogObject = (logger, log) => {
         logger.log(
           makeMessage(
             colors,
-            orchidCore.logColors.boldCyanBright,
+            logColors.boldCyanBright,
             time,
-            orchidCore.logColors.boldBlue,
+            logColors.boldBlue,
             sql.text,
-            orchidCore.logColors.boldYellow,
+            logColors.boldYellow,
             sql.values
           )
         );
@@ -4652,13 +5695,13 @@ const logParamToLogObject = (logger, log) => {
         logger.error(
           `${makeMessage(
             colors,
-            orchidCore.logColors.boldMagenta,
+            logColors.boldMagenta,
             time,
-            orchidCore.logColors.boldRed,
+            logColors.boldRed,
             sql.text,
-            orchidCore.logColors.boldYellow,
+            logColors.boldYellow,
             sql.values
-          )} ${colors ? orchidCore.logColors.boldRed(message) : message}`
+          )} ${colors ? logColors.boldRed(message) : message}`
         );
       }
     },
@@ -4681,7 +5724,7 @@ const commitSql = {
 const rollbackSql = {
   text: "ROLLBACK"
 };
-class AfterCommitError extends orchidCore.OrchidOrmError {
+class AfterCommitError extends OrchidOrmError {
   constructor(result, hookResults) {
     super("After commit hooks have failed");
     this.result = result;
@@ -4712,14 +5755,14 @@ class Transaction {
     let options;
     let fn;
     if (typeof cbOrOptions === "function") {
-      options = orchidCore.emptyObject;
+      options = emptyObject;
       fn = cbOrOptions;
     } else {
       options = typeof cbOrOptions === "object" ? cbOrOptions : { level: cbOrOptions };
       fn = cb;
     }
     const sql = {
-      values: orchidCore.emptyArray
+      values: emptyArray
     };
     const log = options.log !== void 0 ? this.q.log ?? logParamToLogObject(this.q.logger, options.log) : this.q.log;
     let logData;
@@ -4919,7 +5962,7 @@ const runAfterCommit = (afterCommit, result) => {
 const applyBatchTransforms = (q, batches) => {
   if (q.transform) {
     for (const item of batches) {
-      item.parent[item.key] = orchidCore.applyTransforms(
+      item.parent[item.key] = applyTransforms(
         q,
         q.returnType,
         q.transform,
@@ -5209,18 +6252,19 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
   try {
     if (beforeHooks || query.before) {
       await Promise.all(
-        [...beforeHooks || orchidCore.emptyArray, ...query.before || orchidCore.emptyArray].map(
-          orchidCore.callWithThis,
+        [...beforeHooks || emptyArray, ...query.before || emptyArray].map(
+          callWithThis,
           q
         )
       );
     }
     const localSql = sql = q.toSQL();
-    const { hookSelect, delayedRelationSelect } = sql;
+    const { tableHook, delayedRelationSelect } = sql;
     const { returnType = "all" } = query;
-    const tempReturnType = hookSelect || returnType === "rows" && q.q.batchParsers || delayedRelationSelect?.value ? "all" : returnType;
+    const tempReturnType = tableHook?.select || returnType === "rows" && q.q.batchParsers || delayedRelationSelect?.value ? "all" : returnType;
     let result;
     let queryResult;
+    let cteData;
     if ("text" in sql) {
       if (query.autoPreparedStatements) {
         sql.name = queriesNames[sql.text] || (queriesNames[sql.text] = (nameI++).toString(36));
@@ -5237,8 +6281,20 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
         log.afterQuery(sql, logData);
         sql = void 0;
       }
+      if (localSql.cteHooks?.hasSelect) {
+        const lastRowI = queryResult.rows.length - 1;
+        const lastFieldI = queryResult.fields.length - 1;
+        const fieldName = queryResult.fields[lastFieldI].name;
+        cteData = queryResult.rows[lastRowI][fieldName];
+        queryResult.fields.length = lastFieldI;
+        queryResult.rowCount--;
+        queryResult.rows.length = lastRowI;
+        for (const row of queryResult.rows) {
+          delete row[fieldName];
+        }
+      }
       if (query.patchResult) {
-        await query.patchResult(q, hookSelect, queryResult);
+        await query.patchResult(q, tableHook?.select, queryResult);
       }
       result = query.handleResult(q, tempReturnType, queryResult, localSql);
     } else {
@@ -5276,15 +6332,15 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
         if (log) log.afterQuery(commitSql, logData);
       }
       if (query.patchResult) {
-        await query.patchResult(q, hookSelect, queryResult);
+        await query.patchResult(q, tableHook?.select, queryResult);
       }
       result = query.handleResult(q, tempReturnType, queryResult, localSql);
     }
     let tempColumns;
     let renames;
-    if (hookSelect) {
-      for (const column of hookSelect.keys()) {
-        const { as, temp } = hookSelect.get(column);
+    if (tableHook?.select) {
+      for (const column of tableHook.select.keys()) {
+        const { as, temp } = tableHook.select.get(column);
         if (as) {
           (renames ?? (renames = {}))[column] = as;
         }
@@ -5306,42 +6362,103 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
         if (promise2) await promise2;
       }
     }
-    const hasAfterHook = afterHooks || afterCommitHooks || query.after;
+    let cteAfterHooks;
+    let cteAfterCommitHooks;
+    if (localSql.cteHooks) {
+      for (const cteName in localSql.cteHooks.tableHooks) {
+        const hook = localSql.cteHooks.tableHooks[cteName];
+        const data = cteData?.[cteName];
+        if (data) {
+          let hasParsers;
+          const parsers = {};
+          for (const key in hook.shape) {
+            if (hook.shape[key]._parse) {
+              hasParsers = true;
+              parsers[key] = hook.shape[key]._parse;
+            }
+          }
+          if (hasParsers) {
+            for (const row of data) {
+              parseRecord(parsers, row);
+            }
+          }
+        }
+        if (hook.tableHook.after) {
+          (cteAfterHooks ?? (cteAfterHooks = [])).push(
+            ...hook.tableHook.after.map(
+              (fn) => () => fn(cteData?.[cteName], q)
+            )
+          );
+        }
+        if (hook.tableHook.afterCommit) {
+          (cteAfterCommitHooks ?? (cteAfterCommitHooks = [])).push(
+            ...hook.tableHook.afterCommit.map(
+              (fn) => () => fn(cteData?.[cteName], q)
+            )
+          );
+        }
+      }
+    }
+    const hasAfterHook = afterHooks || afterCommitHooks || query.after || cteAfterHooks || cteAfterCommitHooks;
     if (hasAfterHook) {
       if (queryResult.rowCount) {
-        if (afterHooks || query.after) {
+        if (afterHooks || query.after || cteAfterHooks) {
           const args = [result, q];
           await Promise.all(
-            [...afterHooks || orchidCore.emptyArray, ...query.after || orchidCore.emptyArray].map(
-              callAfterHook,
-              args
-            )
+            [
+              ...afterHooks || emptyArray,
+              ...query.after || emptyArray,
+              ...cteAfterHooks || emptyArray
+            ].map(callAfterHook, args)
           );
         }
-        if (afterCommitHooks) {
+        if (afterCommitHooks || cteAfterCommitHooks) {
           if (isInUserTransaction(trx)) {
-            (trx.afterCommit ?? (trx.afterCommit = [])).push(
-              result,
-              q,
-              afterCommitHooks
-            );
+            if (afterCommitHooks) {
+              (trx.afterCommit ?? (trx.afterCommit = [])).push(
+                result,
+                q,
+                afterCommitHooks
+              );
+            }
+            if (cteAfterCommitHooks) {
+              (trx.afterCommit ?? (trx.afterCommit = [])).push(
+                result,
+                q,
+                cteAfterCommitHooks
+              );
+            }
           } else {
             const localResult = result;
             queueMicrotask(async () => {
               const promises = [];
-              for (const fn of afterCommitHooks) {
-                try {
-                  promises.push(
-                    fn(localResult, q)
-                  );
-                } catch (err) {
-                  promises.push(Promise.reject(err));
+              if (afterCommitHooks) {
+                for (const fn of afterCommitHooks) {
+                  try {
+                    promises.push(
+                      fn(localResult, q)
+                    );
+                  } catch (err) {
+                    promises.push(Promise.reject(err));
+                  }
+                }
+              }
+              if (cteAfterCommitHooks) {
+                for (const fn of cteAfterCommitHooks) {
+                  try {
+                    promises.push(fn());
+                  } catch (err) {
+                    promises.push(Promise.reject(err));
+                  }
                 }
               }
               await _runAfterCommitHooks(
                 localResult,
                 promises,
-                () => afterCommitHooks.map((h) => h.name),
+                () => [
+                  ...afterCommitHooks || emptyArray,
+                  ...cteAfterCommitHooks || emptyArray
+                ].map((h) => h.name),
                 q.q.catchAfterCommitErrors
               );
             });
@@ -5354,7 +6471,7 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
     }
     if (delayedRelationSelect?.value) {
       const q2 = delayedRelationSelect.query;
-      const primaryKeys = orchidCore.requirePrimaryKeys(
+      const primaryKeys = requirePrimaryKeys(
         q2,
         "Cannot select a relation of a table that has no primary keys"
       );
@@ -5372,7 +6489,7 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
       const select = [{ selectAs }];
       const relationKeyAliases = primaryKeys.map((key) => {
         if (key in selectAs) {
-          const as = orchidCore.getFreeAlias(selectAs, key);
+          const as = getFreeAlias(selectAs, key);
           selectAs[as] = key;
           return as;
         } else {
@@ -5402,7 +6519,7 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
     }
     const promise = parseBatch(q, queryResult, delayedRelationSelect);
     if (promise) await promise;
-    if (hookSelect || tempReturnType !== returnType) {
+    if (tableHook?.select || tempReturnType !== returnType) {
       if (renames) {
         const renamedResult = Array.from({
           length: result.length
@@ -5428,7 +6545,7 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
       );
     }
     if (query.transform) {
-      result = orchidCore.applyTransforms(query, returnType, query.transform, result);
+      result = applyTransforms(query, returnType, query.transform, result);
     }
     return resolve ? resolve(result) : result;
   } catch (err) {
@@ -5470,11 +6587,11 @@ const execQuery = (adapter, method, sql) => {
   });
 };
 const handleResult = (q, returnType, result, sql, isSubQuery) => {
-  const parsers = orchidCore.getQueryParsers(q, sql.hookSelect);
+  const parsers = getQueryParsers(q, sql.tableHook?.select);
   switch (returnType) {
     case "all": {
       if (q.q.throwOnNotFound && result.rows.length === 0)
-        throw new orchidCore.NotFoundError(q);
+        throw new NotFoundError(q);
       const { rows } = result;
       if (parsers) {
         for (const row of rows) {
@@ -5491,7 +6608,7 @@ const handleResult = (q, returnType, result, sql, isSubQuery) => {
     }
     case "oneOrThrow": {
       const { rows } = result;
-      if (!rows.length) throw new orchidCore.NotFoundError(q);
+      if (!rows.length) throw new NotFoundError(q);
       if (parsers) parseRecord(parsers, rows[0]);
       return rows[0];
     }
@@ -5514,12 +6631,12 @@ const handleResult = (q, returnType, result, sql, isSubQuery) => {
     case "valueOrThrow": {
       if (q.q.returning) {
         if (q.q.throwOnNotFound && result.rowCount === 0) {
-          throw new orchidCore.NotFoundError(q);
+          throw new NotFoundError(q);
         }
         return result.rowCount;
       }
       const { rows } = result;
-      if (rows[0]?.[0] === void 0) throw new orchidCore.NotFoundError(q);
+      if (rows[0]?.[0] === void 0) throw new NotFoundError(q);
       return parseValue(rows[0][0], parsers);
     }
     case "void": {
@@ -5568,7 +6685,7 @@ const parsePluck = (parsers, isSubQuery, rows) => {
   }
 };
 const parseValue = (value, parsers) => {
-  const parser = parsers?.[orchidCore.getValueKey];
+  const parser = parsers?.[getValueKey];
   return parser ? parser(value) : value;
 };
 const filterResult = (q, returnType, queryResult, result, tempColumns, hasAfterHook) => {
@@ -5578,7 +6695,7 @@ const filterResult = (q, returnType, queryResult, result, tempColumns, hasAfterH
   if (returnType === "oneOrThrow" || returnType === "one") {
     let row = result[0];
     if (!row) {
-      if (returnType === "oneOrThrow") throw new orchidCore.NotFoundError(q);
+      if (returnType === "oneOrThrow") throw new NotFoundError(q);
       return void 0;
     } else if (!tempColumns?.size) {
       return row;
@@ -5598,7 +6715,7 @@ const filterResult = (q, returnType, queryResult, result, tempColumns, hasAfterH
       return queryResult.rowCount;
     }
     const row = result[0];
-    if (!row) throw new orchidCore.NotFoundError(q);
+    if (!row) throw new NotFoundError(q);
     return row[getFirstResultKey(q, queryResult)];
   }
   if (returnType === "pluck") {
@@ -5670,10 +6787,10 @@ function queryFrom(self, arg) {
         const parsers = {};
         joinedParsers[item] = parsers;
         addWithParsers(w, parsers);
-      } else if (!orchidCore.isExpression(item)) {
+      } else if (!isExpression(item)) {
         Object.assign(shape, getShapeFromSelect(item, true));
         const key = getQueryAs(item);
-        joinedParsers[key] = orchidCore.getQueryParsers(item);
+        joinedParsers[key] = getQueryParsers(item);
       }
     }
     data.joinedParsers = joinedParsers;
@@ -5681,7 +6798,7 @@ function queryFrom(self, arg) {
     const q = arg;
     data.as || (data.as = q.q.as || q.table || "t");
     data.shape = getShapeFromSelect(q, true);
-    data.defaultParsers = orchidCore.getQueryParsers(q);
+    data.defaultParsers = getQueryParsers(q);
     data.batchParsers = q.q.batchParsers;
   }
   data.from = arg;
@@ -5765,7 +6882,7 @@ class FromMethods {
 }
 
 function queryWrap(self, query, as = "t") {
-  return orchidCore._setQueryAs(queryFrom(query, self), as);
+  return _setQueryAs(queryFrom(query, self), as);
 }
 function cloneQueryBaseUnscoped(query) {
   const q = query.baseQuery.clone();
@@ -5779,7 +6896,7 @@ const addParserForRawExpression = (q, key, raw) => {
 const addParsersForSelectJoined = (q, arg, as = arg) => {
   const parsers = q.q.joinedParsers?.[arg];
   if (parsers) {
-    orchidCore.setParserToQuery(q.q, as, (row) => parseRecord(parsers, row));
+    setParserToQuery(q.q, as, (row) => parseRecord(parsers, row));
   }
   const batchParsers = q.q.joinedBatchParsers?.[arg];
   if (batchParsers) {
@@ -5806,9 +6923,9 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
         }))
       );
     }
-    const parsers = orchidCore.isExpression(arg) ? void 0 : orchidCore.getQueryParsers(arg);
+    const parsers = isExpression(arg) ? void 0 : getQueryParsers(arg);
     if (parsers || query.hookSelect || query.transform || query.returnType === "oneOrThrow" || query.returnType === "valueOrThrow" || query.returnType === "one" || query.returnType === "value") {
-      orchidCore.pushQueryValueImmutable(q, "batchParsers", {
+      pushQueryValueImmutable(q, "batchParsers", {
         path: [key],
         fn: (path, queryResult) => {
           const { rows } = queryResult;
@@ -5850,7 +6967,7 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
                   }
                 } else {
                   for (const { data } of batches) {
-                    if (!data) throw new orchidCore.NotFoundError(arg);
+                    if (!data) throw new NotFoundError(arg);
                     parseRecord(parsers, data);
                   }
                 }
@@ -5861,7 +6978,7 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
                 }
               } else {
                 for (const { data } of batches) {
-                  if (!data) throw new orchidCore.NotFoundError(arg);
+                  if (!data) throw new NotFoundError(arg);
                 }
               }
               if (hookSelect) {
@@ -5885,7 +7002,7 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
             case "value":
             case "valueOrThrow": {
               const notNullable = !query.getColumn?.data.isNullable;
-              const parse = parsers?.[orchidCore.getValueKey];
+              const parse = parsers?.[getValueKey];
               if (parse) {
                 if (returnType === "value") {
                   for (const item of batches) {
@@ -5894,7 +7011,7 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
                 } else {
                   for (const item of batches) {
                     if (notNullable && item.data === null) {
-                      throw new orchidCore.NotFoundError(arg);
+                      throw new NotFoundError(arg);
                     }
                     item.parent[item.key] = item.data = parse(item.data);
                   }
@@ -5907,7 +7024,7 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
                 }
               } else if (notNullable) {
                 for (const { data } of batches) {
-                  if (data === null) throw new orchidCore.NotFoundError(arg);
+                  if (data === null) throw new NotFoundError(arg);
                 }
               }
               if (hookSelect) {
@@ -5967,7 +7084,7 @@ const addParserForSelectItem = (q, as, key, arg, columnAlias, joinQuery) => {
     if (!joinQuery && arg.q?.subQuery && arg.q.expr) {
       arg = arg.q.expr;
     }
-    if (orchidCore.isExpression(arg)) {
+    if (isExpression(arg)) {
       addParserForRawExpression(q, key, arg);
       return arg;
     }
@@ -6025,7 +7142,7 @@ const processSelectArg = (q, as, arg, columnAs) => {
           return false;
         }
       }
-      if (!orchidCore.isExpression(value) && orchidCore.isRelationQuery(value) && // `subQuery = 1` case is when callback returns the same query as it gets,
+      if (!isExpression(value) && isRelationQuery(value) && // `subQuery = 1` case is when callback returns the same query as it gets,
       // for example `q => q.get('name')`.
       value.q.subQuery !== 1) {
         query.q.selectRelation = joinQuery = true;
@@ -6066,7 +7183,7 @@ const processSelectArg = (q, as, arg, columnAs) => {
           innerJoinLateral && returnType !== "one" && returnType !== "oneOrThrow"
         );
         if (as2) {
-          value.q.joinedForSelect = orchidCore._copyQueryAliasToQuery(
+          value.q.joinedForSelect = _copyQueryAliasToQuery(
             value,
             q,
             as2
@@ -6101,7 +7218,7 @@ const setParserForSelectedString = (query, arg, as, columnAs, columnAlias) => {
     return selectColumn(query, q, column, columnAs, columnAlias);
   }
   const parser = q.joinedParsers?.[table]?.[column];
-  if (parser) orchidCore.setParserToQuery(q, columnAs || column, parser);
+  if (parser) setParserToQuery(q, columnAs || column, parser);
   const batchParsers = q.joinedBatchParsers?.[table];
   if (batchParsers) {
     let cloned = false;
@@ -6118,8 +7235,8 @@ const setParserForSelectedString = (query, arg, as, columnAs, columnAlias) => {
   const computeds = q.joinedComputeds?.[table];
   if (computeds?.[column]) {
     const computed = computeds[column];
-    orchidCore._addToHookSelectWithTable(query, computed.deps, table);
-    orchidCore.setObjectValueImmutable(q, "selectedComputeds", column, computed);
+    _addToHookSelectWithTable(query, computed.deps, table);
+    setObjectValueImmutable(q, "selectedComputeds", column, computed);
     return;
   }
   return arg;
@@ -6128,14 +7245,14 @@ const selectColumn = (query, q, key, columnAs, columnAlias) => {
   if (key === "*") {
     const { defaultParsers } = query.q;
     if (defaultParsers) {
-      orchidCore.spreadObjectValues(query.q, "parsers", defaultParsers);
+      spreadObjectValues(query.q, "parsers", defaultParsers);
     }
   } else {
     const parser = query.q.defaultParsers?.[key];
-    if (parser) orchidCore.setObjectValueImmutable(q, "parsers", columnAs || key, parser);
+    if (parser) setObjectValueImmutable(q, "parsers", columnAs || key, parser);
     if (q.runtimeComputeds?.[key]) {
       const computed = q.runtimeComputeds[key];
-      orchidCore._addToHookSelect(query, computed.deps);
+      _addToHookSelect(query, computed.deps);
       query.q.selectedComputeds = {
         ...query.q.selectedComputeds,
         [columnAlias || key]: computed
@@ -6164,7 +7281,7 @@ const getShapeFromSelect = (q, isSubQuery) => {
       for (const key in shape) {
         const column = shape[key];
         if (!column.data.explicitSelect) {
-          result[key] = column.data.name ? orchidCore.setColumnData(column, "name", void 0) : column;
+          result[key] = column.data.name ? setColumnData(column, "name", void 0) : column;
         }
       }
     } else {
@@ -6175,7 +7292,7 @@ const getShapeFromSelect = (q, isSubQuery) => {
     for (const item of select) {
       if (typeof item === "string") {
         addColumnToShapeFromSelect(q, item, shape, query, result, isSubQuery);
-      } else if (orchidCore.isExpression(item)) {
+      } else if (isExpression(item)) {
         result.value = item.result.value;
       } else if (item && "selectAs" in item) {
         for (const key in item.selectAs) {
@@ -6190,7 +7307,7 @@ const getShapeFromSelect = (q, isSubQuery) => {
               isSubQuery,
               key
             );
-          } else if (orchidCore.isExpression(it)) {
+          } else if (isExpression(it)) {
             result[key] = it.result.value || UnknownColumn.instance;
           } else if (it) {
             const { returnType } = it.q;
@@ -6311,7 +7428,7 @@ class Select {
   }
 }
 
-class SelectItemExpression extends orchidCore.Expression {
+class SelectItemExpression extends Expression {
   constructor(query, item, value) {
     super();
     this.query = query;
@@ -6355,13 +7472,13 @@ const _get = (query, returnType, arg) => {
       query,
       arg,
       getQueryAs(query),
-      orchidCore.getValueKey
+      getValueKey
     );
     q.select = selected ? [q.expr = new SelectItemExpression(query, selected, type)] : void 0;
   } else {
     type = arg.result.value;
     q.getColumn = type;
-    addParserForRawExpression(query, orchidCore.getValueKey, arg);
+    addParserForRawExpression(query, getValueKey, arg);
     q.select = [q.expr = arg];
   }
   return setQueryOperators(
@@ -6376,7 +7493,7 @@ function _queryGetOptional(self, arg) {
   return _get(self, "value", arg);
 }
 
-class RowToJsonExpression extends orchidCore.Expression {
+class RowToJsonExpression extends Expression {
   constructor(from, one, coalesce) {
     super();
     this.from = from;
@@ -6395,6 +7512,7 @@ class RowToJsonExpression extends orchidCore.Expression {
       q.q,
       `"${getQueryAs(q)}"`,
       q.q.hookSelect,
+      void 0,
       aliases,
       void 0,
       jsonList
@@ -6435,11 +7553,11 @@ const withToSql = (ctx, items) => {
     if (!item) continue;
     let inner;
     if (item.q) {
-      inner = getSqlText(toSQL(item.q, ctx));
+      inner = toSubSqlText(item.q, item.n, ctx);
     } else {
       inner = item.s.toSQL(ctx, `"${item.n}"`);
     }
-    const o = item.o ?? orchidCore.emptyObject;
+    const o = item.o ?? emptyObject;
     sqls.push(
       `${o.recursive ? "RECURSIVE " : ""}"${item.n}"${o.columns ? `(${o.columns.map((x) => `"${x}"`).join(", ")})` : ""} AS ${o.materialized ? "MATERIALIZED " : o.notMaterialized ? "NOT MATERIALIZED " : ""}(${inner})`
     );
@@ -6463,7 +7581,7 @@ const pushOrAppendWithSql = (ctx, query, items) => {
   }
 };
 
-const makeInsertSql = (ctx, q, query, quotedAs) => {
+const makeInsertSql = (ctx, q, query, quotedAs, isSubSql) => {
   let { columns } = query;
   const { shape, inCTE, hookCreateSet } = query;
   const QueryClass = ctx.qb.constructor;
@@ -6569,7 +7687,7 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
       const arr = [];
       for (const key in set) {
         const val = set[key];
-        const value = orchidCore.isExpression(val) ? val.toSQL(ctx, quotedAs) : orchidCore.addValue(ctx.values, val);
+        const value = isExpression(val) ? val.toSQL(ctx, quotedAs) : addValue(ctx.values, val);
         arr.push(`"${shape[key]?.data.name || key}" = ${value}`);
       }
       ctx.sql.push("DO UPDATE SET", arr.join(", "));
@@ -6578,32 +7696,17 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
     }
   }
   pushWhereStatementSql(ctx, q, query, quotedAs);
-  let returning;
   let delayedRelationSelect;
-  if (inCTE) {
-    const select = inCTE.returning?.select;
-    returning = {
-      select: inCTE.selectNum || !select ? select ? "1, " + select : "1" : select,
-      hookSelect: inCTE.returning?.hookSelect
-    };
-  } else {
-    delayedRelationSelect = q.q.selectRelation ? orchidCore.newDelayedRelationSelect(q) : void 0;
-    returning = makeReturningSql(
-      ctx,
-      q,
-      query,
-      quotedAs,
-      delayedRelationSelect,
-      2
-    );
+  if (!inCTE) {
+    delayedRelationSelect = q.q.selectRelation ? newDelayedRelationSelect(q) : void 0;
   }
-  if (returning.select) ctx.sql.push("RETURNING", returning.select);
+  const returningPos = ctx.sql.length;
   let insertManyFromValuesAs;
   if (insertFrom) {
     if (values.length < 2) {
       const q2 = insertFrom.clone();
       if (values[0]?.length) {
-        orchidCore.pushQueryValueImmutable(
+        pushQueryValueImmutable(
           q2,
           "select",
           new RawSQL(
@@ -6666,7 +7769,18 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
           addWithSqls(ctx, hasWith, withSqls, valuesPos, insertSql);
           ctx.sql[valuesPos] = startingKeyword + valuesSql.join(", ") + valuesAppend;
           ctxValues.length = currentValuesLen;
-          batch = orchidCore.pushOrNewArray(batch, {
+          const returning2 = makeInsertReturning(
+            ctx,
+            q,
+            query,
+            quotedAs,
+            delayedRelationSelect,
+            isSubSql
+          );
+          if (returning2.select) {
+            ctx.sql[returningPos] = "RETURNING " + returning2.select;
+          }
+          batch = pushOrNewArray(batch, {
             text: ctx.sql.join(" "),
             values: ctxValues
           });
@@ -6683,7 +7797,7 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
     addWithSqls(ctx, hasWith, withSqls, valuesPos, insertSql);
     if (batch) {
       if (hasNonSelect) {
-        throw new orchidCore.OrchidOrmInternalError(
+        throw new OrchidOrmInternalError(
           q,
           `Cannot insert many records when having a non-select sub-query`
         );
@@ -6693,8 +7807,19 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
         text: ctx.sql.join(" "),
         values: ctxValues
       });
+      const returning2 = makeInsertReturning(
+        ctx,
+        q,
+        query,
+        quotedAs,
+        delayedRelationSelect,
+        isSubSql
+      );
+      if (returning2.select) {
+        ctx.sql[returningPos] = "RETURNING " + returning2.select;
+      }
       return {
-        hookSelect: returning.hookSelect,
+        tableHook: returning2.tableHook,
         delayedRelationSelect,
         batch
       };
@@ -6705,13 +7830,47 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
       ctx.sql[valuesPos] += ' WHERE NOT EXISTS (SELECT 1 FROM "f")';
     }
   }
+  const returning = makeInsertReturning(
+    ctx,
+    q,
+    query,
+    quotedAs,
+    delayedRelationSelect,
+    isSubSql
+  );
+  if (returning.select) {
+    ctx.sql[returningPos] = "RETURNING " + returning.select;
+  }
   return {
-    hookSelect: returning.hookSelect,
+    tableHook: returning.tableHook,
     delayedRelationSelect,
     text: ctx.sql.join(" "),
     values: ctx.values
   };
 };
+const makeInsertReturning = (ctx, q, query, quotedAs, delayedRelationSelect, isSubSql) => {
+  const { inCTE } = query;
+  if (inCTE) {
+    const select = inCTE.returning?.select;
+    return {
+      select: inCTE.selectNum || !select ? select ? "1, " + select : "1" : select,
+      tableHook: inCTE.returning?.hookSelect && {
+        select: inCTE.returning?.hookSelect
+      }
+    };
+  } else {
+    return makeReturningSql(
+      ctx,
+      q,
+      query,
+      quotedAs,
+      delayedRelationSelect,
+      "Create",
+      void 0,
+      isSubSql
+    );
+  }
+};
 const addWithSqls = (ctx, hasWith, withSqls, valuesPos, insertSql) => {
   if (withSqls.length) {
     if (hasWith) {
@@ -6877,7 +8036,7 @@ const encodeRow = (ctx, values, q, QueryClass, row, runtimeDefaults, quotedAs, h
   );
   if (runtimeDefaults) {
     for (const fn of runtimeDefaults) {
-      arr.push(orchidCore.addValue(values, fn()));
+      arr.push(addValue(values, fn()));
     }
   }
   if (hookSetSql) arr.push(hookSetSql);
@@ -6885,36 +8044,35 @@ const encodeRow = (ctx, values, q, QueryClass, row, runtimeDefaults, quotedAs, h
 };
 const encodeValue = (ctx, values, q, QueryClass, value, quotedAs) => {
   if (value && typeof value === "object") {
-    if (value instanceof orchidCore.Expression) {
+    if (value instanceof Expression) {
       return value.toSQL(ctx, quotedAs);
     } else if (value instanceof QueryClass) {
-      return `(${getSqlText(joinSubQuery(q, value).toSQL(ctx))})`;
+      return `(${toSubSqlText(
+        joinSubQuery(q, value),
+        value.q.as,
+        ctx
+      )})`;
     } else if ("fromHook" in value) {
       return value.fromHook;
     }
   }
-  return value === void 0 ? "DEFAULT" : orchidCore.addValue(values, value);
+  return value === void 0 ? "DEFAULT" : addValue(values, value);
 };
-const hookSelectKeys = [
-  null,
-  "afterUpdateSelect",
-  "afterCreateSelect",
-  "afterDeleteSelect"
-];
-const makeReturningSql = (ctx, q, data, quotedAs, delayedRelationSelect, hookSelectI, addHookSelectI) => {
+const makeReturningSql = (ctx, q, data, quotedAs, delayedRelationSelect, hookPurpose, addHookPurpose, isSubSql) => {
   if (data.inCTE) {
-    if (hookSelectI !== 2) {
+    if (hookPurpose !== "Create") {
       const returning = makeReturningSql(
         ctx,
         q,
         data,
         quotedAs,
         delayedRelationSelect,
-        2,
-        hookSelectI
+        "Create",
+        hookPurpose,
+        isSubSql
       );
-      if (returning.hookSelect) {
-        for (const [key, value] of returning.hookSelect) {
+      if (returning.tableHook?.select) {
+        for (const [key, value] of returning.tableHook.select) {
           data.inCTE.targetHookSelect.set(key, value);
         }
       }
@@ -6924,12 +8082,18 @@ const makeReturningSql = (ctx, q, data, quotedAs, delayedRelationSelect, hookSel
       return data.inCTE.returning;
     }
   }
-  const hookSelect = hookSelectI && data[hookSelectKeys[hookSelectI]];
+  const hookSelect = hookPurpose && data[`after${hookPurpose}Select`];
   const { select } = data;
-  if (!q.q.hookSelect && !hookSelect?.size && !select?.length && !addHookSelectI) {
-    return { hookSelect: hookSelect && /* @__PURE__ */ new Map() };
+  if (!q.q.hookSelect && !hookSelect?.size && !select?.length && !hookPurpose) {
+    const select2 = hookSelect && /* @__PURE__ */ new Map();
+    return {
+      select: !isSubSql && ctx.cteHooks?.hasSelect ? "NULL" : void 0,
+      tableHook: select2 && {
+        select: select2
+      }
+    };
   }
-  const otherCTEHookSelect = addHookSelectI && data[hookSelectKeys[addHookSelectI]];
+  const otherCTEHookSelect = addHookPurpose && data[`after${addHookPurpose}Select`];
   let tempSelect;
   if (q.q.hookSelect || hookSelect || otherCTEHookSelect || q.q.selectRelation) {
     tempSelect = new Map(q.q.hookSelect);
@@ -6944,7 +8108,7 @@ const makeReturningSql = (ctx, q, data, quotedAs, delayedRelationSelect, hookSel
       }
     }
     if (q.q.selectRelation) {
-      for (const column of orchidCore.getPrimaryKeys(q)) {
+      for (const column of getPrimaryKeys(q)) {
         tempSelect.set(column, { select: column });
       }
     }
@@ -6958,18 +8122,25 @@ const makeReturningSql = (ctx, q, data, quotedAs, delayedRelationSelect, hookSel
       quotedAs,
       tempSelect,
       void 0,
+      void 0,
       true,
       void 0,
       delayedRelationSelect
     );
   }
+  const after = hookPurpose && data[`after${hookPurpose}`];
+  const afterCommit = hookPurpose && data[`after${hookPurpose}Commit`];
   return {
-    select: sql,
-    hookSelect: tempSelect
+    select: !isSubSql && ctx.cteHooks?.hasSelect ? sql ? "NULL, " + sql : "NULL" : sql,
+    tableHook: (tempSelect || after || afterCommit) && {
+      select: tempSelect,
+      after: data.after && after ? [...data.after, ...after] : after ? after : data.after,
+      afterCommit
+    }
   };
 };
 
-const pushSelectSql = (ctx, table, query, quotedAs, aliases) => {
+const pushSelectSql = (ctx, table, query, quotedAs, isSubSql, aliases) => {
   if (query.selectCache) {
     ctx.sql.push(query.selectCache.sql);
     if (aliases) aliases.push(...query.selectCache.aliases);
@@ -6980,12 +8151,13 @@ const pushSelectSql = (ctx, table, query, quotedAs, aliases) => {
       query,
       quotedAs,
       query.hookSelect,
+      isSubSql,
       aliases
     );
     if (sql) ctx.sql.push(sql);
   }
 };
-const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect, aliases, skipCTE, jsonList, delayedRelationSelect) => {
+const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect, isSubSql, aliases, skipCTE, jsonList, delayedRelationSelect) => {
   if (query.inCTE && !skipCTE) {
     const { select } = makeReturningSql(
       ctx,
@@ -7060,14 +8232,14 @@ const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect,
             }
             const value = obj[as];
             if (typeof value === "object") {
-              if (orchidCore.isExpression(value)) {
+              if (isExpression(value)) {
                 list.push(`${value.toSQL(ctx, quotedAs)} "${as}"`);
                 if (jsonList) {
                   jsonList[as] = value.result.value;
                 }
                 aliases?.push(as);
-              } else if (delayedRelationSelect && orchidCore.isRelationQuery(value)) {
-                orchidCore.setDelayedRelation(delayedRelationSelect, as, value);
+              } else if (delayedRelationSelect && isRelationQuery(value)) {
+                setDelayedRelation(delayedRelationSelect, as, value);
               } else {
                 pushSubQuerySql(ctx, query, value, as, list, quotedAs, aliases);
                 if (jsonList) {
@@ -7132,7 +8304,7 @@ const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect,
           hookSelect.delete(column);
           continue;
         }
-        name = orchidCore.getFreeAlias(selected, column);
+        name = getFreeAlias(selected, column);
         item.as = name;
         item.temp = name;
         sql += ` "${name}"`;
@@ -7150,6 +8322,10 @@ const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect,
       list.push(sql);
     }
   }
+  if (!isSubSql && ctx.cteHooks?.hasSelect) {
+    const count = ctx.selectedCount = list.length || query.selectAllColumns?.length || 0;
+    return count ? (list.length ? list.join(", ") : selectAllSql(query, quotedAs, jsonList)) + ", NULL" : "";
+  }
   return list.length ? list.join(", ") : query.select ? "" : selectAllSql(query, quotedAs, jsonList);
 };
 const selectAllSql = (query, quotedAs, jsonList) => {
@@ -7181,7 +8357,7 @@ const pushSubQuerySql = (ctx, mainQuery, query, as, list, quotedAs, aliases) =>
         sql = `'[]'::json`;
         break;
       default:
-        throw new orchidCore.UnhandledTypeError(query, returnType);
+        throw new UnhandledTypeError(query, returnType);
     }
     list.push(`${sql} "${as}"`);
     aliases?.push(as);
@@ -7210,7 +8386,7 @@ const pushSubQuerySql = (ctx, mainQuery, query, as, list, quotedAs, aliases) =>
       case "void":
         return;
       default:
-        throw new orchidCore.UnhandledTypeError(query, returnType);
+        throw new UnhandledTypeError(query, returnType);
     }
     if (sql) {
       list.push(`${coalesce(ctx, query, sql, quotedAs)} "${as}"`);
@@ -7230,7 +8406,7 @@ const pushSubQuerySql = (ctx, mainQuery, query, as, list, quotedAs, aliases) =>
       if (!first && query.q.runtimeComputeds?.[as]) {
         query = queryJson(query);
       } else if (!first) {
-        throw new orchidCore.OrchidOrmInternalError(
+        throw new OrchidOrmInternalError(
           query,
           `Nothing was selected for pluck`
         );
@@ -7252,7 +8428,7 @@ const pushSubQuerySql = (ctx, mainQuery, query, as, list, quotedAs, aliases) =>
     case "void":
       break;
     default:
-      throw new orchidCore.UnhandledTypeError(query, returnType);
+      throw new UnhandledTypeError(query, returnType);
   }
   list.push(
     `${coalesce(
@@ -7266,7 +8442,7 @@ const pushSubQuerySql = (ctx, mainQuery, query, as, list, quotedAs, aliases) =>
 const coalesce = (ctx, query, sql, quotedAs) => {
   const { coalesceValue } = query.q;
   if (coalesceValue !== void 0) {
-    const value = orchidCore.isExpression(coalesceValue) ? coalesceValue.toSQL(ctx, quotedAs) : orchidCore.addValue(ctx.values, coalesceValue);
+    const value = isExpression(coalesceValue) ? coalesceValue.toSQL(ctx, quotedAs) : addValue(ctx.values, coalesceValue);
     return `COALESCE(${sql}, ${value})`;
   }
   return sql;
@@ -7281,7 +8457,7 @@ const orderByToSql = (ctx, data, order, quotedAs) => {
   if (typeof order === "string") {
     return addOrder(ctx, data, order, quotedAs);
   }
-  if (orchidCore.isExpression(order)) {
+  if (isExpression(order)) {
     return order.toSQL(ctx, quotedAs);
   }
   const sql = [];
@@ -7294,15 +8470,15 @@ const orderByToSql = (ctx, data, order, quotedAs) => {
 const addOrder = (ctx, data, column, quotedAs, dir) => {
   if (data.sources?.[column]) {
     const search = data.sources[column];
-    const order = dir || (!search.order || search.order === true ? orchidCore.emptyObject : search.order);
-    return `${order.coverDensity ? "ts_rank_cd" : "ts_rank"}(${order.weights ? `${orchidCore.addValue(ctx.values, `{${order.weights}}`)}, ` : ""}${search.vectorSQL}, "${column}"${order.normalization !== void 0 ? `, ${orchidCore.addValue(ctx.values, order.normalization)}` : ""}) ${order.dir || "DESC"}`;
+    const order = dir || (!search.order || search.order === true ? emptyObject : search.order);
+    return `${order.coverDensity ? "ts_rank_cd" : "ts_rank"}(${order.weights ? `${addValue(ctx.values, `{${order.weights}}`)}, ` : ""}${search.vectorSQL}, "${column}"${order.normalization !== void 0 ? `, ${addValue(ctx.values, order.normalization)}` : ""}) ${order.dir || "DESC"}`;
   }
   return `${maybeSelectedColumnToSql(ctx, data, column, quotedAs)} ${dir || "ASC"}`;
 };
 
 const windowToSql = (ctx, data, window, quotedAs) => {
   if (typeof window === "string") return `"${window}"`;
-  if (orchidCore.isExpression(window)) return `(${window.toSQL(ctx, quotedAs)})`;
+  if (isExpression(window)) return `(${window.toSQL(ctx, quotedAs)})`;
   const sql = [];
   if (window.partitionBy) {
     sql.push(
@@ -7412,7 +8588,7 @@ const fromToSql = (ctx, data, from, quotedAs) => {
   let only;
   let sql;
   if (typeof from === "object") {
-    if (orchidCore.isExpression(from)) {
+    if (isExpression(from)) {
       sql = from.toSQL(ctx, quotedAs) + " " + quotedAs;
     } else {
       only = from.q.only;
@@ -7439,7 +8615,7 @@ const fromToSql = (ctx, data, from, quotedAs) => {
   return (only === void 0 ? data.only : only) ? `ONLY ${sql}` : sql;
 };
 const getSearchLang = (ctx, data, source, quotedAs) => {
-  return source.langSQL ?? (source.langSQL = "languageColumn" in source ? columnToSql(ctx, data, data.shape, source.languageColumn, quotedAs) : orchidCore.isRawSQL(source.language) ? source.language.toSQL(ctx) : orchidCore.addValue(ctx.values, source.language || data.language || "english"));
+  return source.langSQL ?? (source.langSQL = "languageColumn" in source ? columnToSql(ctx, data, data.shape, source.languageColumn, quotedAs) : isRawSQL(source.language) ? source.language.toSQL(ctx) : addValue(ctx.values, source.language || data.language || "english"));
 };
 const getSearchText = (ctx, data, source, quotedAs, forHeadline) => {
   let sql = source.textSQL;
@@ -7464,7 +8640,7 @@ const getSearchText = (ctx, data, source, quotedAs, forHeadline) => {
     sql = columnToSql(ctx, data, data.shape, source.vector, quotedAs);
   } else {
     if (typeof source.text === "string") {
-      sql = orchidCore.addValue(ctx.values, source.text);
+      sql = addValue(ctx.values, source.text);
     } else {
       sql = source.text.toSQL(ctx, quotedAs);
     }
@@ -7480,7 +8656,7 @@ const getTsVector = (ctx, data, lang, source, quotedAs) => {
       let tsVector = "";
       let i = 0;
       for (const key in source.in) {
-        tsVector = (tsVector ? `${tsVector} || ` : "") + `setweight(to_tsvector(${lang}, ${text[i++]}), ${orchidCore.addValue(
+        tsVector = (tsVector ? `${tsVector} || ` : "") + `setweight(to_tsvector(${lang}, ${text[i++]}), ${addValue(
           ctx.values,
           source.in[key]
         )})`;
@@ -7494,7 +8670,7 @@ const getTsVector = (ctx, data, lang, source, quotedAs) => {
   }
 };
 
-const pushUpdateSql = (ctx, table, query, quotedAs) => {
+const pushUpdateSql = (ctx, table, query, quotedAs, isSubSql) => {
   const quotedTable = quoteSchemaAndTable(
     query.schema,
     table.table || query.from
@@ -7506,26 +8682,27 @@ const pushUpdateSql = (ctx, table, query, quotedAs) => {
       Object.assign(hookSet, item);
     }
   } else {
-    hookSet = orchidCore.emptyObject;
+    hookSet = emptyObject;
   }
   const set = [];
   processData(ctx, table, set, query.updateData, hookSet, quotedAs);
   if (query.hookUpdateSet) {
-    applySet(ctx, table, set, hookSet, orchidCore.emptyObject, quotedAs);
+    applySet(ctx, table, set, hookSet, emptyObject, quotedAs);
   }
-  let hookSelect;
-  const delayedRelationSelect = query.selectRelation ? orchidCore.newDelayedRelationSelect(table) : void 0;
+  let tableHook;
+  const delayedRelationSelect = query.selectRelation ? newDelayedRelationSelect(table) : void 0;
   if (!set.length) {
     if (!query.select) {
       query.select = countSelect;
     }
-    hookSelect = pushUpdateReturning(
+    tableHook = pushUpdateReturning(
       ctx,
       table,
       query,
       quotedAs,
       "SELECT",
-      delayedRelationSelect
+      delayedRelationSelect,
+      isSubSql
     );
     ctx.sql.push(`FROM ${quotedTable}`);
     pushWhereStatementSql(ctx, table, query, quotedAs);
@@ -7576,43 +8753,45 @@ const pushUpdateSql = (ctx, table, query, quotedAs) => {
     if (whereSql) {
       ctx.sql.push("WHERE", whereSql);
     }
-    hookSelect = pushUpdateReturning(
+    tableHook = pushUpdateReturning(
       ctx,
       table,
       query,
       quotedAs,
       "RETURNING",
-      delayedRelationSelect
+      delayedRelationSelect,
+      isSubSql
     );
   }
   return {
-    hookSelect,
+    tableHook,
     delayedRelationSelect,
     text: ctx.sql.join(" "),
     values: ctx.values
   };
 };
-const pushUpdateReturning = (ctx, table, query, quotedAs, keyword, delayedRelationSelect) => {
+const pushUpdateReturning = (ctx, table, query, quotedAs, keyword, delayedRelationSelect, isSubSql) => {
   const { inCTE } = query;
-  const { select, hookSelect } = makeReturningSql(
+  const { select, tableHook } = makeReturningSql(
     ctx,
     table,
     query,
     quotedAs,
     delayedRelationSelect,
-    1,
-    inCTE && 2
+    "Update",
+    inCTE && "Create",
+    isSubSql
   );
   const s = inCTE && (inCTE.selectNum || !select) ? select ? "0, " + select : "0" : select;
   if (s) ctx.sql.push(keyword, s);
-  return hookSelect;
+  return tableHook;
 };
 const processData = (ctx, table, set, data, hookSet, quotedAs) => {
   let append;
   for (const item of data) {
     if (typeof item === "function") {
       const result = item(data);
-      if (result) append = orchidCore.pushOrNewArray(append, result);
+      if (result) append = pushOrNewArray(append, result);
     } else {
       applySet(ctx, table, set, item, hookSet, quotedAs);
     }
@@ -7639,7 +8818,7 @@ const applySet = (ctx, table, set, item, hookSet, quotedAs) => {
 };
 const processValue = (ctx, table, QueryClass, key, value, quotedAs) => {
   if (value && typeof value === "object") {
-    if (orchidCore.isExpression(value)) {
+    if (isExpression(value)) {
       return value.toSQL(ctx, quotedAs);
     } else if (value instanceof QueryClass) {
       if (value.q.subQuery === 1) {
@@ -7649,13 +8828,13 @@ const processValue = (ctx, table, QueryClass, key, value, quotedAs) => {
         joinSubQuery(table, value).toSQL(ctx)
       )})`;
     } else if ("op" in value && "arg" in value) {
-      return `"${table.q.shape[key].data.name || key}" ${value.op} ${orchidCore.addValue(ctx.values, value.arg)}`;
+      return `"${table.q.shape[key].data.name || key}" ${value.op} ${addValue(ctx.values, value.arg)}`;
     }
   }
-  return orchidCore.addValue(ctx.values, value);
+  return addValue(ctx.values, value);
 };
 
-const pushDeleteSql = (ctx, table, query, quotedAs) => {
+const pushDeleteSql = (ctx, table, query, quotedAs, isSubSql) => {
   const from = `"${table.table || query.from}"`;
   ctx.sql.push(`DELETE FROM ${from}`);
   if (from !== quotedAs) {
@@ -7669,10 +8848,10 @@ const pushDeleteSql = (ctx, table, query, quotedAs) => {
     for (const item of query.join) {
       const lateral = "l" in item.args && item.args.l;
       if (lateral) {
-        if (orchidCore.isRelationQuery(lateral)) {
+        if (isRelationQuery(lateral)) {
           continue;
         }
-        throw new orchidCore.OrchidOrmInternalError(
+        throw new OrchidOrmInternalError(
           table,
           "Join lateral is not supported in delete"
         );
@@ -7699,18 +8878,20 @@ const pushDeleteSql = (ctx, table, query, quotedAs) => {
       ctx.sql.push("WHERE", conditions);
     }
   }
-  const delayedRelationSelect = query.selectRelation ? orchidCore.newDelayedRelationSelect(table) : void 0;
+  const delayedRelationSelect = query.selectRelation ? newDelayedRelationSelect(table) : void 0;
   const returning = makeReturningSql(
     ctx,
     table,
     query,
     quotedAs,
     delayedRelationSelect,
-    3
+    "Delete",
+    void 0,
+    isSubSql
   );
   if (returning.select) ctx.sql.push("RETURNING", returning.select);
   return {
-    hookSelect: returning.hookSelect,
+    tableHook: returning.tableHook,
     delayedRelationSelect,
     text: ctx.sql.join(" "),
     values: ctx.values
@@ -7725,14 +8906,14 @@ const pushTruncateSql = (ctx, table, query) => {
 
 const pushColumnInfoSql = (ctx, table, query) => {
   ctx.sql.push(
-    `SELECT * FROM information_schema.columns WHERE table_name = ${orchidCore.addValue(
+    `SELECT * FROM information_schema.columns WHERE table_name = ${addValue(
       ctx.values,
       table.table
     )} AND table_catalog = current_database() AND table_schema = ${query.schema || "current_schema()"}`
   );
   if (query.column) {
     ctx.sql.push(
-      `AND column_name = ${orchidCore.addValue(
+      `AND column_name = ${addValue(
         ctx.values,
         table.q.shape[query.column]?.data.name || query.column
       )}`
@@ -7776,7 +8957,34 @@ const pushCopySql = (ctx, table, query, quotedAs) => {
   pushWhereStatementSql(ctx, table, query, quotedAs);
 };
 
-const toSQL = (table, options) => {
+const toSubSqlText = (q, cteName, options) => getSqlText(subToSql(q, cteName, options));
+const subToSql = (q, cteName, options) => {
+  var _a;
+  const sql = toSQL(q, options, true);
+  if (sql.tableHook && (sql.tableHook.after || sql.tableHook.afterCommit) && !q.q.inCTE) {
+    const shape = {};
+    if (sql.tableHook.select) {
+      for (const key of sql.tableHook.select.keys()) {
+        shape[key] = q.shape[key];
+      }
+    }
+    const item = {
+      shape,
+      tableHook: sql.tableHook
+    };
+    if (options.cteHooks) {
+      if (sql.tableHook.select) options.cteHooks.hasSelect = true;
+      (_a = options.cteHooks.tableHooks)[cteName] ?? (_a[cteName] = item);
+    } else {
+      options.cteHooks = {
+        hasSelect: !!sql.tableHook.select,
+        tableHooks: { [cteName]: item }
+      };
+    }
+  }
+  return sql;
+};
+const toSQL = (table, options, isSubSql) => {
   const query = table.q;
   const sql = [];
   const values = options?.values || [];
@@ -7787,7 +8995,8 @@ const toSQL = (table, options) => {
     values,
     aliasValue: options?.aliasValue,
     skipBatchCheck: options?.skipBatchCheck,
-    hasNonSelect: options?.hasNonSelect
+    hasNonSelect: options?.hasNonSelect,
+    cteHooks: options?.cteHooks
   };
   if (query.with) {
     pushWithSql(ctx, query.with);
@@ -7806,11 +9015,11 @@ const toSQL = (table, options) => {
     } else {
       const quotedAs = `"${query.as || tableName}"`;
       if (query.type === "insert") {
-        result = makeInsertSql(ctx, table, query, `"${tableName}"`);
+        result = makeInsertSql(ctx, table, query, `"${tableName}"`, isSubSql);
       } else if (query.type === "update") {
-        result = pushUpdateSql(ctx, table, query, quotedAs);
+        result = pushUpdateSql(ctx, table, query, quotedAs, isSubSql);
       } else if (query.type === "delete") {
-        result = pushDeleteSql(ctx, table, query, quotedAs);
+        result = pushDeleteSql(ctx, table, query, quotedAs, isSubSql);
       } else if (query.type === "copy") {
         pushCopySql(ctx, table, query, quotedAs);
         result = { text: sql.join(" "), values };
@@ -7826,7 +9035,7 @@ const toSQL = (table, options) => {
       const s = getSqlText(firstSql);
       sql.push(query.union.p ? s : `(${s})`);
       for (const u of query.union.u) {
-        const s2 = orchidCore.isExpression(u.a) ? u.a.toSQL(ctx, quotedAs) : getSqlText(toSQL(u.a, ctx));
+        const s2 = isExpression(u.a) ? u.a.toSQL(ctx, quotedAs) : getSqlText(toSQL(u.a, ctx));
         sql.push(`${u.k} ${u.p ? s2 : "(" + s2 + ")"}`);
       }
     } else {
@@ -7835,7 +9044,7 @@ const toSQL = (table, options) => {
         pushDistinctSql(ctx, table, query.distinct, quotedAs);
       }
       const aliases = query.group ? [] : void 0;
-      pushSelectSql(ctx, table, query, quotedAs, aliases);
+      pushSelectSql(ctx, table, query, quotedAs, isSubSql, aliases);
       fromQuery = (table.table || query.from) && pushFromAndAs(ctx, table, query, quotedAs) || void 0;
       if (query.join) {
         pushJoinSql(
@@ -7850,7 +9059,7 @@ const toSQL = (table, options) => {
       }
       if (query.group) {
         const group = query.group.map((item) => {
-          if (orchidCore.isExpression(item)) {
+          if (isExpression(item)) {
             return item.toSQL(ctx, quotedAs);
           } else {
             const i = aliases.indexOf(item);
@@ -7884,15 +9093,15 @@ const toSQL = (table, options) => {
     if (query.useFromLimitOffset) {
       const q = fromQuery?.q;
       if (q.limit) {
-        sql.push(`LIMIT ${orchidCore.addValue(values, q.limit)}`);
+        sql.push(`LIMIT ${addValue(values, q.limit)}`);
       }
       if (q.offset) {
-        sql.push(`OFFSET ${orchidCore.addValue(values, q.offset)}`);
+        sql.push(`OFFSET ${addValue(values, q.offset)}`);
       }
     } else {
       pushLimitSQL(sql, values, query);
       if (query.offset && !query.returnsOne) {
-        sql.push(`OFFSET ${orchidCore.addValue(values, query.offset)}`);
+        sql.push(`OFFSET ${addValue(values, query.offset)}`);
       }
     }
     if (query.for) {
@@ -7901,7 +9110,7 @@ const toSQL = (table, options) => {
       if (tableNames) {
         sql.push(
           "OF",
-          orchidCore.isExpression(tableNames) ? tableNames.toSQL(ctx, quotedAs) : tableNames.map((x) => `"${x}"`).join(", ")
+          isExpression(tableNames) ? tableNames.toSQL(ctx, quotedAs) : tableNames.map((x) => `"${x}"`).join(", ")
         );
       }
       if (query.for.mode) sql.push(query.for.mode);
@@ -7909,13 +9118,29 @@ const toSQL = (table, options) => {
     result = {
       text: sql.join(" "),
       values,
-      hookSelect: query.hookSelect,
+      tableHook: query.hookSelect && {
+        select: query.hookSelect
+      },
       delayedRelationSelect: ctx.delayedRelationSelect
     };
   }
   if (options && (query.type || ctx.hasNonSelect)) {
     options.hasNonSelect = true;
   }
+  if (!isSubSql && ctx.cteHooks && "text" in result) {
+    result.cteHooks = ctx.cteHooks;
+    if (ctx.cteHooks.hasSelect) {
+      result.text += ` UNION ALL SELECT ${"NULL, ".repeat(
+        ctx.selectedCount || 0
+      )}json_build_object(${Object.entries(ctx.cteHooks.tableHooks).map(
+        ([cteName, data]) => `'${cteName}', (SELECT json_agg(${makeRowToJson(
+          cteName,
+          data.shape,
+          false
+        )}) FROM "${cteName}")`
+      ).join(", ")})`;
+    }
+  }
   return result;
 };
 function pushLimitSQL(sql, values, q) {
@@ -7923,12 +9148,12 @@ function pushLimitSQL(sql, values, q) {
     if (queryTypeWithLimitOne[q.returnType] && !q.returning) {
       sql.push(`LIMIT 1`);
     } else if (q.limit) {
-      sql.push(`LIMIT ${orchidCore.addValue(values, q.limit)}`);
+      sql.push(`LIMIT ${addValue(values, q.limit)}`);
     }
   }
 }
 
-class FnExpression extends orchidCore.Expression {
+class FnExpression extends Expression {
   /**
    * @param query - query object.
    * @param fn - SQL function name.
@@ -7936,7 +9161,7 @@ class FnExpression extends orchidCore.Expression {
    * @param options - aggregate options.
    * @param value - column type of the function result.
    */
-  constructor(query, fn, args, options = orchidCore.emptyObject, value) {
+  constructor(query, fn, args, options = emptyObject, value) {
     super();
     this.query = query;
     this.fn = fn;
@@ -7949,7 +9174,7 @@ class FnExpression extends orchidCore.Expression {
     query.q.returnsOne = true;
     query.q.getColumn = value;
     query.q.select = [this];
-    addColumnParserToQuery(query.q, orchidCore.getValueKey, value);
+    addColumnParserToQuery(query.q, getValueKey, value);
   }
   // Builds function SQL.
   makeSQL(ctx, quotedAs) {
@@ -7961,7 +9186,7 @@ class FnExpression extends orchidCore.Expression {
       this.args.map((arg) => {
         if (typeof arg === "string") {
           return arg === "*" ? "*" : columnToSql(ctx, this.q, this.q.shape, arg, quotedAs);
-        } else if (arg instanceof orchidCore.Expression) {
+        } else if (arg instanceof Expression) {
           return arg.toSQL(ctx, quotedAs);
         } else if ("pairs" in arg) {
           const args = [];
@@ -7969,7 +9194,7 @@ class FnExpression extends orchidCore.Expression {
           for (const key in pairs) {
             args.push(
               // ::text is needed to bypass "could not determine data type of parameter" postgres error
-              `${orchidCore.addValue(values, key)}::text, ${rawOrColumnToSql(
+              `${addValue(values, key)}::text, ${rawOrColumnToSql(
                 ctx,
                 this.q,
                 pairs[key],
@@ -7979,7 +9204,7 @@ class FnExpression extends orchidCore.Expression {
           }
           return args.join(", ");
         } else {
-          return orchidCore.addValue(values, arg.value);
+          return addValue(values, arg.value);
         }
       }).join(", ")
     );
@@ -7990,7 +9215,7 @@ class FnExpression extends orchidCore.Expression {
         { ...ctx, sql },
         this.q,
         quotedAs,
-        orchidCore.toArray(options.order)
+        toArray(options.order)
       );
     }
     sql.push(")");
@@ -8020,7 +9245,7 @@ class FnExpression extends orchidCore.Expression {
 }
 function makeFnExpression(self, type, fn, args, options) {
   const q = extendQuery(self, type.operators);
-  q.baseQuery.type = orchidCore.ExpressionTypeMethod.prototype.type;
+  q.baseQuery.type = ExpressionTypeMethod.prototype.type;
   new FnExpression(
     q,
     fn,
@@ -8512,7 +9737,7 @@ class AggregateMethods {
    * @param over - OVER clause config
    */
   rowNumber(over) {
-    return makeFnExpression(this, intNullable, "row_number", orchidCore.emptyArray, {
+    return makeFnExpression(this, intNullable, "row_number", emptyArray, {
       over
     });
   }
@@ -8535,7 +9760,7 @@ class AggregateMethods {
    * @param over - OVER clause config
    */
   rank(over) {
-    return makeFnExpression(this, intNullable, "rank", orchidCore.emptyArray, {
+    return makeFnExpression(this, intNullable, "rank", emptyArray, {
       over
     });
   }
@@ -8558,7 +9783,7 @@ class AggregateMethods {
    * @param over - OVER clause config
    */
   denseRank(over) {
-    return makeFnExpression(this, intNullable, "dense_rank", orchidCore.emptyArray, {
+    return makeFnExpression(this, intNullable, "dense_rank", emptyArray, {
       over
     });
   }
@@ -8581,7 +9806,7 @@ class AggregateMethods {
    * @param over - OVER clause config
    */
   percentRank(over) {
-    return makeFnExpression(this, intNullable, "percent_rank", orchidCore.emptyArray, {
+    return makeFnExpression(this, intNullable, "percent_rank", emptyArray, {
       over
     });
   }
@@ -8604,7 +9829,7 @@ class AggregateMethods {
    * @param over - OVER clause config
    */
   cumeDist(over) {
-    return makeFnExpression(this, floatNullable, "cume_dist", orchidCore.emptyArray, {
+    return makeFnExpression(this, floatNullable, "cume_dist", emptyArray, {
       over
     });
   }
@@ -8624,7 +9849,7 @@ class QueryAsMethods {
    * @param as - alias for the table of this query
    */
   as(as) {
-    return orchidCore._setQueryAs(_clone(this), as);
+    return _setQueryAs(_clone(this), as);
   }
 }
 
@@ -8638,7 +9863,7 @@ class Clear {
       } else if (clear === "counters") {
         if ("type" in q.q && q.q.type === "update") {
           q.q.updateData = q.q.updateData.filter((item) => {
-            if (!orchidCore.isExpression(item) && typeof item !== "function") {
+            if (!isExpression(item) && typeof item !== "function") {
               let removed = false;
               for (const key in item) {
                 const value = item[key];
@@ -8813,7 +10038,7 @@ const _addWith = (query, withStore, item, key = "with") => {
   if (item.q) {
     item.q.q.with?.forEach((item2, i, arr) => {
       if (item2?.q?.q.type) {
-        orchidCore.pushOrNewArrayToObjectImmutable(withStore, key, item2);
+        pushOrNewArrayToObjectImmutable(withStore, key, item2);
         arr[i] = void 0;
       }
     });
@@ -8824,7 +10049,7 @@ const _addWith = (query, withStore, item, key = "with") => {
       q.with = q.with ? [...q.with, ...values] : values;
     }
   }
-  orchidCore.pushOrNewArrayToObjectImmutable(withStore, key, item);
+  pushOrNewArrayToObjectImmutable(withStore, key, item);
 };
 const moveQueryValueToWith = (q, withStore, value, withKey, set, key) => {
   if (value.q.type) {
@@ -8839,7 +10064,10 @@ const moveQueryValueToWith = (q, withStore, value, withKey, set, key) => {
       withKey
     );
     if (set) {
-      set[key] = new RawSQL(`(SELECT * FROM "${as}")`);
+      const sub = _clone(value.baseQuery);
+      sub.q.select = value.q.select;
+      sub.q.as = sub.q.from = as;
+      set[key] = sub;
     }
     return as;
   }
@@ -8897,7 +10125,7 @@ class WithMethods {
     const q = _clone(this);
     const [options, shapeFn, sql] = args.length === 2 ? [void 0, args[0], args[1]] : args;
     const shape = shapeFn(this.columnTypes);
-    orchidCore.pushQueryValueImmutable(q, "with", {
+    pushQueryValueImmutable(q, "with", {
       n: name,
       o: { ...options, columns: Object.keys(shape) },
       s: sql(q)
@@ -9199,7 +10427,7 @@ const processCreateItem = (q, item, rowIndex, ctx, encoders) => {
 };
 const throwOnReadOnly$1 = (q, column, key) => {
   if (column.data.appReadOnly || column.data.readOnly) {
-    throw new orchidCore.OrchidOrmInternalError(
+    throw new OrchidOrmInternalError(
       q,
       "Trying to insert a readonly column",
       { column: key }
@@ -9222,7 +10450,7 @@ const handleOneData = (q, data, ctx) => {
     columns.map(
       (key) => (
         // undefined values were stripped and no need to check for them
-        encoders[key] && !orchidCore.isExpression(data[key]) && data[key] !== null ? encoders[key](data[key]) : data[key]
+        encoders[key] && !isExpression(data[key]) && data[key] !== null ? encoders[key](data[key]) : data[key]
       )
     )
   ];
@@ -9241,7 +10469,7 @@ const handleManyData = (q, data, ctx) => {
   const columns = Array.from(ctx.columns.keys());
   data.forEach((item, i) => {
     values[i] = columns.map(
-      (key) => encoders[key] && item[key] !== void 0 && !orchidCore.isExpression(item[key]) ? encoders[key](item[key]) : item[key]
+      (key) => encoders[key] && item[key] !== void 0 && !isExpression(item[key]) ? encoders[key](item[key]) : item[key]
     );
   });
   return { columns, values };
@@ -9276,8 +10504,8 @@ const insert = (self, {
       q.queryColumnsCount = obj.queryColumnsCount;
     }
     if (values.length > 1) {
-      const insertValuesAs = orchidCore._getQueryFreeAlias(q, "v");
-      orchidCore._setQueryAlias(self, "v", insertValuesAs);
+      const insertValuesAs = _getQueryFreeAlias(q, "v");
+      _setQueryAlias(self, "v", insertValuesAs);
       q.insertValuesAs = insertValuesAs;
     }
   }
@@ -9921,7 +11149,7 @@ class Having {
    */
   having(...args) {
     const q = _clone(this);
-    return orchidCore.pushQueryValueImmutable(
+    return pushQueryValueImmutable(
       q,
       "having",
       args.map((arg) => arg(q).q.expr)
@@ -9937,14 +11165,14 @@ class Having {
    * @param args - SQL expression
    */
   havingSql(...args) {
-    return orchidCore.pushQueryValueImmutable(_clone(this), "having", args);
+    return pushQueryValueImmutable(_clone(this), "having", args);
   }
 }
 
-const before = (q, key, cb) => orchidCore.pushQueryValueImmutable(q, `before${key}`, cb);
+const before = (q, key, cb) => pushQueryValueImmutable(q, `before${key}`, cb);
 const after = (query, key, select, cb, commit) => {
   const q = query;
-  orchidCore.pushQueryValueImmutable(
+  pushQueryValueImmutable(
     q,
     `after${key}${commit ? "Commit" : ""}`,
     cb
@@ -9957,16 +11185,16 @@ const after = (query, key, select, cb, commit) => {
   return query;
 };
 const _queryHookBeforeQuery = (q, cb) => {
-  return orchidCore.pushQueryValueImmutable(q, "before", cb);
+  return pushQueryValueImmutable(q, "before", cb);
 };
 const _queryHookAfterQuery = (q, cb) => {
-  return orchidCore.pushQueryValueImmutable(q, "after", cb);
+  return pushQueryValueImmutable(q, "after", cb);
 };
 const _queryHookBeforeCreate = (q, cb) => {
   return before(
     q,
     "Create",
-    (q2) => cb(new orchidCore.QueryHookUtils(q2, q2.q.columns, "hookCreateSet"))
+    (q2) => cb(new QueryHookUtils(q2, q2.q.columns, "hookCreateSet"))
   );
 };
 const _queryHookAfterCreate = (q, select, cb) => {
@@ -9983,7 +11211,7 @@ const _queryHookBeforeUpdate = (q, cb) => {
         columns.push(...Object.keys(item));
       }
     }
-    return cb(new orchidCore.QueryHookUtils(q2, columns, "hookUpdateSet"));
+    return cb(new QueryHookUtils(q2, columns, "hookUpdateSet"));
   });
 };
 const _queryHookAfterUpdate = (q, select, cb) => {
@@ -10198,7 +11426,7 @@ class QueryHooks {
    */
   catchAfterCommitError(fn) {
     const q = _clone(this);
-    orchidCore.pushQueryValueImmutable(q, "catchAfterCommitErrors", fn);
+    pushQueryValueImmutable(q, "catchAfterCommitErrors", fn);
     return q;
   }
 }
@@ -10863,9 +12091,9 @@ class Join {
       Object.entries(shape).map(([key, column]) => [key, column._parse])
     );
     const { q } = query;
-    orchidCore.setObjectValueImmutable(q, "joinedShapes", as, shape);
-    orchidCore.setObjectValueImmutable(q, "joinedParsers", as, parsers);
-    orchidCore.pushOrNewArrayToObjectImmutable(q, "join", {
+    setObjectValueImmutable(q, "joinedShapes", as, shape);
+    setObjectValueImmutable(q, "joinedParsers", as, parsers);
+    pushOrNewArrayToObjectImmutable(q, "join", {
       type: "JOIN",
       args: { a: as, c: shape, d: data }
     });
@@ -10882,7 +12110,7 @@ const makeOnItem = (joinTo, joinFrom, args) => ({
   }
 });
 const pushQueryOnForOuter = (q, joinFrom, joinTo, leftColumn, rightColumn) => {
-  return orchidCore.pushQueryValueImmutable(q, "and", {
+  return pushQueryValueImmutable(q, "and", {
     ON: {
       joinFrom: joinTo,
       from: leftColumn,
@@ -10893,21 +12121,21 @@ const pushQueryOnForOuter = (q, joinFrom, joinTo, leftColumn, rightColumn) => {
   });
 };
 const pushQueryOn = (q, joinFrom, joinTo, ...on) => {
-  return orchidCore.pushQueryValueImmutable(
+  return pushQueryValueImmutable(
     q,
     "and",
     makeOnItem(joinFrom, joinTo, on)
   );
 };
 const pushQueryOrOn = (q, joinFrom, joinTo, ...on) => {
-  return orchidCore.pushQueryValueImmutable(q, "or", [
+  return pushQueryValueImmutable(q, "or", [
     makeOnItem(joinFrom, joinTo, on)
   ]);
 };
 const addQueryOn = (query, joinFrom, joinTo, ...args) => {
   const cloned = _clone(query);
   const { q } = cloned;
-  orchidCore.setObjectValueImmutable(
+  setObjectValueImmutable(
     q,
     "joinedShapes",
     joinFrom.q.as || joinFrom.table,
@@ -10932,7 +12160,7 @@ const _queryJoinOrOn = (q, args) => {
   );
 };
 const _queryJoinOnJsonPathEquals = (q, args) => {
-  return orchidCore.pushQueryValueImmutable(q, "and", {
+  return pushQueryValueImmutable(q, "and", {
     ON: args
   });
 };
@@ -11051,7 +12279,7 @@ class MergeQueryMethods {
 
 const throwOnReadOnly = (q, column, key) => {
   if (column.data.appReadOnly || column.data.readOnly) {
-    throw new orchidCore.OrchidOrmInternalError(
+    throw new OrchidOrmInternalError(
       q,
       "Trying to update a readonly column",
       { column: key }
@@ -11086,7 +12314,7 @@ const _queryChangeCounter = (self, op, data) => {
       throwOnReadOnly(self, column, data);
     }
   }
-  orchidCore.pushQueryValueImmutable(self, "updateData", map);
+  pushQueryValueImmutable(self, "updateData", map);
   return self;
 };
 const _queryUpdate = (updateSelf, arg) => {
@@ -11095,7 +12323,7 @@ const _queryUpdate = (updateSelf, arg) => {
   q.type = "update";
   const returnCount = !q.select;
   const set = { ...arg };
-  orchidCore.pushQueryValueImmutable(query, "updateData", set);
+  pushQueryValueImmutable(query, "updateData", set);
   const { shape } = q;
   const ctx = {};
   let selectQuery;
@@ -11119,14 +12347,14 @@ const _queryUpdate = (updateSelf, arg) => {
           value
         );
         if (value instanceof Db && value.q.type && value.q.subQuery) {
-          throw new orchidCore.OrchidOrmInternalError(
+          throw new OrchidOrmInternalError(
             value,
             `Only selecting queries are allowed inside a callback of update, ${value.q.type} is given instead.`
           );
         }
         set[key] = value;
       }
-      if (value !== null && value !== void 0 && !orchidCore.isExpression(value)) {
+      if (value !== null && value !== void 0 && !isExpression(value)) {
         if (value instanceof Db) {
           moveQueryValueToWith(query, q, value, "with", set, key);
         } else {
@@ -11138,7 +12366,7 @@ const _queryUpdate = (updateSelf, arg) => {
   }
   const { queries } = ctx;
   if (queries) {
-    const primaryKeys = orchidCore.requirePrimaryKeys(
+    const primaryKeys = requirePrimaryKeys(
       query,
       "Cannot perform complex update on a table without primary keys"
     );
@@ -11147,7 +12375,7 @@ const _queryUpdate = (updateSelf, arg) => {
       hookSelect.set(column, { select: column });
     }
     q.patchResult = async (_, _h, queryResult) => {
-      await Promise.all(queries.map(orchidCore.callWithThis, queryResult));
+      await Promise.all(queries.map(callWithThis, queryResult));
       if (ctx.collect) {
         const t = query.baseQuery.clone();
         _queryWhereIn(
@@ -11563,20 +12791,20 @@ class Update {
   }
 }
 
-class Headline extends orchidCore.Expression {
+class Headline extends Expression {
   constructor(q, source, params) {
     super();
     this.q = q;
     this.source = source;
     this.params = params;
-    this.result = orchidCore.emptyObject;
+    this.result = emptyObject;
     q.expr = this;
   }
   makeSQL(ctx, quotedAs) {
     const { q, source, params } = this;
     const lang = getSearchLang(ctx, q, source, quotedAs);
-    const text = params?.text ? params.text instanceof orchidCore.Expression ? params.text.toSQL(ctx, quotedAs) : columnToSql(ctx, q, q.shape, params.text, quotedAs) : getSearchText(ctx, q, source, quotedAs, true);
-    const options = params?.options ? `, ${params.options instanceof orchidCore.Expression ? params.options.toSQL(ctx, quotedAs) : orchidCore.addValue(ctx.values, params.options)}` : "";
+    const text = params?.text ? params.text instanceof Expression ? params.text.toSQL(ctx, quotedAs) : columnToSql(ctx, q, q.shape, params.text, quotedAs) : getSearchText(ctx, q, source, quotedAs, true);
+    const options = params?.options ? `, ${params.options instanceof Expression ? params.options.toSQL(ctx, quotedAs) : addValue(ctx.values, params.options)}` : "";
     return `ts_headline(${lang}, ${text}, "${source.as}"${options})`;
   }
 }
@@ -11585,7 +12813,7 @@ AggregateMethods.prototype.headline = function(search, params) {
   const q = this;
   const source = q.q.sources?.[search];
   if (!source)
-    throw new orchidCore.OrchidOrmInternalError(q, `Search \`${search}\` is not defined`);
+    throw new OrchidOrmInternalError(q, `Search \`${search}\` is not defined`);
   return new Headline(
     q.q,
     source,
@@ -11792,9 +13020,9 @@ class SearchMethods {
     }
     setQueryObjectValueImmutable(q, "sources", arg.as, arg);
     if (arg.order) {
-      orchidCore.pushQueryValueImmutable(q, "order", arg.as);
+      pushQueryValueImmutable(q, "order", arg.as);
     }
-    return orchidCore.pushQueryValueImmutable(q, "and", { SEARCH: arg });
+    return pushQueryValueImmutable(q, "and", { SEARCH: arg });
   }
 }
 
@@ -11827,7 +13055,7 @@ function orCreate(query, data, updateData, mergeData) {
       const inCTE = {
         selectNum: !!(hasAfterCallback || hasAfterCommitCallback),
         targetHookSelect: hookSelect,
-        delayedRelationSelect: orchidCore.newDelayedRelationSelect(
+        delayedRelationSelect: newDelayedRelationSelect(
           query
         )
       };
@@ -11879,7 +13107,7 @@ function orCreate(query, data, updateData, mergeData) {
       await q22;
       created = true;
     } else if (queryResult.rowCount > 1) {
-      throw new orchidCore.MoreThanOneRowError(
+      throw new MoreThanOneRowError(
         q2,
         `Only one row was expected to find, found ${queryResult.rowCount} rows.`
       );
@@ -11903,7 +13131,7 @@ const QueryUpsert = {
     } else {
       updateData = data.update;
     }
-    if (!orchidCore.isObjectEmpty(updateData)) {
+    if (!isObjectEmpty(updateData)) {
       _queryUpdate(q, updateData);
     }
     return orCreate(q, data.create, updateData, mergeData);
@@ -11973,7 +13201,7 @@ class TransformMethods {
    * @param fn - function to transform query result with
    */
   transform(fn) {
-    return orchidCore.pushQueryValueImmutable(_clone(this), "transform", fn);
+    return pushQueryValueImmutable(_clone(this), "transform", fn);
   }
 }
 
@@ -12020,7 +13248,7 @@ class QueryMap {
    * @param thisArg - same as in the native array map
    */
   map(fn, thisArg) {
-    return orchidCore.pushQueryValueImmutable(_clone(this), "transform", {
+    return pushQueryValueImmutable(_clone(this), "transform", {
       map: fn,
       thisArg
     });
@@ -12045,7 +13273,7 @@ class ScopeMethods {
     if (!q.q.scopes?.[scope]) {
       const s = q.internal.scopes[scope];
       if (!s) throw new Error(`Scope ${scope} is not defined`);
-      orchidCore.setObjectValueImmutable(q.q, "scopes", scope, s);
+      setObjectValueImmutable(q.q, "scopes", scope, s);
     }
     return q;
   }
@@ -12087,7 +13315,7 @@ function enableSoftDelete(query, table, shape, softDelete, scopes) {
   };
   scopes.deleted = scope;
   const { q } = query;
-  orchidCore.setObjectValueImmutable(q, "scopes", "nonDeleted", scope);
+  setObjectValueImmutable(q, "scopes", "nonDeleted", scope);
   const _del = _softDelete(
     column,
     query.internal.nowSQL
@@ -12126,7 +13354,7 @@ class SoftDeleteMethods {
   }
 }
 
-class ColumnRefExpression extends orchidCore.Expression {
+class ColumnRefExpression extends Expression {
   constructor(value, name) {
     super();
     this.name = name;
@@ -12143,7 +13371,7 @@ class ColumnRefExpression extends orchidCore.Expression {
     );
   }
 }
-class RefExpression extends orchidCore.Expression {
+class RefExpression extends Expression {
   constructor(value, query, ref) {
     super();
     this.ref = ref;
@@ -12157,7 +13385,7 @@ class RefExpression extends orchidCore.Expression {
     return columnToSql(ctx, this.q, this.q.shape, this.ref, as && `"${as}"`);
   }
 }
-class OrExpression extends orchidCore.Expression {
+class OrExpression extends Expression {
   constructor(args) {
     super();
     this.args = args;
@@ -12167,7 +13395,7 @@ class OrExpression extends orchidCore.Expression {
     const res = [];
     for (const arg of this.args) {
       if (arg) {
-        if (orchidCore.isExpression(arg)) {
+        if (isExpression(arg)) {
           const sql = arg.toSQL(ctx, quotedAs);
           if (sql) res.push(sql);
         } else {
@@ -12253,7 +13481,7 @@ class ExpressionMethods {
     return new RefExpression(column || UnknownColumn.instance, q, arg);
   }
   val(value) {
-    return new orchidCore.ValExpression(value);
+    return new ValExpression(value);
   }
   /**
    * `fn` allows to call an arbitrary SQL function.
@@ -12292,7 +13520,7 @@ class ExpressionMethods {
    * @param options
    */
   fn(fn, args, options) {
-    return makeFnExpression(this, orchidCore.emptyObject, fn, args, options);
+    return makeFnExpression(this, emptyObject, fn, args, options);
   }
   or(...args) {
     return new OrExpression(args);
@@ -12467,7 +13695,7 @@ class QueryMethods {
   find(value) {
     const q = _clone(this);
     if (value === null || value === void 0) {
-      throw new orchidCore.OrchidOrmInternalError(
+      throw new OrchidOrmInternalError(
         q,
         `${value} is not allowed in the find method`
       );
@@ -12651,7 +13879,7 @@ class QueryMethods {
    * @param arg - window config
    */
   window(arg) {
-    return orchidCore.pushQueryValueImmutable(_clone(this), "window", arg);
+    return pushQueryValueImmutable(_clone(this), "window", arg);
   }
   wrap(query, as) {
     return queryWrap(this, _clone(query), as);
@@ -12706,7 +13934,7 @@ class QueryMethods {
    * @param args - SQL expression
    */
   orderSql(...args) {
-    return orchidCore.pushQueryValueImmutable(
+    return pushQueryValueImmutable(
       _clone(this),
       "order",
       sqlQueryArgsToExpression(args)
@@ -12893,9 +14121,9 @@ class QueryMethods {
     const helperAs = this.q.as || this.table;
     return (query, ...args) => {
       const q = _clone(query);
-      const as = orchidCore._getQueryAs(q);
+      const as = _getQueryAs(q);
       if (as) {
-        orchidCore._setQueryAlias(q, as, helperAs);
+        _setQueryAlias(q, as, helperAs);
       }
       return fn(q, ...args);
     };
@@ -13024,7 +14252,7 @@ class QueryMethods {
 }
 Object.assign(QueryMethods.prototype, QueryUpsert);
 Object.assign(QueryMethods.prototype, QueryOrCreate);
-orchidCore.applyMixins(QueryMethods, [
+applyMixins(QueryMethods, [
   QueryAsMethods,
   AggregateMethods,
   Select,
@@ -13162,7 +14390,7 @@ const parseIndexOrExclude = (item) => {
 const performQuery = async (q, args, method) => {
   const trx = q.internal.transactionStorage.getStore();
   let sql;
-  if (orchidCore.isRawSQL(args[0])) {
+  if (isRawSQL(args[0])) {
     const values = [];
     sql = {
       text: args[0].toSQL({ values }),
@@ -13208,7 +14436,7 @@ class Db extends QueryMethods {
     this.columnTypes = columnTypes;
     const self = this;
     const { softDelete } = options;
-    const scopes = options.scopes || softDelete ? {} : orchidCore.emptyObject;
+    const scopes = options.scopes || softDelete ? {} : emptyObject;
     this.baseQuery = this;
     this.relations = {};
     this.relationQueries = {};
@@ -13230,7 +14458,7 @@ class Db extends QueryMethods {
       if (column.data.name) {
         prepareSelectAll = true;
       } else if (snakeCase) {
-        const snakeName = orchidCore.toSnakeCase(key);
+        const snakeName = toSnakeCase(key);
         if (snakeName !== key) {
           prepareSelectAll = true;
           column.data.name = snakeName;
@@ -13241,7 +14469,7 @@ class Db extends QueryMethods {
       }
       const { modifyQuery: mq } = column.data;
       if (mq) {
-        modifyQuery = orchidCore.pushOrNewArray(modifyQuery, (q) => mq(q, column));
+        modifyQuery = pushOrNewArray(modifyQuery, (q) => mq(q, column));
       }
       if (typeof column.data.default === "function") {
         if (!runtimeDefaultColumns) runtimeDefaultColumns = [key];
@@ -13320,7 +14548,7 @@ class Db extends QueryMethods {
         cb(this);
       }
     }
-    this.error = class extends orchidCore.QueryError {
+    this.error = class extends QueryError {
       constructor(message) {
         super(self, message);
       }
@@ -13420,7 +14648,7 @@ class Db extends QueryMethods {
             const {
               rows: [row]
             } = await performQuery(q, args, "query");
-            if (!row) throw new orchidCore.NotFoundError(q);
+            if (!row) throw new NotFoundError(q);
             return row;
           },
           async takeOptional(...args) {
@@ -13439,7 +14667,7 @@ class Db extends QueryMethods {
             const {
               rows: [row]
             } = await performQuery(q, args, "arrays");
-            if (!row) throw new orchidCore.NotFoundError(q);
+            if (!row) throw new NotFoundError(q);
             return row[0];
           },
           async getOptional(...args) {
@@ -13471,7 +14699,7 @@ class Db extends QueryMethods {
     return performQuery(this, args, "arrays");
   }
 }
-orchidCore.applyMixins(Db, [QueryMethods]);
+applyMixins(Db, [QueryMethods]);
 Db.prototype.constructor = Db;
 const createDbWithAdapter = ({
   log,
@@ -13492,7 +14720,7 @@ const createDbWithAdapter = ({
   };
   const ct = typeof ctOrFn === "function" ? ctOrFn(makeColumnTypes(schemaConfig)) : ctOrFn;
   if (snakeCase) {
-    ct[orchidCore.snakeCaseKey] = true;
+    ct[snakeCaseKey] = true;
   }
   const transactionStorage = new node_async_hooks.AsyncLocalStorage();
   const qb = _initQueryBuilder(
@@ -13694,6 +14922,7 @@ exports.CitextColumn = CitextColumn;
 exports.Clear = Clear;
 exports.ColumnRefExpression = ColumnRefExpression;
 exports.ColumnType = ColumnType;
+exports.ColumnTypeBase = ColumnTypeBase;
 exports.ComputedColumn = ComputedColumn;
 exports.CustomTypeColumn = CustomTypeColumn;
 exports.DateBaseColumn = DateBaseColumn;
@@ -13707,7 +14936,9 @@ exports.DomainColumn = DomainColumn;
 exports.DoublePrecisionColumn = DoublePrecisionColumn;
 exports.DynamicRawSQL = DynamicRawSQL;
 exports.EnumColumn = EnumColumn;
+exports.Expression = Expression;
 exports.ExpressionMethods = ExpressionMethods;
+exports.ExpressionTypeMethod = ExpressionTypeMethod;
 exports.FnExpression = FnExpression;
 exports.For = For;
 exports.FromMethods = FromMethods;
@@ -13727,22 +14958,29 @@ exports.MacAddr8Column = MacAddr8Column;
 exports.MacAddrColumn = MacAddrColumn;
 exports.MergeQueryMethods = MergeQueryMethods;
 exports.MoneyColumn = MoneyColumn;
+exports.MoreThanOneRowError = MoreThanOneRowError;
+exports.NotFoundError = NotFoundError;
 exports.NumberAsStringBaseColumn = NumberAsStringBaseColumn;
 exports.NumberBaseColumn = NumberBaseColumn;
 exports.OnMethods = OnMethods;
 exports.Operators = Operators;
 exports.OrExpression = OrExpression;
+exports.OrchidOrmError = OrchidOrmError;
+exports.OrchidOrmInternalError = OrchidOrmInternalError;
 exports.PathColumn = PathColumn;
 exports.PointColumn = PointColumn;
 exports.PolygonColumn = PolygonColumn;
 exports.PostgisGeographyPointColumn = PostgisGeographyPointColumn;
 exports.QueryAsMethods = QueryAsMethods;
+exports.QueryError = QueryError;
 exports.QueryGet = QueryGet;
+exports.QueryHookUtils = QueryHookUtils;
 exports.QueryHooks = QueryHooks;
 exports.QueryLog = QueryLog;
 exports.QueryMethods = QueryMethods;
 exports.QueryUpsert = QueryUpsert;
 exports.RawSQL = RawSQL;
+exports.RawSQLBase = RawSQLBase;
 exports.RealColumn = RealColumn;
 exports.RefExpression = RefExpression;
 exports.SearchMethods = SearchMethods;
@@ -13763,16 +15001,27 @@ exports.TransformMethods = TransformMethods;
 exports.TsQueryColumn = TsQueryColumn;
 exports.TsVectorColumn = TsVectorColumn;
 exports.UUIDColumn = UUIDColumn;
+exports.UnhandledTypeError = UnhandledTypeError;
 exports.Union = Union;
 exports.UnknownColumn = UnknownColumn;
 exports.Update = Update;
+exports.ValExpression = ValExpression;
 exports.VarCharColumn = VarCharColumn;
 exports.VirtualColumn = VirtualColumn;
 exports.Where = Where;
 exports.WithMethods = WithMethods;
 exports.XMLColumn = XMLColumn;
+exports._addToHookSelect = _addToHookSelect;
+exports._addToHookSelectWithTable = _addToHookSelectWithTable;
 exports._addWith = _addWith;
+exports._applyRelationAliases = _applyRelationAliases;
+exports._checkIfAliased = _checkIfAliased;
 exports._clone = _clone;
+exports._copyQueryAliasToQuery = _copyQueryAliasToQuery;
+exports._getQueryAliasOrName = _getQueryAliasOrName;
+exports._getQueryAs = _getQueryAs;
+exports._getQueryFreeAlias = _getQueryFreeAlias;
+exports._getQueryOuterAliases = _getQueryOuterAliases;
 exports._getSelectableColumn = _getSelectableColumn;
 exports._initQueryBuilder = _initQueryBuilder;
 exports._queryAfterSaveCommit = _queryAfterSaveCommit;
@@ -13830,17 +15079,31 @@ exports._queryWhereNotSql = _queryWhereNotSql;
 exports._queryWhereOneOf = _queryWhereOneOf;
 exports._queryWhereSql = _queryWhereSql;
 exports._runAfterCommitHooks = _runAfterCommitHooks;
+exports._setQueryAlias = _setQueryAlias;
+exports._setQueryAs = _setQueryAs;
+exports._setSubQueryAliases = _setSubQueryAliases;
+exports.addCode = addCode;
 exports.addColumnParserToQuery = addColumnParserToQuery;
 exports.addParserForRawExpression = addParserForRawExpression;
 exports.addParserForSelectItem = addParserForSelectItem;
 exports.addQueryOn = addQueryOn;
+exports.addValue = addValue;
 exports.anyShape = anyShape;
 exports.applyComputedColumns = applyComputedColumns;
+exports.applyMixins = applyMixins;
+exports.applyTransforms = applyTransforms;
+exports.arrayDataToCode = arrayDataToCode;
 exports.assignDbDataToColumn = assignDbDataToColumn;
+exports.backtickQuote = backtickQuote;
+exports.callWithThis = callWithThis;
 exports.checkIfASimpleQuery = checkIfASimpleQuery;
 exports.cloneQueryBaseUnscoped = cloneQueryBaseUnscoped;
+exports.codeToString = codeToString;
+exports.colors = colors;
 exports.columnCheckToCode = columnCheckToCode;
 exports.columnCode = columnCode;
+exports.columnDefaultArgumentToCode = columnDefaultArgumentToCode;
+exports.columnErrorMessagesToCode = columnErrorMessagesToCode;
 exports.columnExcludesToCode = columnExcludesToCode;
 exports.columnForeignKeysToCode = columnForeignKeysToCode;
 exports.columnIndexesToCode = columnIndexesToCode;
@@ -13848,79 +15111,141 @@ exports.columnsShapeToCode = columnsShapeToCode;
 exports.commitSql = commitSql;
 exports.constraintInnerToCode = constraintInnerToCode;
 exports.constraintToCode = constraintToCode;
+exports.consumeColumnName = consumeColumnName;
 exports.copyTableData = copyTableData;
 exports.countSelect = countSelect;
 exports.createDbWithAdapter = createDbWithAdapter;
+exports.dateDataToCode = dateDataToCode;
+exports.deepCompare = deepCompare;
 exports.defaultSchemaConfig = defaultSchemaConfig;
+exports.emptyArray = emptyArray;
+exports.emptyObject = emptyObject;
 exports.escapeForLog = escapeForLog;
 exports.escapeForMigration = escapeForMigration;
 exports.escapeString = escapeString;
 exports.excludeInnerToCode = excludeInnerToCode;
 exports.excludeToCode = excludeToCode;
+exports.exhaustive = exhaustive;
 exports.extendQuery = extendQuery;
 exports.filterResult = filterResult;
 exports.foreignKeyArgumentToCode = foreignKeyArgumentToCode;
+exports.getCallerFilePath = getCallerFilePath;
 exports.getClonedQueryData = getClonedQueryData;
 exports.getColumnBaseType = getColumnBaseType;
 exports.getColumnInfo = getColumnInfo;
 exports.getColumnTypes = getColumnTypes;
+exports.getDefaultLanguage = getDefaultLanguage;
+exports.getFreeAlias = getFreeAlias;
+exports.getFreeSetAlias = getFreeSetAlias;
 exports.getFullColumnTable = getFullColumnTable;
+exports.getImportPath = getImportPath;
+exports.getPrimaryKeys = getPrimaryKeys;
 exports.getQueryAs = getQueryAs;
+exports.getQueryParsers = getQueryParsers;
 exports.getShapeFromSelect = getShapeFromSelect;
 exports.getSqlText = getSqlText;
+exports.getStackTrace = getStackTrace;
+exports.getValueKey = getValueKey;
 exports.handleResult = handleResult;
 exports.identityToCode = identityToCode;
 exports.indexInnerToCode = indexInnerToCode;
 exports.indexToCode = indexToCode;
 exports.isDefaultTimeStamp = isDefaultTimeStamp;
+exports.isExpression = isExpression;
 exports.isInUserTransaction = isInUserTransaction;
+exports.isIterable = isIterable;
+exports.isObjectEmpty = isObjectEmpty;
 exports.isQueryReturnsAll = isQueryReturnsAll;
+exports.isRawSQL = isRawSQL;
+exports.isRelationQuery = isRelationQuery;
 exports.isSelectingCount = isSelectingCount;
+exports.isTemplateLiteralArgs = isTemplateLiteralArgs;
 exports.joinSubQuery = joinSubQuery;
+exports.joinTruthy = joinTruthy;
+exports.logColors = logColors;
 exports.logParamToLogObject = logParamToLogObject;
+exports.makeColumnNullable = makeColumnNullable;
 exports.makeColumnTypes = makeColumnTypes;
 exports.makeColumnsByType = makeColumnsByType;
 exports.makeFnExpression = makeFnExpression;
 exports.moveQueryValueToWith = moveQueryValueToWith;
+exports.newDelayedRelationSelect = newDelayedRelationSelect;
+exports.noop = noop;
+exports.numberDataToCode = numberDataToCode;
+exports.objectHasValues = objectHasValues;
+exports.omit = omit;
 exports.parseRecord = parseRecord;
 exports.parseTableData = parseTableData;
 exports.parseTableDataInput = parseTableDataInput;
+exports.pathToLog = pathToLog;
+exports.pick = pick;
+exports.pluralize = pluralize;
 exports.postgisTypmodToSql = postgisTypmodToSql;
 exports.primaryKeyInnerToCode = primaryKeyInnerToCode;
 exports.processComputedBatches = processComputedBatches;
 exports.processComputedResult = processComputedResult;
 exports.processSelectArg = processSelectArg;
+exports.pushColumnData = pushColumnData;
 exports.pushLimitSQL = pushLimitSQL;
+exports.pushOrNewArray = pushOrNewArray;
+exports.pushOrNewArrayToObjectImmutable = pushOrNewArrayToObjectImmutable;
 exports.pushQueryArrayImmutable = pushQueryArrayImmutable;
 exports.pushQueryOn = pushQueryOn;
 exports.pushQueryOnForOuter = pushQueryOnForOuter;
 exports.pushQueryOrOn = pushQueryOrOn;
+exports.pushQueryValueImmutable = pushQueryValueImmutable;
 exports.pushTableDataCode = pushTableDataCode;
+exports.queryColumnNameToKey = queryColumnNameToKey;
 exports.queryFrom = queryFrom;
 exports.queryFromSql = queryFromSql;
 exports.queryJson = queryJson;
 exports.queryMethodByReturnType = queryMethodByReturnType;
 exports.queryTypeWithLimitOne = queryTypeWithLimitOne;
 exports.queryWrap = queryWrap;
+exports.quoteObjectKey = quoteObjectKey;
 exports.raw = raw;
 exports.referencesArgsToCode = referencesArgsToCode;
+exports.requirePrimaryKeys = requirePrimaryKeys;
 exports.resolveSubQueryCallbackV2 = resolveSubQueryCallbackV2;
+exports.returnArg = returnArg;
 exports.rollbackSql = rollbackSql;
 exports.saveAliasedShape = saveAliasedShape;
+exports.setColumnData = setColumnData;
 exports.setColumnDefaultParse = setColumnDefaultParse;
 exports.setColumnEncode = setColumnEncode;
 exports.setColumnParse = setColumnParse;
 exports.setColumnParseNull = setColumnParseNull;
+exports.setConnectRetryConfig = setConnectRetryConfig;
+exports.setCurrentColumnName = setCurrentColumnName;
+exports.setDataValue = setDataValue;
+exports.setDefaultLanguage = setDefaultLanguage;
+exports.setDefaultNowFn = setDefaultNowFn;
+exports.setDelayedRelation = setDelayedRelation;
+exports.setObjectValueImmutable = setObjectValueImmutable;
 exports.setParserForSelectedString = setParserForSelectedString;
+exports.setParserToQuery = setParserToQuery;
 exports.setQueryObjectValueImmutable = setQueryObjectValueImmutable;
 exports.setQueryOperators = setQueryOperators;
 exports.simplifyColumnDefault = simplifyColumnDefault;
+exports.singleQuote = singleQuote;
+exports.singleQuoteArray = singleQuoteArray;
+exports.snakeCaseKey = snakeCaseKey;
+exports.spreadObjectValues = spreadObjectValues;
 exports.sqlFn = sqlFn;
 exports.sqlQueryArgsToExpression = sqlQueryArgsToExpression;
+exports.stringDataToCode = stringDataToCode;
 exports.tableDataMethods = tableDataMethods;
+exports.templateLiteralSQLToCode = templateLiteralSQLToCode;
 exports.templateLiteralToSQL = templateLiteralToSQL;
 exports.testTransaction = testTransaction;
 exports.throwIfJoinLateral = throwIfJoinLateral;
 exports.throwIfNoWhere = throwIfNoWhere;
+exports.timestampHelpers = timestampHelpers;
+exports.toArray = toArray;
+exports.toCamelCase = toCamelCase;
+exports.toPascalCase = toPascalCase;
 exports.toSQL = toSQL;
+exports.toSnakeCase = toSnakeCase;
+exports.toSubSqlText = toSubSqlText;
+exports.wrapAdapterFnWithConnectRetry = wrapAdapterFnWithConnectRetry;
 //# sourceMappingURL=index.js.map