@mateusseiboth/ember-orm 0.1.0

package/dist/client/index.cjs

@@ -0,0 +1,2434 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  EmberClientBase: () => EmberClientBase,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/driver/firebird-driver.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_firebird = __toESM(require("node-firebird"), 1);
+
+// src/errors/index.ts
+var EmberError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var QueryValidationError = class extends EmberError {
+};
+var DatabaseError = class extends EmberError {
+  constructor(message, cause, sql) {
+    super(message);
+    this.cause = cause;
+    this.sql = sql;
+  }
+  cause;
+  sql;
+};
+var RecordNotFoundError = class extends EmberError {
+  constructor(model) {
+    super(`No '${model}' record found matching the given criteria.`);
+  }
+};
+
+// src/driver/firebird-driver.ts
+var fb = import_node_firebird.default;
+function isolationConstant(level) {
+  switch (level) {
+    case "READ_COMMITTED_READ_ONLY":
+      return fb.ISOLATION_READ_COMMITTED_READ_ONLY;
+    case "REPEATABLE_READ":
+      return fb.ISOLATION_REPEATABLE_READ;
+    case "SERIALIZABLE":
+      return fb.ISOLATION_SERIALIZABLE;
+    case "READ_COMMITTED":
+    default:
+      return fb.ISOLATION_READ_COMMITTED;
+  }
+}
+var FirebirdDriver = class {
+  pool = null;
+  options;
+  poolMax;
+  onQuery;
+  activeTx = new import_node_async_hooks.AsyncLocalStorage();
+  constructor(config, driverOptions) {
+    this.poolMax = config.poolMax ?? 5;
+    this.onQuery = driverOptions?.onQuery;
+    this.options = {
+      host: config.host,
+      port: config.port,
+      database: config.database,
+      user: config.user,
+      password: config.password,
+      role: config.role ?? "",
+      pageSize: config.pageSize ?? 4096,
+      encoding: config.encoding ?? "UTF8",
+      blobAsText: config.blobAsText ?? true,
+      lowercase_keys: config.lowercaseKeys ?? false,
+      retryConnectionInterval: 1e3,
+      // FB3+ secure auth (Srp) is negotiated by default; set explicitly to force
+      // a plugin, or "Legacy_Auth" for Firebird 2.1/2.5 servers.
+      ...config.authPlugin ? { pluginName: config.authPlugin } : {},
+      ...config.wireCompression != null ? { wireCompression: config.wireCompression } : {}
+    };
+  }
+  async connect() {
+    if (this.pool) return;
+    this.pool = fb.pool(this.poolMax, this.options);
+  }
+  async disconnect() {
+    if (!this.pool) return;
+    this.pool.destroy();
+    this.pool = null;
+  }
+  async transaction(fn, options) {
+    const existing = this.activeTx.getStore();
+    if (existing) {
+      return fn(existing);
+    }
+    await this.connect();
+    const db = await this.acquire();
+    const tr = await this.begin(db, options?.isolation);
+    const ctx = {
+      query: (sql, params) => this.runOnTransaction(tr, sql, params)
+    };
+    try {
+      const result = await this.activeTx.run(ctx, () => fn(ctx));
+      await this.commit(tr);
+      return result;
+    } catch (err) {
+      await this.safeRollback(tr);
+      throw err;
+    } finally {
+      db.detach();
+    }
+  }
+  // ---- promise wrappers over node-firebird -------------------------------
+  acquire() {
+    return new Promise((resolve2, reject) => {
+      this.pool.get((err, db) => {
+        if (err) return reject(wrap(err, "Failed to acquire connection"));
+        resolve2(db);
+      });
+    });
+  }
+  begin(db, isolation) {
+    return new Promise((resolve2, reject) => {
+      db.transaction(isolationConstant(isolation), (err, tr) => {
+        if (err) return reject(wrap(err, "Failed to start transaction"));
+        resolve2(tr);
+      });
+    });
+  }
+  runOnTransaction(tr, sql, params = []) {
+    const start = this.onQuery ? performance.now() : 0;
+    return new Promise((resolve2, reject) => {
+      tr.query(sql, [...params], (err, result) => {
+        if (err) return reject(wrap(err, "Query failed", sql));
+        const rows = normalizeRows(result);
+        if (this.onQuery) {
+          this.onQuery({
+            sql,
+            params,
+            durationMs: performance.now() - start,
+            rowCount: rows.length
+          });
+        }
+        resolve2(rows);
+      });
+    });
+  }
+  commit(tr) {
+    return new Promise((resolve2, reject) => {
+      tr.commit((err) => {
+        if (err) return reject(wrap(err, "Failed to commit transaction"));
+        resolve2();
+      });
+    });
+  }
+  safeRollback(tr) {
+    return new Promise((resolve2) => {
+      tr.rollback(() => resolve2());
+    });
+  }
+};
+function normalizeRows(result) {
+  if (Array.isArray(result)) return result;
+  if (result === void 0 || result === null) return [];
+  return [result];
+}
+function wrap(err, message, sql) {
+  const detail = err && typeof err === "object" && "message" in err ? String(err.message) : String(err);
+  return new DatabaseError(`${message}: ${detail}`, err, sql);
+}
+
+// src/driver/url.ts
+function parseConnectionUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new EmberError(`Invalid Firebird connection URL: ${url}`);
+  }
+  if (!/^firebird:?$/.test(parsed.protocol.replace(":", "") + ":")) {
+    if (parsed.protocol !== "firebird:") {
+      throw new EmberError(
+        `Unsupported protocol '${parsed.protocol}'. Expected 'firebird:'.`
+      );
+    }
+  }
+  const database = normalizeDatabasePath(parsed.pathname);
+  if (!database) {
+    throw new EmberError(`Connection URL is missing a database path: ${url}`);
+  }
+  const params = parsed.searchParams;
+  const config = {
+    host: parsed.hostname || "127.0.0.1",
+    port: parsed.port ? Number(parsed.port) : 3050,
+    database,
+    user: decodeURIComponent(parsed.username || "SYSDBA"),
+    password: decodeURIComponent(parsed.password || "masterkey"),
+    encoding: params.get("encoding") ?? "UTF8"
+  };
+  const role = params.get("role");
+  if (role) config.role = role;
+  const poolMax = params.get("poolMax") ?? params.get("connection_limit");
+  if (poolMax) config.poolMax = Number(poolMax);
+  const pageSize = params.get("pageSize");
+  if (pageSize) config.pageSize = Number(pageSize);
+  const auth = (params.get("authPlugin") ?? params.get("auth"))?.toLowerCase();
+  if (auth === "legacy" || auth === "legacy_auth") config.authPlugin = "Legacy_Auth";
+  else if (auth === "srp") config.authPlugin = "Srp";
+  const wireCompression = params.get("wireCompression");
+  if (wireCompression != null) {
+    config.wireCompression = wireCompression !== "false" && wireCompression !== "0";
+  }
+  const version = params.get("version");
+  if (version) config.version = normalizeVersion(version);
+  return config;
+}
+var VERSIONS = /* @__PURE__ */ new Set(["2.1", "2.5", "3", "4", "5"]);
+function normalizeVersion(raw) {
+  const trimmed = raw.trim();
+  if (VERSIONS.has(trimmed)) return trimmed;
+  if (/^2\.1/.test(trimmed)) return "2.1";
+  if (/^2\.5/.test(trimmed)) return "2.5";
+  const major = trimmed.split(".")[0];
+  if (major && VERSIONS.has(major)) return major;
+  return void 0;
+}
+function normalizeDatabasePath(pathname) {
+  let p = decodeURIComponent(pathname);
+  if (p.startsWith("//")) p = p.slice(1);
+  if (/^\/[A-Za-z]:\//.test(p)) p = p.slice(1);
+  return p;
+}
+
+// src/driver/index.ts
+function createDriver(source, options) {
+  const config = typeof source === "string" ? parseConnectionUrl(source) : source;
+  return new FirebirdDriver(config, options);
+}
+
+// src/sql/fragment.ts
+var Sql = class _Sql {
+  parts = [];
+  params = [];
+  static raw(text) {
+    return new _Sql().push(text);
+  }
+  static value(value) {
+    return new _Sql().bind(value);
+  }
+  static join(fragments, separator) {
+    const out = new _Sql();
+    fragments.forEach((frag, i) => {
+      if (i > 0) out.push(separator);
+      out.append(frag);
+    });
+    return out;
+  }
+  /** Append raw, trusted SQL text (keywords, already-escaped identifiers). */
+  push(text) {
+    this.parts.push(text);
+    return this;
+  }
+  /** Append a `?` placeholder bound to `value`. */
+  bind(value) {
+    this.parts.push("?");
+    this.params.push(value);
+    return this;
+  }
+  /** Append a comma-separated list of placeholders bound to `values`. */
+  bindList(values) {
+    this.parts.push(values.map(() => "?").join(", "));
+    this.params.push(...values);
+    return this;
+  }
+  /** Merge another fragment (text + params) into this one. */
+  append(other) {
+    this.parts.push(other.text);
+    this.params.push(...other.params);
+    return this;
+  }
+  get text() {
+    return this.parts.join("");
+  }
+  isEmpty() {
+    return this.text.trim().length === 0;
+  }
+  toQuery() {
+    return { sql: this.text, params: this.params };
+  }
+};
+
+// src/sql/dialect.ts
+var FirebirdDialect = class {
+  supportsReturning = true;
+  version;
+  supportsBooleanType;
+  supportsIdentity;
+  supportsWindowFunctions;
+  constructor(options = {}) {
+    this.version = options.version ?? "3";
+    const rank = versionRank(this.version);
+    this.supportsBooleanType = rank >= 30;
+    this.supportsIdentity = rank >= 30;
+    this.supportsWindowFunctions = rank >= 30;
+  }
+  booleanColumnType() {
+    return this.supportsBooleanType ? "BOOLEAN" : "SMALLINT";
+  }
+  quoteId(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+  }
+  quoteRef(table, column) {
+    return `${this.quoteId(table)}.${this.quoteId(column)}`;
+  }
+  paginationClause(take, skip) {
+    const parts = [];
+    if (typeof take === "number" && take >= 0) {
+      parts.push(`FIRST ${Math.trunc(take)}`);
+    }
+    if (typeof skip === "number" && skip > 0) {
+      parts.push(`SKIP ${Math.trunc(skip)}`);
+    }
+    return parts.join(" ");
+  }
+  caseInsensitive(expr) {
+    return `UPPER(${expr})`;
+  }
+  defaultFunctionSql(name) {
+    switch (name) {
+      case "now":
+        return "CURRENT_TIMESTAMP";
+      case "uuid":
+      case "cuid":
+        return "UUID_TO_CHAR(GEN_UUID())";
+      case "autoincrement":
+        return null;
+      // handled via generators/identity, not an inline default
+      default:
+        return null;
+    }
+  }
+  coerceValue(value) {
+    if (value === null || value === void 0) return null;
+    if (value instanceof Date) return value;
+    if (Buffer.isBuffer(value)) return value;
+    if (typeof value === "boolean") {
+      return this.supportsBooleanType ? value : value ? 1 : 0;
+    }
+    if (typeof value === "bigint") return value;
+    if (typeof value === "number") return value;
+    if (typeof value === "string") return value;
+    return JSON.stringify(value);
+  }
+};
+function versionRank(version) {
+  switch (version) {
+    case "2.1":
+      return 21;
+    case "2.5":
+      return 25;
+    case "3":
+      return 30;
+    case "4":
+      return 40;
+    case "5":
+      return 50;
+    default:
+      return 30;
+  }
+}
+
+// src/ast/index.ts
+function findModel(schema, name) {
+  return schema.models.find((m) => m.name === name);
+}
+function fieldColumn(field) {
+  return field.dbName ?? field.name.toUpperCase();
+}
+function modelTable(model) {
+  return model.dbName ?? model.name.toUpperCase();
+}
+function scalarFields(model) {
+  return model.fields.filter((f) => f.kind !== "object");
+}
+function relationFields(model) {
+  return model.fields.filter((f) => f.kind === "object");
+}
+function idFields(model) {
+  if (model.primaryKey.length > 0) {
+    return model.primaryKey.map((n) => model.fields.find((f) => f.name === n)).filter((f) => !!f);
+  }
+  return model.fields.filter((f) => f.isId);
+}
+
+// src/utils/index.ts
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Date) && !Buffer.isBuffer(v);
+}
+function uniq(items) {
+  return [...new Set(items)];
+}
+function lowerFirst(input) {
+  return input.charAt(0).toLowerCase() + input.slice(1);
+}
+
+// src/query/order.ts
+function compileOrderBy(model, tableAlias, orderBy, dialect) {
+  if (!orderBy) return new Sql();
+  const entries = normalize(orderBy);
+  if (entries.length === 0) return new Sql();
+  const parts = entries.map(([fieldName, dir]) => {
+    const field = model.fields.find((f) => f.name === fieldName);
+    if (!field || field.kind === "object") {
+      throw new QueryValidationError(
+        `Cannot order '${model.name}' by '${fieldName}'.`
+      );
+    }
+    const ref = dialect.quoteRef(tableAlias, fieldColumn(field));
+    return Sql.raw(`${ref} ${dir === "desc" ? "DESC" : "ASC"}`);
+  });
+  return Sql.join(parts, ", ");
+}
+function normalize(orderBy) {
+  const list = Array.isArray(orderBy) ? orderBy : [orderBy];
+  const out = [];
+  for (const obj of list) {
+    for (const [key, value] of Object.entries(obj)) {
+      if (value === "asc" || value === "desc") out.push([key, value]);
+    }
+  }
+  return out;
+}
+
+// src/query/relations.ts
+function resolveRelation(schema, model, field) {
+  if (field.kind !== "object") {
+    throw new QueryValidationError(
+      `Field '${model.name}.${field.name}' is not a relation.`
+    );
+  }
+  const relatedModel = findModel(schema, field.type);
+  if (!relatedModel) {
+    throw new QueryValidationError(
+      `Relation '${model.name}.${field.name}' points to unknown model '${field.type}'.`
+    );
+  }
+  if (field.relation?.fields?.length) {
+    const fromFields2 = field.relation.fields;
+    const toFields2 = field.relation.references ?? idFields(relatedModel).map((f) => f.name);
+    return build(field, model, relatedModel, fromFields2, toFields2, true);
+  }
+  const partner = findPartnerField(schema, model, field, relatedModel);
+  if (partner?.relation?.fields?.length) {
+    const toFields2 = partner.relation.fields;
+    const fromFields2 = partner.relation.references ?? idFields(model).map((f) => f.name);
+    return build(field, model, relatedModel, fromFields2, toFields2, false);
+  }
+  const fromFields = idFields(model).map((f) => f.name);
+  const toFields = idFields(relatedModel).map((f) => f.name);
+  return build(field, model, relatedModel, fromFields, toFields, false);
+}
+function build(field, model, relatedModel, fromFields, toFields, owns) {
+  return {
+    field,
+    relatedModel,
+    fromFields,
+    toFields,
+    fromColumns: fromFields.map((n) => columnOf(model, n)),
+    toColumns: toFields.map((n) => columnOf(relatedModel, n)),
+    isList: field.isList,
+    owns
+  };
+}
+function columnOf(model, fieldName) {
+  const f = model.fields.find((x) => x.name === fieldName);
+  if (!f) {
+    throw new QueryValidationError(
+      `Field '${fieldName}' not found on model '${model.name}'.`
+    );
+  }
+  return fieldColumn(f);
+}
+function findPartnerField(_schema, model, field, relatedModel) {
+  const candidates = relatedModel.fields.filter(
+    (f) => f.kind === "object" && f.type === model.name
+  );
+  if (field.relation?.name) {
+    const byName = candidates.find(
+      (f) => f.relation?.name === field.relation?.name
+    );
+    if (byName) return byName;
+  }
+  const owning = candidates.find((f) => f.relation?.fields?.length);
+  return owning ?? candidates[0];
+}
+
+// src/query/where.ts
+var SCALAR_OPERATORS = /* @__PURE__ */ new Set([
+  "equals",
+  "not",
+  "in",
+  "notIn",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "mode"
+]);
+function compileWhere(model, tableAlias, where, ctx) {
+  if (!where || Object.keys(where).length === 0) return new Sql();
+  const conditions = [];
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) continue;
+    if (key === "AND") {
+      conditions.push(combineList(asArray(value), model, tableAlias, ctx, "AND"));
+      continue;
+    }
+    if (key === "OR") {
+      conditions.push(combineList(asArray(value), model, tableAlias, ctx, "OR"));
+      continue;
+    }
+    if (key === "NOT") {
+      const inner = combineList(asArray(value), model, tableAlias, ctx, "AND");
+      if (!inner.isEmpty()) {
+        conditions.push(new Sql().push("NOT (").append(inner).push(")"));
+      }
+      continue;
+    }
+    const field = model.fields.find((f) => f.name === key);
+    if (!field) {
+      throw new QueryValidationError(
+        `Unknown field '${key}' in where clause of model '${model.name}'.`
+      );
+    }
+    if (field.kind === "object") {
+      conditions.push(
+        compileRelationFilter(model, tableAlias, field, value, ctx)
+      );
+    } else {
+      conditions.push(compileScalar(tableAlias, field, value, ctx));
+    }
+  }
+  const nonEmpty = conditions.filter((c) => !c.isEmpty());
+  if (nonEmpty.length === 0) return new Sql();
+  return wrapAnd(nonEmpty);
+}
+function combineList(list, model, tableAlias, ctx, op) {
+  const parts = list.map((w) => compileWhere(model, tableAlias, w, ctx)).filter((p) => !p.isEmpty());
+  if (parts.length === 0) return new Sql();
+  if (parts.length === 1) return parts[0];
+  const joined = Sql.join(
+    parts.map((p) => new Sql().push("(").append(p).push(")")),
+    ` ${op} `
+  );
+  return new Sql().push("(").append(joined).push(")");
+}
+function wrapAnd(parts) {
+  if (parts.length === 1) return parts[0];
+  const joined = Sql.join(
+    parts.map((p) => new Sql().push("(").append(p).push(")")),
+    " AND "
+  );
+  return new Sql().push("(").append(joined).push(")");
+}
+function compileScalar(tableAlias, field, value, ctx) {
+  const ref = ctx.dialect.quoteRef(tableAlias, fieldColumn(field));
+  if (field.type === "Json" && isJsonFilterObject(value)) {
+    return compileJsonFilter(ref, field, value, ctx);
+  }
+  if (!isFilterObject(value)) {
+    if (value === null) return Sql.raw(`${ref} IS NULL`);
+    return new Sql().push(`${ref} = `).bind(ctx.dialect.coerceValue(value));
+  }
+  const filter = value;
+  const insensitive = filter.mode === "insensitive";
+  const parts = [];
+  for (const [op, opValue] of Object.entries(filter)) {
+    if (op === "mode") continue;
+    if (opValue === void 0) continue;
+    parts.push(compileOperator(ref, op, opValue, insensitive, ctx));
+  }
+  if (parts.length === 0) return new Sql();
+  return wrapAnd(parts);
+}
+var JSON_OPERATORS = /* @__PURE__ */ new Set([
+  "equals",
+  "not",
+  "string_contains",
+  "string_starts_with",
+  "string_ends_with",
+  "path"
+]);
+function isJsonFilterObject(value) {
+  return isPlainObject(value) && Object.keys(value).some((k) => JSON_OPERATORS.has(k));
+}
+function compileJsonFilter(ref, field, filter, ctx) {
+  const parts = [];
+  for (const [op, raw] of Object.entries(filter)) {
+    if (raw === void 0) continue;
+    switch (op) {
+      case "path":
+        throw new QueryValidationError(
+          `JSON 'path' filtering is not supported on Firebird (no JSON SQL functions). Filter '${field.name}' in application code or with a generated column.`
+        );
+      case "equals":
+        parts.push(
+          raw === null ? Sql.raw(`${ref} IS NULL`) : new Sql().push(`${ref} = `).bind(jsonText(raw))
+        );
+        break;
+      case "not":
+        parts.push(
+          raw === null ? Sql.raw(`${ref} IS NOT NULL`) : new Sql().push(`${ref} <> `).bind(jsonText(raw))
+        );
+        break;
+      case "string_contains":
+        parts.push(jsonLike(ref, `%${escapeLike(String(raw))}%`));
+        break;
+      case "string_starts_with":
+        parts.push(jsonLike(ref, `${escapeLike(String(raw))}%`));
+        break;
+      case "string_ends_with":
+        parts.push(jsonLike(ref, `%${escapeLike(String(raw))}`));
+        break;
+      default:
+        throw new QueryValidationError(`Unsupported JSON filter operator '${op}'.`);
+    }
+  }
+  return parts.length ? wrapAnd(parts) : new Sql();
+}
+function jsonText(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function jsonLike(ref, pattern) {
+  return new Sql().push(`${ref} LIKE `).bind(pattern).push(" ESCAPE '\\'");
+}
+function compileOperator(ref, op, value, insensitive, ctx) {
+  const d = ctx.dialect;
+  const bound = (v) => d.coerceValue(v);
+  const lhs = insensitive ? d.caseInsensitive(ref) : ref;
+  const rhs = (v) => insensitive && typeof v === "string" ? new Sql().push("UPPER(").bind(bound(v)).push(")") : Sql.value(bound(v));
+  switch (op) {
+    case "equals":
+      if (value === null) return Sql.raw(`${ref} IS NULL`);
+      return new Sql().push(`${lhs} = `).append(rhs(value));
+    case "not":
+      if (value === null) return Sql.raw(`${ref} IS NOT NULL`);
+      if (isFilterObject(value)) {
+        const inner = compileScalarFromRef(ref, value, insensitive, ctx);
+        return new Sql().push("NOT (").append(inner).push(")");
+      }
+      return new Sql().push(`${lhs} <> `).append(rhs(value));
+    case "in":
+      return inClause(lhs, asUnknownArray(value), insensitive, ctx, false);
+    case "notIn":
+      return inClause(lhs, asUnknownArray(value), insensitive, ctx, true);
+    case "lt":
+      return new Sql().push(`${lhs} < `).append(rhs(value));
+    case "lte":
+      return new Sql().push(`${lhs} <= `).append(rhs(value));
+    case "gt":
+      return new Sql().push(`${lhs} > `).append(rhs(value));
+    case "gte":
+      return new Sql().push(`${lhs} >= `).append(rhs(value));
+    case "contains":
+      return likeClause(lhs, `%${escapeLike(String(value))}%`, insensitive);
+    case "startsWith":
+      return likeClause(lhs, `${escapeLike(String(value))}%`, insensitive);
+    case "endsWith":
+      return likeClause(lhs, `%${escapeLike(String(value))}`, insensitive);
+    default:
+      throw new QueryValidationError(`Unsupported filter operator '${op}'.`);
+  }
+}
+function compileScalarFromRef(ref, filter, insensitive, ctx) {
+  const parts = [];
+  for (const [op, opValue] of Object.entries(filter)) {
+    if (op === "mode" || opValue === void 0) continue;
+    parts.push(compileOperator(ref, op, opValue, insensitive, ctx));
+  }
+  return parts.length ? wrapAnd(parts) : new Sql();
+}
+function inClause(lhs, values, insensitive, ctx, negate) {
+  if (values.length === 0) {
+    return Sql.raw(negate ? "1 = 1" : "1 = 0");
+  }
+  const coerced = values.map(
+    (v) => insensitive && typeof v === "string" ? String(v).toUpperCase() : ctx.dialect.coerceValue(v)
+  );
+  const sql = new Sql().push(`${lhs} ${negate ? "NOT IN" : "IN"} (`);
+  sql.bindList(coerced);
+  sql.push(")");
+  return sql;
+}
+function likeClause(lhs, pattern, insensitive) {
+  const value = insensitive ? pattern.toUpperCase() : pattern;
+  return new Sql().push(`${lhs} LIKE `).bind(value).push(" ESCAPE '\\'");
+}
+function compileRelationFilter(model, tableAlias, field, value, ctx) {
+  const rel = resolveRelation(ctx.schema, model, field);
+  const filter = isPlainObject(value) ? value : {};
+  const hasOperator = "some" in filter || "every" in filter || "none" in filter || "is" in filter || "isNot" in filter;
+  if (!rel.isList && !hasOperator) {
+    return existsClause(model, tableAlias, rel, value, ctx, false);
+  }
+  const parts = [];
+  if (filter.some !== void 0) {
+    parts.push(existsClause(model, tableAlias, rel, filter.some ?? {}, ctx, false));
+  }
+  if (filter.none !== void 0) {
+    parts.push(existsClause(model, tableAlias, rel, filter.none ?? {}, ctx, true));
+  }
+  if (filter.every !== void 0) {
+    parts.push(
+      existsClause(model, tableAlias, rel, filter.every ?? {}, ctx, true, true)
+    );
+  }
+  if (filter.is !== void 0) {
+    if (filter.is === null) {
+      parts.push(notExists(model, tableAlias, rel, {}, ctx));
+    } else {
+      parts.push(existsClause(model, tableAlias, rel, filter.is, ctx, false));
+    }
+  }
+  if (filter.isNot !== void 0) {
+    if (filter.isNot === null) {
+      parts.push(existsClause(model, tableAlias, rel, {}, ctx, false));
+    } else {
+      parts.push(existsClause(model, tableAlias, rel, filter.isNot, ctx, true));
+    }
+  }
+  return parts.length ? wrapAnd(parts) : new Sql();
+}
+function notExists(model, tableAlias, rel, sub, ctx) {
+  return existsClause(model, tableAlias, rel, sub, ctx, true);
+}
+function existsClause(_model, tableAlias, rel, sub, ctx, negate, everyMode = false) {
+  const childAlias = `r${ctx.alias.next++}`;
+  const childTable = ctx.dialect.quoteId(modelTable(rel.relatedModel));
+  const sql = new Sql();
+  sql.push(`${negate ? "NOT EXISTS" : "EXISTS"} (SELECT 1 FROM ${childTable} ${ctx.dialect.quoteId(childAlias)} WHERE `);
+  const joins = rel.fromColumns.map((fromCol, i) => {
+    const toCol = rel.toColumns[i];
+    return `${ctx.dialect.quoteRef(childAlias, toCol)} = ${ctx.dialect.quoteRef(tableAlias, fromCol)}`;
+  });
+  sql.push(joins.join(" AND "));
+  const subSql = compileWhere(rel.relatedModel, childAlias, sub, ctx);
+  if (!subSql.isEmpty()) {
+    if (everyMode) {
+      sql.push(" AND NOT (").append(subSql).push(")");
+    } else {
+      sql.push(" AND ").append(subSql);
+    }
+  }
+  sql.push(")");
+  return sql;
+}
+function isFilterObject(value) {
+  if (!isPlainObject(value)) return false;
+  return Object.keys(value).some((k) => SCALAR_OPERATORS.has(k));
+}
+function asArray(value) {
+  const list = Array.isArray(value) ? value : [value];
+  return list.filter(
+    (v) => v !== null && typeof v === "object"
+  );
+}
+function asUnknownArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function escapeLike(input) {
+  return input.replace(/[\\%_]/g, (c) => `\\${c}`);
+}
+
+// src/query/having.ts
+var AGG_FN = {
+  _count: "COUNT",
+  _sum: "SUM",
+  _avg: "AVG",
+  _min: "MIN",
+  _max: "MAX"
+};
+var COMPARATORS = {
+  equals: "=",
+  not: "<>",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+function compileHaving(model, alias, having, ctx) {
+  if (!having || Object.keys(having).length === 0) return new Sql();
+  const parts = [];
+  for (const [key, value] of Object.entries(having)) {
+    if (value === void 0) continue;
+    if (key === "AND" || key === "OR") {
+      const list = Array.isArray(value) ? value : [value];
+      const compiled = list.map((w) => compileHaving(model, alias, w, ctx)).filter((s) => !s.isEmpty());
+      if (compiled.length) parts.push(joinBool(compiled, key));
+      continue;
+    }
+    if (key === "NOT") {
+      const inner = compileHaving(model, alias, value, ctx);
+      if (!inner.isEmpty()) parts.push(new Sql().push("NOT (").append(inner).push(")"));
+      continue;
+    }
+    if (key in AGG_FN) {
+      parts.push(...aggregateConditions(model, alias, key, value, ctx));
+      continue;
+    }
+    const field = model.fields.find((f) => f.name === key && f.kind !== "object");
+    if (!field) {
+      throw new QueryValidationError(
+        `Unknown having field '${model.name}.${key}'.`
+      );
+    }
+    if (isAggregateWrapper(value)) {
+      const ref = ctx.dialect.quoteRef(alias, fieldColumn(field));
+      for (const [agg, filter] of Object.entries(value)) {
+        if (!(agg in AGG_FN)) continue;
+        parts.push(comparison(`${AGG_FN[agg]}(${ref})`, filter, ctx.dialect));
+      }
+    } else {
+      const cond = compileWhere(model, alias, { [key]: value }, ctx);
+      if (!cond.isEmpty()) parts.push(cond);
+    }
+  }
+  const nonEmpty = parts.filter((p) => !p.isEmpty());
+  if (nonEmpty.length === 0) return new Sql();
+  return joinBool(nonEmpty, "AND");
+}
+function aggregateConditions(model, alias, agg, spec, ctx) {
+  if (!isPlainObject(spec)) return [];
+  const out = [];
+  for (const [fieldName, filter] of Object.entries(spec)) {
+    const field = model.fields.find((f) => f.name === fieldName && f.kind !== "object");
+    if (!field) continue;
+    const ref = ctx.dialect.quoteRef(alias, fieldColumn(field));
+    out.push(comparison(`${AGG_FN[agg]}(${ref})`, filter, ctx.dialect));
+  }
+  return out;
+}
+function comparison(lhs, filter, dialect) {
+  if (!isPlainObject(filter)) {
+    return new Sql().push(`${lhs} = `).bind(dialect.coerceValue(filter));
+  }
+  const parts = [];
+  for (const [op, v] of Object.entries(filter)) {
+    const sqlOp = COMPARATORS[op];
+    if (!sqlOp) {
+      throw new QueryValidationError(`Unsupported having operator '${op}'.`);
+    }
+    parts.push(new Sql().push(`${lhs} ${sqlOp} `).bind(dialect.coerceValue(v)));
+  }
+  return parts.length === 1 ? parts[0] : joinBool(parts, "AND");
+}
+function isAggregateWrapper(value) {
+  return isPlainObject(value) && Object.keys(value).some((k) => k in AGG_FN);
+}
+function joinBool(parts, op) {
+  if (parts.length === 1) return parts[0];
+  const joined = Sql.join(
+    parts.map((p) => new Sql().push("(").append(p).push(")")),
+    ` ${op} `
+  );
+  return new Sql().push("(").append(joined).push(")");
+}
+
+// src/query/compiler.ts
+function setAssignments(values) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [col, value] of values) out.set(col, { kind: "set", value });
+  return out;
+}
+var ROOT_ALIAS = "t0";
+function newContext(schema, dialect) {
+  return { schema, dialect, alias: { next: 1 } };
+}
+function compileFindMany(model, options, projection, ctx) {
+  const d = ctx.dialect;
+  const cols = projection.map(
+    (f) => `${d.quoteRef(ROOT_ALIAS, fieldColumn(f))} AS ${d.quoteId(f.name)}`
+  );
+  const sql = new Sql();
+  const pagination = d.paginationClause(options.take, options.skip);
+  sql.push(pagination ? `SELECT ${pagination} ` : "SELECT ");
+  sql.push(cols.join(", "));
+  sql.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`);
+  appendWhere(sql, model, options.where, ctx);
+  const order = compileOrderBy(model, ROOT_ALIAS, options.orderBy, d);
+  if (!order.isEmpty()) sql.push(" ORDER BY ").append(order);
+  return { sql, columns: projection };
+}
+function compileDistinctFindMany(model, options, projection, distinctFields, ctx) {
+  const d = ctx.dialect;
+  const innerOrder = options.orderBy ? compileOrderBy(model, ROOT_ALIAS, options.orderBy, d) : defaultOrder(model, d);
+  const partitionBy = distinctFields.map((f) => d.quoteRef(ROOT_ALIAS, fieldColumn(f))).join(", ");
+  const inner = new Sql();
+  const innerCols = projection.map(
+    (f) => `${d.quoteRef(ROOT_ALIAS, fieldColumn(f))} AS ${d.quoteId(f.name)}`
+  );
+  inner.push(`SELECT ${innerCols.join(", ")}, ROW_NUMBER() OVER (PARTITION BY ${partitionBy} ORDER BY `);
+  inner.append(innerOrder);
+  inner.push(`) AS ${d.quoteId("__rn")}`);
+  inner.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`);
+  appendWhere(inner, model, options.where, ctx);
+  const sql = new Sql();
+  const pagination = d.paginationClause(options.take, options.skip);
+  const sub = "sub";
+  const outerCols = projection.map((f) => `${d.quoteRef(sub, f.name)} AS ${d.quoteId(f.name)}`).join(", ");
+  sql.push(pagination ? `SELECT ${pagination} ` : "SELECT ");
+  sql.push(outerCols);
+  sql.push(` FROM (`).append(inner).push(`) ${d.quoteId(sub)}`);
+  sql.push(` WHERE ${d.quoteRef(sub, "__rn")} = 1`);
+  const outerOrder = outerOrderBy(model, sub, options.orderBy, d);
+  if (!outerOrder.isEmpty()) sql.push(" ORDER BY ").append(outerOrder);
+  return { sql, columns: projection };
+}
+function compileCount(model, where, ctx, pagination) {
+  const d = ctx.dialect;
+  const sql = new Sql();
+  const clause = pagination ? d.paginationClause(pagination.take, pagination.skip) : "";
+  sql.push(clause ? `SELECT ${clause} COUNT(*) AS "_count"` : `SELECT COUNT(*) AS "_count"`);
+  sql.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`);
+  appendWhere(sql, model, where, ctx);
+  return sql;
+}
+function compileAggregate(model, args, ctx) {
+  const d = ctx.dialect;
+  const selects = aggregateSelections(model, args, d);
+  if (selects.length === 0) {
+    throw new QueryValidationError("Aggregate requires at least one operator.");
+  }
+  const sql = new Sql();
+  sql.push(`SELECT ${selects.join(", ")}`);
+  sql.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`);
+  appendWhere(sql, model, args.where, ctx);
+  return sql;
+}
+function compileGroupBy(model, args, ctx) {
+  const d = ctx.dialect;
+  const groupColumns = args.by.map((name) => requireScalar(model, name));
+  const groupSelects = groupColumns.map(
+    (f) => `${d.quoteRef(ROOT_ALIAS, fieldColumn(f))} AS ${d.quoteId(f.name)}`
+  );
+  const aggSelects = aggregateSelections(model, args, d);
+  const sql = new Sql();
+  sql.push(`SELECT ${[...groupSelects, ...aggSelects].join(", ")}`);
+  sql.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`);
+  appendWhere(sql, model, args.where, ctx);
+  sql.push(
+    ` GROUP BY ${groupColumns.map((f) => d.quoteRef(ROOT_ALIAS, fieldColumn(f))).join(", ")}`
+  );
+  const having = compileHaving(model, ROOT_ALIAS, args.having, ctx);
+  if (!having.isEmpty()) sql.push(" HAVING ").append(having);
+  const order = compileOrderBy(model, ROOT_ALIAS, args.orderBy, d);
+  if (!order.isEmpty()) sql.push(" ORDER BY ").append(order);
+  return { sql, groupColumns };
+}
+function compileInsert(model, row, ctx, returning) {
+  const d = ctx.dialect;
+  const sql = new Sql();
+  const columns = [...row.keys()];
+  sql.push(`INSERT INTO ${d.quoteId(modelTable(model))} (`);
+  sql.push(columns.map((c) => d.quoteId(c)).join(", "));
+  sql.push(") VALUES (");
+  sql.bindList(columns.map((c) => row.get(c)));
+  sql.push(")");
+  appendReturning(sql, d, returning);
+  return { sql, columns: returning };
+}
+function compileUpdate(model, where, assignments, ctx, returning) {
+  const d = ctx.dialect;
+  if (assignments.size === 0) {
+    throw new QueryValidationError("Update requires at least one field to set.");
+  }
+  const sql = new Sql();
+  sql.push(`UPDATE ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)} SET `);
+  const cols = [...assignments.keys()];
+  cols.forEach((col, i) => {
+    if (i > 0) sql.push(", ");
+    const assignment = assignments.get(col);
+    const quoted = d.quoteId(col);
+    if (assignment.kind === "arith") {
+      sql.push(`${quoted} = ${quoted} ${assignment.op} `).bind(assignment.value);
+    } else {
+      sql.push(`${quoted} = `).bind(assignment.value);
+    }
+  });
+  appendWhere(sql, model, where, ctx);
+  if (returning) appendReturning(sql, d, returning);
+  return { sql, columns: returning ?? [] };
+}
+function compileDelete(model, where, ctx, returning) {
+  const d = ctx.dialect;
+  const sql = new Sql();
+  sql.push(
+    `DELETE FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`
+  );
+  appendWhere(sql, model, where, ctx);
+  if (returning) appendReturning(sql, d, returning);
+  return { sql, columns: returning ?? [] };
+}
+function appendWhere(sql, model, where, ctx) {
+  const compiled = compileWhere(model, ROOT_ALIAS, where, ctx);
+  if (!compiled.isEmpty()) sql.push(" WHERE ").append(compiled);
+}
+function defaultOrder(model, d) {
+  const ids = idFields(model);
+  const cols = (ids.length ? ids : model.fields.filter((f) => f.kind !== "object")).map((f) => `${d.quoteRef(ROOT_ALIAS, fieldColumn(f))} ASC`);
+  return Sql.raw(cols.join(", "));
+}
+function outerOrderBy(model, alias, orderBy, d) {
+  if (!orderBy) return new Sql();
+  const list = Array.isArray(orderBy) ? orderBy : [orderBy];
+  const parts = [];
+  for (const obj of list) {
+    for (const [name, dir] of Object.entries(obj)) {
+      if (dir !== "asc" && dir !== "desc") continue;
+      if (!model.fields.some((f) => f.name === name && f.kind !== "object")) {
+        continue;
+      }
+      parts.push(
+        Sql.raw(`${d.quoteRef(alias, name)} ${dir === "desc" ? "DESC" : "ASC"}`)
+      );
+    }
+  }
+  return Sql.join(parts, ", ");
+}
+function appendReturning(sql, d, returning) {
+  if (returning.length === 0) return;
+  sql.push(" RETURNING ");
+  sql.push(
+    returning.map((f) => `${d.quoteId(fieldColumn(f))} AS ${d.quoteId(f.name)}`).join(", ")
+  );
+}
+function aggregateSelections(model, args, d) {
+  const out = [];
+  if (args._count) {
+    if (args._count === true) {
+      out.push(`COUNT(*) AS "_count_all"`);
+    } else {
+      for (const field of trueKeys(args._count)) {
+        const col = d.quoteRef(ROOT_ALIAS, fieldColumn(requireScalar(model, field)));
+        out.push(`COUNT(${col}) AS ${d.quoteId(`_count_${field}`)}`);
+      }
+    }
+  }
+  pushAgg(out, "SUM", "_sum", model, args._sum, d);
+  pushAgg(out, "AVG", "_avg", model, args._avg, d);
+  pushAgg(out, "MIN", "_min", model, args._min, d);
+  pushAgg(out, "MAX", "_max", model, args._max, d);
+  return out;
+}
+function pushAgg(out, fn, prefix, model, spec, d) {
+  if (!spec) return;
+  for (const field of trueKeys(spec)) {
+    const col = d.quoteRef(ROOT_ALIAS, fieldColumn(requireScalar(model, field)));
+    out.push(`${fn}(${col}) AS ${d.quoteId(`${prefix}_${field}`)}`);
+  }
+}
+function trueKeys(spec) {
+  return Object.entries(spec).filter(([, v]) => v === true).map(([k]) => k);
+}
+function requireScalar(model, name) {
+  const field = model.fields.find((f) => f.name === name);
+  if (!field || field.kind === "object") {
+    throw new QueryValidationError(
+      `'${name}' is not a scalar field on model '${model.name}'.`
+    );
+  }
+  return field;
+}
+
+// src/query/coerce.ts
+function coerceFromDb(value, field) {
+  if (value === null || value === void 0) return null;
+  switch (field.type) {
+    case "Boolean":
+      return toBoolean(value);
+    case "Int":
+      return typeof value === "number" ? value : Number(value);
+    case "BigInt":
+      return typeof value === "bigint" ? value : BigInt(String(value));
+    case "Float":
+    case "Decimal":
+      return typeof value === "number" ? value : Number(value);
+    case "DateTime":
+      return value instanceof Date ? value : new Date(String(value));
+    case "Json":
+      return parseJson(value);
+    case "Bytes":
+      return Buffer.isBuffer(value) ? value : Buffer.from(String(value));
+    case "String":
+    default:
+      return typeof value === "string" ? value : String(value);
+  }
+}
+function coerceRow(row, fields) {
+  const out = {};
+  for (const field of fields) {
+    if (field.name in row) {
+      out[field.name] = coerceFromDb(row[field.name], field);
+    }
+  }
+  return out;
+}
+function toBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  const s = String(value).trim().toUpperCase();
+  return s === "1" || s === "T" || s === "TRUE" || s === "Y";
+}
+function parseJson(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+// src/query/defaults.ts
+var import_node_crypto = require("crypto");
+function applyCreateDefaults(model, data) {
+  const out = { ...data };
+  for (const field of model.fields) {
+    if (field.kind === "object") continue;
+    if (field.isUpdatedAt && out[field.name] === void 0) {
+      out[field.name] = /* @__PURE__ */ new Date();
+      continue;
+    }
+    if (out[field.name] !== void 0) continue;
+    const def = field.default;
+    if (!def) continue;
+    if (def.function) {
+      const computed = computeFunctionDefault(def.function.name);
+      if (computed !== SKIP) out[field.name] = computed;
+      continue;
+    }
+    if (def.literal !== void 0) {
+      out[field.name] = def.literal;
+    }
+  }
+  return out;
+}
+function applyUpdateDefaults(model, data) {
+  const out = { ...data };
+  for (const field of model.fields) {
+    if (field.isUpdatedAt && out[field.name] === void 0) {
+      out[field.name] = /* @__PURE__ */ new Date();
+    }
+  }
+  return out;
+}
+var SKIP = /* @__PURE__ */ Symbol("skip-default");
+function computeFunctionDefault(name) {
+  switch (name) {
+    case "now":
+      return /* @__PURE__ */ new Date();
+    case "uuid":
+      return (0, import_node_crypto.randomUUID)();
+    case "cuid":
+      return generateCuid();
+    case "autoincrement":
+      return SKIP;
+    default:
+      return SKIP;
+  }
+}
+function generateCuid() {
+  const time = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 10);
+  return `c${time}${rand}`;
+}
+function isAutoincrement(field) {
+  return field.default?.function?.name === "autoincrement";
+}
+
+// src/query/writer.ts
+var WriteProcessor = class {
+  constructor(schema, dialect, exec) {
+    this.schema = schema;
+    this.dialect = dialect;
+    this.exec = exec;
+  }
+  schema;
+  dialect;
+  exec;
+  ctx() {
+    return newContext(this.schema, this.dialect);
+  }
+  /** Insert one row (with nested writes) and return its key values. */
+  async create(model, data) {
+    const { scalars, owning, children } = this.partition(model, data);
+    for (const [field, op] of owning) {
+      for (const [fieldName, value] of await this.resolveOwning(model, field, op)) {
+        scalars.set(fieldName, value);
+      }
+    }
+    const withDefaults = applyCreateDefaults(model, recordOf(scalars));
+    const row = this.toColumnMap(model, withDefaults);
+    const returning = idFields(model);
+    const stmt = compileInsert(model, row, this.ctx(), returning);
+    const result = await this.exec(stmt.sql);
+    const keys = this.keyValues(model, result[0] ?? {}, withDefaults);
+    for (const [field, op] of children) {
+      await this.writeChildren(model, keys, field, op);
+    }
+    return keys;
+  }
+  /** Update rows matched by `where` (with nested writes). */
+  async updateRow(model, where, data, keys) {
+    const { scalars, owning, children } = this.partition(model, data, true);
+    for (const [field, op] of owning) {
+      for (const [fieldName, value] of await this.resolveOwningForUpdate(
+        model,
+        field,
+        op
+      )) {
+        scalars.set(fieldName, value);
+      }
+    }
+    const withDefaults = applyUpdateDefaults(model, recordOf(scalars));
+    const assignments = this.toUpdateColumnMap(model, withDefaults);
+    if (assignments.size > 0) {
+      const stmt = compileUpdate(model, where, assignments, this.ctx());
+      await this.exec(stmt.sql);
+    }
+    for (const [field, op] of children) {
+      await this.writeChildren(model, keys, field, op);
+    }
+  }
+  /**
+   * Scalar-only bulk update (for `updateMany`). Atomic operators are supported;
+   * nested relation writes are rejected, matching Prisma's `updateMany`.
+   */
+  async updateManyRows(model, where, data) {
+    for (const key of Object.keys(data)) {
+      const field = model.fields.find((f) => f.name === key);
+      if (field?.kind === "object") {
+        throw new QueryValidationError(
+          `updateMany does not support nested relation writes ('${model.name}.${key}'). Use update() per record.`
+        );
+      }
+    }
+    const withDefaults = applyUpdateDefaults(model, data);
+    const assignments = this.toUpdateColumnMap(model, withDefaults);
+    if (assignments.size > 0) {
+      const stmt = compileUpdate(model, where, assignments, this.ctx());
+      await this.exec(stmt.sql);
+    }
+  }
+  // ---- partition & mapping ------------------------------------------------
+  partition(model, data, isUpdate = false) {
+    const scalars = /* @__PURE__ */ new Map();
+    const owning = [];
+    const children = [];
+    for (const [key, value] of Object.entries(data)) {
+      if (value === void 0) continue;
+      const field = model.fields.find((f) => f.name === key);
+      if (!field) {
+        throw new QueryValidationError(
+          `Unknown field '${key}' on model '${model.name}'.`
+        );
+      }
+      if (field.kind !== "object") {
+        scalars.set(key, value);
+        continue;
+      }
+      if (!isPlainObject(value)) {
+        throw new QueryValidationError(
+          `Relation '${model.name}.${key}' expects a nested write object.`
+        );
+      }
+      const rel = resolveRelation(this.schema, model, field);
+      if (rel.owns) owning.push([field, value]);
+      else children.push([field, value]);
+    }
+    return { scalars, owning, children };
+  }
+  toColumnMap(model, record) {
+    const out = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries(record)) {
+      const field = model.fields.find((f) => f.name === name);
+      if (!field || field.kind === "object") continue;
+      if (isAutoincrement(field) && (value === void 0 || value === null)) {
+        continue;
+      }
+      out.set(fieldColumn(field), this.dialect.coerceValue(value));
+    }
+    return out;
+  }
+  /**
+   * Build UPDATE assignments, interpreting atomic scalar operators:
+   * `{ set }`, `{ increment }`, `{ decrement }`, `{ multiply }`, `{ divide }`.
+   * A bare value is a plain `set`.
+   */
+  toUpdateColumnMap(model, record) {
+    const out = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries(record)) {
+      const field = model.fields.find((f) => f.name === name);
+      if (!field || field.kind === "object") continue;
+      out.set(fieldColumn(field), this.toColumnUpdate(field, value));
+    }
+    return out;
+  }
+  toColumnUpdate(field, value) {
+    const coerce = (v) => this.dialect.coerceValue(v);
+    if (isPlainObject(value)) {
+      if ("set" in value) return { kind: "set", value: coerce(value.set) };
+      const arith = ARITH_OPS.find((op) => op.key in value);
+      if (arith) {
+        requireNumeric(field, arith.key);
+        return { kind: "arith", op: arith.op, value: coerce(value[arith.key]) };
+      }
+    }
+    return { kind: "set", value: coerce(value) };
+  }
+  keyValues(model, returnedRow, writtenData) {
+    const out = {};
+    for (const f of idFields(model)) {
+      out[f.name] = returnedRow[f.name] ?? returnedRow[fieldColumn(f)] ?? writtenData[f.name];
+    }
+    return out;
+  }
+  // ---- owning-side relations ---------------------------------------------
+  async resolveOwning(model, field, op) {
+    const rel = resolveRelation(this.schema, model, field);
+    if (op.connect) {
+      const ref = await this.lookupReference(rel, op.connect);
+      return this.mapFkByField(rel, ref);
+    }
+    if (op.create) {
+      const childKeys = await this.create(
+        rel.relatedModel,
+        op.create
+      );
+      return this.mapFkByField(rel, childKeys);
+    }
+    if (op.connectOrCreate) {
+      const spec = op.connectOrCreate;
+      const existing = await this.tryLookupReference(rel, spec.where);
+      const ref = existing ?? await this.create(rel.relatedModel, spec.create);
+      return this.mapFkByField(rel, ref);
+    }
+    throw new QueryValidationError(
+      `Unsupported nested write on '${model.name}.${field.name}'.`
+    );
+  }
+  async resolveOwningForUpdate(model, field, op) {
+    if (op.disconnect) {
+      const rel = resolveRelation(this.schema, model, field);
+      return rel.fromFields.map((name) => [name, null]);
+    }
+    return this.resolveOwning(model, field, op);
+  }
+  /** [localFieldName, value] pairs from the referenced model's key values. */
+  mapFkByField(rel, refValues) {
+    return rel.fromFields.map((fromField, i) => {
+      const toField = rel.toFields[i];
+      return [fromField, this.dialect.coerceValue(refValues[toField] ?? null)];
+    });
+  }
+  async lookupReference(rel, where) {
+    const found = await this.tryLookupReference(rel, where);
+    if (!found) throw new RecordNotFoundError(rel.relatedModel.name);
+    return found;
+  }
+  async tryLookupReference(rel, where) {
+    const fields = rel.toFields.map((n) => requireField(rel.relatedModel, n));
+    const stmt = this.selectKeys(rel.relatedModel, fields, where);
+    const rows = await this.exec(stmt);
+    return rows[0] ?? null;
+  }
+  selectKeys(model, fields, where) {
+    const d = this.dialect;
+    const alias = "t0";
+    const sql = new Sql();
+    sql.push("SELECT FIRST 1 ");
+    sql.push(
+      fields.map((f) => `${d.quoteRef(alias, fieldColumn(f))} AS ${d.quoteId(f.name)}`).join(", ")
+    );
+    sql.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(alias)}`);
+    const cond = compileWhere(model, alias, where, this.ctx());
+    if (!cond.isEmpty()) sql.push(" WHERE ").append(cond);
+    return sql;
+  }
+  // ---- child-side relations ----------------------------------------------
+  async writeChildren(parentModel, parentKeys, field, op) {
+    const rel = resolveRelation(this.schema, parentModel, field);
+    const fkColumns = rel.toColumns.map((toCol, i) => {
+      const fromField = rel.fromFields[i];
+      return [toCol, this.dialect.coerceValue(parentKeys[fromField] ?? null)];
+    });
+    for (const childData of toArray(op.create)) {
+      await this.create(rel.relatedModel, { ...childData, ...fkRecord(rel, parentKeys) });
+    }
+    for (const where of toArray(op.connect)) {
+      await this.setChildForeignKey(rel, where, fkColumns);
+    }
+    if (op.set !== void 0) {
+      await this.clearChildren(rel, parentKeys);
+      for (const where of toArray(op.set)) {
+        await this.setChildForeignKey(rel, where, fkColumns);
+      }
+    }
+    for (const where of toArray(op.disconnect)) {
+      await this.setChildForeignKey(
+        rel,
+        where,
+        rel.toColumns.map((c) => [c, null])
+      );
+    }
+    for (const where of toArray(op.delete)) {
+      const stmt = compileDelete(rel.relatedModel, where, this.ctx());
+      await this.exec(stmt.sql);
+    }
+  }
+  async setChildForeignKey(rel, where, fkColumns) {
+    const assignments = setAssignments(new Map(fkColumns));
+    const stmt = compileUpdate(rel.relatedModel, where, assignments, this.ctx());
+    await this.exec(stmt.sql);
+  }
+  async clearChildren(rel, parentKeys) {
+    const matchWhere = {};
+    rel.toFields.forEach((toField, i) => {
+      const fromField = rel.fromFields[i];
+      matchWhere[toField] = parentKeys[fromField];
+    });
+    const assignments = setAssignments(
+      new Map(
+        rel.toColumns.map((c) => [c, null])
+      )
+    );
+    const stmt = compileUpdate(rel.relatedModel, matchWhere, assignments, this.ctx());
+    await this.exec(stmt.sql);
+  }
+};
+var ARITH_OPS = [
+  { key: "increment", op: "+" },
+  { key: "decrement", op: "-" },
+  { key: "multiply", op: "*" },
+  { key: "divide", op: "/" }
+];
+var NUMERIC_TYPES = /* @__PURE__ */ new Set(["Int", "BigInt", "Float", "Decimal"]);
+function requireNumeric(field, op) {
+  if (!NUMERIC_TYPES.has(field.type)) {
+    throw new QueryValidationError(
+      `Operator '${op}' is only valid on numeric fields, not '${field.name}' (${field.type}).`
+    );
+  }
+}
+function requireField(model, name) {
+  const f = model.fields.find((x) => x.name === name);
+  if (!f) {
+    throw new QueryValidationError(`Field '${name}' not found on '${model.name}'.`);
+  }
+  return f;
+}
+function fkRecord(rel, parentKeys) {
+  const out = {};
+  rel.toFields.forEach((toField, i) => {
+    const fromField = rel.fromFields[i];
+    out[toField] = parentKeys[fromField];
+  });
+  return out;
+}
+function recordOf(scalars) {
+  const out = {};
+  for (const [k, v] of scalars) out[k] = v;
+  return out;
+}
+function toArray(value) {
+  if (value === void 0 || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/query/engine.ts
+function readShape(args) {
+  return { select: args.select, include: args.include, omit: args.omit };
+}
+var QueryEngine = class {
+  constructor(schema, dialect, driver) {
+    this.schema = schema;
+    this.dialect = dialect;
+    this.driver = driver;
+  }
+  schema;
+  dialect;
+  driver;
+  model(name) {
+    const model = findModel(this.schema, name);
+    if (!model) throw new QueryValidationError(`Unknown model '${name}'.`);
+    return model;
+  }
+  run(fn, options) {
+    return this.driver.transaction(fn, options);
+  }
+  execOn(tx) {
+    return (sql) => tx.query(sql.text, sql.params);
+  }
+  // ---- reads --------------------------------------------------------------
+  findMany(name, args = {}) {
+    const model = this.model(name);
+    return this.run((tx) => this.readMany(model, args, this.execOn(tx)));
+  }
+  async findFirst(name, args = {}) {
+    const rows = await this.findMany(name, { ...args, take: 1 });
+    return rows[0] ?? null;
+  }
+  async findFirstOrThrow(name, args = {}) {
+    const row = await this.findFirst(name, args);
+    if (!row) throw new RecordNotFoundError(name);
+    return row;
+  }
+  async findUnique(name, args) {
+    const model = this.model(name);
+    this.assertUniqueWhere(model, args.where);
+    const rows = await this.run(
+      (tx) => this.readMany(
+        model,
+        { where: args.where, select: args.select, include: args.include, take: 1 },
+        this.execOn(tx)
+      )
+    );
+    return rows[0] ?? null;
+  }
+  async findUniqueOrThrow(name, args) {
+    const row = await this.findUnique(name, args);
+    if (!row) throw new RecordNotFoundError(name);
+    return row;
+  }
+  // ---- aggregations -------------------------------------------------------
+  count(name, args = {}) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const stmt = compileCount(model, args.where, newContext(this.schema, this.dialect), {
+        take: args.take,
+        skip: args.skip
+      });
+      const rows = await tx.query(stmt.text, stmt.params);
+      return Number(rows[0]?._count ?? 0);
+    });
+  }
+  aggregate(name, args = {}) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const stmt = compileAggregate(model, args, newContext(this.schema, this.dialect));
+      const rows = await tx.query(stmt.text, stmt.params);
+      return reshapeAggregate(rows[0] ?? {});
+    });
+  }
+  groupBy(name, args) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const { sql } = compileGroupBy(model, args, newContext(this.schema, this.dialect));
+      const rows = await tx.query(sql.text, sql.params);
+      return rows.map((r) => reshapeGroupRow(model, args.by, r));
+    });
+  }
+  // ---- writes -------------------------------------------------------------
+  create(name, args) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const writer = new WriteProcessor(this.schema, this.dialect, this.execOn(tx));
+      const keys = await writer.create(model, args.data);
+      return this.readBack(model, keys, readShape(args), this.execOn(tx));
+    });
+  }
+  createMany(name, args) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const writer = new WriteProcessor(this.schema, this.dialect, this.execOn(tx));
+      let count = 0;
+      for (const data of args.data) {
+        await writer.create(model, data);
+        count++;
+      }
+      return { count };
+    });
+  }
+  /** Like createMany, but returns the created records (no nested relations). */
+  createManyAndReturn(name, args) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const writer = new WriteProcessor(this.schema, this.dialect, exec);
+      const out = [];
+      const shape = { select: args.select, omit: args.omit };
+      for (const data of args.data) {
+        const keys = await writer.create(model, data);
+        out.push(await this.readBack(model, keys, shape, exec));
+      }
+      return out;
+    });
+  }
+  update(name, args) {
+    const model = this.model(name);
+    this.assertUniqueWhere(model, args.where);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const target = await this.requireOne(model, args.where, exec);
+      const keys = this.pickKeys(model, target);
+      const writer = new WriteProcessor(this.schema, this.dialect, exec);
+      await writer.updateRow(model, args.where, args.data, keys);
+      return this.readBack(model, keys, readShape(args), exec);
+    });
+  }
+  updateMany(name, args) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const count = await this.countMatching(model, args.where, exec);
+      const writer = new WriteProcessor(this.schema, this.dialect, exec);
+      await writer.updateManyRows(model, args.where, args.data);
+      return { count };
+    });
+  }
+  upsert(name, args) {
+    const model = this.model(name);
+    this.assertUniqueWhere(model, args.where);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const existing = await this.findOneRaw(model, args.where, exec);
+      const writer = new WriteProcessor(this.schema, this.dialect, exec);
+      if (existing) {
+        const keys2 = this.pickKeys(model, existing);
+        await writer.updateRow(model, args.where, args.update, keys2);
+        return this.readBack(model, keys2, readShape(args), exec);
+      }
+      const keys = await writer.create(model, args.create);
+      return this.readBack(model, keys, readShape(args), exec);
+    });
+  }
+  delete(name, args) {
+    const model = this.model(name);
+    this.assertUniqueWhere(model, args.where);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const row = await this.readBackOne(model, args.where, readShape(args), exec);
+      if (!row) throw new RecordNotFoundError(name);
+      const stmt = compileDelete(model, args.where, newContext(this.schema, this.dialect));
+      await exec(stmt.sql);
+      return row;
+    });
+  }
+  deleteMany(name, args = {}) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const count = await this.countMatching(model, args.where, exec);
+      const stmt = compileDelete(model, args.where, newContext(this.schema, this.dialect));
+      await exec(stmt.sql);
+      return { count };
+    });
+  }
+  // ---- read pipeline ------------------------------------------------------
+  async readMany(model, args, exec, forceKeep = []) {
+    const relations = this.readRelations(model, args.select, args.include);
+    const countFields = this.readCountRelations(model, args.select, args.include);
+    const selectedScalars = applyOmit(
+      model,
+      selectedScalarNames(model, args.select),
+      args.omit
+    );
+    const distinctFields = normalizeDistinct(model, args.distinct);
+    const useWindowDistinct = distinctFields.length > 0 && this.dialect.supportsWindowFunctions;
+    const memoryPaginate = distinctFields.length > 0 && !useWindowDistinct;
+    const { where, orderBy } = applyCursor(model, args, distinctFields);
+    const relationKeyFields = uniq(
+      [...relations.map((r) => r.field), ...countFields].flatMap(
+        (field) => resolveRelation(this.schema, model, field).fromFields
+      )
+    );
+    const internalKeys = uniq([
+      ...relationKeyFields,
+      ...distinctFields
+      // fetched for de-dup; stripped below if not selected
+    ]);
+    const projectionNames = uniq([
+      ...selectedScalars ?? scalarFields(model).map((f) => f.name),
+      ...internalKeys,
+      ...forceKeep
+    ]);
+    const projection = projectionNames.map((n) => fieldByName(model, n));
+    const findOptions = {
+      where,
+      orderBy,
+      take: memoryPaginate ? void 0 : args.take,
+      skip: memoryPaginate ? void 0 : args.skip
+    };
+    const stmt = useWindowDistinct ? compileDistinctFindMany(
+      model,
+      findOptions,
+      projection,
+      distinctFields.map((n) => fieldByName(model, n)),
+      newContext(this.schema, this.dialect)
+    ) : compileFindMany(
+      model,
+      findOptions,
+      projection,
+      newContext(this.schema, this.dialect)
+    );
+    const rawRows = await exec(stmt.sql);
+    let rows = rawRows.map((r) => coerceRow(r, projection));
+    if (memoryPaginate) {
+      rows = dedupeBy(rows, distinctFields);
+      rows = applyPagination(rows, args.take, args.skip);
+    }
+    for (const relation of relations) {
+      await this.loadRelation(model, rows, relation, exec);
+    }
+    if (countFields.length > 0) {
+      await this.loadCounts(model, rows, countFields, exec);
+    }
+    if (selectedScalars) {
+      const visible = /* @__PURE__ */ new Set([...selectedScalars, ...forceKeep]);
+      for (const row of rows) {
+        for (const name of internalKeys) {
+          if (!visible.has(name)) delete row[name];
+        }
+      }
+    }
+    return rows;
+  }
+  async loadRelation(parentModel, parentRows, relation, exec) {
+    if (parentRows.length === 0) return;
+    const rel = resolveRelation(this.schema, parentModel, relation.field);
+    const fieldName = relation.field.name;
+    const { fromFields, toFields } = rel;
+    const parentTuples = uniqueTuples(parentRows, fromFields);
+    const grouped = /* @__PURE__ */ new Map();
+    if (parentTuples.length > 0) {
+      const childWhere = relationKeyWhere(
+        toFields,
+        parentTuples,
+        relation.args.where
+      );
+      const childRows = await this.readMany(
+        rel.relatedModel,
+        {
+          where: childWhere,
+          orderBy: relation.args.orderBy,
+          select: relation.args.select,
+          include: relation.args.include,
+          // take/skip on to-many are applied per parent below; skip here.
+          ...rel.isList ? {} : { take: relation.args.take, skip: relation.args.skip }
+        },
+        exec,
+        toFields
+      );
+      for (const child of childRows) {
+        const k = tupleKey(child, toFields);
+        const list = grouped.get(k) ?? [];
+        list.push(child);
+        grouped.set(k, list);
+      }
+    }
+    const visible = selectedScalarNames(rel.relatedModel, relation.args.select);
+    const stripFields = visible ? toFields.filter((f) => !visible.has(f)) : [];
+    for (const parent of parentRows) {
+      const k = tupleKey(parent, fromFields);
+      let matches = grouped.get(k) ?? [];
+      if (rel.isList && (relation.args.take != null || relation.args.skip != null)) {
+        matches = applyPagination(matches, relation.args.take, relation.args.skip);
+      }
+      const attached = stripFields.length ? matches.map((m) => omitAll(m, stripFields)) : matches;
+      parent[fieldName] = rel.isList ? attached : attached[0] ?? null;
+    }
+  }
+  readRelations(model, select, include) {
+    const out = [];
+    const add = (key, value) => {
+      if (!value) return;
+      const field = model.fields.find((f) => f.name === key && f.kind === "object");
+      if (!field) return;
+      out.push({ field, args: typeof value === "object" ? value : {} });
+    };
+    if (include) for (const [k, v] of Object.entries(include)) add(k, v);
+    if (select) {
+      for (const [k, v] of Object.entries(select)) {
+        const field = model.fields.find((f) => f.name === k);
+        if (field?.kind === "object") add(k, v);
+      }
+    }
+    return out;
+  }
+  /**
+   * Resolve which to-many relations to count for `_count` in select/include.
+   * `_count: true` counts every list relation; `_count: { select: { rel } }`
+   * counts the named ones.
+   */
+  readCountRelations(model, select, include) {
+    const spec = include?._count ?? select?._count;
+    if (!spec) return [];
+    const listRelations = model.fields.filter(
+      (f) => f.kind === "object" && f.isList
+    );
+    if (spec === true) return listRelations;
+    const selected = spec.select;
+    if (!selected) return listRelations;
+    return listRelations.filter((f) => selected[f.name]);
+  }
+  /** Attach a `_count` object to each row with per-relation child counts. */
+  async loadCounts(model, rows, countFields, exec) {
+    for (const row of rows) row._count = {};
+    for (const field of countFields) {
+      const rel = resolveRelation(this.schema, model, field);
+      const tuples = uniqueTuples(rows, rel.fromFields);
+      const grouped = /* @__PURE__ */ new Map();
+      if (tuples.length > 0) {
+        const where = relationKeyWhere(rel.toFields, tuples, void 0);
+        const { sql } = compileGroupBy(
+          rel.relatedModel,
+          { by: rel.toFields, _count: true, where },
+          newContext(this.schema, this.dialect)
+        );
+        const countRows = await exec(sql);
+        for (const cr of countRows) {
+          grouped.set(tupleKey(cr, rel.toFields), Number(cr._count_all ?? 0));
+        }
+      }
+      for (const row of rows) {
+        const count = grouped.get(tupleKey(row, rel.fromFields)) ?? 0;
+        row._count[field.name] = count;
+      }
+    }
+  }
+  // ---- read-back & helpers ------------------------------------------------
+  async readBack(model, keys, shape, exec) {
+    const where = keysToWhere(model, keys);
+    const row = await this.readBackOne(model, where, shape, exec);
+    if (!row) throw new RecordNotFoundError(model.name);
+    return row;
+  }
+  async readBackOne(model, where, shape, exec) {
+    const rows = await this.readMany(
+      model,
+      { where, select: shape.select, include: shape.include, omit: shape.omit, take: 1 },
+      exec
+    );
+    return rows[0] ?? null;
+  }
+  async requireOne(model, where, exec) {
+    const row = await this.findOneRaw(model, where, exec);
+    if (!row) throw new RecordNotFoundError(model.name);
+    return row;
+  }
+  async findOneRaw(model, where, exec) {
+    const rows = await this.readMany(model, { where, take: 1 }, exec);
+    return rows[0] ?? null;
+  }
+  async countMatching(model, where, exec) {
+    const stmt = compileCount(model, where, newContext(this.schema, this.dialect));
+    const rows = await exec(stmt);
+    return Number(rows[0]?._count ?? 0);
+  }
+  pickKeys(model, row) {
+    const out = {};
+    for (const f of idFields(model)) out[f.name] = row[f.name];
+    return out;
+  }
+  assertUniqueWhere(model, where) {
+    if (!where || Object.keys(where).length === 0) {
+      throw new QueryValidationError(
+        `A unique 'where' is required for this operation on '${model.name}'.`
+      );
+    }
+  }
+};
+function fieldByName(model, name) {
+  const f = model.fields.find((x) => x.name === name);
+  if (!f) throw new QueryValidationError(`Field '${name}' not found on '${model.name}'.`);
+  return f;
+}
+function selectedScalarNames(model, select) {
+  if (!select) return null;
+  const names = /* @__PURE__ */ new Set();
+  for (const [k, v] of Object.entries(select)) {
+    if (!v) continue;
+    const field = model.fields.find((f) => f.name === k);
+    if (field && field.kind !== "object") names.add(k);
+  }
+  return names;
+}
+function applyOmit(model, selected, omit) {
+  if (selected || !omit) return selected;
+  const omitted = new Set(
+    Object.entries(omit).filter(([, v]) => v).map(([k]) => k)
+  );
+  if (omitted.size === 0) return null;
+  return new Set(
+    scalarFields(model).map((f) => f.name).filter((n) => !omitted.has(n))
+  );
+}
+function keysToWhere(model, keys) {
+  const where = {};
+  for (const f of idFields(model)) where[f.name] = keys[f.name];
+  return where;
+}
+function keyOf(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+function tupleKey(row, fields) {
+  return fields.map((f) => keyOf(row[f])).join("\0");
+}
+function uniqueTuples(rows, fields) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const row of rows) {
+    const tuple = fields.map((f) => row[f]);
+    if (tuple.some((v) => v === null || v === void 0)) continue;
+    const key = tuple.map(keyOf).join("\0");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(tuple);
+  }
+  return out;
+}
+function relationKeyWhere(toFields, parentTuples, baseWhere) {
+  const base = baseWhere ?? {};
+  if (toFields.length === 1) {
+    const field = toFields[0];
+    return { ...base, [field]: { in: parentTuples.map((t) => t[0]) } };
+  }
+  const or = parentTuples.map((tuple) => {
+    const cond = {};
+    toFields.forEach((f, i) => {
+      cond[f] = tuple[i];
+    });
+    return cond;
+  });
+  if (Object.keys(base).length === 0) return { OR: or };
+  return { AND: [base, { OR: or }] };
+}
+function omitAll(obj, keys) {
+  const out = { ...obj };
+  for (const k of keys) delete out[k];
+  return out;
+}
+function applyPagination(rows, take, skip) {
+  const start = skip ?? 0;
+  const end = take != null ? start + take : void 0;
+  return rows.slice(start, end);
+}
+function normalizeDistinct(model, distinct) {
+  if (!distinct || distinct.length === 0) return [];
+  for (const name of distinct) {
+    const field = model.fields.find((f) => f.name === name);
+    if (!field || field.kind === "object") {
+      throw new QueryValidationError(
+        `Cannot apply distinct on '${model.name}.${name}' (not a scalar field).`
+      );
+    }
+  }
+  return uniq(distinct);
+}
+function dedupeBy(rows, fields) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const row of rows) {
+    const key = tupleKey(row, fields);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(row);
+  }
+  return out;
+}
+function applyCursor(model, args, _distinctFields) {
+  if (!args.cursor || Object.keys(args.cursor).length === 0) {
+    return { where: args.where, orderBy: args.orderBy };
+  }
+  const entries = Object.entries(args.cursor).filter(([, v]) => v !== void 0);
+  if (entries.length === 0) return { where: args.where, orderBy: args.orderBy };
+  const fields = entries.map(([name, value]) => {
+    if (!model.fields.some((f) => f.name === name && f.kind !== "object")) {
+      throw new QueryValidationError(
+        `Cursor field '${model.name}.${name}' must be a scalar field.`
+      );
+    }
+    return { name, value, direction: directionForField(args.orderBy, name) ?? "asc" };
+  });
+  const cursorCond = keysetCondition(fields);
+  const where = args.where ? { AND: [args.where, cursorCond] } : cursorCond;
+  const orderBy = args.orderBy ?? fields.map((f) => ({ [f.name]: f.direction }));
+  return { where, orderBy };
+}
+function keysetCondition(fields) {
+  const clauses = [];
+  for (let i = 0; i < fields.length; i++) {
+    const clause = {};
+    for (let j = 0; j < i; j++) {
+      clause[fields[j].name] = fields[j].value;
+    }
+    const last = i === fields.length - 1;
+    const f = fields[i];
+    const op = comparator(f.direction, last);
+    clause[f.name] = { [op]: f.value };
+    clauses.push(clause);
+  }
+  return clauses.length === 1 ? clauses[0] : { OR: clauses };
+}
+function comparator(direction, inclusive) {
+  if (direction === "desc") return inclusive ? "lte" : "lt";
+  return inclusive ? "gte" : "gt";
+}
+function directionForField(orderBy, field) {
+  if (!orderBy) return void 0;
+  const list = Array.isArray(orderBy) ? orderBy : [orderBy];
+  for (const obj of list) {
+    const dir = obj[field];
+    if (dir === "asc" || dir === "desc") return dir;
+  }
+  return void 0;
+}
+function reshapeAggregate(row) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (key === "_count_all") {
+      out._count ??= {};
+      out._count._all = Number(value);
+      continue;
+    }
+    const m = /^(_count|_sum|_avg|_min|_max)_(.+)$/.exec(key);
+    if (m) {
+      const group = out[m[1]] ??= {};
+      group[m[2]] = value === null ? null : Number(value);
+    }
+  }
+  return out;
+}
+function reshapeGroupRow(model, by, row) {
+  const out = {};
+  const groupFields = scalarFields(model).filter((f) => by.includes(f.name));
+  for (const f of groupFields) {
+    out[f.name] = f.name in row ? coerceField(row[f.name], f) : row[f.name];
+  }
+  const aggregates = reshapeAggregate(row);
+  return { ...out, ...aggregates };
+}
+function coerceField(value, field) {
+  return coerceRow({ [field.name]: value }, [field])[field.name];
+}
+
+// src/schema/index.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function resolveDatasourceUrl(doc, _base) {
+  const ds = doc.datasource;
+  if (!ds) return void 0;
+  if (ds.url.kind === "literal") return ds.url.value;
+  return process.env[ds.url.value];
+}
+
+// src/client/runtime.ts
+var RECORD_OPS = /* @__PURE__ */ new Set([
+  "findMany",
+  "findFirst",
+  "findFirstOrThrow",
+  "findUnique",
+  "findUniqueOrThrow",
+  "create",
+  "createManyAndReturn",
+  "update",
+  "upsert",
+  "delete"
+]);
+var ALL_OPS = [
+  "findMany",
+  "findFirst",
+  "findFirstOrThrow",
+  "findUnique",
+  "findUniqueOrThrow",
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "update",
+  "updateMany",
+  "upsert",
+  "delete",
+  "deleteMany",
+  "count",
+  "aggregate",
+  "groupBy"
+];
+var FLUENT_OPS = /* @__PURE__ */ new Set([
+  "findUnique",
+  "findUniqueOrThrow",
+  "findFirst",
+  "findFirstOrThrow"
+]);
+function buildDelegate(ctx, modelName) {
+  const model = findModel(ctx.schema, modelName);
+  const delegate = {};
+  for (const operation of ALL_OPS) {
+    delegate[operation] = (args = {}) => runOperation(ctx, modelName, operation, args, delegate);
+  }
+  for (const ext of ctx.extensions) {
+    const methods = {
+      ...ext.model?.$allModels ?? {},
+      ...ext.model?.[modelName] ?? {}
+    };
+    for (const [name, fn] of Object.entries(methods)) {
+      delegate[name] = (...args) => fn.apply(delegate, args);
+    }
+  }
+  void model;
+  return delegate;
+}
+function runOperation(ctx, modelName, operation, args, delegate) {
+  const base = async (a) => {
+    const expanded = expandComputedSelect(ctx, modelName, operation, a);
+    const raw = await runMiddleware(ctx, modelName, operation, expanded.args);
+    return applyResultExtensions(ctx, modelName, operation, raw, expanded.computeOnly);
+  };
+  const hooks = gatherQueryHooks(ctx, modelName, operation);
+  const run = composeHooks(hooks, modelName, operation, base);
+  if (FLUENT_OPS.has(operation)) {
+    return makeFluent(ctx, modelName, args, () => run(args));
+  }
+  void delegate;
+  return run(args);
+}
+function gatherQueryHooks(ctx, model, operation) {
+  const hooks = [];
+  for (const ext of ctx.extensions) {
+    const q = ext.query;
+    if (!q) continue;
+    pushHook(hooks, q[model], operation);
+    pushHook(hooks, q.$allModels, operation);
+  }
+  return hooks;
+}
+function pushHook(hooks, map, operation) {
+  if (!map) return;
+  if (map[operation]) hooks.push(map[operation]);
+  if (map.$allOperations) hooks.push(map.$allOperations);
+}
+function composeHooks(hooks, model, operation, base) {
+  let next = base;
+  for (const hook of hooks) {
+    const inner = next;
+    next = (args) => hook({ model, operation, args, query: (a) => inner(a) });
+  }
+  return next;
+}
+function runMiddleware(ctx, model, action, args) {
+  const engine = ctx.engine;
+  const engineCall = (a) => engine[a.action](model, a.args);
+  let next = engineCall;
+  for (const mw of ctx.middlewares) {
+    const inner = next;
+    next = (params) => mw(params, inner);
+  }
+  return next({ model, action, args });
+}
+function resultComputers(ctx, model) {
+  const out = [];
+  for (const ext of ctx.extensions) {
+    const r = ext.result?.[model];
+    if (!r) continue;
+    for (const [field, def] of Object.entries(r)) {
+      out.push({ field, compute: def.compute });
+    }
+  }
+  return out;
+}
+function applyResultExtensions(ctx, model, operation, value, computeFields) {
+  if (!RECORD_OPS.has(operation)) return value;
+  const computers = resultComputers(ctx, model).filter(
+    (c) => !computeFields || computeFields.has(c.field)
+  );
+  if (computers.length === 0) return value;
+  const compute = (rec) => {
+    if (!rec || typeof rec !== "object") return rec;
+    const record = rec;
+    for (const c of computers) {
+      try {
+        record[c.field] = c.compute(record);
+      } catch {
+      }
+    }
+    return record;
+  };
+  return Array.isArray(value) ? value.map(compute) : compute(value);
+}
+function expandComputedSelect(ctx, model, operation, args) {
+  const computers = resultComputers(ctx, model);
+  if (computers.length === 0) return { args, computeOnly: null };
+  const select = args.select;
+  if (!select) return { args, computeOnly: null };
+  const byField = new Map(
+    ctx.extensions.flatMap((e) => Object.entries(e.result?.[model] ?? {})).map(([f, def]) => [f, def])
+  );
+  const computeOnly = /* @__PURE__ */ new Set();
+  const newSelect = { ...select };
+  for (const key of Object.keys(select)) {
+    const def = byField.get(key);
+    if (!def) continue;
+    computeOnly.add(key);
+    delete newSelect[key];
+    for (const need of Object.keys(def.needs ?? {})) newSelect[need] = true;
+  }
+  if (computeOnly.size === 0) return { args, computeOnly: null };
+  return { args: { ...args, select: newSelect }, computeOnly };
+}
+function makeFluent(ctx, modelName, args, exec) {
+  const model = findModel(ctx.schema, modelName);
+  const where = args.where ?? {};
+  let cached = null;
+  const run = () => cached ??= exec();
+  const fluent = {
+    then: (res, rej) => run().then(res, rej),
+    catch: (rej) => run().catch(rej),
+    finally: (f) => run().finally(f)
+  };
+  for (const rel of relationFields(model)) {
+    fluent[rel.name] = (subArgs = {}) => traverse(ctx, model, rel, where, subArgs);
+  }
+  return fluent;
+}
+function traverse(ctx, model, rel, parentWhere, subArgs) {
+  const inverse = inverseField(ctx.schema, model, rel);
+  const relatedWhere = inverse ? inverse.isList ? { [inverse.name]: { some: parentWhere } } : { [inverse.name]: parentWhere } : {};
+  const where = subArgs.where ? { AND: [relatedWhere, subArgs.where] } : relatedWhere;
+  const findArgs = { ...subArgs, where };
+  if (rel.isList) {
+    return ctx.engine.findMany(rel.type, findArgs);
+  }
+  return makeFluent(
+    ctx,
+    rel.type,
+    { ...subArgs, where },
+    () => ctx.engine.findFirst(rel.type, findArgs)
+  );
+}
+function inverseField(schema, model, rel) {
+  const related = findModel(schema, rel.type);
+  if (!related) return void 0;
+  const candidates = related.fields.filter(
+    (f) => f.kind === "object" && f.type === model.name
+  );
+  if (rel.relation?.name) {
+    const byName = candidates.find((f) => f.relation?.name === rel.relation?.name);
+    if (byName) return byName;
+  }
+  return candidates[0];
+}
+
+// src/client/index.ts
+var EmberClientBase = class {
+  driver;
+  engine;
+  dialect;
+  schema;
+  connected = false;
+  /** Mutated by $extends (per instance) and $use (shared). */
+  extensions = [];
+  middlewares = [];
+  queryListeners = [];
+  baseLog;
+  constructor(options) {
+    this.schema = options.schema;
+    const url = options.datasourceUrl ?? resolveDatasourceUrl(options.schema, process.cwd());
+    if (!options.datasource && !url) {
+      throw new EmberError(
+        "No datasource configured. Provide datasourceUrl, datasource, or a datasource block with a resolvable url."
+      );
+    }
+    const config = options.datasource ?? parseConnectionUrl(url);
+    this.dialect = new FirebirdDialect({ version: config.version });
+    this.baseLog = buildLogger(options.log);
+    this.driver = createDriver(config, { onQuery: (e) => this.dispatchQuery(e) });
+    this.engine = new QueryEngine(options.schema, this.dialect, this.driver);
+    this.installDelegates();
+  }
+  dispatchQuery(event) {
+    this.baseLog?.(event);
+    for (const listener of this.queryListeners) listener(event);
+  }
+  delegateContext() {
+    return {
+      engine: this.engine,
+      schema: this.schema,
+      extensions: this.extensions,
+      middlewares: this.middlewares
+    };
+  }
+  /** (Re)define one delegate property per model using the current extensions. */
+  installDelegates() {
+    const ctx = this.delegateContext();
+    for (const model of this.schema.models) {
+      Object.defineProperty(this, lowerFirst(model.name), {
+        value: buildDelegate(ctx, model.name),
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+  /**
+   * Prisma-style Client Extensions. Returns a new client (the original is
+   * unchanged) that shares the connection/engine but applies the extension's
+   * `result` / `model` / `query` / `client` definitions.
+   */
+  $extends(extension) {
+    const clone = Object.create(this);
+    clone.extensions = [...this.extensions, extension];
+    clone.installDelegates();
+    if (extension.client) {
+      for (const [key, value] of Object.entries(extension.client)) {
+        Object.defineProperty(clone, key, {
+          value: typeof value === "function" ? value.bind(clone) : value,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    return clone;
+  }
+  /** Prisma-style middleware: runs around every operation. */
+  $use(middleware) {
+    this.middlewares.push(middleware);
+  }
+  /** Subscribe to query events (mirrors the `log` callback). */
+  $on(event, listener) {
+    if (event === "query") this.queryListeners.push(listener);
+  }
+  /** Type-safe access to a delegate by model name. */
+  model(name) {
+    return this[lowerFirst(name)];
+  }
+  async $connect() {
+    if (this.connected) return;
+    await this.driver.connect();
+    this.connected = true;
+  }
+  async $disconnect() {
+    if (!this.connected) return;
+    await this.driver.disconnect();
+    this.connected = false;
+  }
+  $transaction(arg, options) {
+    if (Array.isArray(arg)) {
+      return this.driver.transaction(async () => {
+        const results = [];
+        for (const thunk of arg) results.push(await thunk(this));
+        return results;
+      }, options);
+    }
+    return this.driver.transaction(() => arg(this), options);
+  }
+  /** Execute a raw read query (returns rows) inside a transaction. */
+  $queryRawUnsafe(sql, ...params) {
+    return this.driver.transaction(
+      (tx) => tx.query(sql, params.map(toSqlValue))
+    );
+  }
+  /** Execute a raw write statement inside a transaction; returns affected rows when available. */
+  $executeRawUnsafe(sql, ...params) {
+    return this.driver.transaction(async (tx) => {
+      const rows = await tx.query(sql, params.map(toSqlValue));
+      return Array.isArray(rows) ? rows.length : 0;
+    });
+  }
+  /** Tagged-template raw query: `client.$queryRaw\`SELECT * FROM T WHERE id = ${id}\``. */
+  $queryRaw(strings, ...values) {
+    const { sql, params } = buildTemplate(strings, values);
+    return this.$queryRawUnsafe(sql, ...params);
+  }
+  $executeRaw(strings, ...values) {
+    const { sql, params } = buildTemplate(strings, values);
+    return this.$executeRawUnsafe(sql, ...params);
+  }
+};
+function buildTemplate(strings, values) {
+  let sql = "";
+  strings.forEach((part, i) => {
+    sql += part;
+    if (i < values.length) sql += "?";
+  });
+  return { sql, params: values };
+}
+function toSqlValue(v) {
+  return v;
+}
+function buildLogger(log) {
+  if (!log) return void 0;
+  if (typeof log === "function") return log;
+  return (e) => {
+    const params = e.params.length ? ` -- ${JSON.stringify(e.params)}` : "";
+    console.log(
+      `ember:query (${e.durationMs.toFixed(1)}ms, ${e.rowCount} rows) ${e.sql}${params}`
+    );
+  };
+}
+function createClient(options) {
+  return new EmberClientBase(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EmberClientBase,
+  createClient
+});
+//# sourceMappingURL=index.cjs.map