alinea 2.0.0-preview.6 → 2.0.0-preview.8

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

@@ -0,0 +1,364 @@
+import {
+  cached,
+  getData,
+  getField,
+  getSelection,
+  getSql,
+  getTable,
+  hasField,
+  hasSelection,
+  hasSql,
+  hasTable,
+  internalData,
+  internalField,
+  internalSql,
+  internalTarget,
+  sql
+} from "./chunk-ETBQTP2S.js";
+
+// node_modules/rado/dist/core/Index.js
+var IndexData = class {
+  name;
+  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 });
+  }
+};
+function index(name) {
+  return new Index({ name, fields: [] });
+}
+
+// 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, entries) {
+    this.nullable = nullable;
+    this.entries = entries;
+  }
+  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(input) {
+  const expr = getSql(input);
+  if (expr) return hasField(input) ? getField(input).targetName : void 0;
+  if (!input || typeof input !== "object") return;
+  for (const value of Object.values(input)) {
+    const name = firstTargetName(value);
+    if (name) return name;
+  }
+}
+var Selection = class _Selection {
+  constructor(input, nullable = /* @__PURE__ */ new Set()) {
+    this.input = input;
+    this.nullable = nullable;
+    const root = this.#defineColumn(nullable, input);
+    this.mapRow = root.result.bind(root);
+  }
+  input;
+  nullable;
+  mapRow;
+  makeVirtual(name) {
+    return virtualTarget(name, this.input);
+  }
+  #defineColumn(nullable, input) {
+    const expr = getSql(input);
+    if (expr) return new SqlColumn(expr, getField(input)?.targetName);
+    return new ObjectColumn(
+      nullable,
+      Object.entries(input).map(([name, value]) => [
+        name,
+        this.#defineColumn(nullable, value)
+      ])
+    );
+  }
+  #columns;
+  #aliases;
+  // Flattened selected expressions with their deduplicated output names
+  #selected() {
+    if (this.#columns) return this.#columns;
+    const columns = [];
+    const names = /* @__PURE__ */ new Set();
+    const collect = (input, name) => {
+      const expr = getSql(input);
+      if (expr) {
+        let exprName = name ?? expr.alias;
+        if (exprName) {
+          while (names.has(exprName)) exprName = `${exprName}_`;
+          names.add(exprName);
+        }
+        columns.push({ input, expr, name: exprName });
+        return;
+      }
+      for (const [name2, value] of Object.entries(input)) collect(value, name2);
+    };
+    collect(this.input);
+    return this.#columns = columns;
+  }
+  fieldNames() {
+    return this.#selected().map((column) => {
+      if (!column.name) throw new Error("Missing field name");
+      return column.name;
+    });
+  }
+  aliasOf(input) {
+    if (!this.#aliases) {
+      this.#aliases = /* @__PURE__ */ new Map();
+      for (const { expr, name } of this.#selected())
+        if (name && !this.#aliases.has(expr)) this.#aliases.set(expr, name);
+    }
+    return this.#aliases.get(getSql(input));
+  }
+  get [internalSql]() {
+    return cached(this, internalSql, () => {
+      const parts = this.#selected().map(({ input, expr, name }) => {
+        if (!name) return expr;
+        if (hasField(input) && getField(input).fieldName === name) return expr;
+        return sql`${expr.forSelection()} as ${sql.identifier(name)}`;
+      });
+      return sql.join(parts, sql`, `);
+    });
+  }
+  #collectTargetNames(input, names) {
+    const expr = getSql(input);
+    if (expr) {
+      if (hasField(input)) names.add(getField(input).targetName);
+      return;
+    }
+    for (const value of Object.values(input))
+      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(table) {
+    super(table, /* @__PURE__ */ new Set());
+    this.table = table;
+  }
+  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((table) => [getTable(table).aliased, table])),
+      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 table of this.tables) nullable.add(getTable(table).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(input) {
+  if (input instanceof Selection) return input;
+  if (selected.has(input)) return selected.get(input);
+  const selection2 = hasTable(input) ? new TableSelection(input) : new Selection(input);
+  selected.set(input, selection2);
+  return selection2;
+}
+
+export {
+  Field,
+  virtualTarget,
+  StarSelection,
+  selection,
+  Index,
+  index
+};