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

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

package/dist/chunks/chunk-A42DP5T7.js

@@ -0,0 +1,94 @@
+import {
+  ReusedStatement,
+  StatementCache,
+  execTransaction,
+  sqliteDialect,
+  sqliteDiff
+} from "./chunk-M7KDJEGH.js";
+import {
+  Batch,
+  SyncDatabase
+} from "./chunk-N47Y62CI.js";
+
+// node_modules/rado/dist/driver/bun-sqlite.js
+var PreparedStatement = class extends ReusedStatement {
+  constructor(statements, sql, isSelection) {
+    super(statements, sql);
+    this.isSelection = isSelection;
+  }
+  isSelection;
+  all(params) {
+    return this.stmt.all(...params);
+  }
+  run(params) {
+    const result = this.stmt.run(...params);
+    return {
+      affectedRows: result.changes,
+      insertId: result.lastInsertRowid
+    };
+  }
+  get(params) {
+    return this.stmt.get(...params);
+  }
+  values(params) {
+    if (!this.isSelection) {
+      this.stmt.run(...params);
+      return [];
+    }
+    return this.stmt.values(...params);
+  }
+};
+var BunSqliteDriver = class _BunSqliteDriver {
+  constructor(client, depth = 0, statements = new StatementCache(
+    (sql) => client.prepare(sql),
+    (stmt) => stmt.finalize()
+  )) {
+    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, options) {
+    return new PreparedStatement(
+      this.statements,
+      sql,
+      options?.isSelection ?? false
+    );
+  }
+  batch(queries) {
+    return this.transaction((tx) => Batch.run(tx, queries), {});
+  }
+  transaction(run, options) {
+    return execTransaction(
+      this,
+      this.depth,
+      (depth) => new _BunSqliteDriver(this.client, depth, this.statements),
+      run,
+      options
+    );
+  }
+};
+function connect(db, options) {
+  return new SyncDatabase(
+    new BunSqliteDriver(db),
+    sqliteDialect,
+    sqliteDiff,
+    options
+  );
+}
+
+export {
+  connect
+};

package/dist/chunks/chunk-ATF42T2B.js

@@ -0,0 +1,35 @@
+import {
+  getField,
+  getSql,
+  getTable,
+  hasField,
+  hasSql,
+  hasTable,
+  sql
+} from "./chunk-ETBQTP2S.js";
+
+// node_modules/rado/dist/core/expr/Input.js
+function input(value, maybeField) {
+  const isObject = value && typeof value === "object";
+  if (isObject && hasTable(value))
+    return sql.identifier(getTable(value).aliased);
+  if (isObject && hasSql(value)) return getSql(value);
+  const fieldSource = maybeField && typeof maybeField === "object" && hasField(maybeField) && getField(maybeField).source;
+  return fieldSource && "mapToDriverValue" in fieldSource ? mapToColumn(fieldSource, value) : sql.value(value);
+}
+function mapToColumn({ mapToDriverValue, type }, expr) {
+  const isObject = expr && typeof expr === "object";
+  if (isObject && hasSql(expr)) return getSql(expr);
+  if (Array.isArray(expr) && type.kind === "array") {
+    if (!mapToDriverValue) return input(expr);
+    return input(mapToDriverValue(expr));
+  }
+  return input(
+    expr !== null && mapToDriverValue ? mapToDriverValue(expr) : expr
+  );
+}
+
+export {
+  input,
+  mapToColumn
+};

package/dist/chunks/{chunk-NWQXN4SB.js → chunk-ETBQTP2S.js}

@@ -11,6 +11,15 @@ var internalConstraint = /* @__PURE__ */ Symbol();
 var internalEnum = /* @__PURE__ */ Symbol();
 var internalCreate = /* @__PURE__ */ Symbol();
 var internalDrop = /* @__PURE__ */ Symbol();
