alinea 1.7.0 → 2.0.0-preview.0

package/dist/chunks/chunk-G6E35DMJ.js

@@ -0,0 +1,1997 @@
+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
+};