pqb 0.57.0 → 0.57.2

package/dist/index.mjs

@@ -1,8 +1,1051 @@
-import { ExpressionTypeMethod, Expression, RawSQLBase, emptyObject, isTemplateLiteralArgs, ColumnTypeBase, setColumnData, pushColumnData, templateLiteralSQLToCode, quoteObjectKey, toArray, emptyArray, singleQuote, addCode, singleQuoteArray, objectHasValues, toSnakeCase, columnDefaultArgumentToCode, columnErrorMessagesToCode, setObjectValueImmutable, getValueKey, addValue, isIterable, isExpression, dateDataToCode, joinTruthy, arrayDataToCode, numberDataToCode, noop, stringDataToCode, getDefaultLanguage, setDefaultNowFn, setDefaultLanguage, setCurrentColumnName, timestampHelpers, _getQueryAliasOrName, _getQueryOuterAliases, returnArg, pushQueryValueImmutable, NotFoundError, applyTransforms, OrchidOrmInternalError, _setSubQueryAliases, _applyRelationAliases, isRelationQuery, getFreeAlias, _checkIfAliased, getQueryParsers, logColors, OrchidOrmError, callWithThis, requirePrimaryKeys, _setQueryAs, _copyQueryAliasToQuery, setParserToQuery, _addToHookSelectWithTable, spreadObjectValues, _addToHookSelect, newDelayedRelationSelect, pushOrNewArray, getPrimaryKeys, setDelayedRelation, UnhandledTypeError, isRawSQL, pushOrNewArrayToObjectImmutable, _getQueryFreeAlias, _setQueryAlias, QueryHookUtils, MoreThanOneRowError, isObjectEmpty, ValExpression, applyMixins, _getQueryAs, QueryError, snakeCaseKey } from 'orchid-core';
+import url from 'url';
+import path from 'node:path';
+import { setTimeout } from 'timers/promises';
 import { inspect } from 'node:util';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { templateLiteralToSQL as templateLiteralToSQL$1 } from '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) => 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) => {
@@ -5214,11 +6257,12 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
       );
     }
     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));
@@ -5235,8 +6279,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 {
@@ -5274,15 +6330,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;
         }
@@ -5304,42 +6360,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 || emptyArray, ...query.after || 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
               );
             });
