alinea 2.0.0-preview.7 → 2.0.0-preview.8

package/dist/chunks/chunk-2BJ2IFQM.js

@@ -0,0 +1,1085 @@
+import {
+  and
+} from "./chunk-XCZXR3C2.js";
+import {
+  Index,
+  StarSelection,
+  selection,
+  virtualTarget
+} from "./chunk-2PIFHEYR.js";
+import {
+  input,
+  mapToColumn
+} from "./chunk-ATF42T2B.js";
+import {
+  Sql,
+  cached,
+  getData,
+  getField,
+  getQuery,
+  getResolver,
+  getSelection,
+  getSql,
+  getTable,
+  getTarget,
+  hasData,
+  hasField,
+  hasQuery,
+  hasSelection,
+  hasSql,
+  hasTable,
+  hasTarget,
+  internalData,
+  internalQuery,
+  internalSelection,
+  internalSql,
+  internalTarget,
+  sql
+} from "./chunk-ETBQTP2S.js";
+
+// node_modules/rado/dist/core/Queries.js
+var Executable = class {
+  #execute;
+  constructor(exec) {
+    this.#execute = exec;
+  }
+  *[Symbol.iterator]() {
+    const interim = this.#execute();
+    const isAsync = interim instanceof Promise;
+    if (!isAsync) return interim;
+    let result;
+    yield interim.then((v) => result = v);
+    return result;
+  }
+  run() {
+    return this.#execute();
+  }
+  async then(onfulfilled, onrejected) {
+    try {
+      const result = await this.#execute();
+      return onfulfilled ? onfulfilled(result) : result;
+    } catch (error) {
+      return onrejected ? onrejected(error) : Promise.reject(error);
+    }
+  }
+  catch(onrejected) {
+    return this.then().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.then().finally(onfinally);
+  }
+};
+var BatchQuery = class extends Executable {
+  constructor(queryResolver, queries) {
+    super(() => {
+      return queryResolver.batch(queries).execute();
+    });
+  }
+};
+var SingleQuery = class extends Executable {
+  [internalData];
+  constructor(data) {
+    super(() => this.#exec());
+    this[internalData] = data;
+  }
+  #resolver(db) {
+    const data = getData(this);
+    const resolver = db ? getResolver(db) : data.resolver;
+    if (!resolver) throw new Error("Query has no resolver");
+    return resolver;
+  }
+  #exec(db) {
+    const data = getData(this);
+    const resolver = this.#resolver(db);
+    if (!hasSelection(this)) return resolver.run(this);
+    return data.first ? resolver.get(this) : resolver.all(this);
+  }
+  all(db) {
+    return this.#resolver(db).all(this);
+  }
+  get(db) {
+    return this.#resolver(db).get(this);
+  }
+  run(db) {
+    return this.#resolver(db).run(this);
+  }
+  async execute(inputs, db) {
+    const data = getData(this);
+    const resolver = db ? getResolver(db) : data.resolver;
+    if (!resolver) throw new Error("Query has no resolver");
+    const prepared = resolver.prepare(this, "");
+    try {
+      return await prepared.execute(inputs);
+    } finally {
+      prepared[Symbol.dispose]();
+    }
+  }
+  prepare(name, db) {
+    const data = getData(this);
+    const resolver = db ? getResolver(db) : data.resolver;
+    if (!resolver) throw new Error("Query has no resolver");
+    return resolver.prepare(this, name);
+  }
+  toSQL(db) {
+    const resolver = db ? getResolver(db) : getData(this).resolver;
+    if (!resolver) throw new Error("Query has no resolver");
+    return resolver.toSQL(this);
+  }
+};
+var MutationQuery = class extends SingleQuery {
+};
+
+// node_modules/rado/dist/core/query/CTE.js
+function formatCTE(query) {
+  const isRecursive = query.withRecursive;
+  const definitions = isRecursive ? query.withRecursive : query.with;
+  if (!definitions) return;
+  return sql.query({
+    [isRecursive ? "withRecursive" : "with"]: sql.join(
+      definitions.map((cte) => {
+        const query2 = getQuery(cte);
+        const target = getTarget(cte);
+        return sql`${target} as (${query2})`;
+      }),
+      sql`, `
+    )
+  });
+}
+
+// node_modules/rado/dist/core/query/Shared.js
+function formatModifiers(modifiers, selected) {
+  const { orderBy, limit, offset } = modifiers;
+  const normalizedLimit = typeof limit === "number" && limit < 0 ? void 0 : limit;
+  if (!orderBy && normalizedLimit === void 0 && offset === void 0)
+    return void 0;
+  return sql.query({
+    orderBy: orderBy && sql.join(
+      orderBy.map((part) => {
+        const inner = getSql(part);
+        const alias = selected?.aliasOf(part) ?? inner.alias;
+        if (alias) return sql.identifier(alias);
+        return part;
+      }),
+      sql`, `
+    ),
+    limit: normalizedLimit !== void 0 && input(normalizedLimit),
+    offset: offset !== void 0 && input(offset)
+  });
+}
+
+// node_modules/rado/dist/core/query/Delete.js
+var Delete = class _Delete extends MutationQuery {
+  [internalData];
+  constructor(data) {
+    super(data);
+    this[internalData] = data;
+    if (data.returning) this[internalSelection] = selection(data.returning);
+  }
+  get [internalQuery]() {
+    return cached(
+      this,
+      internalQuery,
+      () => deleteQuery(getData(this))
+    );
+  }
+  limit(limit) {
+    return new _Delete({ ...getData(this), limit });
+  }
+  offset(offset) {
+    return new _Delete({ ...getData(this), offset });
+  }
+  orderBy(...orderBy) {
+    return new _Delete({ ...getData(this), orderBy });
+  }
+};
+var DeleteFrom = class _DeleteFrom extends Delete {
+  where(...where) {
+    return new _DeleteFrom({ ...getData(this), where: and(...where) });
+  }
+  returning(returning) {
+    const data = getData(this);
+    return new Delete({
+      ...data,
+      returning: returning ?? data.delete
+    });
+  }
+};
+function deleteQuery(query) {
+  const { delete: from, where, returning } = query;
+  const table = getTable(from);
+  return sql.query(
+    formatCTE(query),
+    {
+      deleteFrom: table.identifier(),
+      where,
+      returning: returning && selection(returning)
+    },
+    formatModifiers(query)
+  );
+}
+
+// node_modules/rado/dist/core/query/Select.js
+function isUnionQuery(query) {
+  return Array.isArray(query.select);
+}
+var SelectFirst = class extends SingleQuery {
+  [internalData];
+  constructor(data) {
+    const inner = { ...data, first: true };
+    super(inner);
+    this[internalData] = inner;
+  }
+  get [internalSelection]() {
+    return cached(this, internalSelection, () => querySelection(getData(this)));
+  }
+  get [internalQuery]() {
+    return cached(
+      this,
+      internalQuery,
+      () => selectQuery(getData(this))
+    );
+  }
+  get [internalSql]() {
+    return cached(
+      this,
+      internalSql,
+      () => getQuery(this).asScalar(getSelection(this).input)
+    );
+  }
+};
+var UnionBase = class extends SingleQuery {
+  [internalData];
+  constructor(data) {
+    super(data);
+    this[internalData] = data;
+  }
+  get [internalSql]() {
+    return cached(
+      this,
+      internalSql,
+      () => getQuery(this).asScalar(getSelection(this).input)
+    );
+  }
+  as(alias) {
+    const selected = getSelection(this);
+    const fields = selected.makeVirtual(alias);
+    return Object.assign({}, fields, {
+      [internalSelection]: selection(fields),
+      [internalSql]: getQuery(this).asScalar(selected.input),
+      [internalTarget]: sql`(${getQuery(this)}) as ${sql.identifier(
+        alias
+      )}`.inlineFields(true)
+    });
+  }
+  #makeSelf() {
+    const selected = getSelection(this);
+    return selected.makeVirtual(Sql.SELF_TARGET);
+  }
+  #getSelect(base) {
+    const data = getData(base);
+    if (!("compound" in data)) throw new Error("No compound defined");
+    return data.compound;
+  }
+  #selectFields(select) {
+    return querySelection(select).fieldNames();
+  }
+  #segmentSelect(segment) {
+    const query = segment;
+    if (isUnionQuery(query)) return query.select[0];
+    if ("union" in segment) return this.#segmentSelect(segment.union);
+    if ("unionAll" in segment) return this.#segmentSelect(segment.unionAll);
+    if ("intersect" in segment) return this.#segmentSelect(segment.intersect);
+    if ("intersectAll" in segment)
+      return this.#segmentSelect(segment.intersectAll);
+    if ("except" in segment) return this.#segmentSelect(segment.except);
+    if ("exceptAll" in segment) return this.#segmentSelect(segment.exceptAll);
+    return segment;
+  }
+  #unionSegment(op, query) {
+    switch (op) {
+      case "union":
+        return { union: query };
+      case "unionAll":
+        return { unionAll: query };
+      case "intersect":
+        return { intersect: query };
+      case "intersectAll":
+        return { intersectAll: query };
+      case "except":
+        return { except: query };
+      case "exceptAll":
+        return { exceptAll: query };
+    }
+  }
+  #assertMatchingFields(left, right) {
+    const fields = this.#selectFields(left[0]);
+    const assert = (query) => {
+      const names = this.#selectFields(query);
+      if (fields.length !== names.length)
+        throw new Error("Union segments must have the same fields");
+      for (let i = 0; i < fields.length; i++)
+        if (fields[i] !== names[i])
+          throw new Error("Union segments must have the same fields");
+    };
+    for (const segment of left.slice(1)) assert(this.#segmentSelect(segment));
+    for (const segment of right) assert(this.#segmentSelect(segment));
+  }
+  #appendCompound(left, op, right) {
+    const [firstRight, ...restRight] = right.select;
+    if (restRight.length === 0)
+      return [...left, this.#unionSegment(op, firstRight)];
+    return [...left, this.#unionSegment(op, right)];
+  }
+  #compound(op, target) {
+    const left = this.#getSelect(this);
+    const rightBase = typeof target === "function" ? target(this.#makeSelf()) : target;
+    const rightData = getData(rightBase);
+    const rightSelect = this.#getSelect(rightBase);
+    const right = { ...rightData, select: rightSelect };
+    this.#assertMatchingFields(left, rightSelect);
+    const select = this.#appendCompound(left, op, right);
+    const {
+      resolver,
+      with: withDefs,
+      withRecursive
+    } = getData(this);
+    return new Union({
+      resolver,
+      with: withDefs,
+      withRecursive,
+      select
+    });
+  }
+  union(target) {
+    return this.#compound("union", target);
+  }
+  unionAll(target) {
+    return this.#compound("unionAll", target);
+  }
+  intersect(target) {
+    return this.#compound("intersect", target);
+  }
+  intersectAll(target) {
+    return this.#compound("intersectAll", target);
+  }
+  except(target) {
+    return this.#compound("except", target);
+  }
+  exceptAll(target) {
+    return this.#compound("exceptAll", target);
+  }
+};
+var forKeywords = ["update", "no key update", "share", "key share"];
+var Select = class _Select extends UnionBase {
+  [internalData];
+  constructor(data) {
+    const compound = [data];
+    const withCompound = { ...data, compound };
+    super(withCompound);
+    this[internalData] = withCompound;
+  }
+  from(from, config) {
+    return new _Select({ ...getData(this), from, ...config });
+  }
+  for(keyword, config = {}) {
+    if (!forKeywords.includes(keyword))
+      throw new Error(`Invalid FOR keyword: ${keyword}`);
+    return new _Select({
+      ...getData(this),
+      for: sql.query(sql.unsafe(keyword), {
+        of: config.of && sql.join([config.of].flat().map(getTarget), sql`, `),
+        nowait: config.noWait,
+        skipLocked: config.skipLocked
+      })
+    });
+  }
+  #fromTarget() {
+    const { from } = getData(this);
+    if (!from) throw new Error("No target defined");
+    if (Array.isArray(from)) return from;
+    return [from];
+  }
+  #join(join) {
+    return new _Select({ ...getData(this), from: [...this.#fromTarget(), join] });
+  }
+  leftJoin(leftJoin, on, config) {
+    return this.#join({ leftJoin, on, ...config });
+  }
+  leftJoinLateral(leftJoinLateral, on, config) {
+    return this.#join({ leftJoinLateral, on, ...config });
+  }
+  rightJoin(rightJoin, on, config) {
+    return this.#join({ rightJoin, on, ...config });
+  }
+  innerJoin(innerJoin, on, config) {
+    return this.#join({ innerJoin, on, ...config });
+  }
+  innerJoinLateral(innerJoinLateral, on, config) {
+    return this.#join({ innerJoinLateral, on, ...config });
+  }
+  fullJoin(fullJoin, on, config) {
+    return this.#join({ fullJoin, on, ...config });
+  }
+  crossJoin(crossJoin, config) {
+    return this.#join({ crossJoin, ...config });
+  }
+  crossJoinLateral(crossJoinLateral, config) {
+    return this.#join({ crossJoinLateral, ...config });
+  }
+  where(...where) {
+    return new _Select({ ...getData(this), where: and(...where) });
+  }
+  groupBy(...groupBy) {
+    return new _Select({ ...getData(this), groupBy });
+  }
+  having(having) {
+    return new _Select({ ...getData(this), having });
+  }
+  orderBy(...orderBy) {
+    return new _Select({ ...getData(this), orderBy });
+  }
+  limit(limit) {
+    return new _Select({ ...getData(this), limit });
+  }
+  offset(offset) {
+    return new _Select({ ...getData(this), offset });
+  }
+  $dynamic() {
+    return this;
+  }
+  $first() {
+    return new SelectFirst(getData(this));
+  }
+  get [internalSelection]() {
+    return cached(this, internalSelection, () => querySelection(getData(this)));
+  }
+  get [internalQuery]() {
+    return cached(
+      this,
+      internalQuery,
+      () => selectQuery(getData(this))
+    );
+  }
+};
+function collectReferencedTargets(input2, names) {
+  if (hasSql(input2)) {
+    if (hasField(input2)) {
+      const field = getField(input2);
+      const source = field.source;
+      if (!(source && typeof source === "object" && hasSql(source)))
+        names.add(field.targetName);
+    }
+    return;
+  }
+  if (!input2 || typeof input2 !== "object") return;
+  for (const value of Object.values(input2))
+    collectReferencedTargets(value, names);
+}
+function collectFromTargets(from, names) {
+  if (!from) return;
+  const collect = (target) => {
+    if (hasTable(target)) {
+      names.add(getTable(target).aliased);
+      return;
+    }
+    if (!hasSelection(target)) return;
+    collectReferencedTargets(getSelection(target).input, names);
+  };
+  if (Array.isArray(from)) {
+    for (const entry of from) {
+      if (hasTarget(entry)) collect(entry);
+      else if (!hasSql(entry)) {
+        const { target } = joinOp(entry);
+        if (hasTarget(target)) collect(target);
+      }
+    }
+    return;
+  }
+  if (hasTarget(from)) collect(from);
+}
+function hasUnnamedDerivedSource(input2) {
+  if (hasField(input2)) {
+    const source = getField(input2).source;
+    if (source && typeof source === "object" && hasSql(source)) {
+      const sourceSql = source;
+      if (!hasField(sourceSql) && !getSql(sourceSql).alias) return true;
+    }
+    return false;
+  }
+  if (hasSql(input2)) return false;
+  if (!input2 || typeof input2 !== "object") return false;
+  return Object.values(input2).some(
+    hasUnnamedDerivedSource
+  );
+}
+var selections = /* @__PURE__ */ new WeakMap();
+function querySelection(query) {
+  let selected = selections.get(query);
+  if (!selected) selections.set(query, selected = createSelection(query));
+  return selected;
+}
+function createSelection({ select, from }) {
+  if (select) {
+    if (from) {
+      const selectedTargets = /* @__PURE__ */ new Set();
+      const fromTargets = /* @__PURE__ */ new Set();
+      collectReferencedTargets(select, selectedTargets);
+      collectFromTargets(from, fromTargets);
+      if (fromTargets.size > 0) {
+        for (const targetName of selectedTargets)
+          if (!fromTargets.has(targetName))
+            throw new Error(`Unknown target in select: ${targetName}`);
+      }
+    }
+    if (hasSql(select) && hasSelection(select)) {
+      const selected = getSelection(select);
+      if (!from || !Array.isArray(from)) return selected;
+      const [, ...joins2] = from;
+      return applyJoins(selected, joins2);
+    }
+    if (!from || !Array.isArray(from))
+      return selection(select);
+    const [, ...joins] = from;
+    return applyJoins(selection(select), joins);
+  }
+  if (!from) throw new Error("No selection defined");
+  if (Array.isArray(from)) {
+    const [target, ...joins] = from;
+    return applyJoins(selection(target), joins);
+  }
+  if (hasSelection(from)) {
+    const selected = getSelection(from);
+    if (hasUnnamedDerivedSource(selected.input))
+      throw new Error("Cannot select all from subquery without alias");
+    return selected;
+  }
+  return selection(sql`*`);
+}
+function applyJoins(base, joins) {
+  let current = base;
+  for (const join of joins) {
+    const { target, op } = joinOp(join);
+    current = current.join(target, op);
+  }
+  return current;
+}
+function joinOp(join) {
+  const { on, useIndex, forceIndex, ignoreIndex, indexedBy, ...rest } = join;
+  const op = Object.keys(rest)[0];
+  const target = rest[op];
+  return {
+    target,
+    op,
+    on,
+    config: { useIndex, forceIndex, ignoreIndex, indexedBy }
+  };
+}
+function indexHintName(hint) {
+  if (typeof hint === "string") return hint;
+  if (hint instanceof Index) {
+    const { name } = getData(hint);
+    if (!name) throw new Error("Index hint requires a named index");
+    return name;
+  }
+  throw new Error("Invalid index hint");
+}
+function formatIndexHint(hints) {
+  const values = hints ? [hints].flat() : [];
+  if (values.length === 0) return;
+  const names = sql.join(
+    values.map((index) => sql.identifier(indexHintName(index))),
+    sql`, `
+  );
+  return sql`(${names})`;
+}
+function formatIndexHints(config) {
+  if (!config) return;
+  return sql.query({
+    useIndex: formatIndexHint(config.useIndex),
+    forceIndex: formatIndexHint(config.forceIndex),
+    ignoreIndex: formatIndexHint(config.ignoreIndex),
+    indexedBy: config.indexedBy ? sql.identifier(indexHintName(config.indexedBy)) : void 0
+  });
+}
+function formatTarget(target, indexHints) {
+  const formattedTarget = hasTable(target) ? getTable(target).target() : getTarget(target);
+  if (!hasTable(target)) return formattedTarget;
+  return sql.join([formattedTarget, formatIndexHints(indexHints)]);
+}
+function formatFrom(from, baseConfig) {
+  if (!from) throw new Error("No target defined");
+  if (Array.isArray(from)) {
+    return sql.join(
+      from.map((join) => {
+        if (hasTarget(join)) return formatTarget(join, baseConfig);
+        if (hasSql(join)) return getSql(join);
+        const { target, op, on, config } = joinOp(join);
+        return sql.query({
+          [op]: hasTarget(target) ? formatTarget(target, config) : getSql(target),
+          on
+        });
+      })
+    );
+  }
+  return hasTarget(from) ? formatTarget(from, baseConfig) : getSql(from);
+}
+function selectQuery(query) {
+  const { from, where, groupBy, having, distinct, distinctOn } = query;
+  const prefix = distinctOn ? sql`distinct on (${sql.join(distinctOn, sql`, `)})` : distinct && sql`distinct`;
+  const selected = querySelection(query);
+  const select = sql.join([prefix, selected]);
+  return sql.query(
+    formatCTE(query),
+    {
+      select,
+      from: from && formatFrom(from, query),
+      for: query.for,
+      where,
+      groupBy: groupBy && sql.join(groupBy, sql`, `),
+      having: typeof having === "function" ? having(selected.input) : having
+    },
+    formatModifiers(query, selected)
+  );
+}
+var Union = class _Union extends UnionBase {
+  [internalData];
+  constructor(data) {
+    const compound = data.select;
+    const withCompound = { ...data, compound };
+    super(withCompound);
+    this[internalData] = withCompound;
+  }
+  get [internalQuery]() {
+    return cached(this, internalQuery, () => unionQuery(getData(this)));
+  }
+  get [internalSelection]() {
+    const {
+      select: [first]
+    } = getData(this);
+    return cached(this, internalSelection, () => querySelection(first));
+  }
+  orderBy(...orderBy) {
+    return new _Union({ ...getData(this), orderBy });
+  }
+  limit(limit) {
+    return new _Union({ ...getData(this), limit });
+  }
+  offset(offset) {
+    return new _Union({ ...getData(this), offset });
+  }
+};
+function unionQuery(query) {
+  const { select } = query;
+  let fields;
+  const firstSelect = (query2) => isUnionQuery(query2) ? query2.select[0] : query2;
+  const segmentQuery = (query2) => {
+    if (isUnionQuery(query2)) {
+      const nested = unionQuery(query2);
+      return sql.universal({
+        sqlite: sql`select * from (${nested})`,
+        default: sql`(${nested})`
+      });
+    }
+    const inner = selectQuery(query2);
+    return query2.orderBy || query2.limit !== void 0 || query2.offset !== void 0 ? sql`(${inner})` : inner;
+  };
+  const segments = sql.join(
+    select.map((segment, i) => {
+      if (i === 0) {
+        fields = querySelection(segment).fieldNames();
+        return segmentQuery(segment);
+      }
+      const op = Object.keys(segment)[0];
+      const query2 = segment[op];
+      const names = querySelection(firstSelect(query2)).fieldNames();
+      if (fields.length !== names.length)
+        throw new Error("Union segments must have the same fields");
+      for (let i2 = 0; i2 < fields.length; i2++)
+        if (fields[i2] !== names[i2])
+          throw new Error("Union segments must have the same fields");
+      return sql.query({ [op]: segmentQuery(query2) });
+    })
+  );
+  return sql.query(formatCTE(query), segments, formatModifiers(query));
+}
+
+// node_modules/rado/dist/core/query/Insert.js
+var Insert = class extends MutationQuery {
+  [internalData];
+  constructor(data) {
+    super(data);
+    this[internalData] = data;
+    if (data.returning) this[internalSelection] = selection(data.returning);
+  }
+  get [internalQuery]() {
+    return cached(
+      this,
+      internalQuery,
+      () => insertQuery(getData(this))
+    );
+  }
+};
+var InsertCanReturn = class extends Insert {
+  returning(returning) {
+    const data = getData(this);
+    return new Insert({
+      ...data,
+      returning: returning ?? data.insert
+    });
+  }
+};
+var InsertCanConflict = class _InsertCanConflict extends InsertCanReturn {
+  onConflictDoNothing(onConflictDoNothing) {
+    const { on = [], ...data } = getData(this);
+    return new _InsertCanConflict({
+      ...data,
+      on: [...on, { conflictDoNothing: onConflictDoNothing ?? true }]
+    });
+  }
+  onConflictDoUpdate(onConflict) {
+    const { on = [], ...data } = getData(this);
+    return new _InsertCanConflict({
+      ...data,
+      on: [...on, { conflictDoUpdate: onConflict }]
+    });
+  }
+  onDuplicateKeyUpdate(onDuplicateKeyUpdate) {
+    const { on = [], ...data } = getData(this);
+    return new _InsertCanConflict({
+      ...data,
+      on: [...on, { duplicateKeyUpdate: onDuplicateKeyUpdate }]
+    });
+  }
+};
+var InsertInto = class _InsertInto {
+  [internalData];
+  constructor(data) {
+    this[internalData] = data;
+  }
+  ignore() {
+    return new _InsertInto({ ...getData(this), ignore: true });
+  }
+  overridingSystemValue() {
+    return new _InsertInto({
+      ...getData(this),
+      overridingSystemValue: true
+    });
+  }
+  values(values) {
+    return new InsertCanConflict({
+      ...getData(this),
+      values
+    });
+  }
+  select(query) {
+    const insert = getTable(getData(this).insert);
+    const expected = Object.keys(insert.columns);
+    const actual = querySelection(getData(query)).fieldNames();
+    if (expected.length !== actual.length)
+      throw new Error("Insert select fields must match table columns");
+    for (let i = 0; i < expected.length; i++) {
+      if (expected[i] !== actual[i])
+        throw new Error("Insert select fields must match table columns");
+    }
+    return new InsertCanConflict({
+      ...getData(this),
+      ...getData(query)
+    });
+  }
+};
+function formatDefaultValue(value) {
+  return sql.universal({
+    sqlite: value,
+    default: sql`default`
+  });
+}
+var defaultKeyword = formatDefaultValue(sql`null`);
+function formatValues(table, rows) {
+  return sql.join(
+    rows.map((row) => {
+      return sql`(${sql.join(
+        Object.entries(table.columns).map(([key, column]) => {
+          const expr = row[key];
+          const columnApi = getData(column);
+          const { $onUpdate, $default, defaultValue } = columnApi;
+          if (expr !== void 0) return mapToColumn(columnApi, expr);
+          if ($default) return $default();
+          if (defaultValue) return formatDefaultValue(defaultValue);
+          if ($onUpdate) return $onUpdate();
+          return defaultKeyword;
+        }),
+        sql`, `
+      )})`;
+    }),
+    sql`, `
+  );
+}
+function formatUpdates(update) {
+  return sql.join(
+    Object.entries(update).map(
+      ([key, value]) => sql`${sql.identifier(key)} = ${input(value)}`
+    ),
+    sql`, `
+  );
+}
+function formatConflict({
+  target,
+  targetWhere,
+  set,
+  where: setWhere
+}) {
+  const update = set && formatUpdates(set);
+  return sql.query({
+    onConflict: sql.join([
+      target && sql`(${Array.isArray(target) ? sql.join(target, sql`, `) : target})`,
+      targetWhere && sql`where ${targetWhere}`,
+      update ? sql.join([
+        sql`do update set ${update}`,
+        setWhere && sql`where ${setWhere}`
+      ]) : sql`do nothing`
+    ])
+  });
+}
+function formatConflicts(on) {
+  return sql.join(
+    on.map((conflict) => {
+      if ("duplicateKeyUpdate" in conflict)
+        return sql.query({
+          onDuplicateKeyUpdate: formatUpdates(conflict.duplicateKeyUpdate.set)
+        });
+      if ("conflictDoUpdate" in conflict)
+        return formatConflict(conflict.conflictDoUpdate);
+      if ("conflictDoNothing" in conflict)
+        return formatConflict(
+          conflict.conflictDoNothing === true ? {} : conflict.conflictDoNothing
+        );
+      throw new Error("Unknown conflict type");
+    })
+  );
+}
+function insertQuery(query) {
+  const { insert, values, select, returning, overridingSystemValue, ignore } = query;
+  if (!values && !select) throw new Error("No values defined");
+  const table = getTable(insert);
+  const toInsert = values ? sql.query({
+    values: formatValues(table, Array.isArray(values) ? values : [values])
+  }) : selectQuery(query);
+  const conflicts = query.on ? formatConflicts(query.on) : void 0;
+  return sql.query(
+    formatCTE(query),
+    {
+      "": sql.universal({
+        mysql: ignore ? sql`insert ignore into` : sql`insert into`,
+        default: sql`insert into`
+      })
+    },
+    sql`${table.identifier()} (${table.listColumns()})`,
+    { overridingSystemValue },
+    toInsert,
+    conflicts,
+    returning && sql.query({ returning: selection(returning) })
+  ).inlineFields(false);
+}
+
+// node_modules/rado/dist/core/query/Update.js
+var Update = class _Update extends MutationQuery {
+  [internalData];
+  constructor(data) {
+    super(data);
+    this[internalData] = data;
+    if (data.returning) this[internalSelection] = selection(data.returning);
+  }
+  get [internalQuery]() {
+    return cached(
+      this,
+      internalQuery,
+      () => updateQuery(getData(this))
+    );
+  }
+  limit(limit) {
+    return new _Update({ ...getData(this), limit });
+  }
+  offset(offset) {
+    return new _Update({ ...getData(this), offset });
+  }
+  orderBy(...orderBy) {
+    return new _Update({ ...getData(this), orderBy });
+  }
+};
+var UpdateTable = class _UpdateTable extends Update {
+  set(set) {
+    const data = getData(this);
+    const hasDefinedValue = Object.values(set).some(
+      (value) => value !== void 0
+    );
+    if (!hasDefinedValue) {
+      const hasOnUpdate = Object.values(getTable(data.update).columns).some(
+        (column) => !!getData(column).$onUpdate
+      );
+      if (!hasOnUpdate) throw new Error("No values to set");
+    }
+    return new _UpdateTable({ ...data, set });
+  }
+  from(from) {
+    return new _UpdateTable({ ...getData(this), from });
+  }
+  where(...where) {
+    return new _UpdateTable({
+      ...getData(this),
+      where: and(...where)
+    });
+  }
+  returning(returning) {
+    const data = getData(this);
+    return new Update({
+      ...data,
+      returning: returning ?? data.update
+    });
+  }
+};
+function formatUpdateFrom(target, set, from) {
+  if (!from) return sql`update ${target} set ${set}`;
+  const source = formatFrom(from);
+  return sql.universal({
+    mysql: sql`update ${target} join ${source} set ${set}`,
+    default: sql`update ${target} set ${set} from ${source}`
+  });
+}
+function updateQuery(query) {
+  const { update: table, set: values, from, where, returning } = query;
+  const tableApi = getTable(table);
+  if (!values) throw new Error("Update values are required");
+  const assignments = Object.entries(tableApi.columns).flatMap(
+    ([key, column]) => {
+      const columnApi = getData(column);
+      const { name, $onUpdate } = columnApi;
+      const value = values[key];
+      let expr;
+      if (value === void 0) {
+        if ($onUpdate) expr = $onUpdate();
+        else return [];
+      } else {
+        expr = mapToColumn(columnApi, value);
+      }
+      const fieldName = name ?? key;
+      const field = sql.identifier(fieldName);
+      const assignment = from ? sql.universal({
+        mysql: sql`${sql.identifier(tableApi.aliased)}.${field}`,
+        default: field
+      }) : field;
+      return [sql`${assignment} = ${expr}`];
+    }
+  );
+  if (assignments.length === 0) throw new Error("No values to set");
+  const set = sql.join(assignments, sql`, `);
+  const target = tableApi.target();
+  const selected = returning && getSql(selection(returning));
+  const returningSelection = selected && from ? sql.universal({
+    postgres: selected,
+    default: selected.inlineFields(false)
+  }) : selected?.inlineFields(false);
+  return sql.query(
+    formatCTE(query),
+    formatUpdateFrom(target, set, from),
+    { where, returning: returningSelection },
+    formatModifiers(query)
+  );
+}
+
+// node_modules/rado/dist/core/Builder.js
+function aliasSql(input2, name) {
+  const expr = getSql(input2);
+  if (expr.alias) return expr;
+  const aliased = new Sql((emitter) => expr.emit(emitter));
+  aliased.alias = name;
+  aliased.mapFromDriverValue = expr.mapFromDriverValue;
+  return aliased;
+}
+function aliasUnnamedFields(input2, name) {
+  if (hasSql(input2)) {
+    if (!name) return input2;
+    return aliasSql(input2, name);
+  }
+  if (!input2 || typeof input2 !== "object") return input2;
+  return Object.fromEntries(
+    Object.entries(input2).map(([key, value]) => [
+      key,
+      aliasUnnamedFields(value, key)
+    ])
+  );
+}
+var BuilderBase = class {
+  [internalData];
+  constructor(data = {}) {
+    this[internalData] = data;
+  }
+  $query(query) {
+    const data = { ...getData(this), ...query };
+    if ("delete" in query) return new Delete(data);
+    if ("insert" in query) return new Insert(data);
+    if ("update" in query) return new Update(data);
+    return new Select(data);
+  }
+  select(select) {
+    return new Select({
+      ...getData(this),
+      select
+    });
+  }
+  selectDistinct(select) {
+    return new Select({
+      ...getData(this),
+      select,
+      distinct: true
+    });
+  }
+  selectDistinctOn(columns, select) {
+    return new Select({
+      ...getData(this),
+      select,
+      distinctOn: columns
+    });
+  }
+  update(table) {
+    return new UpdateTable({ ...getData(this), update: table });
+  }
+  insert(into) {
+    return new InsertInto({ ...getData(this), insert: into });
+  }
+  delete(from) {
+    return new DeleteFrom({ ...getData(this), delete: from });
+  }
+};
+var Builder = class extends BuilderBase {
+  $with(cteName, columns) {
+    return {
+      as(query) {
+        let input2 = hasQuery(query) ? hasSelection(query) ? getSelection(query).input : columns : columns;
+        const data = hasQuery(query) && hasData(query) ? getData(query) : void 0;
+        if (input2 && data?.compound?.length > 1)
+          input2 = aliasUnnamedFields(input2);
+        const target = virtualTarget(cteName, input2 ?? {});
+        return {
+          ...target,
+          [internalSelection]: new StarSelection(target),
+          get [internalQuery]() {
+            return hasQuery(query) ? getQuery(query).nameSelf(cteName) : getSql(query);
+          }
+        };
+      }
+    };
+  }
+  with(...definitions) {
+    return new BuilderBase({ ...getData(this), with: definitions });
+  }
+  withRecursive(...definitions) {
+    return new BuilderBase({ ...getData(this), withRecursive: definitions });
+  }
+};
+
+export {
+  BatchQuery,
+  querySelection,
+  selectQuery,
+  Builder
+};