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

package/dist/chunks/chunk-G6E35DMJ.js

@@ -1,1997 +0,0 @@
-import {
-  Sql,
-  getConstraint,
-  getData,
-  getEnum,
-  getField,
-  getQuery,
-  getResolver,
-  getSelection,
-  getSql,
-  getTable,
-  getTarget,
-  hasConstraint,
-  hasData,
-  hasEnum,
-  hasField,
-  hasQuery,
-  hasSelection,
-  hasSql,
-  hasTable,
-  hasTarget,
-  input,
-  internalConstraint,
-  internalCreate,
-  internalData,
-  internalDrop,
-  internalField,
-  internalQuery,
-  internalSelection,
-  internalSql,
-  internalTable,
-  internalTarget,
-  mapToColumn,
-  sql
-} from "./chunk-NWQXN4SB.js";
-
-// node_modules/rado/dist/core/expr/Conditions.js
-function bool(impl) {
-  return impl.mapWith(Boolean);
-}
-function binop(operator) {
-  return (left, right) => bool(
-    sql`${input(left, right)} ${sql.unsafe(operator)} ${input(right, left)}`
-  );
-}
-var eq = binop("=");
-var ne = binop("<>");
-var gt = binop(">");
-var gte = binop(">=");
-var lt = binop("<");
-var lte = binop("<=");
-var like = binop("like");
-var notLike = binop("not like");
-var ilike = binop("ilike");
-var notILike = binop("not ilike");
-var arrayContains = binop("@>");
-var arrayContained = binop("<@");
-var arrayOverlaps = binop("&&");
-function and(...conditions) {
-  const inputs = conditions.filter((v) => v !== void 0).map((i) => input(i));
-  if (inputs.length === 0) return bool(sql`true`);
-  if (inputs.length === 1) return bool(inputs[0]);
-  return bool(sql`(${sql.join(inputs, sql` and `)})`);
-}
-function or(...conditions) {
-  const inputs = conditions.filter((v) => v !== void 0).map((i) => input(i));
-  if (inputs.length === 0) return bool(sql`true`);
-  if (inputs.length === 1) return bool(inputs[0]);
-  return bool(sql`(${sql.join(inputs, sql` or `)})`);
-}
-function not(condition) {
-  return bool(sql`not ${input(condition)}`);
-}
-function isNull(value) {
-  return bool(sql`${input(value)} is null`);
-}
-function isNotNull(value) {
-  return bool(sql`${input(value)} is not null`);
-}
-function asc(input2) {
-  return sql`${input2} asc`;
-}
-function when(...cases) {
-  const compare = cases.length > 1 && !Array.isArray(cases[0]) ? cases.shift() : void 0;
-  return sql.join([
-    sql`case`,
-    compare && input(compare),
-    sql.join(
-      cases.map((pair, index) => {
-        if (Array.isArray(pair)) {
-          const [condition, result] = pair;
-          return sql`when ${input(condition)} then ${input(result)}`;
-        }
-        if (index === cases.length - 1) return sql`else ${input(pair)}`;
-        throw new Error("Unexpected else condition");
-      })
-    ),
-    sql`end`
-  ]);
-}
-
-// 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(void 0));
-    this[internalData] = data;
-  }
-  #exec(method, db) {
-    const data = getData(this);
-    const resolver = db ? getResolver(db) : data.resolver;
-    if (!resolver) throw new Error("Query has no resolver");
-    const isSelection = hasSelection(this);
-    const isFirst = data.first;
-    const prepared = resolver.prepare(this, "");
-    const resultType = method ?? (isSelection ? isFirst ? "get" : "all" : "run");
-    try {
-      const result = prepared[resultType]();
-      if (result instanceof Promise)
-        return result.then((res) => res ?? null).finally(prepared.free.bind(prepared));
-      prepared.free();
-      return result ?? null;
-    } catch (error) {
-      prepared.free();
-      throw error;
-    }
-  }
-  all(db) {
-    return this.#exec("all", db);
-  }
-  get(db) {
-    return this.#exec("get", db);
-  }
-  run(db) {
-    return this.#exec("run", db);
-  }
-  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.free();
-    }
-  }
-  prepare(name) {
-    return getData(this).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);
-  }
-};
-
-// node_modules/rado/dist/core/expr/Field.js
-var Field = class {
-  [internalField];
-  [internalSql];
-  constructor(targetName, fieldName, source = {}) {
-    const field = { targetName, fieldName, source };
-    this[internalField] = field;
-    const expr = sql.field(field).as(fieldName).mapWith(source);
-    this[internalSql] = expr;
-  }
-};
-
-// node_modules/rado/dist/core/Virtual.js
-function virtualFields(alias, source) {
-  return Object.fromEntries(
-    Object.entries(source).map(([key, value]) => {
-      if (value && typeof value === "object" && !hasSql(value))
-        return [key, virtualFields(alias, value)];
-      return [key, new Field(alias, key, getSql(value))];
-    })
-  );
-}
-function virtualTarget(alias, source) {
-  const target = {
-    [internalTarget]: sql.identifier(alias)
-  };
-  if (!source || typeof source !== "object")
-    throw new Error("Cannot alias a non-object");
-  if (hasSql(source)) {
-    const expr = getSql(source);
-    const name = expr.alias;
-    if (!name) throw new Error("Cannot alias a virtual field without a name");
-    return Object.assign(new Field(alias, name, expr), target);
-  }
-  return {
-    ...target,
-    ...virtualFields(alias, source)
-  };
-}
-
-// node_modules/rado/dist/core/Selection.js
-var SqlColumn = class {
-  constructor(sql2, targetName) {
-    this.sql = sql2;
-    this.targetName = targetName;
-  }
-  sql;
-  targetName;
-  result(ctx) {
-    const value = ctx.values[ctx.index++];
-    if (!this.sql.mapFromDriverValue) return value;
-    return this.sql.mapFromDriverValue(value, ctx.specs);
-  }
-};
-var ObjectColumn = class {
-  constructor(nullable, entries2) {
-    this.nullable = nullable;
-    this.entries = entries2;
-  }
-  nullable;
-  entries;
-  result(ctx) {
-    const result = {};
-    let isNullable = this.nullable.size > 0;
-    for (const entry of this.entries) {
-      const name = entry[0];
-      const col = entry[1];
-      const value = col.result(ctx);
-      result[name] = value;
-      if (isNullable) {
-        if (value === null) {
-          if (col.targetName && !this.nullable.has(col.targetName))
-            isNullable = false;
-        } else {
-          isNullable = false;
-        }
-      }
-    }
-    if (isNullable) return null;
-    return result;
-  }
-};
-function firstTargetName(input2) {
-  const expr = getSql(input2);
-  if (expr) return hasField(input2) ? getField(input2).targetName : void 0;
-  if (!input2 || typeof input2 !== "object") return;
-  for (const value of Object.values(input2)) {
-    const name = firstTargetName(value);
-    if (name) return name;
-  }
-}
-var Selection = class _Selection {
-  constructor(input2, nullable = /* @__PURE__ */ new Set()) {
-    this.input = input2;
-    this.nullable = nullable;
-    const root = this.#defineColumn(nullable, input2);
-    this.mapRow = root.result.bind(root);
-  }
-  input;
-  nullable;
-  mapRow;
-  makeVirtual(name) {
-    return virtualTarget(name, this.input);
-  }
-  #defineColumn(nullable, input2) {
-    const expr = getSql(input2);
-    if (expr) return new SqlColumn(expr, getField(input2)?.targetName);
-    return new ObjectColumn(
-      nullable,
-      Object.entries(input2).map(([name, value]) => [
-        name,
-        this.#defineColumn(nullable, value)
-      ])
-    );
-  }
-  fieldNames() {
-    return this.#fieldNames(this.input, /* @__PURE__ */ new Set());
-  }
-  aliasOf(input2) {
-    return this.#aliasOf(this.input, /* @__PURE__ */ new Set(), getSql(input2));
-  }
-  #aliasOf(input2, names, target, name) {
-    const expr = getSql(input2);
-    if (expr) {
-      let exprName = name ?? expr.alias;
-      if (!exprName) return;
-      while (names.has(exprName)) exprName = `${exprName}_`;
-      names.add(exprName);
-      if (expr === target) return exprName;
-      return;
-    }
-    for (const [name2, value] of Object.entries(input2)) {
-      const alias = this.#aliasOf(value, names, target, name2);
-      if (alias) return alias;
-    }
-  }
-  #fieldNames(input2, names, name) {
-    const expr = getSql(input2);
-    if (expr) {
-      let exprName = name ?? expr.alias;
-      if (!exprName) throw new Error("Missing field name");
-      while (names.has(exprName)) exprName = `${exprName}_`;
-      return [exprName];
-    }
-    return Object.entries(input2).flatMap(
-      ([name2, value]) => this.#fieldNames(value, names, name2)
-    );
-  }
-  #selectionToSql(input2, names, name) {
-    const expr = getSql(input2);
-    if (expr) {
-      let exprName = name ?? expr.alias;
-      if (exprName) {
-        while (names.has(exprName)) exprName = `${exprName}_`;
-        names.add(exprName);
-        if (hasField(input2)) {
-          const field = getField(input2);
-          if (field.fieldName === exprName) return [expr];
-        }
-        return [sql`${expr.forSelection()} as ${sql.identifier(exprName)}`];
-      }
-      return [expr];
-    }
-    return Object.entries(input2).flatMap(
-      ([name2, value]) => this.#selectionToSql(value, names, name2)
-    );
-  }
-  get [internalSql]() {
-    return sql.join(this.#selectionToSql(this.input, /* @__PURE__ */ new Set()), sql`, `);
-  }
-  #collectTargetNames(input2, names) {
-    const expr = getSql(input2);
-    if (expr) {
-      if (hasField(input2)) names.add(getField(input2).targetName);
-      return;
-    }
-    for (const value of Object.values(input2))
-      this.#collectTargetNames(value, names);
-  }
-  #targetNames() {
-    const names = /* @__PURE__ */ new Set();
-    this.#collectTargetNames(this.input, names);
-    return names;
-  }
-  join(right, operator) {
-    if (hasSelection(right)) {
-      const selected2 = getSelection(right);
-      const alias = firstTargetName(selected2.input);
-      if (!alias) return this;
-      const nullable2 = new Set(this.nullable);
-      if (operator === "leftJoin" || operator === "fullJoin")
-        nullable2.add(alias);
-      if (operator === "rightJoin" || operator === "fullJoin")
-        for (const name of this.#targetNames()) nullable2.add(name);
-      return new _Selection(this.input, nullable2);
-    }
-    if (!hasTable(right)) return this;
-    const rightTable = getTable(right);
-    const nullable = new Set(this.nullable);
-    if (operator === "leftJoin" || operator === "fullJoin")
-      nullable.add(rightTable.aliased);
-    if (operator === "rightJoin" || operator === "fullJoin")
-      for (const name of this.#targetNames()) nullable.add(name);
-    return new _Selection(this.input, nullable);
-  }
-};
-var TableSelection = class extends Selection {
-  constructor(table2) {
-    super(table2, /* @__PURE__ */ new Set());
-    this.table = table2;
-  }
-  table;
-  join(right, operator) {
-    const leftTable = getTable(this.table);
-    if (hasSelection(right)) {
-      const selected2 = getSelection(right);
-      const alias = firstTargetName(selected2.input);
-      if (!alias) return this;
-      const nullable2 = new Set(this.nullable);
-      if (operator === "rightJoin" || operator === "fullJoin")
-        nullable2.add(leftTable.aliased);
-      if (operator === "leftJoin" || operator === "fullJoin")
-        nullable2.add(alias);
-      return new Selection(
-        { [leftTable.aliased]: this.table, [alias]: selected2.input },
-        nullable2
-      );
-    }
-    if (!hasTable(right)) return this;
-    const rightTable = getTable(right);
-    const nullable = new Set(this.nullable);
-    if (operator === "rightJoin" || operator === "fullJoin")
-      nullable.add(leftTable.aliased);
-    if (operator === "leftJoin" || operator === "fullJoin")
-      nullable.add(rightTable.aliased);
-    return new JoinSelection([this.table, right], nullable);
-  }
-};
-var JoinSelection = class _JoinSelection extends Selection {
-  constructor(tables, nullable) {
-    super(
-      Object.fromEntries(tables.map((table2) => [getTable(table2).aliased, table2])),
-      nullable
-    );
-    this.tables = tables;
-  }
-  tables;
-  join(right, operator) {
-    if (!hasTable(right)) return this;
-    const rightTable = getTable(right);
-    const nullable = new Set(this.nullable);
-    if (operator === "rightJoin" || operator === "fullJoin")
-      for (const table2 of this.tables) nullable.add(getTable(table2).aliased);
-    if (operator === "leftJoin" || operator === "fullJoin")
-      nullable.add(rightTable.aliased);
-    return new _JoinSelection([...this.tables, right], nullable);
-  }
-};
-var StarSelection = class extends Selection {
-  get [internalSql]() {
-    return sql`*`;
-  }
-};
-var selected = /* @__PURE__ */ new WeakMap();
-function selection(input2) {
-  if (input2 instanceof Selection) return input2;
-  if (selected.has(input2)) return selected.get(input2);
-  const selection2 = hasTable(input2) ? new TableSelection(input2) : new Selection(input2);
-  selected.set(input2, selection2);
-  return selection2;
-}
-
-// 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, selected2) {
-  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 = selected2?.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 SingleQuery {
-  [internalData];
-  constructor(data) {
-    super(data);
-    this[internalData] = data;
-    if (data.returning) this[internalSelection] = selection(data.returning);
-  }
-  get [internalQuery]() {
-    return 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 table2 = getTable(from);
-  return sql.query(
-    formatCTE(query),
-    {
-      deleteFrom: table2.identifier(),
-      where,
-      returning: returning && selection(returning)
-    },
-    formatModifiers(query)
-  );
-}
-
-// node_modules/rado/dist/core/query/Select.js
-function isUnionQuery(query) {
-  return Array.isArray(query.select);
-}
-function mapScalarSelection(query, selected2) {
-  if (hasSql(selected2)) return query.mapWith(getSql(selected2));
-  if (selected2 && typeof selected2 === "object") {
-    const values = Object.values(selected2);
-    if (values.length === 1) {
-      const first = values[0];
-      if (first && typeof first === "object" && hasSql(first))
-        return query.mapWith(getSql(first));
-    }
-  }
-  return query;
-}
-var SelectFirst = class extends SingleQuery {
-  [internalData];
-  constructor(data) {
-    const inner = { ...data, first: true };
-    super(inner);
-    this[internalData] = inner;
-  }
-  get [internalSelection]() {
-    return querySelection(getData(this));
-  }
-  get [internalQuery]() {
-    return selectQuery(getData(this));
-  }
-  get [internalSql]() {
-    return mapScalarSelection(
-      sql`(${getQuery(this)})`,
-      getSelection(this).input
-    );
-  }
-};
-var UnionBase = class extends SingleQuery {
-  [internalData];
-  constructor(data) {
-    super(data);
-    this[internalData] = data;
-  }
-  as(alias) {
-    const selected2 = getSelection(this);
-    const fields = selected2.makeVirtual(alias);
-    return Object.assign({}, fields, {
-      [internalSelection]: selection(fields),
-      [internalSql]: mapScalarSelection(
-        sql`(${getQuery(this)})`,
-        selected2.input
-      ),
-      [internalTarget]: sql`(${getQuery(this)}) as ${sql.identifier(
-        alias
-      )}`.inlineFields(true)
-    });
-  }
-  #makeSelf() {
-    const selected2 = getSelection(this);
-    return selected2.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) {
-    return new _Select({ ...getData(this), from });
-  }
-  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) {
-    return this.#join({ leftJoin, on });
-  }
-  leftJoinLateral(leftJoinLateral, on) {
-    return this.#join({ leftJoinLateral, on });
-  }
-  rightJoin(rightJoin, on) {
-    return this.#join({ rightJoin, on });
-  }
-  innerJoin(innerJoin, on) {
-    return this.#join({ innerJoin, on });
-  }
-  innerJoinLateral(innerJoinLateral, on) {
-    return this.#join({ innerJoinLateral, on });
-  }
-  fullJoin(fullJoin, on) {
-    return this.#join({ fullJoin, on });
-  }
-  crossJoin(crossJoin) {
-    return this.#join({ crossJoin });
-  }
-  crossJoinLateral(crossJoinLateral) {
-    return this.#join({ crossJoinLateral });
-  }
-  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 querySelection(getData(this));
-  }
-  get [internalQuery]() {
-    return selectQuery(getData(this));
-  }
-  get [internalSql]() {
-    return sql`(${getQuery(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
-  );
-}
-function querySelection({ 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 selected2 = getSelection(select);
-      if (!from || !Array.isArray(from)) return selected2;
-      const [, ...joins2] = from;
-      return applyJoins(selected2, 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 selected2 = getSelection(from);
-    if (hasUnnamedDerivedSource(selected2.input))
-      throw new Error("Cannot select all from subquery without alias");
-    return selected2;
-  }
-  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, ...rest } = join;
-  const op = Object.keys(rest)[0];
-  const target = rest[op];
-  return { target, op, on };
-}
-function formatTarget(target) {
-  if (hasTable(target)) return getTable(target).target();
-  return getTarget(target);
-}
-function formatFrom(from) {
-  if (!from) throw new Error("No target defined");
-  if (Array.isArray(from)) {
-    return sql.join(
-      from.map((join) => {
-        if (hasTarget(join)) return formatTarget(join);
-        if (hasSql(join)) return getSql(join);
-        const { target, op, on } = joinOp(join);
-        return sql.query({
-          [op]: hasTarget(target) ? formatTarget(target) : getSql(target),
-          on
-        });
-      })
-    );
-  }
-  return hasTarget(from) ? formatTarget(from) : 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 selected2 = querySelection(query);
-  const select = sql.join([prefix, selected2]);
-  return sql.query(
-    formatCTE(query),
-    {
-      select,
-      from: from && formatFrom(from),
-      for: query.for,
-      where,
-      groupBy: groupBy && sql.join(groupBy, sql`, `),
-      having: typeof having === "function" ? having(selected2.input) : having
-    },
-    formatModifiers(query, selected2)
-  );
-}
-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 unionQuery(getData(this));
-  }
-  get [internalSelection]() {
-    const {
-      select: [first]
-    } = getData(this);
-    return 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 SingleQuery {
-  [internalData];
-  constructor(data) {
-    super(data);
-    this[internalData] = data;
-    if (data.returning) this[internalSelection] = selection(data.returning);
-  }
-  get [internalQuery]() {
-    return 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;
-  }
-  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(table2, rows) {
-  return sql.join(
-    rows.map((row) => {
-      return sql`(${sql.join(
-        Object.entries(table2.columns).map(([key, column2]) => {
-          const expr = row[key];
-          const columnApi = getData(column2);
-          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 } = query;
-  if (!values && !select) throw new Error("No values defined");
-  const table2 = getTable(insert);
-  const toInsert = values ? sql.query({
-    values: formatValues(table2, Array.isArray(values) ? values : [values])
-  }) : selectQuery(query);
-  const conflicts = query.on ? formatConflicts(query.on) : void 0;
-  return sql.query(
-    formatCTE(query),
-    { insertInto: sql`${table2.identifier()} (${table2.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 SingleQuery {
-  [internalData];
-  constructor(data) {
-    super(data);
-    this[internalData] = data;
-    if (data.returning) this[internalSelection] = selection(data.returning);
-  }
-  get [internalQuery]() {
-    return 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(
-        (column2) => !!getData(column2).$onUpdate
-      );
-      if (!hasOnUpdate) throw new Error("No values to set");
-    }
-    return new _UpdateTable({ ...data, set });
-  }
-  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 updateQuery(query) {
-  const { update: table2, set: values, where, returning } = query;
-  const tableApi = getTable(table2);
-  if (!values) throw new Error("Update values are required");
-  const assignments = Object.entries(tableApi.columns).flatMap(
-    ([key, column2]) => {
-      const columnApi = getData(column2);
-      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;
-      return [sql`${sql.identifier(fieldName)} = ${expr}`];
-    }
-  );
-  if (assignments.length === 0) throw new Error("No values to set");
-  const set = sql.join(assignments, sql`, `);
-  return sql.query(
-    formatCTE(query),
-    {
-      update: tableApi.identifier(),
-      set,
-      where,
-      returning: returning && selection(returning)
-    },
-    formatModifiers(query)
-  ).inlineFields(false);
-}
-
-// 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(table2) {
-    return new UpdateTable({ ...getData(this), update: table2 });
-  }
-  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 });
-  }
-};
-
-// node_modules/rado/dist/core/expr/Functions.js
-function callFunction(name, args) {
-  return sql`${name}(${sql.join(args.map(input), sql`, `)})`;
-}
-function get(target, method) {
-  return target[method] ??= (...args) => {
-    return callFunction(sql.identifier(method), args);
-  };
-}
-var Functions = new Proxy(/* @__PURE__ */ Object.create(null), { get });
-
-// node_modules/rado/dist/core/Column.js
-function formatType(kind, args) {
-  return args.length === 0 ? sql.unsafe(kind) : sql`${sql.unsafe(kind)}(${sql.join(args.map(sql.inline), sql`, `)})`;
-}
-var ColumnType = class {
-  constructor(kind, args, sql2 = formatType(kind, args)) {
-    this.kind = kind;
-    this.args = args;
-    this[internalSql] = sql2;
-  }
-  kind;
-  args;
-  [internalSql];
-};
-var Column = class _Column {
-  [internalData];
-  constructor(data) {
-    this[internalData] = data;
-  }
-  notNull() {
-    return new _Column({
-      ...getData(this),
-      notNull: true
-    });
-  }
-  $defaultFn(value) {
-    return this.$default(value);
-  }
-  $default(value) {
-    return new _Column({
-      ...getData(this),
-      $default: () => mapToColumn(
-        getData(this),
-        typeof value === "function" ? value() : value
-      )
-    });
-  }
-  $onUpdateFn(fn) {
-    return this.$onUpdate(fn);
-  }
-  $onUpdate(fn) {
-    return new _Column({
-      ...getData(this),
-      $onUpdate: () => mapToColumn(getData(this), fn())
-    });
-  }
-  default(value) {
-    return new _Column({
-      ...getData(this),
-      defaultValue: input(value)
-    });
-  }
-  defaultNow() {
-    return new _Column({
-      ...getData(this),
-      defaultValue: sql.unsafe("now()")
-    });
-  }
-  primaryKey(options) {
-    return new _Column({ ...getData(this), ...options, primary: true });
-  }
-  unique(name) {
-    return new _Column({ ...getData(this), isUnique: true });
-  }
-  references(foreignField, options) {
-    return new _Column({
-      ...getData(this),
-      references() {
-        return getField(
-          typeof foreignField === "function" ? foreignField() : foreignField
-        );
-      },
-      referenceOptions: options
-    });
-  }
-  $type() {
-    return this;
-  }
-};
-var JsonColumn = class extends Column {
-  constructor(data) {
-    super({ ...data, json: true });
-  }
-};
-var column = new Proxy(
-  {},
-  {
-    get(target, method) {
-      return target[method] ??= (...args) => {
-        while (args.length > 0)
-          if (args.at(-1) === void 0) args.pop();
-          else break;
-        return new ColumnType(method, args);
-      };
-    }
-  }
-);
-function columnConfig(args) {
-  if (args.length > 1)
-    return { name: args[0], options: args[1] };
-  if (typeof args[0] === "string")
-    return { name: args[0], options: args[1] };
-  return { name: void 0, options: args[0] };
-}
-function formatReferences(fields, options = {}) {
-  return sql.query(
-    callFunction(
-      sql.identifier(fields[0].targetName),
-      fields.map((field) => sql.identifier(field.fieldName))
-    ),
-    {
-      onDelete: options.onDelete && sql.unsafe(options.onDelete),
-      onUpdate: options.onUpdate && sql.unsafe(options.onUpdate)
-    }
-  );
-}
-function formatColumn(column2) {
-  return sql.query(
-    column2.type,
-    {
-      primaryKey: column2.primary,
-      notNull: column2.notNull,
-      unique: column2.isUnique,
-      nullsNotDistinct: column2.nullsNotDistinct,
-      autoincrement: column2.autoIncrement
-    },
-    column2.defaultValue !== void 0 ? sql`default (${column2.defaultValue})`.inlineValues() : void 0,
-    {
-      references: column2.references && formatReferences([column2.references()], column2.referenceOptions)
-    }
-  );
-}
-
-// node_modules/rado/dist/postgres/columns.js
-function parsePgArrayValue(input2) {
-  if (!input2.startsWith("{") || !input2.endsWith("}")) return [input2];
-  const source = input2.slice(1, -1);
-  const parts = [];
-  let token = "";
-  let depth = 0;
-  let inQuotes = false;
-  let wasQuoted = false;
-  const pushToken = () => {
-    if (!wasQuoted && token === "NULL") parts.push("\0NULL");
-    else parts.push(token);
-    token = "";
-    wasQuoted = false;
-  };
-  for (let i = 0; i < source.length; i++) {
-    const char2 = source[i];
-    if (inQuotes) {
-      if (char2 === "\\") {
-        const next = source[++i];
-        if (next !== void 0) token += next;
-        continue;
-      }
-      if (char2 === '"') {
-        inQuotes = false;
-        wasQuoted = true;
-        continue;
-      }
-      token += char2;
-      continue;
-    }
-    if (char2 === '"') {
-      inQuotes = true;
-      continue;
-    }
-    if (char2 === "{") {
-      depth++;
-      token += char2;
-      continue;
-    }
-    if (char2 === "}") {
-      depth--;
-      token += char2;
-      continue;
-    }
-    if (char2 === "," && depth === 0) {
-      pushToken();
-      continue;
-    }
-    token += char2;
-  }
-  pushToken();
-  return parts.map((part) => {
-    if (part === "\0NULL") return null;
-    if (part.startsWith("{") && part.endsWith("}"))
-      return parsePgArrayValue(part);
-    return part;
-  });
-}
-function serializePgArrayValue(value) {
-  return `{${value.map(serializePgArrayItem).join(",")}}`;
-}
-function serializePgArrayItem(value) {
-  if (Array.isArray(value)) return serializePgArrayValue(value);
-  if (value === null || value === void 0) return "NULL";
-  let normalized;
-  if (value instanceof Date) normalized = value.toISOString();
-  else if (typeof value === "string") normalized = value;
-  else if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
-    normalized = String(value);
-  else normalized = JSON.stringify(value);
-  const escaped = normalized.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-  return `"${escaped}"`;
-}
-function mapArrayItems(value, mapper) {
-  if (!Array.isArray(value)) return value;
-  return value.map((item) => mapper(item));
-}
-var PgColumn = class _PgColumn extends Column {
-  notNull() {
-    return new _PgColumn({
-      ...getData(this),
-      notNull: true
-    });
-  }
-  unique(name, config) {
-    return new _PgColumn({
-      ...getData(this),
-      isUnique: true,
-      nullsNotDistinct: config?.nulls === "not distinct",
-      name
-    });
-  }
-  array(size) {
-    const data = getData(this);
-    const mapTo = data.mapToDriverValue;
-    const mapFrom = data.mapFromDriverValue;
-    return new _PgColumn({
-      ...data,
-      type: new ColumnType("array", [data.type], sql`${data.type}[${size}]`),
-      mapToDriverValue(value) {
-        if (!Array.isArray(value)) return value;
-        const mapped = mapArrayItems(
-          value,
-          (item) => item !== null && item !== void 0 && mapTo ? mapTo(item) : item
-        );
-        return serializePgArrayValue(mapped);
-      },
-      mapFromDriverValue(value, specs) {
-        const parsed = typeof value === "string" ? parsePgArrayValue(value) : value;
-        if (!Array.isArray(parsed)) return parsed;
-        return mapArrayItems(
-          parsed,
-          (item) => item !== null && item !== void 0 && mapFrom ? mapFrom(item, specs) : item
-        );
-      }
-    });
-  }
-  generatedAlwaysAsIdentity() {
-    const data = getData(this);
-    return new _PgColumn({
-      ...data,
-      type: new ColumnType(
-        data.type.kind,
-        data.type.args,
-        sql`${data.type} generated always as identity`
-      )
-    });
-  }
-  generatedByDefaultAsIdentity() {
-    const data = getData(this);
-    return new _PgColumn({
-      ...data,
-      type: new ColumnType(
-        data.type.kind,
-        data.type.args,
-        sql`${data.type} generated by default as identity`
-      )
-    });
-  }
-};
-function integer(name) {
-  return new PgColumn({ name, type: column.integer() });
-}
-function oid(name) {
-  return new PgColumn({ name, type: column.oid() });
-}
-function boolean(name) {
-  return new PgColumn({ name, type: column.boolean() });
-}
-function text(name) {
-  return new PgColumn({ name, type: column.text() });
-}
-
-// node_modules/rado/dist/postgres/enum.js
-function enumQuery(enumInfo) {
-  const enumIdentifier = enumInfo.schema ? sql.join(
-    [sql.identifier(enumInfo.schema), sql.identifier(enumInfo.name)],
-    sql`.`
-  ) : sql.identifier(enumInfo.name);
-  return sql`do $$ begin create type ${enumIdentifier} as enum (${sql.join(
-    enumInfo.values.map(sql.inline),
-    sql`, `
-  )}); exception when duplicate_object then null; end $$`;
-}
-function collectEnumQuery(table2) {
-  const enums = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const column2 of Object.values(table2.columns)) {
-    const data = getData(column2);
-    if (!hasEnum(data)) continue;
-    const info = getEnum(data);
-    const enumKey = info.schema ? `${info.schema}.${info.name}` : info.name;
-    if (seen.has(enumKey)) continue;
-    seen.add(enumKey);
-    enums.push(enumQuery(info));
-  }
-  return enums;
-}
-
-// node_modules/rado/dist/core/Constraint.js
-var UniqueConstraint = class _UniqueConstraint {
-  [internalData];
-  constructor(data) {
-    this[internalData] = data;
-  }
-  on(...columns) {
-    const fields = columns.map(getField);
-    return new _UniqueConstraint({ ...getData(this), fields });
-  }
-  nullsNotDistinct() {
-    return new _UniqueConstraint({ ...getData(this), nullsNotDistinct: true });
-  }
-  get [internalConstraint]() {
-    const { fields, nullsNotDistinct } = getData(this);
-    return sql.join([
-      sql`unique`,
-      nullsNotDistinct ? sql`nulls not distinct` : void 0,
-      sql`(${sql.join(
-        fields.map((field) => sql.identifier(field.fieldName)),
-        sql`, `
-      )})`
-    ]);
-  }
-};
-var PrimaryKeyConstraint = class {
-  constructor(data) {
-    this.data = data;
-    this[internalData] = data;
-  }
-  data;
-  [internalData];
-  get [internalConstraint]() {
-    const { fields } = getData(this);
-    return sql`primary key (${sql.join(
-      fields.map((field) => sql.identifier(field.fieldName)),
-      sql`, `
-    )})`;
-  }
-};
-var ForeignKeyConstraint = class _ForeignKeyConstraint {
-  [internalData];
-  constructor(data) {
-    this[internalData] = data;
-  }
-  references(...fields) {
-    return new _ForeignKeyConstraint({
-      ...getData(this),
-      references: fields.map(getField)
-    });
-  }
-  get [internalConstraint]() {
-    const { fields, references } = getData(this);
-    return sql`foreign key (${sql.join(
-      fields.map((field) => sql.identifier(field.fieldName)),
-      sql`, `
-    )}) references ${sql.identifier(references[0].targetName)} (${sql.join(
-      references.map((field) => sql.identifier(field.fieldName)),
-      sql`, `
-    )})`;
-  }
-};
-
-// node_modules/rado/dist/core/expr/Json.js
-var INDEX_PROPERTY = /^\d+$/;
-function jsonExpr(e) {
-  return new Proxy(e, {
-    get(target, prop) {
-      if (typeof prop !== "string") return Reflect.get(target, prop);
-      const isNumber = INDEX_PROPERTY.test(prop);
-      return jsonExpr(
-        sql.jsonPath({
-          target: getSql(target),
-          segments: [isNumber ? Number(prop) : prop],
-          asSql: true
-        }).mapWith({
-          mapFromDriverValue(value, specs) {
-            return specs.parsesJson ? value : JSON.parse(value);
-          }
-        })
-      );
-    }
-  });
-}
-function jsonAggregateArray(...args) {
-  return callFunction(
-    sql.universal({
-      // Once sqlite 3.45+ is more commonplace we can use jsonb_group_array
-      sqlite: sql`json_group_array`,
-      postgres: sql`jsonb_agg`,
-      mysql: sql`json_arrayagg`
-    }),
-    args
-  );
-}
-function jsonArray(...args) {
-  return callFunction(
-    sql.universal({
-      postgres: sql`jsonb_build_array`,
-      default: sql`json_array`
-    }),
-    args
-  );
-}
-
-// node_modules/rado/dist/core/Index.js
-var IndexData = class {
-  fields;
-  concurrently;
-  unique;
-  only;
-  using;
-  order;
-  nulls;
-  where;
-};
-var IndexApi = class extends IndexData {
-  toSql(tableName, indexName, ifNotExists) {
-    const fields = this.fields.map(
-      (field) => sql.join([
-        field,
-        this.order && sql.unsafe(this.order),
-        this.nulls && sql`nulls ${sql.unsafe(this.nulls)}`
-      ])
-    );
-    return sql.join([
-      sql`create`,
-      this.unique && sql`unique`,
-      sql`index`,
-      this.concurrently && sql`concurrently`,
-      ifNotExists && sql`if not exists`,
-      sql.identifier(indexName),
-      sql`on`,
-      this.only && sql`only`,
-      sql.identifier(tableName),
-      this.using && sql`using ${this.using}`,
-      sql`(${sql.join(fields, sql`, `)})`,
-      this.where && sql`where ${this.where}`
-    ]).inlineFields(false);
-  }
-};
-var Index = class _Index {
-  [internalData];
-  constructor(data) {
-    this[internalData] = Object.assign(new IndexApi(), data);
-  }
-  on(...fields) {
-    return new _Index({ ...getData(this), fields });
-  }
-  concurrently() {
-    return new _Index({ ...getData(this), concurrently: true });
-  }
-  only() {
-    return new _Index({ ...getData(this), only: true });
-  }
-  using(using) {
-    return new _Index({ ...getData(this), using });
-  }
-  asc() {
-    return new _Index({ ...getData(this), order: "asc" });
-  }
-  desc() {
-    return new _Index({ ...getData(this), order: "desc" });
-  }
-  nullsFirst() {
-    return new _Index({ ...getData(this), nulls: "first" });
-  }
-  nullsLast() {
-    return new _Index({ ...getData(this), nulls: "last" });
-  }
-  where(where) {
-    return new _Index({ ...getData(this), where });
-  }
-};
-
-// node_modules/rado/dist/core/Table.js
-var { assign, fromEntries, entries, keys } = Object;
-var TableData = class {
-  name;
-  alias;
-  schemaName;
-  columns;
-  config;
-};
-var TableApi = class extends TableData {
-  get aliased() {
-    return this.alias ?? this.name;
-  }
-  identifier(altName) {
-    return sql.join(
-      [
-        this.schemaName ? sql.identifier(this.schemaName) : void 0,
-        sql.identifier(altName ?? this.name)
-      ],
-      sql`.`
-    );
-  }
-  target() {
-    return sql.join([
-      this.identifier(),
-      this.alias ? sql`as ${sql.identifier(this.alias)}` : void 0
-    ]);
-  }
-  columnDefinition(name) {
-    const columnData = this.columns[name];
-    const column2 = getData(columnData);
-    const columnName = sql.identifier(column2.name ?? name);
-    return sql`${columnName} ${formatColumn(column2)}`;
-  }
-  createDefinition() {
-    const createColumns = keys(this.columns).map(
-      (name) => this.columnDefinition(name)
-    );
-    const createConstraints = entries(this.config ?? {}).filter(([, constraint]) => hasConstraint(constraint)).map(([key, constraint]) => {
-      const { name } = getData(constraint);
-      return sql`constraint ${sql.identifier(name ?? key)} ${getConstraint(
-        constraint
-      )}`;
-    });
-    return sql.join(createColumns.concat(createConstraints), sql`, `);
-  }
-  listColumns() {
-    return sql.join(
-      entries(this.columns).map(([name, column2]) => {
-        const columnApi = getData(column2);
-        const { name: givenName } = columnApi;
-        return sql.identifier(givenName ?? name);
-      }),
-      sql`, `
-    );
-  }
-  createTable(altName, ifNotExists = false) {
-    return sql.join([
-      sql`create table`,
-      ifNotExists ? sql`if not exists` : void 0,
-      this.identifier(altName),
-      sql`(${this.createDefinition()})`
-    ]);
-  }
-  createIndexes() {
-    return entries(this.indexes()).map(([name, index]) => {
-      const indexApi = getData(index);
-      return indexApi.toSql(this.name, name, false);
-    });
-  }
-  createEnums() {
-    return collectEnumQuery(this);
-  }
-  create() {
-    return [...this.createEnums(), this.createTable(), ...this.createIndexes()];
-  }
-  drop() {
-    return [sql`drop table if exists ${this.identifier()}`];
-  }
-  indexes() {
-    return fromEntries(
-      entries(this.config ?? {}).filter(([, config]) => config instanceof Index)
-    );
-  }
-};
-function tableFields(targetName, columns) {
-  return fromEntries(
-    entries(columns).map(([name, column2]) => {
-      const columnApi = getData(column2);
-      const { name: givenName } = columnApi;
-      const field = new Field(targetName, givenName ?? name, columnApi);
-      if (columnApi.json) return [name, jsonExpr(field)];
-      return [name, field];
-    })
-  );
-}
-function primaryKeyColumns(tableApi) {
-  const columns = /* @__PURE__ */ new Set();
-  for (const [name, column2] of entries(tableApi.columns)) {
-    const columnApi = getData(column2);
-    if (columnApi.primary) columns.add(columnApi.name ?? name);
-  }
-  for (const constraint of Object.values(tableApi.config ?? {})) {
-    if (!(constraint instanceof PrimaryKeyConstraint)) continue;
-    for (const field of getData(constraint).fields) columns.add(field.fieldName);
-  }
-  return columns;
-}
-function table(name, columns, config, schemaName) {
-  const api = assign(new TableApi(), {
-    name,
-    schemaName,
-    columns
-  });
-  const fields = tableFields(api.aliased, api.columns);
-  const table2 = {
-    [internalTable]: api,
-    [internalTarget]: api.identifier(),
-    [internalSelection]: selection(fields),
-    get [internalCreate]() {
-      return api.create();
-    },
-    get [internalDrop]() {
-      return api.drop();
-    },
-    ...fields
-  };
-  if (config) api.config = config(table2);
-  return table2;
-}
-
-export {
-  Functions,
-  ColumnType,
-  Column,
-  JsonColumn,
-  column,
-  columnConfig,
-  formatColumn,
-  eq,
-  gt,
-  like,
-  and,
-  or,
-  not,
-  isNull,
-  isNotNull,
-  asc,
-  when,
-  BatchQuery,
-  querySelection,
-  selectQuery,
-  Builder,
-  integer,
-  oid,
-  boolean,
-  text,
-  jsonAggregateArray,
-  jsonArray,
-  primaryKeyColumns,
-  table
-};