@@ -5400,7 +6517,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
@@ -5468,7 +6585,7 @@ const execQuery = (adapter, method, sql) => {
   });
 };
 const handleResult = (q, returnType, result, sql, isSubQuery) => {
-  const parsers = getQueryParsers(q, sql.hookSelect);
+  const parsers = getQueryParsers(q, sql.tableHook?.select);
   switch (returnType) {
     case "all": {
       if (q.q.throwOnNotFound && result.rows.length === 0)
@@ -6393,6 +7510,7 @@ class RowToJsonExpression extends Expression {
       q.q,
       `"${getQueryAs(q)}"`,
       q.q.hookSelect,
+      void 0,
       aliases,
       void 0,
       jsonList
@@ -6433,7 +7551,7 @@ 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}"`);
     }
@@ -6461,7 +7579,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;
@@ -6576,26 +7694,11 @@ 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 {
+  if (!inCTE) {
     delayedRelationSelect = q.q.selectRelation ? newDelayedRelationSelect(q) : void 0;
-    returning = makeReturningSql(
-      ctx,
-      q,
-      query,
-      quotedAs,
-      delayedRelationSelect,
-      2
-    );
   }
-  if (returning.select) ctx.sql.push("RETURNING", returning.select);
+  const returningPos = ctx.sql.length;
   let insertManyFromValuesAs;
   if (insertFrom) {
     if (values.length < 2) {
@@ -6664,6 +7767,17 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
           addWithSqls(ctx, hasWith, withSqls, valuesPos, insertSql);
           ctx.sql[valuesPos] = startingKeyword + valuesSql.join(", ") + valuesAppend;
           ctxValues.length = currentValuesLen;
+          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
@@ -6691,8 +7805,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
       };
@@ -6703,13 +7828,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) {
@@ -6886,33 +8045,32 @@ const encodeValue = (ctx, values, q, QueryClass, value, quotedAs) => {
     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" : 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);
         }
       }
@@ -6922,12 +8080,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);
@@ -6956,18 +8120,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);
@@ -6978,12 +8149,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,
@@ -7148,6 +8320,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) => {
@@ -7492,7 +8668,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
@@ -7511,19 +8687,20 @@ const pushUpdateSql = (ctx, table, query, quotedAs) => {
   if (query.hookUpdateSet) {
     applySet(ctx, table, set, hookSet, emptyObject, quotedAs);
   }
-  let hookSelect;
+  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);
@@ -7574,36 +8751,38 @@ 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;
@@ -7653,7 +8832,7 @@ const processValue = (ctx, table, QueryClass, key, value, quotedAs) => {
   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) {
@@ -7704,11 +8883,13 @@ const pushDeleteSql = (ctx, table, query, quotedAs) => {
     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
@@ -7774,7 +8955,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 || [];
@@ -7785,7 +8993,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);
@@ -7804,11 +9013,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 };
@@ -7833,7 +9042,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(
@@ -7907,13 +9116,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) {
@@ -8837,7 +10062,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;
   }
@@ -13676,5 +14904,5 @@ function copyTableData(query, arg) {
   return q;
 }
 
-export { AfterCommitError, AggregateMethods, ArrayColumn, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ColumnRefExpression, ColumnType, ComputedColumn, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DecimalColumn, Delete, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, EnumColumn, ExpressionMethods, FnExpression, For, FromMethods, Having, InetColumn, IntegerBaseColumn, IntegerColumn, IntervalColumn, JSONColumn, JSONTextColumn, Join, JsonMethods, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQueryMethods, MoneyColumn, NumberAsStringBaseColumn, NumberBaseColumn, OnMethods, Operators, OrExpression, PathColumn, PointColumn, PolygonColumn, PostgisGeographyPointColumn, QueryAsMethods, QueryGet, QueryHooks, QueryLog, QueryMethods, QueryUpsert, RawSQL, RealColumn, RefExpression, SearchMethods, Select, SerialColumn, SmallIntColumn, SmallSerialColumn, SqlMethod, StringColumn, TextBaseColumn, TextColumn, Then, TimeColumn, TimestampColumn, TimestampTZColumn, Transaction, TransformMethods, TsQueryColumn, TsVectorColumn, UUIDColumn, Union, UnknownColumn, Update, VarCharColumn, VirtualColumn, Where, WithMethods, XMLColumn, _addWith, _clone, _getSelectableColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryChangeCounter, _queryCreate, _queryCreateForEachFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateOneFrom, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertForEachFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertOneFrom, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _querySelectAll, _queryTake, _queryTakeOptional, _queryUnion, _queryUpdate, _queryUpdateOrThrow, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotOneOf, _queryWhereNotSql, _queryWhereOneOf, _queryWhereSql, _runAfterCommitHooks, addColumnParserToQuery, addParserForRawExpression, addParserForSelectItem, addQueryOn, anyShape, applyComputedColumns, assignDbDataToColumn, checkIfASimpleQuery, cloneQueryBaseUnscoped, columnCheckToCode, columnCode, columnExcludesToCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, commitSql, constraintInnerToCode, constraintToCode, copyTableData, countSelect, createDbWithAdapter, defaultSchemaConfig, escapeForLog, escapeForMigration, escapeString, excludeInnerToCode, excludeToCode, extendQuery, filterResult, foreignKeyArgumentToCode, getClonedQueryData, getColumnBaseType, getColumnInfo, getColumnTypes, getFullColumnTable, getQueryAs, getShapeFromSelect, getSqlText, handleResult, identityToCode, indexInnerToCode, indexToCode, isDefaultTimeStamp, isInUserTransaction, isQueryReturnsAll, isSelectingCount, joinSubQuery, logParamToLogObject, makeColumnTypes, makeColumnsByType, makeFnExpression, moveQueryValueToWith, parseRecord, parseTableData, parseTableDataInput, postgisTypmodToSql, primaryKeyInnerToCode, processComputedBatches, processComputedResult, processSelectArg, pushLimitSQL, pushQueryArrayImmutable, pushQueryOn, pushQueryOnForOuter, pushQueryOrOn, pushTableDataCode, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, raw, referencesArgsToCode, resolveSubQueryCallbackV2, rollbackSql, saveAliasedShape, setColumnDefaultParse, setColumnEncode, setColumnParse, setColumnParseNull, setParserForSelectedString, setQueryObjectValueImmutable, setQueryOperators, simplifyColumnDefault, sqlFn, sqlQueryArgsToExpression, tableDataMethods, templateLiteralToSQL, testTransaction, throwIfJoinLateral, throwIfNoWhere, toSQL };
+export { AfterCommitError, AggregateMethods, ArrayColumn, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CidrColumn, CircleColumn, CitextColumn, Clear, ColumnRefExpression, ColumnType, ColumnTypeBase, ComputedColumn, CustomTypeColumn, DateBaseColumn, DateColumn, DateTimeBaseClass, DateTimeTzBaseClass, Db, DecimalColumn, Delete, DomainColumn, DoublePrecisionColumn, DynamicRawSQL, EnumColumn, Expression, ExpressionMethods, ExpressionTypeMethod, FnExpression, For, FromMethods, Having, InetColumn, IntegerBaseColumn, IntegerColumn, IntervalColumn, JSONColumn, JSONTextColumn, Join, JsonMethods, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MergeQueryMethods, MoneyColumn, MoreThanOneRowError, NotFoundError, NumberAsStringBaseColumn, NumberBaseColumn, OnMethods, Operators, OrExpression, OrchidOrmError, OrchidOrmInternalError, PathColumn, PointColumn, PolygonColumn, PostgisGeographyPointColumn, QueryAsMethods, QueryError, QueryGet, QueryHookUtils, QueryHooks, QueryLog, QueryMethods, QueryUpsert, RawSQL, RawSQLBase, RealColumn, RefExpression, SearchMethods, Select, SerialColumn, SmallIntColumn, SmallSerialColumn, SqlMethod, StringColumn, TextBaseColumn, TextColumn, Then, TimeColumn, TimestampColumn, TimestampTZColumn, Transaction, TransformMethods, TsQueryColumn, TsVectorColumn, UUIDColumn, UnhandledTypeError, Union, UnknownColumn, Update, ValExpression, VarCharColumn, VirtualColumn, Where, WithMethods, XMLColumn, _addToHookSelect, _addToHookSelectWithTable, _addWith, _applyRelationAliases, _checkIfAliased, _clone, _copyQueryAliasToQuery, _getQueryAliasOrName, _getQueryAs, _getQueryFreeAlias, _getQueryOuterAliases, _getSelectableColumn, _initQueryBuilder, _queryAfterSaveCommit, _queryAll, _queryChangeCounter, _queryCreate, _queryCreateForEachFrom, _queryCreateMany, _queryCreateManyFrom, _queryCreateOneFrom, _queryDefaults, _queryDelete, _queryExec, _queryFindBy, _queryFindByOptional, _queryGet, _queryGetOptional, _queryHookAfterCreate, _queryHookAfterCreateCommit, _queryHookAfterDelete, _queryHookAfterDeleteCommit, _queryHookAfterQuery, _queryHookAfterSave, _queryHookAfterUpdate, _queryHookAfterUpdateCommit, _queryHookBeforeCreate, _queryHookBeforeDelete, _queryHookBeforeQuery, _queryHookBeforeSave, _queryHookBeforeUpdate, _queryInsert, _queryInsertForEachFrom, _queryInsertMany, _queryInsertManyFrom, _queryInsertOneFrom, _queryJoinOn, _queryJoinOnJsonPathEquals, _queryJoinOrOn, _queryOr, _queryOrNot, _queryRows, _querySelect, _querySelectAll, _queryTake, _queryTakeOptional, _queryUnion, _queryUpdate, _queryUpdateOrThrow, _queryWhere, _queryWhereExists, _queryWhereIn, _queryWhereNot, _queryWhereNotOneOf, _queryWhereNotSql, _queryWhereOneOf, _queryWhereSql, _runAfterCommitHooks, _setQueryAlias, _setQueryAs, _setSubQueryAliases, addCode, addColumnParserToQuery, addParserForRawExpression, addParserForSelectItem, addQueryOn, addValue, anyShape, applyComputedColumns, applyMixins, applyTransforms, arrayDataToCode, assignDbDataToColumn, backtickQuote, callWithThis, checkIfASimpleQuery, cloneQueryBaseUnscoped, codeToString, colors, columnCheckToCode, columnCode, columnDefaultArgumentToCode, columnErrorMessagesToCode, columnExcludesToCode, columnForeignKeysToCode, columnIndexesToCode, columnsShapeToCode, commitSql, constraintInnerToCode, constraintToCode, consumeColumnName, copyTableData, countSelect, createDbWithAdapter, dateDataToCode, deepCompare, defaultSchemaConfig, emptyArray, emptyObject, escapeForLog, escapeForMigration, escapeString, excludeInnerToCode, excludeToCode, exhaustive, extendQuery, filterResult, foreignKeyArgumentToCode, getCallerFilePath, getClonedQueryData, getColumnBaseType, getColumnInfo, getColumnTypes, getDefaultLanguage, getFreeAlias, getFreeSetAlias, getFullColumnTable, getImportPath, getPrimaryKeys, getQueryAs, getQueryParsers, getShapeFromSelect, getSqlText, getStackTrace, getValueKey, handleResult, identityToCode, indexInnerToCode, indexToCode, isDefaultTimeStamp, isExpression, isInUserTransaction, isIterable, isObjectEmpty, isQueryReturnsAll, isRawSQL, isRelationQuery, isSelectingCount, isTemplateLiteralArgs, joinSubQuery, joinTruthy, logColors, logParamToLogObject, makeColumnNullable, makeColumnTypes, makeColumnsByType, makeFnExpression, moveQueryValueToWith, newDelayedRelationSelect, noop, numberDataToCode, objectHasValues, omit, parseRecord, parseTableData, parseTableDataInput, pathToLog, pick, pluralize, postgisTypmodToSql, primaryKeyInnerToCode, processComputedBatches, processComputedResult, processSelectArg, pushColumnData, pushLimitSQL, pushOrNewArray, pushOrNewArrayToObjectImmutable, pushQueryArrayImmutable, pushQueryOn, pushQueryOnForOuter, pushQueryOrOn, pushQueryValueImmutable, pushTableDataCode, queryColumnNameToKey, queryFrom, queryFromSql, queryJson, queryMethodByReturnType, queryTypeWithLimitOne, queryWrap, quoteObjectKey, raw, referencesArgsToCode, requirePrimaryKeys, resolveSubQueryCallbackV2, returnArg, rollbackSql, saveAliasedShape, setColumnData, setColumnDefaultParse, setColumnEncode, setColumnParse, setColumnParseNull, setConnectRetryConfig, setCurrentColumnName, setDataValue, setDefaultLanguage, setDefaultNowFn, setDelayedRelation, setObjectValueImmutable, setParserForSelectedString, setParserToQuery, setQueryObjectValueImmutable, setQueryOperators, simplifyColumnDefault, singleQuote, singleQuoteArray, snakeCaseKey, spreadObjectValues, sqlFn, sqlQueryArgsToExpression, stringDataToCode, tableDataMethods, templateLiteralSQLToCode, templateLiteralToSQL, testTransaction, throwIfJoinLateral, throwIfNoWhere, timestampHelpers, toArray, toCamelCase, toPascalCase, toSQL, toSnakeCase, toSubSqlText, wrapAdapterFnWithConnectRetry };
 //# sourceMappingURL=index.mjs.map