tempest-db-js 0.1.0

package/dist/chunk-F36ZSQAN.js

@@ -0,0 +1,1360 @@
+import { createRequire } from 'module';
+
+// src/conditions.ts
+var CONDITION = /* @__PURE__ */ Symbol.for("tempest-db-js.condition");
+function isCondition(value) {
+  return typeof value === "object" && value !== null && value[CONDITION] === true;
+}
+function toCondNode(input) {
+  return isCondition(input) ? input.node : { kind: "fields", fields: input };
+}
+function wrap(node) {
+  return { [CONDITION]: true, node };
+}
+function and(...inputs) {
+  return wrap({
+    kind: "and",
+    parts: inputs.map((i) => toCondNode(i))
+  });
+}
+function or(...inputs) {
+  return wrap({
+    kind: "or",
+    parts: inputs.map((i) => toCondNode(i))
+  });
+}
+function not(input) {
+  return wrap({ kind: "not", part: toCondNode(input) });
+}
+
+// src/query.ts
+var OPERATORS = [
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "like",
+  "ilike",
+  "in",
+  "notIn",
+  "between",
+  "isNull"
+];
+var SelectBuilder = class _SelectBuilder {
+  constructor(node, source) {
+    this.node = node;
+    this.source = source;
+  }
+  node;
+  source;
+  with(patch) {
+    return new _SelectBuilder({ ...this.node, ...patch }, this.source);
+  }
+  /** Add a WHERE filter: the object form (keys typed) or an `and`/`or`/`not`. */
+  where(input) {
+    return this.with({ where: toCondNode(input) });
+  }
+  /** Order by a column of `Full`. */
+  orderBy(column2, direction = "asc") {
+    return this.with({
+      orderBy: [...this.node.orderBy, { column: column2, direction }]
+    });
+  }
+  /** Limit the number of rows. */
+  limit(n) {
+    return this.with({ limit: n });
+  }
+  /** Skip the first `n` rows. */
+  offset(n) {
+    return this.with({ offset: n });
+  }
+};
+function select(model, columns) {
+  return new SelectBuilder(
+    {
+      kind: "select",
+      table: model.tablename,
+      columns: columns ?? "*",
+      where: void 0,
+      orderBy: [],
+      limit: void 0,
+      offset: void 0
+    },
+    model
+  );
+}
+
+// src/mutations.ts
+var InsertBuilder = class _InsertBuilder {
+  constructor(node, source) {
+    this.node = node;
+    this.source = source;
+  }
+  node;
+  source;
+  with(patch) {
+    return new _InsertBuilder({ ...this.node, ...patch }, this.source);
+  }
+  /** Provide one row or many rows to insert, typed by the insert shape. */
+  values(rows) {
+    const list = Array.isArray(rows) ? rows : [rows];
+    return this.with({ values: list });
+  }
+  returning(columns) {
+    return this.with({ returning: columns ?? "*" });
+  }
+};
+function insert(model) {
+  return new InsertBuilder(
+    {
+      kind: "insert",
+      table: model.tablename,
+      values: [],
+      returning: null
+    },
+    model
+  );
+}
+var UpdateBuilder = class _UpdateBuilder {
+  constructor(node, source) {
+    this.node = node;
+    this.source = source;
+  }
+  node;
+  source;
+  with(patch) {
+    return new _UpdateBuilder({ ...this.node, ...patch }, this.source);
+  }
+  /** The columns to write. Partial — only the given columns change. */
+  set(values) {
+    return this.with({ set: values });
+  }
+  /** Restrict the rows to update. Marks the builder safe to execute. */
+  where(input) {
+    return this.with({
+      where: toCondNode(input),
+      guarded: true
+    });
+  }
+  /** Explicit opt-in to update EVERY row. Use deliberately. */
+  unguarded() {
+    return this.with({ guarded: true });
+  }
+  returning(columns) {
+    return this.with({ returning: columns ?? "*" });
+  }
+};
+function update(model) {
+  return new UpdateBuilder(
+    {
+      kind: "update",
+      table: model.tablename,
+      set: {},
+      where: void 0,
+      guarded: false,
+      returning: null
+    },
+    model
+  );
+}
+var DeleteBuilder = class _DeleteBuilder {
+  constructor(node, source) {
+    this.node = node;
+    this.source = source;
+  }
+  node;
+  source;
+  with(patch) {
+    return new _DeleteBuilder({ ...this.node, ...patch }, this.source);
+  }
+  /** Restrict the rows to delete. Marks the builder safe to execute. */
+  where(input) {
+    return this.with({
+      where: toCondNode(input),
+      guarded: true
+    });
+  }
+  /** Explicit opt-in to delete EVERY row. Use deliberately. */
+  unguarded() {
+    return this.with({ guarded: true });
+  }
+  returning(columns) {
+    return this.with({ returning: columns ?? "*" });
+  }
+};
+function del(model) {
+  return new DeleteBuilder(
+    {
+      kind: "delete",
+      table: model.tablename,
+      where: void 0,
+      guarded: false,
+      returning: null
+    },
+    model
+  );
+}
+
+// src/url.ts
+var InvalidDatabaseUrl = class extends Error {
+  constructor(url, reason) {
+    super(`Invalid database URL ${JSON.stringify(url)}: ${reason}`);
+    this.name = "InvalidDatabaseUrl";
+  }
+};
+var DIALECT_ALIASES = {
+  sqlite: "sqlite",
+  sqlite3: "sqlite",
+  postgresql: "postgresql",
+  postgres: "postgresql",
+  pg: "postgresql"
+};
+function splitScheme(scheme) {
+  const plus = scheme.indexOf("+");
+  if (plus === -1) return { base: scheme.toLowerCase(), driver: null };
+  return {
+    base: scheme.slice(0, plus).toLowerCase(),
+    driver: scheme.slice(plus + 1) || null
+  };
+}
+function decode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function parseSqlite(raw, driver, rest) {
+  let database;
+  if (rest.endsWith(":memory:")) {
+    database = ":memory:";
+  } else if (rest.startsWith("///")) {
+    database = rest.slice(3) || ":memory:";
+  } else if (rest.startsWith("//")) {
+    database = rest.slice(2) || ":memory:";
+  } else {
+    database = rest || ":memory:";
+  }
+  return {
+    dialect: "sqlite",
+    driver,
+    host: null,
+    port: null,
+    user: null,
+    password: null,
+    database: decode(database),
+    options: {},
+    raw
+  };
+}
+function parsePostgres(raw, driver, rest) {
+  let parsed;
+  try {
+    parsed = new URL(`postgresql:${rest}`);
+  } catch {
+    throw new InvalidDatabaseUrl(raw, "could not parse host/credentials");
+  }
+  const database = decode(parsed.pathname.replace(/^\//, "")) || null;
+  const options = {};
+  for (const [key, value] of parsed.searchParams) options[key] = value;
+  return {
+    dialect: "postgresql",
+    driver,
+    host: parsed.hostname || null,
+    port: parsed.port ? Number(parsed.port) : null,
+    user: parsed.username ? decode(parsed.username) : null,
+    password: parsed.password ? decode(parsed.password) : null,
+    database,
+    options,
+    raw
+  };
+}
+function parseDatabaseUrl(url) {
+  const schemeEnd = url.indexOf(":");
+  if (schemeEnd === -1) {
+    throw new InvalidDatabaseUrl(
+      url,
+      "missing scheme (expected e.g. sqlite:// or postgresql://)"
+    );
+  }
+  const { base, driver } = splitScheme(url.slice(0, schemeEnd));
+  const dialect = DIALECT_ALIASES[base];
+  if (!dialect) {
+    throw new InvalidDatabaseUrl(url, `unknown dialect ${JSON.stringify(base)}`);
+  }
+  const rest = url.slice(schemeEnd + 1);
+  return dialect === "sqlite" ? parseSqlite(url, driver, rest) : parsePostgres(url, driver, rest);
+}
+function detectDialect(url) {
+  return parseDatabaseUrl(url).dialect;
+}
+
+// src/serialize.ts
+var ValidationError = class extends Error {
+  constructor(table, issues) {
+    super(`Validation failed for ${table}:
+  - ${issues.join("\n  - ")}`);
+    this.table = table;
+    this.issues = issues;
+    this.name = "ValidationError";
+  }
+  table;
+  issues;
+};
+function toBase64(bytes) {
+  if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function fromBase64(value) {
+  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(value, "base64"));
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function encodeValue(column2, value) {
+  if (value === null || value === void 0) return null;
+  switch (column2.type.kind) {
+    case "bigint":
+      return typeof value === "bigint" ? value.toString() : value;
+    case "date":
+    case "datetime":
+    case "timestamp":
+      return value instanceof Date ? value.toISOString() : value;
+    case "blob":
+      return value instanceof Uint8Array ? toBase64(value) : value;
+    default:
+      return value;
+  }
+}
+function decodeValue(column2, value) {
+  if (value === null || value === void 0) return null;
+  switch (column2.type.kind) {
+    case "bigint":
+      return typeof value === "bigint" ? value : BigInt(value);
+    case "date":
+    case "datetime":
+    case "timestamp":
+      return value instanceof Date ? value : new Date(value);
+    case "blob":
+      return value instanceof Uint8Array ? value : fromBase64(value);
+    case "json":
+      return typeof value === "string" ? JSON.parse(value) : value;
+    case "numeric":
+      return typeof value === "string" ? value : String(value);
+    case "boolean":
+      return typeof value === "boolean" ? value : value === 1 || value === "true";
+    case "smallint":
+    case "integer":
+    case "real":
+    case "double":
+      return typeof value === "number" ? value : Number(value);
+    default:
+      return value;
+  }
+}
+function toDict(model, row) {
+  const columns = columnsOf(model);
+  const out = {};
+  for (const name of Object.keys(columns)) {
+    out[name] = row[name] ?? null;
+  }
+  return out;
+}
+function toJSON(model, row) {
+  const columns = columnsOf(model);
+  const out = {};
+  for (const [name, col] of Object.entries(columns)) {
+    out[name] = encodeValue(col, row[name] ?? null);
+  }
+  return out;
+}
+function stringify(model, row) {
+  return JSON.stringify(toJSON(model, row));
+}
+function fromDict(model, data) {
+  const columns = columnsOf(model);
+  const out = {};
+  const issues = [];
+  for (const [name, col] of Object.entries(columns)) {
+    const present = name in data && data[name] !== void 0 && data[name] !== null;
+    if (!present) {
+      const required = col.flags.notNull && !col.flags.hasDefault;
+      if (required) {
+        issues.push(`missing required column "${name}"`);
+        continue;
+      }
+      out[name] = null;
+      continue;
+    }
+    try {
+      out[name] = decodeValue(col, data[name]);
+    } catch (error) {
+      issues.push(`column "${name}": ${error.message}`);
+    }
+  }
+  if (issues.length > 0) {
+    throw new ValidationError(model.tablename, issues);
+  }
+  return out;
+}
+function parse(model, json) {
+  return fromDict(model, JSON.parse(json));
+}
+function coerceRow(model, raw) {
+  const columns = columnsOf(model);
+  const out = {};
+  for (const [name, value] of Object.entries(raw)) {
+    const col = columns[name];
+    out[name] = col ? decodeValue(col, value) : value;
+  }
+  return out;
+}
+
+// src/dialect.ts
+var OPERATOR_SET = new Set(OPERATORS);
+function isOperatorObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date || value instanceof Uint8Array) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((k) => OPERATOR_SET.has(k));
+}
+var Params = class {
+  constructor(placeholder) {
+    this.placeholder = placeholder;
+  }
+  placeholder;
+  values = [];
+  bind(value) {
+    this.values.push(value);
+    return this.placeholder(this.values.length);
+  }
+};
+var BaseDialect = class {
+  /** Quote an identifier (column/table) for the active dialect. */
+  quoteId(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+  }
+  /** Compile any node to `{ sql, params }`. */
+  compile(node) {
+    const params = new Params((i) => this.placeholder(i));
+    let sql2;
+    switch (node.kind) {
+      case "select":
+        sql2 = this.compileSelect(node, params);
+        break;
+      case "insert":
+        sql2 = this.compileInsert(node, params);
+        break;
+      case "update":
+        sql2 = this.compileUpdate(node, params);
+        break;
+      case "delete":
+        sql2 = this.compileDelete(node, params);
+        break;
+      case "join_select":
+        sql2 = this.compileJoin(node, params);
+        break;
+    }
+    return { sql: sql2, params: params.values };
+  }
+  /** Render a qualified `alias.column` ref as `"alias"."column"`. */
+  qualify(ref) {
+    const dot = ref.indexOf(".");
+    if (dot === -1) return this.quoteId(ref);
+    return `${this.quoteId(ref.slice(0, dot))}.${this.quoteId(ref.slice(dot + 1))}`;
+  }
+  // ---- statements -------------------------------------------------------
+  compileSelect(node, params) {
+    const cols = node.columns === "*" ? "*" : node.columns.map((c) => this.quoteId(c)).join(", ");
+    let sql2 = `SELECT ${cols} FROM ${this.quoteId(node.table)}`;
+    const where = this.compileCondition(node.where, params, (k) => this.quoteId(k));
+    if (where) sql2 += ` WHERE ${where}`;
+    if (node.orderBy.length > 0) {
+      const terms = node.orderBy.map(
+        (t) => `${this.quoteId(t.column)} ${t.direction === "desc" ? "DESC" : "ASC"}`
+      ).join(", ");
+      sql2 += ` ORDER BY ${terms}`;
+    }
+    if (node.limit !== void 0) sql2 += ` LIMIT ${params.bind(node.limit)}`;
+    if (node.offset !== void 0) sql2 += ` OFFSET ${params.bind(node.offset)}`;
+    return sql2;
+  }
+  compileInsert(node, params) {
+    const columns = node.values.length > 0 ? Object.keys(node.values[0]) : [];
+    const colSql = columns.map((c) => this.quoteId(c)).join(", ");
+    const rowsSql = node.values.map(
+      (row) => `(${columns.map((c) => params.bind(row[c] ?? null)).join(", ")})`
+    ).join(", ");
+    let sql2 = `INSERT INTO ${this.quoteId(node.table)} (${colSql}) VALUES ${rowsSql}`;
+    sql2 += this.compileReturning(node.returning);
+    return sql2;
+  }
+  compileUpdate(node, params) {
+    const sets = Object.entries(node.set).map(([col, value]) => `${this.quoteId(col)} = ${params.bind(value)}`).join(", ");
+    let sql2 = `UPDATE ${this.quoteId(node.table)} SET ${sets}`;
+    const where = this.compileCondition(node.where, params, (k) => this.quoteId(k));
+    if (where) sql2 += ` WHERE ${where}`;
+    sql2 += this.compileReturning(node.returning);
+    return sql2;
+  }
+  compileDelete(node, params) {
+    let sql2 = `DELETE FROM ${this.quoteId(node.table)}`;
+    const where = this.compileCondition(node.where, params, (k) => this.quoteId(k));
+    if (where) sql2 += ` WHERE ${where}`;
+    sql2 += this.compileReturning(node.returning);
+    return sql2;
+  }
+  compileJoin(node, params) {
+    const cols = node.selections.map((s) => {
+      const ref = `${s.alias}.${s.column}`;
+      return `${this.qualify(ref)} AS ${this.quoteId(ref)}`;
+    }).join(", ");
+    let sql2 = `SELECT ${cols} FROM ${this.quoteId(node.base.table)} AS ${this.quoteId(node.base.alias)}`;
+    for (const j of node.joins) {
+      const kw = j.kind === "left" ? "LEFT JOIN" : "INNER JOIN";
+      const on = j.on.map(([l, r]) => `${this.qualify(l)} = ${this.qualify(r)}`).join(" AND ");
+      sql2 += ` ${kw} ${this.quoteId(j.table)} AS ${this.quoteId(j.alias)} ON ${on}`;
+    }
+    const where = this.compileCondition(node.where, params, (k) => this.qualify(k));
+    if (where) sql2 += ` WHERE ${where}`;
+    if (node.orderBy.length > 0) {
+      const terms = node.orderBy.map((t) => `${this.qualify(t.ref)} ${t.direction === "desc" ? "DESC" : "ASC"}`).join(", ");
+      sql2 += ` ORDER BY ${terms}`;
+    }
+    if (node.limit !== void 0) sql2 += ` LIMIT ${params.bind(node.limit)}`;
+    if (node.offset !== void 0) sql2 += ` OFFSET ${params.bind(node.offset)}`;
+    return sql2;
+  }
+  // ---- clauses ----------------------------------------------------------
+  compileReturning(returning) {
+    if (returning === null) return "";
+    if (returning === "*") return " RETURNING *";
+    return ` RETURNING ${returning.map((c) => this.quoteId(c)).join(", ")}`;
+  }
+  /**
+   * Compile a condition tree (fields / and / or / not) to SQL. `idFor` renders a
+   * key to a quoted identifier — `quoteId` for single-table, `qualify` for joins —
+   * so select/update/delete/join all share this one compiler.
+   */
+  compileCondition(node, params, idFor) {
+    if (!node) return "";
+    switch (node.kind) {
+      case "fields": {
+        const conditions = [];
+        for (const [key, value] of Object.entries(node.fields)) {
+          const id = idFor(key);
+          if (isOperatorObject(value)) {
+            for (const [op, operand] of Object.entries(value)) {
+              conditions.push(this.compileOperator(id, op, operand, params));
+            }
+          } else {
+            conditions.push(
+              value === null ? `${id} IS NULL` : `${id} = ${params.bind(value)}`
+            );
+          }
+        }
+        return conditions.join(" AND ");
+      }
+      case "and":
+      case "or": {
+        const parts = node.parts.map((p) => this.compileCondition(p, params, idFor)).filter((s) => s.length > 0);
+        if (parts.length === 0) return "";
+        const sep = node.kind === "and" ? " AND " : " OR ";
+        return parts.map((p) => `(${p})`).join(sep);
+      }
+      case "not": {
+        const inner = this.compileCondition(node.part, params, idFor);
+        return inner ? `NOT (${inner})` : "";
+      }
+    }
+  }
+  compileOperator(id, op, operand, params) {
+    switch (op) {
+      case "eq":
+        return operand === null ? `${id} IS NULL` : `${id} = ${params.bind(operand)}`;
+      case "ne":
+        return operand === null ? `${id} IS NOT NULL` : `${id} <> ${params.bind(operand)}`;
+      case "gt":
+        return `${id} > ${params.bind(operand)}`;
+      case "gte":
+        return `${id} >= ${params.bind(operand)}`;
+      case "lt":
+        return `${id} < ${params.bind(operand)}`;
+      case "lte":
+        return `${id} <= ${params.bind(operand)}`;
+      case "like":
+        return `${id} LIKE ${params.bind(operand)}`;
+      case "ilike":
+        return this.ilike(id, params.bind(operand));
+      case "in":
+        return this.compileIn(id, operand, params, false);
+      case "notIn":
+        return this.compileIn(id, operand, params, true);
+      case "between": {
+        const [lo, hi] = operand;
+        return `${id} BETWEEN ${params.bind(lo)} AND ${params.bind(hi)}`;
+      }
+      case "isNull":
+        return operand ? `${id} IS NULL` : `${id} IS NOT NULL`;
+      default:
+        throw new Error(`Unknown operator ${JSON.stringify(op)}`);
+    }
+  }
+  compileIn(id, values, params, negate) {
+    if (values.length === 0) {
+      return negate ? "1 = 1" : "1 = 0";
+    }
+    const list = values.map((v) => params.bind(v)).join(", ");
+    return `${id} ${negate ? "NOT IN" : "IN"} (${list})`;
+  }
+};
+var SqliteDialect = class extends BaseDialect {
+  name = "sqlite";
+  placeholder() {
+    return "?";
+  }
+  ilike(column2, param) {
+    return `${column2} LIKE ${param}`;
+  }
+};
+var PostgresDialect = class extends BaseDialect {
+  name = "postgresql";
+  placeholder(index) {
+    return `$${index}`;
+  }
+  ilike(column2, param) {
+    return `${column2} ILIKE ${param}`;
+  }
+};
+function getDialect(name) {
+  return name === "sqlite" ? new SqliteDialect() : new PostgresDialect();
+}
+
+// src/join.ts
+function selectionsFor(alias, model) {
+  return Object.keys(columnsOf(model)).map((column2) => ({ alias, column: column2 }));
+}
+var JoinBuilder = class _JoinBuilder {
+  constructor(node, sources) {
+    this.node = node;
+    this.sources = sources;
+  }
+  node;
+  sources;
+  add(clause, model) {
+    return new _JoinBuilder(
+      {
+        ...this.node,
+        joins: [...this.node.joins, clause],
+        selections: [...this.node.selections, ...selectionsFor(clause.alias, model)]
+      },
+      { ...this.sources, [clause.alias]: model }
+    );
+  }
+  clause(kind, model, alias, on) {
+    return {
+      kind,
+      table: model.tablename,
+      alias,
+      on: Object.entries(on)
+    };
+  }
+  /** Inner join another model under `alias`. */
+  innerJoin(model, alias, on) {
+    return this.add(
+      this.clause("inner", model, alias, on),
+      model
+    );
+  }
+  /** Left (outer) join another model under `alias` — its side becomes nullable. */
+  leftJoin(model, alias, on) {
+    return this.add(
+      this.clause("left", model, alias, on),
+      model
+    );
+  }
+  /** Filter by `alias.column` references (object form) or an `and`/`or`/`not`. */
+  where(input) {
+    return new _JoinBuilder(
+      { ...this.node, where: toCondNode(input) },
+      this.sources
+    );
+  }
+  /** Order by an `alias.column` reference. */
+  orderBy(ref, direction = "asc") {
+    return new _JoinBuilder(
+      {
+        ...this.node,
+        orderBy: [...this.node.orderBy, { ref, direction }]
+      },
+      this.sources
+    );
+  }
+  limit(n) {
+    return new _JoinBuilder({ ...this.node, limit: n }, this.sources);
+  }
+  offset(n) {
+    return new _JoinBuilder({ ...this.node, offset: n }, this.sources);
+  }
+};
+function join(model, alias) {
+  return new JoinBuilder(
+    {
+      kind: "join_select",
+      base: { table: model.tablename, alias },
+      joins: [],
+      selections: selectionsFor(alias, model),
+      where: void 0,
+      orderBy: [],
+      limit: void 0,
+      offset: void 0
+    },
+    { [alias]: model }
+  );
+}
+
+// src/repository.ts
+var RecordNotFound = class extends Error {
+  constructor(table, id) {
+    super(`${table} not found for id ${JSON.stringify(id)}`);
+    this.name = "RecordNotFound";
+  }
+};
+function primaryKeyOf(model) {
+  for (const [name, col] of Object.entries(columnsOf(model))) {
+    if (col.flags.primaryKey) return name;
+  }
+  throw new Error(`${model.tablename} has no primary key`);
+}
+var BaseRepository = class {
+  constructor(model, session) {
+    this.model = model;
+    this.session = session;
+    this.pk = primaryKeyOf(model);
+  }
+  model;
+  session;
+  pk;
+  /** All rows matching `filters` (or everything). Empty list when none match. */
+  async list(filters) {
+    const query = filters ? select(this.model).where(filters) : select(this.model);
+    return this.session.execute(query).all();
+  }
+  /** The first row matching `filters`, or `null`. */
+  async first(filters) {
+    const query = filters ? select(this.model).where(filters) : select(this.model);
+    return this.session.execute(query).first();
+  }
+  /** A single row by primary key, or `null`. */
+  async getByIdOrNull(id) {
+    return this.session.execute(select(this.model).where({ [this.pk]: id })).first();
+  }
+  /** A single row by primary key; throws `RecordNotFound` when absent. */
+  async getById(id) {
+    const row = await this.getByIdOrNull(id);
+    if (row === null) throw new RecordNotFound(this.model.tablename, id);
+    return row;
+  }
+  /** Whether any row matches `filters`. */
+  async exists(filters) {
+    return await this.first(filters) !== null;
+  }
+  /** How many rows match `filters` (or the whole table). */
+  async count(filters) {
+    const query = filters ? select(this.model, [this.pk]).where(filters) : select(this.model, [this.pk]);
+    return (await this.session.execute(query).all()).length;
+  }
+  /** Insert one row, returning the created row. */
+  async create(data) {
+    return this.session.execute(insert(this.model).values(data).returning()).one();
+  }
+  /** Insert many rows, returning the created rows. */
+  async createMany(data) {
+    if (data.length === 0) return [];
+    return this.session.execute(insert(this.model).values(data).returning()).all();
+  }
+  /** Update rows matching `filters`; returns the number of rows affected. */
+  async update(filters, set) {
+    return this.session.execute(update(this.model).set(set).where(filters)).rowsAffected();
+  }
+  /** Delete rows matching `filters`; returns the number of rows affected. */
+  async delete(filters) {
+    return this.session.execute(del(this.model).where(filters)).rowsAffected();
+  }
+  /**
+   * A page of rows plus metadata. `total` counts all matching rows.
+   *
+   * @param filter Page, size, ordering and filters.
+   * @returns The page and pagination metadata.
+   */
+  async paginate(filter = {}) {
+    const page = Math.max(1, filter.page ?? 1);
+    const pageSize = Math.max(1, filter.pageSize ?? 20);
+    const where = filter.filters;
+    let query = where ? select(this.model).where(where) : select(this.model);
+    if (filter.orderBy) {
+      query = query.orderBy(filter.orderBy, filter.ascending === false ? "desc" : "asc");
+    }
+    query = query.limit(pageSize).offset((page - 1) * pageSize);
+    const items = await this.session.execute(query).all();
+    const total = await this.count(where);
+    return {
+      items,
+      total,
+      page,
+      pageSize,
+      pages: Math.max(1, Math.ceil(total / pageSize))
+    };
+  }
+};
+
+// src/relations.ts
+function hasMany(target, keys) {
+  return {
+    kind: "hasMany",
+    target,
+    localKey: keys.localKey,
+    foreignKey: keys.foreignKey
+  };
+}
+function belongsTo(target, keys) {
+  return {
+    kind: "belongsTo",
+    target,
+    localKey: keys.localKey,
+    foreignKey: keys.foreignKey
+  };
+}
+async function loadRelations(session, rows, spec) {
+  const out = rows.map((r) => ({ ...r }));
+  for (const [name, rel] of Object.entries(spec)) {
+    const target = rel.target();
+    const localValues = [...new Set(rows.map((r) => r[rel.localKey]))];
+    const related = localValues.length > 0 ? await session.execute(
+      select(target).where({
+        [rel.foreignKey]: { in: localValues }
+      })
+    ).all() : [];
+    if (rel.kind === "hasMany") {
+      const grouped = /* @__PURE__ */ new Map();
+      for (const row of related) {
+        const key = row[rel.foreignKey];
+        const list = grouped.get(key) ?? [];
+        list.push(row);
+        grouped.set(key, list);
+      }
+      out.forEach((r, i) => {
+        r[name] = grouped.get(rows[i]?.[rel.localKey]) ?? [];
+      });
+    } else {
+      const byKey = /* @__PURE__ */ new Map();
+      for (const row of related) {
+        byKey.set(row[rel.foreignKey], row);
+      }
+      out.forEach((r, i) => {
+        r[name] = byKey.get(rows[i]?.[rel.localKey]) ?? null;
+      });
+    }
+  }
+  return out;
+}
+var nodeRequire = createRequire(import.meta.url);
+function encodeSqliteParam(value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof Uint8Array) return value;
+  if (typeof value === "object") return JSON.stringify(value);
+  return value;
+}
+var NodeSqliteDriver = class _NodeSqliteDriver {
+  // biome-ignore lint/suspicious/noExplicitAny: node:sqlite DatabaseSync has no shipped types here.
+  db;
+  // biome-ignore lint/suspicious/noExplicitAny: accept an already-open DatabaseSync handle.
+  constructor(database) {
+    this.db = database;
+  }
+  /** Open a `node:sqlite` database at the given path (or `:memory:`). */
+  static open(path) {
+    const { DatabaseSync } = nodeRequire("node:sqlite");
+    return new _NodeSqliteDriver(new DatabaseSync(path));
+  }
+  execute(sql2, params) {
+    const stmt = this.db.prepare(sql2);
+    const bound = params.map(encodeSqliteParam);
+    if (returnsRows(sql2)) {
+      return { rows: stmt.all(...bound), changes: 0 };
+    }
+    const info = stmt.run(...bound);
+    return { rows: [], changes: Number(info.changes ?? 0) };
+  }
+  *iterate(sql2, params) {
+    const stmt = this.db.prepare(sql2);
+    const bound = params.map(encodeSqliteParam);
+    yield* stmt.iterate(...bound);
+  }
+  close() {
+    this.db.close();
+  }
+};
+function returnsRows(sql2) {
+  return /^\s*(select|pragma)/i.test(sql2) || /\breturning\b/i.test(sql2);
+}
+function splitJoinRow(node, sources, raw) {
+  const leftAliases = new Set(
+    node.joins.filter((j) => j.kind === "left").map((j) => j.alias)
+  );
+  const out = {};
+  for (const [alias, model] of Object.entries(sources)) {
+    const sub = {};
+    let allNull = true;
+    for (const colName of Object.keys(columnsOf(model))) {
+      const value = raw[`${alias}.${colName}`];
+      if (value !== null && value !== void 0) allNull = false;
+      sub[colName] = value;
+    }
+    out[alias] = leftAliases.has(alias) && allNull ? null : coerceRow(model, sub);
+  }
+  return out;
+}
+function coerceOne(builder, raw) {
+  const node = builder.node;
+  if (node.kind === "join_select") {
+    const b2 = builder;
+    return splitJoinRow(b2.node, b2.sources, raw);
+  }
+  const b = builder;
+  return coerceRow(b.source, raw);
+}
+function mapRows(builder, raw) {
+  return raw.map((r) => coerceOne(builder, r));
+}
+var NoResultError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NoResultError";
+  }
+};
+function firstScalar(row) {
+  if (!row) return null;
+  const keys = Object.keys(row);
+  return keys.length > 0 ? row[keys[0]] : null;
+}
+var SyncResult = class {
+  constructor(rows, changes) {
+    this.rows = rows;
+    this.changes = changes;
+  }
+  rows;
+  changes;
+  all() {
+    return this.rows;
+  }
+  first() {
+    return this.rows[0] ?? null;
+  }
+  one() {
+    if (this.rows.length !== 1) {
+      throw new NoResultError(`expected exactly one row, got ${this.rows.length}`);
+    }
+    return this.rows[0];
+  }
+  oneOrNull() {
+    if (this.rows.length > 1) {
+      throw new NoResultError(`expected at most one row, got ${this.rows.length}`);
+    }
+    return this.rows[0] ?? null;
+  }
+  scalar() {
+    return firstScalar(this.rows[0]);
+  }
+  scalars() {
+    return this.rows.map((r) => firstScalar(r));
+  }
+  rowsAffected() {
+    return this.changes;
+  }
+};
+var AsyncResult = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  inner;
+  async all() {
+    return (await this.inner).all();
+  }
+  async first() {
+    return (await this.inner).first();
+  }
+  async one() {
+    return (await this.inner).one();
+  }
+  async oneOrNull() {
+    return (await this.inner).oneOrNull();
+  }
+  async scalar() {
+    return (await this.inner).scalar();
+  }
+  async scalars() {
+    return (await this.inner).scalars();
+  }
+  async rowsAffected() {
+    return (await this.inner).rowsAffected();
+  }
+};
+var savepointCounter = 0;
+var SyncSession = class {
+  constructor(driver, dialect) {
+    this.driver = driver;
+    this.dialect = dialect;
+  }
+  driver;
+  dialect;
+  /** Compile, run, and coerce a builder into a result. */
+  execute(builder) {
+    const node = builder.node;
+    const { sql: sql2, params } = this.dialect.compile(node);
+    const result = this.driver.execute(sql2, params);
+    const rows = mapRows(builder, result.rows);
+    return new SyncResult(rows, result.changes);
+  }
+  /** Run `fn` inside a transaction: commit on success, rollback on throw. */
+  transaction(fn) {
+    this.driver.execute("BEGIN", []);
+    try {
+      const out = fn(this);
+      this.driver.execute("COMMIT", []);
+      return out;
+    } catch (error) {
+      this.driver.execute("ROLLBACK", []);
+      throw error;
+    }
+  }
+  /** Run `fn` inside a SAVEPOINT (nested transaction). */
+  beginNested(fn) {
+    savepointCounter += 1;
+    const name = `qsp_${savepointCounter}`;
+    this.driver.execute(`SAVEPOINT ${name}`, []);
+    try {
+      const out = fn(this);
+      this.driver.execute(`RELEASE ${name}`, []);
+      return out;
+    } catch (error) {
+      this.driver.execute(`ROLLBACK TO ${name}`, []);
+      throw error;
+    }
+  }
+  /**
+   * Lazily iterate result rows without materializing them all. Falls back to a
+   * buffered fetch when the driver has no native iteration.
+   */
+  *stream(builder) {
+    const node = builder.node;
+    const { sql: sql2, params } = this.dialect.compile(node);
+    if (this.driver.iterate) {
+      for (const raw of this.driver.iterate(sql2, params)) {
+        yield coerceOne(builder, raw);
+      }
+      return;
+    }
+    for (const raw of this.driver.execute(sql2, params).rows) {
+      yield coerceOne(builder, raw);
+    }
+  }
+  close() {
+    this.driver.close();
+  }
+};
+var AsyncSession = class {
+  constructor(driver, dialect) {
+    this.driver = driver;
+    this.dialect = dialect;
+  }
+  driver;
+  dialect;
+  execute(builder) {
+    const node = builder.node;
+    const { sql: sql2, params } = this.dialect.compile(node);
+    const inner = this.driver.execute(sql2, params).then((result) => {
+      const rows = mapRows(builder, result.rows);
+      return new SyncResult(rows, result.changes);
+    });
+    return new AsyncResult(inner);
+  }
+  /** Lazily iterate result rows. Uses driver streaming when available. */
+  async *stream(builder) {
+    const node = builder.node;
+    const { sql: sql2, params } = this.dialect.compile(node);
+    if (this.driver.iterate) {
+      for await (const raw of this.driver.iterate(sql2, params)) {
+        yield coerceOne(builder, raw);
+      }
+      return;
+    }
+    const result = await this.driver.execute(sql2, params);
+    for (const raw of result.rows) {
+      yield coerceOne(builder, raw);
+    }
+  }
+  async transaction(fn) {
+    await this.driver.execute("BEGIN", []);
+    try {
+      const out = await fn(this);
+      await this.driver.execute("COMMIT", []);
+      return out;
+    } catch (error) {
+      await this.driver.execute("ROLLBACK", []);
+      throw error;
+    }
+  }
+  async close() {
+    await this.driver.close();
+  }
+};
+var SyncEngine = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  driver;
+  dialect = "sqlite";
+  session() {
+    return new SyncSession(this.driver, getDialect("sqlite"));
+  }
+  transaction(fn) {
+    return this.session().transaction(fn);
+  }
+  close() {
+    this.driver.close();
+  }
+};
+var AsyncEngine = class {
+  constructor(driver, dialect) {
+    this.driver = driver;
+    this.dialect = dialect;
+  }
+  driver;
+  dialect;
+  session() {
+    return new AsyncSession(this.driver, getDialect(this.dialect));
+  }
+  transaction(fn) {
+    return this.session().transaction(fn);
+  }
+  async close() {
+    await this.driver.close();
+  }
+};
+function asAsync(driver) {
+  const syncIterate = driver.iterate?.bind(driver);
+  return {
+    execute: (sql2, params) => Promise.resolve(driver.execute(sql2, params)),
+    close: () => Promise.resolve(driver.close()),
+    ...syncIterate ? {
+      iterate: async function* (sql2, params) {
+        yield* syncIterate(sql2, params);
+      }
+    } : {}
+  };
+}
+function openSqliteDriver(path, _options) {
+  return NodeSqliteDriver.open(path);
+}
+function createSyncEngine(url, options) {
+  const parsed = parseDatabaseUrl(url);
+  if (parsed.dialect !== "sqlite") {
+    throw new Error(
+      `createSyncEngine supports only SQLite; ${parsed.dialect} is async-only \u2014 use createEngine.`
+    );
+  }
+  return new SyncEngine(openSqliteDriver(parsed.database ?? ":memory:"));
+}
+function createEngine(url, options) {
+  const parsed = parseDatabaseUrl(url);
+  if (parsed.dialect === "sqlite") {
+    return new AsyncEngine(
+      asAsync(openSqliteDriver(parsed.database ?? ":memory:")),
+      "sqlite"
+    );
+  }
+  return new AsyncEngine(createPostgresDriver(parsed.raw, options?.pool), "postgresql");
+}
+function createPostgresDriver(url, pool) {
+  let client;
+  const ensure = async () => {
+    if (client) return;
+    const moduleName = "postgres";
+    const mod = await import(
+      /* @vite-ignore */
+      moduleName
+    );
+    const opts = {};
+    if (pool?.size !== void 0) opts.max = pool.size;
+    if (pool?.idleTimeoutMs !== void 0)
+      opts.idle_timeout = Math.ceil(pool.idleTimeoutMs / 1e3);
+    if (pool?.connectTimeoutMs !== void 0) {
+      opts.connect_timeout = Math.ceil(pool.connectTimeoutMs / 1e3);
+    }
+    client = (mod.default ?? mod)(url, opts);
+  };
+  return {
+    async execute(sql2, params) {
+      await ensure();
+      const rows = await client.unsafe(sql2, params);
+      return {
+        rows: Array.from(rows),
+        changes: rows.count ?? rows.length
+      };
+    },
+    async close() {
+      if (client) await client.end();
+    }
+  };
+}
+
+// src/index.ts
+var DEFAULT_FLAGS = {
+  primaryKey: false,
+  notNull: false,
+  hasDefault: false
+};
+var sql = {
+  /** Current timestamp at insert (`CURRENT_TIMESTAMP` / `now()`). */
+  now: () => ({ kind: "expression", expression: "now" }),
+  /** Current date. */
+  currentDate: () => ({ kind: "expression", expression: "current_date" }),
+  /** Current time. */
+  currentTime: () => ({ kind: "expression", expression: "current_time" }),
+  /** A freshly generated UUID v4 (`gen_random_uuid()` / portable fallback). */
+  uuidv4: () => ({ kind: "expression", expression: "uuidv4" }),
+  /** Escape hatch: a verbatim SQL expression rendered as-is. */
+  raw: (expression) => ({
+    kind: "expression",
+    expression: { raw: expression }
+  })
+};
+function isDefaultValue(value) {
+  return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "expression");
+}
+var Column = class _Column {
+  constructor(type, flags, defaultValue = null, onUpdateValue = null) {
+    this.type = type;
+    this.flags = flags;
+    this.defaultValue = defaultValue;
+    this.onUpdateValue = onUpdateValue;
+  }
+  type;
+  flags;
+  defaultValue;
+  onUpdateValue;
+  primaryKey() {
+    return new _Column(
+      this.type,
+      { ...this.flags, primaryKey: true, hasDefault: true },
+      this.defaultValue,
+      this.onUpdateValue
+    );
+  }
+  notNull() {
+    return new _Column(
+      this.type,
+      { ...this.flags, notNull: true },
+      this.defaultValue,
+      this.onUpdateValue
+    );
+  }
+  /**
+   * Set the insert-time default: a constant value of type `T`, or a portable
+   * server-side expression from {@link sql} (e.g. `sql.now()`, `sql.uuidv4()`).
+   */
+  default(value) {
+    const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
+    return new _Column(
+      this.type,
+      { ...this.flags, hasDefault: true },
+      resolved,
+      this.onUpdateValue
+    );
+  }
+  /**
+   * Re-apply a value whenever the row is updated (e.g. an `updated_at` column
+   * with `sql.now()`). Mirrors SQLAlchemy's `onupdate`.
+   */
+  onUpdate(value) {
+    const resolved = isDefaultValue(value) ? value : { kind: "literal", value };
+    return new _Column(this.type, this.flags, this.defaultValue, resolved);
+  }
+};
+function makeColumn(kind, meta = {}) {
+  return new Column({ kind, meta }, DEFAULT_FLAGS);
+}
+var column = {
+  /** `SMALLINT` → `number`. */
+  smallInteger: () => makeColumn("smallint"),
+  /** `INTEGER` → `number`. */
+  integer: () => makeColumn("integer"),
+  /** `BIGINT` → `bigint` (64-bit precision preserved). */
+  bigInteger: () => makeColumn("bigint"),
+  /** `NUMERIC(precision, scale)` → `string` (exact decimal, no float loss). */
+  numeric: (precision, scale) => makeColumn("numeric", { precision, scale }),
+  /** Alias of {@link column.numeric}. */
+  decimal: (precision, scale) => makeColumn("numeric", { precision, scale }),
+  /** `REAL` → `number`. */
+  real: () => makeColumn("real"),
+  /** `DOUBLE PRECISION` → `number`. */
+  double: () => makeColumn("double"),
+  /** `VARCHAR(length)` → `string`. Distinct from {@link column.text}. */
+  varchar: (length) => makeColumn("varchar", { length }),
+  /** Alias of {@link column.varchar} (SQLAlchemy's `String`). */
+  string: (length) => makeColumn("varchar", { length }),
+  /** `CHAR(length)` → `string` (fixed-width). */
+  char: (length) => makeColumn("char", { length }),
+  /** `TEXT` → `string` (unbounded). Distinct from {@link column.varchar}. */
+  text: () => makeColumn("text"),
+  /** `BOOLEAN` → `boolean`. */
+  boolean: () => makeColumn("boolean"),
+  /** `DATE` → `Date`. */
+  date: () => makeColumn("date"),
+  /** `TIME` → `string`. Pass `{ timezone: true }` for `WITH TIME ZONE`. */
+  time: (options) => makeColumn("time", { withTimezone: options?.timezone }),
+  /**
+   * `DATETIME`/`TIMESTAMP` → `Date` (SQLAlchemy's generic `DateTime`). Pass
+   * `{ timezone: true }` for `WITH TIME ZONE`. Pair with `.default(sql.now())`
+   * and `.onUpdate(sql.now())` for managed `created_at`/`updated_at` columns.
+   */
+  datetime: (options) => makeColumn("datetime", { withTimezone: options?.timezone }),
+  /** `TIMESTAMP` → `Date` (SQL-specific). Pass `{ timezone: true }`. */
+  timestamp: (options) => makeColumn("timestamp", { withTimezone: options?.timezone }),
+  /** `BLOB`/`BYTEA` → `Uint8Array`. */
+  blob: () => makeColumn("blob"),
+  /** `JSON` → the given parsed value type `T` (defaults to `unknown`). */
+  json: () => makeColumn("json"),
+  /** `JSONB` (PostgreSQL) → the given parsed value type `T`. */
+  jsonb: () => makeColumn("json", { jsonb: true }),
+  /** `UUID` → `string`. */
+  uuid: () => makeColumn("uuid"),
+  /** `ENUM(...values)` → a string-literal union of the given values. */
+  enum: (...values) => makeColumn("enum", { values })
+};
+var Model = class {
+  static tablename;
+};
+function columnsOf(model) {
+  const instance = new model();
+  const out = {};
+  for (const [key, value] of Object.entries(instance)) {
+    if (value instanceof Column) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+export { AsyncEngine, AsyncResult, AsyncSession, BaseDialect, BaseRepository, Column, DeleteBuilder, InsertBuilder, InvalidDatabaseUrl, JoinBuilder, Model, NoResultError, NodeSqliteDriver, OPERATORS, PostgresDialect, RecordNotFound, SelectBuilder, SqliteDialect, SyncEngine, SyncResult, SyncSession, UpdateBuilder, ValidationError, and, belongsTo, column, columnsOf, createEngine, createSyncEngine, del, detectDialect, fromDict, getDialect, hasMany, insert, isCondition, join, loadRelations, not, or, parse, parseDatabaseUrl, select, sql, stringify, toCondNode, toDict, toJSON, update };
+//# sourceMappingURL=chunk-F36ZSQAN.js.map
+//# sourceMappingURL=chunk-F36ZSQAN.js.map