+var caches = /* @__PURE__ */ new Map();
+function cached(instance, key, create) {
+  let cache = caches.get(key);
+  if (!cache) caches.set(key, cache = /* @__PURE__ */ new WeakMap());
+  if (cache.has(instance)) return cache.get(instance);
+  const value = create();
+  cache.set(instance, value);
+  return value;
+}
 var hasData = (obj) => internalData in obj;
 var getData = (obj) => obj[internalData];
 var hasSql = (obj) => internalSql in obj;
@@ -37,7 +46,7 @@ var getDrop = (obj) => obj[internalDrop];
 var noop = () => {
 };
 var Sql = class _Sql {
-  constructor(emit) {
+  constructor(emit = noop) {
     this.emit = emit;
   }
   emit;
@@ -51,9 +60,18 @@ var Sql = class _Sql {
   }
   mapWith(decoder) {
     const res = this;
-    res.mapFromDriverValue = typeof decoder === "function" ? (input2) => input2 === null ? null : decoder(input2) : decoder.mapFromDriverValue;
+    res.mapFromDriverValue = typeof decoder === "function" ? (input) => input === null ? null : decoder(input) : decoder.mapFromDriverValue;
     return res;
   }
+  asScalar(selection) {
+    const scalar = sql`(${this})`;
+    if (!selection || typeof selection !== "object") return scalar;
+    if (hasSql(selection)) return scalar.mapWith(getSql(selection));
+    const values = Object.values(selection);
+    if (values.length !== 1) return scalar;
+    const first = values[0];
+    return first && typeof first === "object" && hasSql(first) ? scalar.mapWith(getSql(first)) : scalar;
+  }
   inlineFields(withTableName) {
     return new _Sql((emitter) => emitter.inlineFields(this, withTableName));
   }
@@ -69,6 +87,9 @@ var Sql = class _Sql {
   if(condition) {
     return condition ? this : void 0;
   }
+  get isEmpty() {
+    return this.emit === noop;
+  }
 };
 var JsonPathSql = class extends Sql {
   constructor(path) {
@@ -97,7 +118,7 @@ function sql(strings, ...inner) {
 }
 ((sql2) => {
   function empty() {
-    return new Sql(noop);
+    return new Sql();
   }
   sql2.empty = empty;
   function unsafe(directSql) {
@@ -120,6 +141,12 @@ function sql(strings, ...inner) {
     return new Sql((emitter) => emitter.emitIdentifierOrSelf(identifier2));
   }
   sql2.identifier = identifier;
+  function functionName(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
+      throw new Error(`Invalid SQL function name: ${name}`);
+    return new Sql((emitter) => emitter.emitUnsafe(name));
+  }
+  sql2.functionName = functionName;
   function field(field2) {
     return new Sql((emitter) => emitter.emitField(field2));
   }
@@ -155,38 +182,23 @@ function sql(strings, ...inner) {
   }
   sql2.query = query;
   function join(items, separator = sql2` `) {
-    const parts = items.filter(Boolean);
+    const parts = [];
+    for (const item of items) {
+      if (!item) continue;
+      const inner = getSql(item);
+      if (!inner.isEmpty) parts.push(inner);
+    }
+    if (parts.length === 0) return empty();
     return new Sql((emitter) => {
       for (let i = 0; i < parts.length; i++) {
         if (i > 0) separator.emit(emitter);
-        getSql(parts[i]).emit(emitter);
+        parts[i].emit(emitter);
       }
     });
   }
   sql2.join = join;
 })(sql || (sql = {}));
 
-// node_modules/rado/dist/core/expr/Input.js
-function input(value, maybeField) {
-  const isObject = value && typeof value === "object";
-  if (isObject && hasTable(value))
-    return sql.identifier(getTable(value).aliased);
-  if (isObject && hasSql(value)) return getSql(value);
-  const fieldSource = maybeField && typeof maybeField === "object" && hasField(maybeField) && getField(maybeField).source;
-  return fieldSource && "mapToDriverValue" in fieldSource ? mapToColumn(fieldSource, value) : sql.value(value);
-}
-function mapToColumn({ mapToDriverValue, type }, expr) {
-  const isObject = expr && typeof expr === "object";
-  if (isObject && hasSql(expr)) return getSql(expr);
-  if (Array.isArray(expr) && type.kind === "array") {
-    if (!mapToDriverValue) return input(expr);
-    return input(mapToDriverValue(expr));
-  }
-  return input(
-    expr !== null && mapToDriverValue ? mapToDriverValue(expr) : expr
-  );
-}
-
 export {
   internalData,
   internalSql,
@@ -199,6 +211,7 @@ export {
   internalConstraint,
   internalCreate,
   internalDrop,
+  cached,
   hasData,
   getData,
   hasSql,
@@ -221,7 +234,5 @@ export {
   getCreate,
   getDrop,
   Sql,
-  sql,
-  input,
-  mapToColumn
+  sql
 };

package/dist/chunks/chunk-IL7FJQAY.js

@@ -0,0 +1,94 @@
+import {
+  ReusedStatement,
+  StatementCache,
+  execTransaction,
+  sqliteDialect,
+  sqliteDiff
+} from "./chunk-M7KDJEGH.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-K62JP6HR.js

@@ -0,0 +1,22 @@
+import {
+  input
+} from "./chunk-ATF42T2B.js";
+import {
+  sql
+} from "./chunk-ETBQTP2S.js";
+
+// 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.functionName(method), args);
+  };
+}
+var Functions = new Proxy(/* @__PURE__ */ Object.create(null), { get });
+
+export {
+  callFunction,
+  Functions
+};

package/dist/chunks/chunk-K7LHQXI4.js

@@ -0,0 +1,103 @@
+import {
+  Column,
+  ColumnType,
+  JsonColumn,
+  column
+} from "./chunk-TFMUSWGG.js";
+import {
+  sql
+} from "./chunk-ETBQTP2S.js";
+
+// node_modules/rado/dist/universal/columns.js
+var idType = new ColumnType(
+  "id",
+  [],
+  sql.universal({
+    sqlite: sql`integer`,
+    postgres: sql`integer generated always as identity`,
+    mysql: sql`int not null auto_increment`
+  })
+);
+var blobType = new ColumnType(
+  "blob",
+  [],
+  sql.universal({
+    postgres: sql`bytea`,
+    default: sql`blob`
+  })
+);
+var numberType = new ColumnType(
+  "number",
+  [],
+  sql.universal({
+    mysql: sql`double`,
+    default: sql`numeric`
+  })
+);
+var jsonbType = new ColumnType(
+  "json",
+  [],
+  sql.universal({
+    mysql: sql`json`,
+    default: sql`jsonb`
+  })
+);
+function id(name) {
+  return new Column({
+    name,
+    type: idType,
+    primary: true,
+    notNull: true
+  });
+}
+function text(name) {
+  return new Column({ name, type: column.text() });
+}
+function varchar(name, options) {
+  return new Column({ name, type: column.varchar(options?.length) });
+}
+function integer(name) {
+  return new Column({ name, type: column.integer() });
+}
+function number(name) {
+  return new Column({ name, type: numberType, mapFromDriverValue: Number });
+}
+function boolean(name) {
+  return new Column({
+    name,
+    type: column.boolean(),
+    mapFromDriverValue: Boolean
+  });
+}
+function json(name) {
+  return new JsonColumn({
+    name,
+    type: column.json(),
+    mapToDriverValue(value) {
+      return JSON.stringify(value);
+    },
+    mapFromDriverValue(value, { parsesJson }) {
+      return parsesJson ? value : JSON.parse(value);
+    }
+  });
+}
+function blob(name) {
+  return new Column({
+    name,
+    type: blobType,
+    mapFromDriverValue(value) {
+      return new Uint8Array(value);
+    }
+  });
+}
+
+export {
+  id,
+  text,
+  varchar,
+  integer,
+  number,
+  boolean,
+  json,
+  blob
+};