alinea 2.0.0-preview.7 → 2.0.0-preview.9

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
+};

package/dist/chunks/chunk-66YZ47TY.js

@@ -0,0 +1,94 @@
+import {
+  ReusedStatement,
+  StatementCache,
+  execTransaction,
+  sqliteDialect,
+  sqliteDiff
+} from "./chunk-AIU6CMVT.js";
+import {
+  Batch,
+  SyncDatabase
+} from "./chunk-N47Y62CI.js";
+
+// node_modules/rado/dist/driver/sql.js.js
+var PreparedStatement = class extends ReusedStatement {
+  constructor(client, statements, sql) {
+    super(statements, sql);
+    this.client = client;
+  }
+  client;
+  *iterate(params) {
+    this.stmt.bind(params);
+    while (this.stmt.step()) yield this.stmt.getAsObject();
+    this.stmt.reset();
+  }
+  *iterateValues(params) {
+    this.stmt.bind(params);
+    while (this.stmt.step()) yield this.stmt.get();
+    this.stmt.reset();
+  }
+  all(params) {
+    return Array.from(this.iterate(params));
+  }
+  run(params) {
+    this.stmt.run(params);
+    this.stmt.reset();
+    return { affectedRows: this.client.getRowsModified() };
+  }
+  get(params) {
+    return this.all(params)[0] ?? null;
+  }
+  values(params) {
+    return Array.from(this.iterateValues(params));
+  }
+};
+var SqlJsDriver = class _SqlJsDriver {
+  constructor(client, depth = 0, statements = new StatementCache(
+    (sql) => client.prepare(sql),
+    (stmt) => stmt.free()
+  )) {
+    this.client = client;
+    this.depth = depth;
+    this.statements = statements;
+  }
+  client;
+  depth;
+  statements;
+  parsesJson = false;
+  supportsTransactions = true;
+  exec(query) {
+    this.statements.invalidate(query);
+    this.client.exec(query);
+  }
+  close() {
+    this.statements.clear();
+    this.client.close();
+  }
+  prepare(sql) {
+    return new PreparedStatement(this.client, this.statements, sql);
+  }
+  batch(queries) {
+    return this.transaction((tx) => Batch.run(tx, queries), {});
+  }
+  transaction(run, options) {
+    return execTransaction(
+      this,
+      this.depth,
+      (depth) => new _SqlJsDriver(this.client, depth, this.statements),
+      run,
+      options
+    );
+  }
+};
+function connect(db, options) {
+  return new SyncDatabase(
+    new SqlJsDriver(db),
+    sqliteDialect,
+    sqliteDiff,
+    options
+  );
+}
+
+export {
+  connect
+};

package/dist/chunks/chunk-76VMZTLN.js

@@ -0,0 +1,55 @@
+import {
+  callFunction
+} from "./chunk-K62JP6HR.js";
+import {
+  getSql,
+  sql
+} from "./chunk-ETBQTP2S.js";
+
+// 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
+  );
+}
+
+export {
+  jsonExpr,
+  jsonAggregateArray,
+  jsonArray
+};