@getstrata/core 2.2.32 → 2.2.33

package/dist/entries/auth/scimAuthMiddleware.js

@@ -42,26 +42,81 @@ var init_connectionContext = __esm(() => {
   activeConnection = createAsyncContextStore("@getstrata/databaseConnectionContext");
 });
 
-// ../../src/core/tenant/tenancyConfig.ts
-function readTenancyDriver(env = process.env) {
-  const raw = env.TENANCY_DRIVER?.trim();
-  if (raw === undefined || raw === "") {
-    return "rls";
+// ../../src/core/events/eventBus.ts
+class EventBus {
+  constructor() {}
+  transactionalListeners = new Map;
+  listenTransactional(event, listener) {
+    const handlers = this.transactionalListeners.get(event) ?? new Set;
+    handlers.add(listener);
+    this.transactionalListeners.set(event, handlers);
+    return () => {
+      handlers.delete(listener);
+      if (!handlers.size)
+        this.transactionalListeners.delete(event);
+    };
   }
-  if (TENANCY_DRIVERS.includes(raw)) {
-    return raw;
+  hasTransactionalListeners(event) {
+    return (this.transactionalListeners.get(event)?.size ?? 0) > 0;
+  }
+  async dispatchTransactional(event, payload) {
+    for (const listener of this.transactionalListeners.get(event) ?? [])
+      await listener(payload);
+  }
+  listeners = new Map;
+  on(event, listener) {
+    return this.listen(event, listener);
+  }
+  listen(event, listener) {
+    const handlers = this.listeners.get(event) ?? new Set;
+    handlers.add(listener);
+    this.listeners.set(event, handlers);
+    return () => {
+      handlers.delete(listener);
+      if (handlers.size === 0) {
+        this.listeners.delete(event);
+      }
+    };
+  }
+  async emit(event, payload) {
+    await this.dispatch(event, payload);
+  }
+  async dispatch(event, payload) {
+    const handlers = this.listeners.get(event);
+    if (!handlers || handlers.size === 0) {
+      return;
+    }
+    for (const handler of handlers) {
+      await handler(payload);
+    }
   }
-  throw new Error(`TENANCY_DRIVER must be one of ${TENANCY_DRIVERS.join(", ")}; received "${raw}".`);
 }
-function isTenancyEnabled(env = process.env) {
-  return readTenancyDriver(env) !== "none";
+function readSharedEventBus() {
+  const globalBus = globalThis[EVENT_BUS_KEY];
+  if (globalBus) {
+    return globalBus;
+  }
+  const bus = new EventBus;
+  globalThis[EVENT_BUS_KEY] = bus;
+  return bus;
 }
-function isRlsTenancy(env = process.env) {
-  return readTenancyDriver(env) === "rls";
+var EVENT_BUS_KEY, eventBus;
+var init_eventBus = __esm(() => {
+  EVENT_BUS_KEY = Symbol.for("@getstrata/eventBus");
+  eventBus = readSharedEventBus();
+});
+
+// ../../src/core/tenant/tenantContext.ts
+function runWithTenant(tenant, callback) {
+  return tenantContext.run(tenant, callback);
 }
-var TENANCY_DRIVERS;
-var init_tenancyConfig = __esm(() => {
-  TENANCY_DRIVERS = ["rls", "column", "none"];
+function currentTenant() {
+  return tenantContext.getStore() ?? null;
+}
+var tenantContext;
+var init_tenantContext = __esm(() => {
+  init_asyncContextStore();
+  tenantContext = createAsyncContextStore("@getstrata/tenantContext");
 });
 
 // ../../src/core/database/transactionControl.ts
@@ -142,167 +197,6 @@ var init_transactionControl = __esm(() => {
   transactionScopes = createAsyncContextStore("@getstrata/transactionScopes");
 });
 
-// ../../src/core/tenant/tenantContext.ts
-function runWithTenant(tenant, callback) {
-  return tenantContext.run(tenant, callback);
-}
-function currentTenant() {
-  return tenantContext.getStore() ?? null;
-}
-var tenantContext;
-var init_tenantContext = __esm(() => {
-  init_asyncContextStore();
-  tenantContext = createAsyncContextStore("@getstrata/tenantContext");
-});
-
-// ../../src/core/events/eventBus.ts
-class EventBus {
-  constructor() {}
-  transactionalListeners = new Map;
-  listenTransactional(event, listener) {
-    const handlers = this.transactionalListeners.get(event) ?? new Set;
-    handlers.add(listener);
-    this.transactionalListeners.set(event, handlers);
-    return () => {
-      handlers.delete(listener);
-      if (!handlers.size)
-        this.transactionalListeners.delete(event);
-    };
-  }
-  hasTransactionalListeners(event) {
-    return (this.transactionalListeners.get(event)?.size ?? 0) > 0;
-  }
-  async dispatchTransactional(event, payload) {
-    for (const listener of this.transactionalListeners.get(event) ?? [])
-      await listener(payload);
-  }
-  listeners = new Map;
-  on(event, listener) {
-    return this.listen(event, listener);
-  }
-  listen(event, listener) {
-    const handlers = this.listeners.get(event) ?? new Set;
-    handlers.add(listener);
-    this.listeners.set(event, handlers);
-    return () => {
-      handlers.delete(listener);
-      if (handlers.size === 0) {
-        this.listeners.delete(event);
-      }
-    };
-  }
-  async emit(event, payload) {
-    await this.dispatch(event, payload);
-  }
-  async dispatch(event, payload) {
-    const handlers = this.listeners.get(event);
-    if (!handlers || handlers.size === 0) {
-      return;
-    }
-    for (const handler of handlers) {
-      await handler(payload);
-    }
-  }
-}
-function readSharedEventBus() {
-  const globalBus = globalThis[EVENT_BUS_KEY];
-  if (globalBus) {
-    return globalBus;
-  }
-  const bus = new EventBus;
-  globalThis[EVENT_BUS_KEY] = bus;
-  return bus;
-}
-var EVENT_BUS_KEY, eventBus;
-var init_eventBus = __esm(() => {
-  EVENT_BUS_KEY = Symbol.for("@getstrata/eventBus");
-  eventBus = readSharedEventBus();
-});
-
-// ../../src/core/events/deferredModelEvents.ts
-function sameTenant(left, right) {
-  if (left === null && right === null) {
-    return true;
-  }
-  if (left === null || right === null) {
-    return false;
-  }
-  return left.id === right.id;
-}
-function groupQueuedModelEvents(queued) {
-  const groups = [];
-  for (const item of queued) {
-    const lastGroup = groups[groups.length - 1];
-    const last = lastGroup?.[lastGroup.length - 1];
-    if (!lastGroup || !last || !sameTenant(last.tenant, item.tenant)) {
-      groups.push([item]);
-    } else {
-      lastGroup.push(item);
-    }
-  }
-  return groups;
-}
-async function dispatchEventBatch(batch) {
-  for (const item of batch) {
-    await eventBus.dispatch(item.event, item.payload);
-  }
-}
-async function dispatchQueuedModelEvents(queued) {
-  if (queued.length === 0) {
-    return;
-  }
-  await Promise.resolve().then(() => init_tenantDatabaseScope());
-  for (const batch of groupQueuedModelEvents(queued)) {
-    const tenant = batch[0]?.tenant ?? null;
-    if (tenant) {
-      await runWithTenantDatabase(tenant, () => dispatchEventBatch(batch));
-    } else {
-      await dispatchEventBatch(batch);
-    }
-  }
-}
-async function runWithDeferredModelEvents(callback) {
-  const existing = deferredModelEvents.getStore();
-  if (existing) {
-    existing.frames.push([]);
-    existing.rollbackFrames.push([]);
-    try {
-      const result = await callback();
-      const nested = existing.frames.pop() ?? [];
-      const rollback = existing.rollbackFrames.pop() ?? [];
-      existing.rollbackFrames.at(-1)?.push(...rollback);
-      const parent = existing.frames[existing.frames.length - 1];
-      if (parent) {
-        parent.push(...nested);
-      }
-      return result;
-    } catch (error) {
-      existing.frames.pop();
-      for (const rollback of (existing.rollbackFrames.pop() ?? []).reverse())
-        rollback();
-      throw error;
-    }
-  }
-  const state = { frames: [[]], rollbackFrames: [[]] };
-  let result;
-  try {
-    result = await deferredModelEvents.run(state, callback);
-  } catch (error) {
-    for (const rollback of (state.rollbackFrames[0] ?? []).reverse())
-      rollback();
-    throw error;
-  }
-  await dispatchQueuedModelEvents(state.frames[0] ?? []);
-  return result;
-}
-var deferredModelEvents;
-var init_deferredModelEvents = __esm(() => {
-  init_asyncContextStore();
-  init_tenantContext();
-  init_eventBus();
-  deferredModelEvents = createAsyncContextStore("@getstrata/deferredModelEvents");
-});
-
 // ../../src/core/database/acquisitionMetrics.ts
 async function observeTransactionAcquisition(metrics, acquire, signal) {
   const state = states.get(metrics);
@@ -755,16 +649,38 @@ var init_transaction = __esm(() => {
   outerFrames = new WeakMap;
 });
 
-// ../../src/core/tenant/databaseTenantContext.ts
-import { getDefaultDatabasePool as getDefaultDatabasePool2 } from "@getstrata/core/database/defaultConnection";
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
-async function applyBypassToTransaction(transaction, bypass) {
-  await transaction.unsafe(`SELECT set_config('app.bypass_rls', $1, true)`, [
-    bypass ? "true" : "false"
-  ]);
-}
-function stringifyBypassIdentifier(identifier) {
-  if (typeof identifier === "number") {
+// ../../src/core/tenant/tenancyConfig.ts
+function readTenancyDriver(env = process.env) {
+  const raw = env.TENANCY_DRIVER?.trim();
+  if (raw === undefined || raw === "") {
+    return "rls";
+  }
+  if (TENANCY_DRIVERS.includes(raw)) {
+    return raw;
+  }
+  throw new Error(`TENANCY_DRIVER must be one of ${TENANCY_DRIVERS.join(", ")}; received "${raw}".`);
+}
+function isTenancyEnabled(env = process.env) {
+  return readTenancyDriver(env) !== "none";
+}
+function isRlsTenancy(env = process.env) {
+  return readTenancyDriver(env) === "rls";
+}
+var TENANCY_DRIVERS;
+var init_tenancyConfig = __esm(() => {
+  TENANCY_DRIVERS = ["rls", "column", "none"];
+});
+
+// ../../src/core/tenant/databaseTenantContext.ts
+import { getDefaultDatabasePool as getDefaultDatabasePool2 } from "@getstrata/core/database/defaultConnection";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+async function applyBypassToTransaction(transaction, bypass) {
+  await transaction.unsafe(`SELECT set_config('app.bypass_rls', $1, true)`, [
+    bypass ? "true" : "false"
+  ]);
+}
+function stringifyBypassIdentifier(identifier) {
+  if (typeof identifier === "number") {
     return String(identifier);
   }
   return identifier.trim();
@@ -875,6 +791,104 @@ var init_tenantDatabaseScope = __esm(() => {
   init_tenantContext();
 });
 
+// ../../src/core/events/deferredModelEvents.ts
+function sameTenant(left, right) {
+  if (left === null && right === null) {
+    return true;
+  }
+  if (left === null || right === null) {
+    return false;
+  }
+  return left.id === right.id;
+}
+function groupQueuedModelEvents(queued) {
+  const groups = [];
+  for (const item of queued) {
+    const lastGroup = groups[groups.length - 1];
+    const last = lastGroup?.[lastGroup.length - 1];
+    if (!lastGroup || !last || !sameTenant(last.tenant, item.tenant)) {
+      groups.push([item]);
+    } else {
+      lastGroup.push(item);
+    }
+  }
+  return groups;
+}
+async function dispatchEventBatch(batch) {
+  for (const item of batch) {
+    await eventBus.dispatch(item.event, item.payload);
+  }
+}
+async function dispatchQueuedModelEvents(queued) {
+  if (queued.length === 0) {
+    return;
+  }
+  await Promise.resolve().then(() => init_tenantDatabaseScope());
+  for (const batch of groupQueuedModelEvents(queued)) {
+    const tenant = batch[0]?.tenant ?? null;
+    if (tenant) {
+      await runWithTenantDatabase(tenant, () => dispatchEventBatch(batch));
+    } else {
+      await dispatchEventBatch(batch);
+    }
+  }
+}
+async function dispatchModelEvent(event, payload) {
+  await eventBus.dispatchTransactional(event, payload);
+  const state = deferredModelEvents.getStore();
+  const frame = state?.frames[state.frames.length - 1];
+  if (frame) {
+    frame.push({
+      event,
+      payload,
+      tenant: currentTenant()
+    });
+    return;
+  }
+  await eventBus.dispatch(event, payload);
+}
+async function runWithDeferredModelEvents(callback) {
+  const existing = deferredModelEvents.getStore();
+  if (existing) {
+    existing.frames.push([]);
+    existing.rollbackFrames.push([]);
+    try {
+      const result = await callback();
+      const nested = existing.frames.pop() ?? [];
+      const rollback = existing.rollbackFrames.pop() ?? [];
+      existing.rollbackFrames.at(-1)?.push(...rollback);
+      const parent = existing.frames[existing.frames.length - 1];
+      if (parent) {
+        parent.push(...nested);
+      }
+      return result;
+    } catch (error) {
+      existing.frames.pop();
+      for (const rollback of (existing.rollbackFrames.pop() ?? []).reverse())
+        rollback();
+      throw error;
+    }
+  }
+  const state = { frames: [[]], rollbackFrames: [[]] };
+  let result;
+  try {
+    result = await deferredModelEvents.run(state, callback);
+  } catch (error) {
+    for (const rollback of (state.rollbackFrames[0] ?? []).reverse())
+      rollback();
+    throw error;
+  }
+  await dispatchQueuedModelEvents(state.frames[0] ?? []);
+  return result;
+}
+var deferredModelEvents;
+var init_deferredModelEvents = __esm(() => {
+  init_asyncContextStore();
+  init_tenantContext();
+  init_eventBus();
+  deferredModelEvents = createAsyncContextStore("@getstrata/deferredModelEvents");
+});
+
 // ../../src/core/auth/scimAuthMiddleware.ts
 init_connectionContext();
 import { bindDatabaseConnection } from "@getstrata/core/database/bindConnection";
@@ -932,9 +946,2137 @@ function resolveScimTenantFromToken(token) {
   return null;
 }
 
+// ../../src/core/database/baseRepository.ts
+init_eventBus();
+
+// ../../src/core/events/index.ts
+init_deferredModelEvents();
+init_eventBus();
+function modelEventName(tableName, action) {
+  return `${tableName}.${action}`;
+}
+
+// ../../src/core/pagination/index.ts
+function buildPaginationMeta(input) {
+  const lastPage = Math.max(1, Math.ceil(input.total / input.perPage));
+  return {
+    page: input.page,
+    per_page: input.perPage,
+    total: input.total,
+    last_page: lastPage
+  };
+}
+
+// ../../src/core/database/baseRepository.ts
+init_connectionContext();
+init_dialect();
+
+// ../../src/core/database/errors.ts
+import {
+  BadRequestError,
+  ConflictError,
+  InternalServerError,
+  toHttpError,
+  UnprocessableEntityError
+} from "@getstrata/core/errors/http";
+function isPostgresError(error) {
+  return typeof error === "object" && error !== null && (("errno" in error) || ("code" in error));
+}
+function getPostgresSqlState(error) {
+  if (typeof error.errno === "string" && /^\d{5}$/.test(error.errno)) {
+    return error.errno;
+  }
+  if (typeof error.errno === "number") {
+    return String(error.errno).padStart(5, "0");
+  }
+  if (typeof error.code === "string" && /^\d{5}$/.test(error.code)) {
+    return error.code;
+  }
+  return;
+}
+var MYSQL_ERRNO_MESSAGES = {
+  1062: () => new ConflictError("A record with these values already exists."),
+  1451: () => new UnprocessableEntityError("Record is still referenced by other records."),
+  1452: () => new UnprocessableEntityError("Referenced record does not exist."),
+  1048: () => new BadRequestError("Required field is missing."),
+  3819: () => new BadRequestError("Value violates a database constraint.")
+};
+function mapSqliteError(error) {
+  const code = typeof error.code === "string" ? error.code : "";
+  if (!code.startsWith("SQLITE_")) {
+    return null;
+  }
+  if (code === "SQLITE_CONSTRAINT_UNIQUE" || code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
+    return new ConflictError("A record with these values already exists.");
+  }
+  if (code === "SQLITE_CONSTRAINT_FOREIGNKEY") {
+    return new UnprocessableEntityError("Operation conflicts with related records.");
+  }
+  if (code === "SQLITE_CONSTRAINT_NOTNULL") {
+    return new BadRequestError("Required field is missing.");
+  }
+  if (code.startsWith("SQLITE_CONSTRAINT")) {
+    return new BadRequestError("Value violates a database constraint.");
+  }
+  return new InternalServerError("Database operation failed.");
+}
+function mapMysqlError(error) {
+  const code = typeof error.code === "string" ? error.code : "";
+  if (!code.startsWith("ER_")) {
+    return null;
+  }
+  const factory = typeof error.errno === "number" ? MYSQL_ERRNO_MESSAGES[error.errno] : undefined;
+  return factory ? factory() : new InternalServerError("Database operation failed.");
+}
+function mapDatabaseError(error) {
+  const httpError = toHttpError(error);
+  if (httpError) {
+    return httpError;
+  }
+  if (!isPostgresError(error)) {
+    return new InternalServerError;
+  }
+  const sqlite = mapSqliteError(error);
+  if (sqlite) {
+    return sqlite;
+  }
+  const mysql = mapMysqlError(error);
+  if (mysql) {
+    return mysql;
+  }
+  const sqlState = getPostgresSqlState(error);
+  switch (sqlState) {
+    case "23505":
+      if (error.detail) {
+        console.error("[database] unique violation", error.detail);
+      }
+      return new ConflictError("A record with these values already exists.");
+    case "23503":
+      if (error.detail) {
+        console.error("[database] foreign-key violation", error.detail);
+      }
+      return new UnprocessableEntityError("Operation conflicts with related records.");
+    case "23502":
+      if (error.detail) {
+        console.error("[database] not-null violation", error.detail);
+      }
+      return new BadRequestError("Required field is missing.");
+    case "23514":
+      if (error.detail) {
+        console.error("[database] check violation", error.detail);
+      }
+      return new BadRequestError("Value violates a database constraint.");
+    default:
+      return new InternalServerError("Database operation failed.");
+  }
+}
+async function withDatabaseErrorHandling(operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    throw mapDatabaseError(error);
+  }
+}
+function isUniqueConstraintError(error) {
+  if (!isPostgresError(error)) {
+    return false;
+  }
+  if (error.code === "SQLITE_CONSTRAINT_UNIQUE" || error.code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
+    return true;
+  }
+  if (error.errno === 1062) {
+    return true;
+  }
+  return getPostgresSqlState(error) === "23505";
+}
+
+// ../../src/core/database/keyset.ts
+init_dialect();
+var KEYSET_ALIAS_PREFIX = "__strata_keyset_";
+function validateKeyset(table, options) {
+  if (!Number.isInteger(options.perPage) || options.perPage < 1 || options.perPage > 1000)
+    throw new RangeError("Keyset page size must be between 1 and 1000.");
+  if (!Array.isArray(options.orderBy) || options.orderBy.length < 1 || options.orderBy.length > 8)
+    throw new TypeError("Keyset ordering requires between 1 and 8 columns.");
+  if (table.columns.some((column) => column.toLowerCase().startsWith(KEYSET_ALIAS_PREFIX)))
+    throw new TypeError("Table columns conflict with reserved keyset aliases.");
+  const seen = new Set;
+  const order = Array.from(options.orderBy).map(({ column, direction }) => {
+    if (!table.columns.includes(column) || seen.has(column) || !["asc", "desc"].includes(direction))
+      throw new TypeError("Invalid or duplicate keyset ordering column/direction.");
+    seen.add(column);
+    return { column, direction };
+  });
+  if (order.at(-1)?.column !== table.primaryKey)
+    throw new TypeError("Keyset ordering must end with the table primary key.");
+  if (options.cursor !== undefined) {
+    const cursor = options.cursor;
+    if (cursor?.version !== 1 || !Array.isArray(cursor.order) || cursor.order.length !== order.length || !Array.isArray(cursor.values) || cursor.values.length !== order.length || Array.from(cursor.order).some((item, i) => !item || item.column !== order[i]?.column || item.direction !== order[i]?.direction) || Array.from(cursor.values).some((value) => typeof value !== "string" || value.length > 4096))
+      throw new TypeError("Invalid keyset cursor or ordering mismatch.");
+  }
+  return order;
+}
+function keysetBoundary(order, cursor) {
+  if (!cursor)
+    return [];
+  if (currentSqlDialect().driver === "pgsql" && order.length > 1 && order.every((item) => item.direction === order[0]?.direction)) {
+    return [
+      {
+        kind: "and",
+        compareRow: {
+          columns: order.map((item) => item.column),
+          operator: order[0]?.direction === "asc" ? "gt" : "lt",
+          values: [...cursor.values]
+        }
+      }
+    ];
+  }
+  const branches = order.map((item, i) => {
+    const where = {};
+    order.slice(0, i).forEach((prefix, j) => {
+      where[prefix.column] = cursor.values[j];
+    });
+    where[item.column] = { [item.direction === "asc" ? "gt" : "lt"]: cursor.values[i] };
+    return { kind: i === 0 ? "and" : "or", where };
+  });
+  return [{ kind: "and", group: branches }];
+}
+
+// ../../src/core/database/query.ts
+import { currentSqlDialect as currentSqlDialect2 } from "@getstrata/core/database/dialect";
+function quoteIdentifier(identifier) {
+  return currentSqlDialect2().quoteIdentifier(identifier);
+}
+function returningSuffix(columns) {
+  return currentSqlDialect2().returningClause(columns);
+}
+function qualifyColumn(tableName, column) {
+  return `${quoteIdentifier(tableName)}.${quoteIdentifier(column)}`;
+}
+function resolveQualifiedColumn(defaultTable, columnName) {
+  if (columnName.includes(".")) {
+    const [table, column] = columnName.split(".", 2);
+    if (!table || !column) {
+      throw new Error(`Invalid qualified column: ${columnName}`);
+    }
+    return qualifyColumn(table, column);
+  }
+  return qualifyColumn(defaultTable, columnName);
+}
+function parseQualifiedColumn(reference) {
+  const [table, column] = reference.split(".", 2);
+  if (!table || !column) {
+    throw new Error(`Join columns must be qualified as table.column: ${reference}`);
+  }
+  return { table, column };
+}
+function normalizeDirection(direction = "ASC") {
+  return direction.toUpperCase() === "DESC" ? "DESC" : "ASC";
+}
+function isQueryOperator(value) {
+  return value !== null && !Array.isArray(value) && !(value instanceof Date) && typeof value === "object";
+}
+function pushParam(values, value) {
+  values.push(value);
+  return currentSqlDialect2().placeholder(values.length);
+}
+var SUPPORTED_OPERATORS = new Set([
+  "eq",
+  "ne",
+  "in",
+  "notIn",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "isNull",
+  "ilike",
+  "tsMatch"
+]);
+function buildInClause(column, values, params, negated = false) {
+  if (values.length === 0) {
+    return negated ? "1 = 1" : "1 = 0";
+  }
+  const placeholders = values.map((value) => pushParam(params, value)).join(", ");
+  return `${column}${negated ? " NOT" : ""} IN (${placeholders})`;
+}
+function buildOperatorClauses(column, operator, params) {
+  const clauses = [];
+  const unsupported = Object.keys(operator).filter((key) => !SUPPORTED_OPERATORS.has(key));
+  if (unsupported.length > 0) {
+    throw new Error(`Unsupported query operator(s) for ${column}: ${unsupported.join(", ")}. Supported: ${[...SUPPORTED_OPERATORS].join(", ")}.`);
+  }
+  if (operator.isNull === true) {
+    clauses.push(`${column} IS NULL`);
+  }
+  if (operator.isNull === false) {
+    clauses.push(`${column} IS NOT NULL`);
+  }
+  if (operator.eq !== undefined) {
+    if (operator.eq === null) {
+      clauses.push(`${column} IS NULL`);
+    } else {
+      clauses.push(`${column} = ${pushParam(params, operator.eq)}`);
+    }
+  }
+  if (operator.ne !== undefined) {
+    if (operator.ne === null) {
+      clauses.push(`${column} IS NOT NULL`);
+    } else {
+      clauses.push(`${column} <> ${pushParam(params, operator.ne)}`);
+    }
+  }
+  if (operator.in !== undefined) {
+    clauses.push(buildInClause(column, operator.in, params));
+  }
+  if (operator.notIn !== undefined) {
+    clauses.push(buildInClause(column, operator.notIn, params, true));
+  }
+  if (operator.gt !== undefined) {
+    clauses.push(`${column} > ${pushParam(params, operator.gt)}`);
+  }
+  if (operator.gte !== undefined) {
+    clauses.push(`${column} >= ${pushParam(params, operator.gte)}`);
+  }
+  if (operator.lt !== undefined) {
+    clauses.push(`${column} < ${pushParam(params, operator.lt)}`);
+  }
+  if (operator.lte !== undefined) {
+    clauses.push(`${column} <= ${pushParam(params, operator.lte)}`);
+  }
+  if (operator.ilike !== undefined) {
+    clauses.push(`${column} ${currentSqlDialect2().ilikeOperator()} ${pushParam(params, operator.ilike)}`);
+  }
+  if (operator.tsMatch !== undefined) {
+    if (currentSqlDialect2().driver !== "pgsql") {
+      throw new Error("Full-text search (tsMatch) is only available on PostgreSQL.");
+    }
+    clauses.push(`${column} @@ plainto_tsquery('english', ${pushParam(params, operator.tsMatch)})`);
+  }
+  return clauses;
+}
+function appendWhereParts(tableName, where, params) {
+  const clauses = [];
+  for (const [columnName, filterValue] of Object.entries(where)) {
+    if (filterValue === undefined) {
+      continue;
+    }
+    const column = resolveQualifiedColumn(tableName, columnName);
+    if (Array.isArray(filterValue)) {
+      clauses.push(buildInClause(column, filterValue, params));
+      continue;
+    }
+    if (isQueryOperator(filterValue)) {
+      clauses.push(...buildOperatorClauses(column, filterValue, params));
+      continue;
+    }
+    if (filterValue === null) {
+      clauses.push(`${column} IS NULL`);
+      continue;
+    }
+    clauses.push(`${column} = ${pushParam(params, filterValue)}`);
+  }
+  return clauses.join(" AND ");
+}
+function buildWhereClause(tableName, where = {}) {
+  const params = [];
+  const body = appendWhereParts(tableName, where, params);
+  return {
+    clause: body.length > 0 ? ` WHERE ${body}` : "",
+    params
+  };
+}
+function remapExistsSql(sql, existsParams, params) {
+  const offset = params.length;
+  params.push(...existsParams);
+  return sql.replace(/\$(\d+)/g, (_match, index) => `$${offset + Number(index)}`);
+}
+function buildWhereNodeClause(tableName, node, params) {
+  if ("compareRow" in node) {
+    const { columns, operator, values } = node.compareRow;
+    if (!Array.isArray(columns) || !columns.length || !Array.isArray(values) || columns.length !== values.length || !["lt", "gt"].includes(operator) || Array.from(columns).some((column) => typeof column !== "string" || !column.length))
+      throw new TypeError("Invalid row comparison columns, values or operator.");
+    return `(${columns.map((column) => qualifyColumn(tableName, column)).join(", ")}) ${operator === "lt" ? "<" : ">"} (${values.map((value) => pushParam(params, value)).join(", ")})`;
+  }
+  if ("exists" in node) {
+    const body = remapExistsSql(node.exists.sql, node.exists.params, params);
+    return `${node.exists.not ? "NOT " : ""}EXISTS (${body})`;
+  }
+  if ("where" in node) {
+    return appendWhereParts(tableName, node.where, params);
+  }
+  const grouped = buildWhereGroupClause(tableName, node.group, params);
+  if (!grouped) {
+    return "";
+  }
+  return grouped.includes(" OR ") ? `(${grouped})` : grouped;
+}
+function buildWhereGroupClause(tableName, nodes, params) {
+  let result = "";
+  for (const node of nodes) {
+    const part = buildWhereNodeClause(tableName, node, params);
+    if (!part) {
+      continue;
+    }
+    if (!result) {
+      result = part;
+      continue;
+    }
+    result = node.kind === "or" ? `${result} OR ${part}` : `${result} AND ${part}`;
+  }
+  if (!result) {
+    return "";
+  }
+  return result;
+}
+function buildAdvancedWhereClause(tableName, where = {}, whereNodes = [], params = []) {
+  const nodes = [];
+  if (Object.keys(where).length > 0) {
+    nodes.push({ kind: "and", where });
+  }
+  nodes.push(...whereNodes);
+  const combined = buildWhereGroupClause(tableName, nodes, params);
+  return {
+    clause: combined ? ` WHERE ${combined}` : "",
+    params
+  };
+}
+function resolveSoftDeleteColumn(table) {
+  if (!table.softDeletes) {
+    return null;
+  }
+  if (table.softDeletes === true) {
+    return "deleted_at";
+  }
+  return table.softDeletes.column ?? "deleted_at";
+}
+function appendSoftDeleteScope(table, options, clauses) {
+  const column = resolveSoftDeleteColumn(table);
+  if (!column) {
+    return;
+  }
+  const qualifiedColumn = qualifyColumn(table.name, column);
+  if (options.onlyTrashed) {
+    clauses.push(`${qualifiedColumn} IS NOT NULL`);
+    return;
+  }
+  if (!options.withTrashed) {
+    clauses.push(`${qualifiedColumn} IS NULL`);
+  }
+}
+function buildQueryWhereClause(table, options = {}, whereNodes = [], params = []) {
+  const { clause, params: whereParams } = buildAdvancedWhereClause(table.name, options.where ?? {}, whereNodes, params);
+  const softDeleteClauses = [];
+  appendSoftDeleteScope(table, options, softDeleteClauses);
+  if (softDeleteClauses.length === 0) {
+    return { clause, params: whereParams };
+  }
+  const base = clause.replace(/^ WHERE /, "");
+  const scope = softDeleteClauses.join(" AND ");
+  return {
+    clause: base ? ` WHERE (${base}) AND ${scope}` : ` WHERE ${scope}`,
+    params: whereParams
+  };
+}
+function isQueryOrder(value) {
+  return "column" in value;
+}
+function normalizeOrderBy(orderBy) {
+  if (!orderBy) {
+    return [];
+  }
+  if (Array.isArray(orderBy)) {
+    return orderBy;
+  }
+  if (isQueryOrder(orderBy)) {
+    return [orderBy];
+  }
+  return Object.entries(orderBy).map(([column, direction]) => ({
+    column,
+    direction
+  }));
+}
+function buildOrderByClause(tableName, orderBy) {
+  const parts = normalizeOrderBy(orderBy).map(({ column, direction, nulls }) => {
+    if (nulls !== undefined && nulls !== "first" && nulls !== "last") {
+      throw new TypeError("Invalid null ordering: expected first or last.");
+    }
+    const reference = resolveQualifiedColumn(tableName, column);
+    const ordered = `${reference} ${normalizeDirection(direction)}`;
+    if (nulls === undefined)
+      return ordered;
+    if (currentSqlDialect2().driver === "mysql") {
+      return `(${reference} IS NULL) ${nulls === "first" ? "DESC" : "ASC"}, ${ordered}`;
+    }
+    return `${ordered} NULLS ${nulls.toUpperCase()}`;
+  });
+  return parts.length > 0 ? ` ORDER BY ${parts.join(", ")}` : "";
+}
+function buildGroupByClause(tableName, groupBy) {
+  if (!groupBy) {
+    return "";
+  }
+  const columns = (Array.isArray(groupBy) ? groupBy : [groupBy]).map((column) => String(column));
+  const parts = columns.map((column) => resolveQualifiedColumn(tableName, column));
+  return parts.length > 0 ? ` GROUP BY ${parts.join(", ")}` : "";
+}
+function buildHavingClause(tableName, having, params) {
+  if (!having) {
+    return "";
+  }
+  const body = appendWhereParts(tableName, having, params);
+  return body.length > 0 ? ` HAVING ${body}` : "";
+}
+function buildJoinClause(joins = []) {
+  return joins.map((join) => {
+    const joinType = join.type === "left" ? "LEFT JOIN" : "INNER JOIN";
+    const onClause = join.on.map(({ left, right }) => `${qualifyColumn(left.table, left.column)} = ${qualifyColumn(right.table, right.column)}`).join(" AND ");
+    return ` ${joinType} ${quoteIdentifier(join.table)} ON ${onClause}`;
+  }).join("");
+}
+function buildLimitClause(limit) {
+  if (limit === undefined) {
+    return "";
+  }
+  if (!Number.isInteger(limit) || limit <= 0) {
+    throw new Error("Query limit must be a positive integer.");
+  }
+  return ` LIMIT ${limit}`;
+}
+function buildOffsetClause(offset) {
+  if (offset === undefined) {
+    return "";
+  }
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw new Error("Query offset must be a non-negative integer.");
+  }
+  return ` OFFSET ${offset}`;
+}
+function buildReturningColumns(table) {
+  return table.columns.map((column) => qualifyColumn(table.name, column)).join(", ");
+}
+function buildSelectList(table, select, params = []) {
+  if (!select || select.length === 0) {
+    return buildReturningColumns(table);
+  }
+  return select.map((item) => {
+    if (item.kind === "column") {
+      const column = qualifyColumn(item.table, item.column);
+      return item.as ? `${column} AS ${quoteIdentifier(item.as)}` : column;
+    }
+    if (item.kind === "textColumn") {
+      const dialect = currentSqlDialect2();
+      const column = qualifyColumn(item.table, item.column);
+      const text = dialect.driver === "sqlite" ? `CASE WHEN typeof(${column}) = 'real' THEN printf('%!.26g', ${column}) ELSE ${dialect.castToText(column)} END` : dialect.castToText(column);
+      return `${text} AS ${quoteIdentifier(item.as)}`;
+    }
+    if (item.kind === "literalText") {
+      return `${currentSqlDialect2().castToText(pushParam(params, item.value))} AS ${quoteIdentifier(item.as)}`;
+    }
+    if (item.kind === "subqueryCount") {
+      const body = remapExistsSql(item.sql, item.params, params);
+      return `(${body}) AS ${quoteIdentifier(item.as)}`;
+    }
+    const column = qualifyColumn(item.table, item.column);
+    const placeholder = pushParam(params, item.query);
+    return `ts_rank(${column}, plainto_tsquery('english', ${placeholder})) AS ${quoteIdentifier(item.as)}`;
+  }).join(", ");
+}
+function getDefinedColumnEntries(table, values, options = {}) {
+  const record = values;
+  const excluded = new Set(options.exclude ?? []);
+  return table.columns.flatMap((column) => {
+    if (excluded.has(column) || !Object.hasOwn(record, column)) {
+      return [];
+    }
+    const value = record[column];
+    if (value === undefined) {
+      return [];
+    }
+    return [[column, value]];
+  });
+}
+function buildSelectLock(table, options) {
+  const lock = options.lock;
+  if (!lock)
+    return "";
+  const driver = currentSqlDialect2().driver;
+  if (driver === "sqlite")
+    throw new Error("Row locks are not supported on SQLite; use an explicit write transaction.");
+  if (lock.mode !== "update" && lock.mode !== "share")
+    throw new TypeError("Invalid row lock mode.");
+  if (lock.wait !== undefined && !["wait", "nowait", "skipLocked"].includes(lock.wait))
+    throw new TypeError("Invalid row lock wait policy.");
+  if (options.groupBy || options.having)
+    throw new Error("Row locks cannot be combined with grouped/aggregate queries.");
+  let target = "";
+  if (lock.of !== undefined) {
+    if (driver !== "pgsql")
+      throw new Error("Row lock targets are supported only on PostgreSQL.");
+    const tables = [table.name, ...(options.joins ?? []).map((join) => join.table)];
+    if (!lock.of.length || lock.of.some((name) => !tables.includes(name)))
+      throw new TypeError("Row lock targets must name tables in this query.");
+    target = ` OF ${lock.of.map(quoteIdentifier).join(", ")}`;
+  }
+  const wait = lock.wait === "nowait" ? " NOWAIT" : lock.wait === "skipLocked" ? " SKIP LOCKED" : "";
+  return ` FOR ${lock.mode === "update" ? "UPDATE" : "SHARE"}${target}${wait}`;
+}
+function buildSelectQuery(table, options = {}, whereNodes = []) {
+  const params = [];
+  const columns = buildSelectList(table, options.select, params);
+  const { clause } = buildQueryWhereClause(table, options, whereNodes, params);
+  const joins = buildJoinClause(options.joins);
+  const groupBy = buildGroupByClause(table.name, options.groupBy);
+  const havingClause = buildHavingClause(table.name, options.having, params);
+  const orderBy = buildOrderByClause(table.name, options.orderBy ?? table.defaultOrderBy);
+  const limit = buildLimitClause(options.limit);
+  const offset = buildOffsetClause(options.offset);
+  const lock = buildSelectLock(table, options);
+  return {
+    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}${lock}`,
+    params
+  };
+}
+function buildCountQuery(table, where = {}, options = {}, whereNodes = []) {
+  const params = [];
+  const { clause, params: whereParams } = buildQueryWhereClause(table, {
+    where,
+    withTrashed: options.withTrashed,
+    onlyTrashed: options.onlyTrashed
+  }, whereNodes);
+  params.push(...whereParams);
+  const joins = buildJoinClause(options.joins);
+  const groupBy = buildGroupByClause(table.name, options.groupBy);
+  return {
+    text: `SELECT COUNT(*) AS count FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}`,
+    params
+  };
+}
+function buildProjectionQuery(table, expression, alias, options = {}, whereNodes = []) {
+  assertSafeProjectionExpression(expression);
+  const params = [];
+  const { clause, params: whereParams } = buildQueryWhereClause(table, options, whereNodes);
+  params.push(...whereParams);
+  const joins = buildJoinClause(options.joins);
+  const groupBy = buildGroupByClause(table.name, options.groupBy);
+  const orderBy = buildOrderByClause(table.name, options.orderBy);
+  const limit = buildLimitClause(options.limit);
+  return {
+    text: `SELECT ${expression} AS ${quoteIdentifier(alias)} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${orderBy}${limit}`,
+    params
+  };
+}
+var SAFE_PROJECTION_EXPRESSION = /^(COUNT\(\*\)|(?:"[\w_]+"(?:\."[\w_]+")?)|(?:AVG|SUM|MIN|MAX)\((?:"[\w_]+"(?:\."[\w_]+")?)\))$/;
+function assertSafeProjectionExpression(expression) {
+  if (!SAFE_PROJECTION_EXPRESSION.test(expression.trim())) {
+    throw new Error(`Unsafe projection expression: ${expression}`);
+  }
+}
+function buildGroupedSumQuery(table, groupColumn, column, options = {}, whereNodes = options.whereNodes ?? []) {
+  if (!table.columns.includes(groupColumn) || !table.columns.includes(column))
+    throw new TypeError("Grouped sums require declared columns.");
+  for (const key of Object.keys(options))
+    if (!["where", "whereNodes", "withTrashed", "onlyTrashed"].includes(key))
+      throw new TypeError("Grouped sums do not support joins, selection, ordering, pagination, grouping or locks.");
+  const group = qualifyColumn(table.name, groupColumn);
+  const total = currentSqlDialect2().castToText(`SUM(${qualifyColumn(table.name, column)})`);
+  const { clause, params } = buildQueryWhereClause(table, options, whereNodes);
+  return {
+    text: `SELECT ${group} AS ${quoteIdentifier("value")}, ${total} AS ${quoteIdentifier("sum")} FROM ${quoteIdentifier(table.name)}${clause} GROUP BY ${group} ORDER BY ${group} ASC`,
+    params
+  };
+}
+function buildGroupedCountQuery(table, column, where = {}, options = {}) {
+  const qualifiedColumn = qualifyColumn(table.name, column);
+  const { clause, params } = buildQueryWhereClause(table, {
+    where,
+    ...options
+  });
+  return {
+    text: `SELECT ${qualifiedColumn} AS ${quoteIdentifier("value")}, COUNT(*) AS ${quoteIdentifier("count")} FROM ${quoteIdentifier(table.name)}${clause} GROUP BY ${qualifiedColumn} ORDER BY ${qualifiedColumn} ASC`,
+    params
+  };
+}
+function buildInsertQuery(table, values) {
+  const entries = getDefinedColumnEntries(table, values);
+  if (entries.length === 0) {
+    throw new Error(`Cannot insert into ${table.name} without any column values.`);
+  }
+  const params = [];
+  const columns = entries.map(([column]) => quoteIdentifier(column)).join(", ");
+  const placeholders = entries.map(([, value]) => pushParam(params, value)).join(", ");
+  const returningColumns = buildReturningColumns(table);
+  return {
+    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders})${returningSuffix(returningColumns)}`,
+    params
+  };
+}
+function buildUpsertQuery(table, values, conflictColumns, updateColumns) {
+  const entries = getDefinedColumnEntries(table, values);
+  if (entries.length === 0) {
+    throw new Error(`Cannot upsert into ${table.name} without any column values.`);
+  }
+  if (conflictColumns.length === 0) {
+    throw new Error(`Cannot upsert into ${table.name} without any conflict columns.`);
+  }
+  const insertable = new Set(entries.map(([column]) => column));
+  const conflict = new Set(conflictColumns);
+  const updatable = (updateColumns ?? entries.map(([column]) => column).filter((c) => !conflict.has(c))).filter((column) => insertable.has(column));
+  const params = [];
+  const columns = entries.map(([column]) => quoteIdentifier(column)).join(", ");
+  const placeholders = entries.map(([, value]) => pushParam(params, value)).join(", ");
+  const returningColumns = buildReturningColumns(table);
+  const suffix = currentSqlDialect2().upsertSuffix(conflictColumns, updatable);
+  return {
+    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders})${suffix}${returningSuffix(returningColumns)}`,
+    params
+  };
+}
+function buildIncrementQuery(table, id, column, amount, extra = {}) {
+  if (!Number.isFinite(amount)) {
+    throw new Error("Increment amount must be a finite number.");
+  }
+  if (!table.columns.includes(column)) {
+    throw new Error(`Unknown column ${String(column)} on ${table.name}.`);
+  }
+  const params = [];
+  const target = quoteIdentifier(column);
+  const assignments = [`${target} = ${target} + ${pushParam(params, amount)}`];
+  for (const [name, value] of getDefinedColumnEntries(table, extra, {
+    exclude: [table.primaryKey, column]
+  })) {
+    assignments.push(`${quoteIdentifier(name)} = ${pushParam(params, value)}`);
+  }
+  const primaryKeyPlaceholder = pushParam(params, id);
+  const returningColumns = buildReturningColumns(table);
+  const scopeClauses = [];
+  appendSoftDeleteScope(table, {}, scopeClauses);
+  const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
+  return {
+    text: `UPDATE ${quoteIdentifier(table.name)} SET ${assignments.join(", ")} WHERE ${quoteIdentifier(table.primaryKey)} = ${primaryKeyPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
+    params
+  };
+}
+function buildUpdateQuery(table, id, changes) {
+  const entries = getDefinedColumnEntries(table, changes, {
+    exclude: [table.primaryKey]
+  });
+  if (entries.length === 0) {
+    throw new Error(`Cannot update ${table.name} without any changed column values.`);
+  }
+  const params = [];
+  const setClause = entries.map(([column, value]) => `${quoteIdentifier(column)} = ${pushParam(params, value)}`).join(", ");
+  const primaryKeyPlaceholder = pushParam(params, id);
+  const returningColumns = buildReturningColumns(table);
+  const scopeClauses = [];
+  appendSoftDeleteScope(table, {}, scopeClauses);
+  const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
+  return {
+    text: `UPDATE ${quoteIdentifier(table.name)} SET ${setClause} WHERE ${quoteIdentifier(table.primaryKey)} = ${primaryKeyPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
+    params
+  };
+}
+function buildSoftDeleteByIdQuery(table, id, deletedAt) {
+  const deletedAtColumn = resolveSoftDeleteColumn(table);
+  if (!deletedAtColumn) {
+    throw new Error(`Table ${table.name} does not support soft deletes.`);
+  }
+  const returningColumns = buildReturningColumns(table);
+  const scopeClauses = [];
+  appendSoftDeleteScope(table, {}, scopeClauses);
+  const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
+  const params = [];
+  const deletedAtPlaceholder = pushParam(params, deletedAt);
+  const idPlaceholder = pushParam(params, id);
+  return {
+    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = ${deletedAtPlaceholder} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
+    params
+  };
+}
+function buildRestoreByIdQuery(table, id) {
+  const deletedAtColumn = resolveSoftDeleteColumn(table);
+  if (!deletedAtColumn) {
+    throw new Error(`Table ${table.name} does not support soft deletes.`);
+  }
+  const returningColumns = buildReturningColumns(table);
+  const params = [];
+  const deletedAtPlaceholder = pushParam(params, null);
+  const idPlaceholder = pushParam(params, id);
+  return {
+    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = ${deletedAtPlaceholder} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder} AND ${qualifyColumn(table.name, deletedAtColumn)} IS NOT NULL${returningSuffix(returningColumns)}`,
+    params
+  };
+}
+function buildDeleteByIdQuery(table, id) {
+  const params = [];
+  const idPlaceholder = pushParam(params, id);
+  const returning = returningSuffix(`${quoteIdentifier(table.primaryKey)} AS ${quoteIdentifier("deleted_id")}`);
+  return {
+    text: `DELETE FROM ${quoteIdentifier(table.name)} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder}${returning}`,
+    params
+  };
+}
+function buildConditionalWriteQuery(table, operation, changes, options, returning) {
+  for (const key of [
+    "joins",
+    "groupBy",
+    "having",
+    "select",
+    "orderBy",
+    "limit",
+    "offset",
+    "lock"
+  ]) {
+    if (options[key] !== undefined)
+      throw new Error(`Conditional writes do not support ${key}.`);
+  }
+  const params = [];
+  const predicate = buildAdvancedWhereClause(table.name, options.where ?? {}, options.whereNodes ?? []);
+  if (!predicate.clause)
+    throw new Error("Conditional writes require an explicit predicate.");
+  if (returning !== undefined && currentSqlDialect2().driver === "mysql")
+    throw new Error("Mutation RETURNING is not supported on MySQL.");
+  const columns = returning ?? [table.primaryKey];
+  if (!columns.length || columns.some((column) => !table.columns.includes(column)))
+    throw new Error("RETURNING columns must be nonempty declared table columns.");
+  const deletedAt = resolveSoftDeleteColumn(table);
+  const values = operation === "delete" && deletedAt ? { [deletedAt]: new Date } : changes;
+  let prefix;
+  if (operation === "update" || deletedAt) {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    if (!entries.length)
+      throw new Error("Conditional updates require at least one value.");
+    if (entries.some(([column]) => column === table.primaryKey || !table.columns.includes(column)))
+      throw new Error("Conditional updates require declared non-primary-key columns.");
+    const assignments = entries.map(([column, value]) => `${quoteIdentifier(column)} = ${pushParam(params, value)}`);
+    prefix = `UPDATE ${quoteIdentifier(table.name)} SET ${assignments.join(", ")}`;
+  } else
+    prefix = `DELETE FROM ${quoteIdentifier(table.name)}`;
+  const { clause } = buildQueryWhereClause(table, options, options.whereNodes ?? [], params);
+  return {
+    text: prefix + clause + returningSuffix(columns.map(quoteIdentifier).join(", ")),
+    params
+  };
+}
+
+// ../../src/core/database/relationships.ts
+function hasMany(definition) {
+  return {
+    type: "hasMany",
+    ...definition
+  };
+}
+function hasOne(definition) {
+  return {
+    type: "hasOne",
+    ...definition
+  };
+}
+function belongsTo(definition) {
+  return {
+    type: "belongsTo",
+    ...definition
+  };
+}
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
+}
+function belongsToMany(definition) {
+  return {
+    type: "belongsToMany",
+    ...definition
+  };
+}
+function relationMatchKey(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return BigInt(value).toString();
+  }
+  return String(value);
+}
+var relationLookupCache = new WeakMap;
+function indexedRelationLookup(map) {
+  const cached = relationLookupCache.get(map);
+  if (cached) {
+    return cached;
+  }
+  const indexed = new Map;
+  for (const [existing, value] of map) {
+    indexed.set(relationMatchKey(existing), value);
+  }
+  relationLookupCache.set(map, indexed);
+  return indexed;
+}
+function getByRelationKey(map, key) {
+  if (map.has(key)) {
+    return map.get(key);
+  }
+  const want = relationMatchKey(key);
+  if (want === "") {
+    return;
+  }
+  return indexedRelationLookup(map).get(want);
+}
+function indexHasManyRelation(parents, children, relation) {
+  const groups = new Map;
+  const originalKeys = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
+  }
+  for (const child of children) {
+    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
+    if (!group) {
+      continue;
+    }
+    group.push(child);
+  }
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
+}
+function indexHasOneRelation(parents, children, relation) {
+  const grouped = indexHasManyRelation(parents, children, relation);
+  const result = new Map;
+  for (const parent of parents) {
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
+    result.set(parent[relation.localKey], matches[0]);
+  }
+  return result;
+}
+function indexBelongsToRelation(children, parents, relation) {
+  const parentsById = new Map;
+  for (const parent of parents) {
+    parentsById.set(relationMatchKey(parent[relation.ownerKey]), parent);
+  }
+  const result = new Map;
+  for (const child of children) {
+    const foreignKey = child[relation.foreignKey];
+    const parent = parentsById.get(relationMatchKey(foreignKey));
+    if (parent) {
+      result.set(foreignKey, parent);
+    }
+  }
+  return result;
+}
+function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
+  const relatedById = new Map;
+  for (const related of relatedRows) {
+    relatedById.set(relationMatchKey(related[relation.relatedKey]), related);
+  }
+  const groups = new Map;
+  const originalKeys = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.parentKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.parentKey]);
+    }
+  }
+  for (const pivot of pivotRows) {
+    const group = groups.get(relationMatchKey(pivot[relation.foreignPivotKey]));
+    const related = relatedById.get(relationMatchKey(pivot[relation.relatedPivotKey]));
+    if (!group || !related) {
+      continue;
+    }
+    group.push(related);
+  }
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
+}
+function morphMany(definition) {
+  return {
+    type: "morphMany",
+    ...definition
+  };
+}
+function morphOne(definition) {
+  return {
+    type: "morphOne",
+    ...definition
+  };
+}
+function morphTo(definition) {
+  return {
+    type: "morphTo",
+    ...definition
+  };
+}
+function indexMorphManyRelation(parents, children, relation) {
+  const groups = new Map;
+  const originalKeys = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
+  }
+  for (const child of children) {
+    if (child[relation.morphTypeKey] !== relation.morphType) {
+      continue;
+    }
+    const group = groups.get(relationMatchKey(child[relation.morphIdKey]));
+    if (!group) {
+      continue;
+    }
+    group.push(child);
+  }
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
+}
+function indexMorphOneRelation(parents, children, relation) {
+  const grouped = indexMorphManyRelation(parents, children, relation);
+  const result = new Map;
+  for (const parent of parents) {
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
+    result.set(parent[relation.localKey], matches[0]);
+  }
+  return result;
+}
+function indexHasManyThroughRelation(parents, children, relation) {
+  const throughKey = relation.throughParentKey ?? "__through_parent_id";
+  const grouped = new Map;
+  for (const child of children) {
+    const key = relationMatchKey(child[throughKey]);
+    if (key === "") {
+      continue;
+    }
+    const existing = grouped.get(key) ?? [];
+    const { [throughKey]: _through, ...far } = child;
+    existing.push(far);
+    grouped.set(key, existing);
+  }
+  const result = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    result.set(parent[relation.localKey], grouped.get(key) ?? []);
+  }
+  return result;
+}
+function indexMorphToRelation(children, parentsByType, relation) {
+  const result = new Map;
+  for (const child of children) {
+    const morphType = String(child[relation.morphTypeKey]);
+    const parents = parentsByType.get(morphType);
+    if (!parents) {
+      continue;
+    }
+    const parent = getByRelationKey(parents, child[relation.morphIdKey]);
+    if (parent) {
+      result.set(child[relation.morphIdKey], parent);
+    }
+  }
+  return result;
+}
+
+// ../../src/core/database/baseRepository.ts
+init_repositoryConnection();
+
+// ../../src/core/database/pluck.ts
+function uniqueColumnSelect(table, columns) {
+  const seen = new Set;
+  const select = [];
+  for (const column of columns) {
+    if (seen.has(column)) {
+      continue;
+    }
+    seen.add(column);
+    select.push({ kind: "column", table, column, as: column });
+  }
+  return select;
+}
+function projectPluck(rows, column, keyBy) {
+  if (keyBy === undefined) {
+    return rows.map((row) => row[column]);
+  }
+  const keyed = new Map;
+  for (const row of rows) {
+    keyed.set(row[keyBy], row[column]);
+  }
+  return keyed;
+}
+
+// ../../src/core/database/whereBuilder.ts
+class WhereBuilder {
+  nodes = [];
+  where(where) {
+    this.nodes.push({ kind: "and", where });
+    return this;
+  }
+  orWhere(where) {
+    this.nodes.push({ kind: "or", where });
+    return this;
+  }
+  whereGroup(fn) {
+    const nested = new WhereBuilder;
+    fn(nested);
+    if (nested.nodes.length > 0) {
+      this.nodes.push({ kind: "and", group: nested.nodes });
+    }
+    return this;
+  }
+  orWhereGroup(fn) {
+    const nested = new WhereBuilder;
+    fn(nested);
+    if (nested.nodes.length > 0) {
+      this.nodes.push({ kind: "or", group: nested.nodes });
+    }
+    return this;
+  }
+}
+
+// ../../src/core/database/repositoryQuery.ts
+class RepositoryQuery {
+  repository;
+  whereClause;
+  queryOptions;
+  eagerLoads = [];
+  whereNodes = [];
+  protectedWhere = [];
+  constructor(repository, whereClause = {}, queryOptions = {}) {
+    this.repository = repository;
+    this.whereClause = whereClause;
+    this.queryOptions = queryOptions;
+  }
+  where(input) {
+    if (typeof input === "function") {
+      const builder = new WhereBuilder;
+      input(builder);
+      if (builder.nodes.length > 0)
+        this.whereNodes.push({ kind: "and", group: builder.nodes });
+      return this;
+    }
+    this.whereNodes.push({ kind: "and", where: { ...input } });
+    return this;
+  }
+  protectWhere() {
+    const nodes = [];
+    if (Object.keys(this.whereClause).length > 0) {
+      nodes.push({ kind: "and", where: this.whereClause });
+    }
+    nodes.push(...this.whereNodes);
+    if (nodes.length > 0)
+      this.protectedWhere.push({ kind: "and", group: nodes });
+    this.whereClause = {};
+    this.whereNodes.length = 0;
+    return this;
+  }
+  orWhere(input) {
+    if (typeof input === "function") {
+      const builder = new WhereBuilder;
+      input(builder);
+      if (builder.nodes.length > 0) {
+        this.whereNodes.push({ kind: "or", group: builder.nodes });
+      }
+      return this;
+    }
+    this.whereNodes.push({ kind: "or", where: input });
+    return this;
+  }
+  lockForUpdate(options = {}) {
+    this.queryOptions = {
+      ...this.queryOptions,
+      lock: { ...options, of: options.of ? [...options.of] : undefined, mode: "update" }
+    };
+    return this;
+  }
+  sharedLock(options = {}) {
+    this.queryOptions = {
+      ...this.queryOptions,
+      lock: { ...options, of: options.of ? [...options.of] : undefined, mode: "share" }
+    };
+    return this;
+  }
+  orderBy(orderBy) {
+    this.queryOptions = { ...this.queryOptions, orderBy };
+    return this;
+  }
+  limit(limit) {
+    this.queryOptions = { ...this.queryOptions, limit };
+    return this;
+  }
+  whereNull(column) {
+    return this.where({ [column]: null });
+  }
+  whereNotNull(column) {
+    return this.where({ [column]: { isNull: false } });
+  }
+  whereNotIn(column, values) {
+    return this.where({ [column]: { notIn: values } });
+  }
+  withSubqueryCount(alias, sql, params = []) {
+    const table = this.repository.getTable();
+    const existing = this.queryOptions.select ?? table.columns.map((column) => ({
+      kind: "column",
+      table: table.name,
+      column
+    }));
+    this.queryOptions = {
+      ...this.queryOptions,
+      select: [...existing, { kind: "subqueryCount", sql, params, as: alias }]
+    };
+    return this;
+  }
+  whereIn(column, values) {
+    return this.where({ [column]: values });
+  }
+  whereExists(sql, params = []) {
+    this.whereNodes.push({ kind: "and", exists: { sql, params } });
+    return this;
+  }
+  whereNotExists(sql, params = []) {
+    this.whereNodes.push({ kind: "and", exists: { sql, params, not: true } });
+    return this;
+  }
+  offset(offset) {
+    this.queryOptions = { ...this.queryOptions, offset };
+    return this;
+  }
+  join(left, right) {
+    return this.addJoin("inner", left, right);
+  }
+  leftJoin(left, right) {
+    return this.addJoin("left", left, right);
+  }
+  groupBy(groupBy) {
+    this.queryOptions = { ...this.queryOptions, groupBy };
+    return this;
+  }
+  having(having) {
+    this.queryOptions = { ...this.queryOptions, having };
+    return this;
+  }
+  withHasMany(as, relation, childRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "hasMany",
+      as,
+      relation,
+      repository: childRepository,
+      options
+    });
+    return this;
+  }
+  withBelongsTo(as, relation, parentRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "belongsTo",
+      as,
+      relation,
+      repository: parentRepository,
+      options
+    });
+    return this;
+  }
+  withMorphMany(as, relation, childRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "morphMany",
+      as,
+      relation,
+      repository: childRepository,
+      options
+    });
+    return this;
+  }
+  withMorphOne(as, relation, childRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "morphOne",
+      as,
+      relation,
+      repository: childRepository,
+      options
+    });
+    return this;
+  }
+  withMorphTo(as, relation, repositoriesByType, options = {}, optionsByType) {
+    this.eagerLoads.push({
+      kind: "morphTo",
+      morphOptions: optionsByType,
+      as,
+      relation,
+      repository: this.repository,
+      morphRepositories: repositoriesByType,
+      options
+    });
+    return this;
+  }
+  withBelongsToMany(as, relation, relatedRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "belongsToMany",
+      as,
+      relation,
+      repository: relatedRepository,
+      options
+    });
+    return this;
+  }
+  withHasManyThrough(as, relation, farRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "hasManyThrough",
+      as,
+      relation,
+      repository: farRepository,
+      options
+    });
+    return this;
+  }
+  withTrashed() {
+    this.queryOptions = { ...this.queryOptions, withTrashed: true };
+    return this;
+  }
+  onlyTrashed() {
+    this.queryOptions = { ...this.queryOptions, onlyTrashed: true };
+    return this;
+  }
+  async update(changes) {
+    this.assertNoMutationEagerLoads();
+    return this.repository.updateWhere(changes, this.buildOptions());
+  }
+  async updateReturning(changes, ...columns) {
+    this.assertNoMutationEagerLoads();
+    return this.repository.updateWhereReturning(changes, columns, this.buildOptions());
+  }
+  async delete() {
+    this.assertNoMutationEagerLoads();
+    return this.repository.deleteWhere(this.buildOptions());
+  }
+  assertNoMutationEagerLoads() {
+    if (this.eagerLoads.length)
+      throw new Error("Conditional writes do not support eager loading.");
+  }
+  async get() {
+    const rows = await this.repository.findAll(this.buildOptions());
+    return await this.attach(rows);
+  }
+  async first() {
+    const rows = await this.repository.findAll({ ...this.buildOptions(), limit: 1 });
+    const attached = await this.attach(rows);
+    return attached[0] ?? null;
+  }
+  async sumBy(groupColumn, column) {
+    if (this.eagerLoads.length)
+      throw new TypeError("Grouped sums do not support eager loading.");
+    return this.repository.sumBy(groupColumn, column, this.buildOptions());
+  }
+  async count() {
+    return await this.repository.count(this.buildOptions());
+  }
+  async pluck(column, keyBy) {
+    const rows = await this.repository.findAll({
+      ...this.buildOptions(),
+      select: uniqueColumnSelect(this.repository.getTable().name, keyBy === undefined || keyBy === column ? [column] : [column, keyBy])
+    });
+    if (keyBy === undefined) {
+      return projectPluck(rows, column);
+    }
+    return projectPluck(rows, column, keyBy);
+  }
+  async value(column) {
+    const rows = await this.repository.findAll({
+      ...this.buildOptions(),
+      select: uniqueColumnSelect(this.repository.getTable().name, [column]),
+      limit: 1
+    });
+    const row = rows[0];
+    if (row === undefined) {
+      return null;
+    }
+    return row[column];
+  }
+  async project(columns, limit) {
+    if (columns.length === 0)
+      throw new RangeError("A projection requires at least one column.");
+    const table = this.repository.getTable();
+    for (const column of columns)
+      if (!table.columns.includes(column))
+        throw new TypeError(`Unknown projection column: ${column}`);
+    return await this.repository.findAll({
+      ...this.buildOptions(),
+      ...limit === undefined ? {} : { limit },
+      select: uniqueColumnSelect(table.name, columns)
+    });
+  }
+  async attachToRows(rows) {
+    return await this.attach(rows);
+  }
+  async paginate(options) {
+    return await this.repository.paginate({
+      ...this.buildOptions(),
+      page: options.page,
+      perPage: options.perPage
+    });
+  }
+  async chunk(count, callback) {
+    await this.repository.chunk(count, async (rows) => callback(await this.attach(rows)), this.buildOptions());
+  }
+  async cursorPaginate(options) {
+    const page = await this.repository.cursorPaginate({ ...this.buildOptions(), ...options });
+    return { ...page, data: await this.attach(page.data) };
+  }
+  async keysetPaginate(options) {
+    const page = await this.repository.keysetPaginate({ ...this.buildOptions(), ...options });
+    return { ...page, data: await this.attach(page.data) };
+  }
+  async projectKeyset(columns, options) {
+    if (!columns.length || columns.some((column) => !this.repository.getTable().columns.includes(column)))
+      throw new TypeError("Keyset projections require declared columns.");
+    const page = await this.repository.keysetPaginate({
+      ...this.buildOptions(),
+      ...options,
+      select: uniqueColumnSelect(this.repository.getTable().name, columns)
+    });
+    return { ...page, data: page.data };
+  }
+  getOptions() {
+    return this.buildOptions();
+  }
+  buildOptions() {
+    if (this.protectedWhere.length === 0) {
+      return { ...this.queryOptions, where: this.whereClause, whereNodes: this.whereNodes };
+    }
+    return {
+      ...this.queryOptions,
+      where: {},
+      whereNodes: [...this.protectedWhere, { kind: "and", group: [...this.whereNodes] }]
+    };
+  }
+  addJoin(type, left, right) {
+    const leftRef = parseQualifiedColumn(left);
+    const rightRef = parseQualifiedColumn(right);
+    const table = type === "inner" ? rightRef.table : rightRef.table;
+    const joins = this.queryOptions.joins ?? [];
+    const existing = joins.find((join) => join.table === table && join.type === type);
+    if (existing) {
+      existing.on.push({ left: leftRef, right: rightRef });
+      return this;
+    }
+    this.queryOptions = {
+      ...this.queryOptions,
+      joins: [
+        ...joins,
+        {
+          type,
+          table,
+          on: [{ left: leftRef, right: rightRef }]
+        }
+      ]
+    };
+    return this;
+  }
+  async attach(rows) {
+    const result = rows.map((row) => ({ ...row }));
+    if (result.length === 0 || this.eagerLoads.length === 0) {
+      return result;
+    }
+    await Promise.all(this.eagerLoads.map((load) => this.hydrateEagerLoad(rows, result, load)));
+    return result;
+  }
+  async hydrateEagerLoad(rows, result, load) {
+    if (load.kind === "hasMany") {
+      const relation = load.relation;
+      const grouped = await load.repository.withConnection(this.repository.getConnection()).loadHasManyForParents(rows, relation, load.options);
+      for (const row of result) {
+        row[load.as] = getByRelationKey(grouped, row[relation.localKey]) ?? [];
+      }
+      return;
+    }
+    if (load.kind === "morphMany") {
+      const relation = load.relation;
+      const grouped = await load.repository.withConnection(this.repository.getConnection()).loadMorphManyForParents(rows, relation, load.options);
+      for (const row of result) {
+        row[load.as] = getByRelationKey(grouped, row[relation.localKey]) ?? [];
+      }
+      return;
+    }
+    if (load.kind === "morphOne") {
+      const relation = load.relation;
+      const grouped = await load.repository.withConnection(this.repository.getConnection()).loadMorphOneForParents(rows, relation, load.options);
+      for (const row of result) {
+        row[load.as] = getByRelationKey(grouped, row[relation.localKey]);
+      }
+      return;
+    }
+    if (load.kind === "hasManyThrough") {
+      const relation = load.relation;
+      const grouped = await load.repository.withConnection(this.repository.getConnection()).loadHasManyThroughForParents(rows, relation, load.options);
+      for (const row of result) {
+        row[load.as] = getByRelationKey(grouped, row[relation.localKey]) ?? [];
+      }
+      return;
+    }
+    if (load.kind === "belongsToMany") {
+      const relation = load.relation;
+      const grouped = await this.repository.loadBelongsToManyForParents(rows, relation, load.repository, load.options);
+      for (const row of result) {
+        row[load.as] = getByRelationKey(grouped, row[relation.parentKey]) ?? [];
+      }
+      return;
+    }
+    if (load.kind === "morphTo") {
+      const relation = load.relation;
+      const repositories = load.morphRepositories ?? new Map;
+      const partitions = new Map;
+      rows.forEach((row, index) => {
+        const type = String(row[relation.morphTypeKey]);
+        const target = result[index];
+        if (!target || !repositories.has(type))
+          return;
+        const partition = partitions.get(type) ?? { rows: [], targets: [] };
+        partition.rows.push(row);
+        partition.targets.push(target);
+        partitions.set(type, partition);
+      });
+      await Promise.all([...partitions.entries()].map(async ([type, partition]) => {
+        const repository = repositories.get(type);
+        if (!repository)
+          return;
+        const grouped = await this.repository.loadMorphToForChildren(partition.rows, relation, new Map([[type, repository]]), load.morphOptions?.get(type) ?? load.options);
+        for (const row of partition.targets) {
+          row[load.as] = getByRelationKey(grouped, row[relation.morphIdKey]);
+        }
+      }));
+      return;
+    }
+    const relation = load.relation;
+    const grouped = await this.repository.loadBelongsToForParents(rows, relation, load.repository, load.options);
+    for (const row of result) {
+      row[load.as] = getByRelationKey(grouped, row[relation.foreignKey]);
+    }
+  }
+}
+
+// ../../src/core/database/baseRepository.ts
+init_transaction();
+init_transactionControl();
+function listOrders(orderBy) {
+  if (!orderBy)
+    return [];
+  if (Array.isArray(orderBy))
+    return orderBy.map(readOrder);
+  if ("column" in orderBy)
+    return [readOrder(orderBy)];
+  return Object.entries(orderBy).flatMap(([column, direction]) => {
+    if (direction === undefined)
+      return [];
+    return [
+      {
+        column,
+        direction: String(direction).toUpperCase() === "DESC" ? "desc" : "asc"
+      }
+    ];
+  });
+}
+function readOrder(order) {
+  return {
+    column: String(order.column),
+    direction: String(order.direction).toUpperCase() === "DESC" ? "desc" : "asc",
+    ...order.nulls === undefined ? {} : { nulls: order.nulls }
+  };
+}
+
+class BaseRepository {
+  table;
+  connection;
+  constructor(table, connection = repositoryConnection) {
+    this.table = table;
+    this.connection = connection;
+  }
+  assertTransactionalEvent(action) {
+    if (!eventBus.hasTransactionalListeners(modelEventName(this.table.name, action)))
+      return;
+    if (!hasActiveTransaction() || this.connection !== repositoryConnection && this.connection !== getActiveDatabaseConnection(repositoryConnection))
+      throw new Error("Transactional model listeners require runInTransaction and the framework-bound repository connection before writing.");
+  }
+  async runModelMutation(action, operation) {
+    if (!eventBus.hasTransactionalListeners(modelEventName(this.table.name, action)))
+      return operation();
+    return runInTransaction(operation);
+  }
+  async count(options = {}) {
+    if (options.lock)
+      throw new Error("Row locks require a row selection, not count().");
+    const { whereNodes, where, ...rest } = options;
+    return await this.countWhere(where ?? {}, rest, whereNodes ?? []);
+  }
+  async findAll(options = {}) {
+    return await withDatabaseErrorHandling(async () => {
+      if (options.lock && (!hasActiveTransaction() || this.connection !== repositoryConnection && this.connection !== getActiveDatabaseConnection(repositoryConnection))) {
+        throw new Error("Row locks require the framework active transaction connection.");
+      }
+      const { whereNodes, ...queryOptions } = options;
+      const { text, params } = buildSelectQuery(this.table, queryOptions, whereNodes ?? []);
+      return await this.connection.unsafe(text, params);
+    });
+  }
+  async paginate(options) {
+    const { whereNodes, where = {}, page, perPage, ...queryOptions } = options;
+    const total = await this.countWhere(where, {
+      withTrashed: options.withTrashed,
+      onlyTrashed: options.onlyTrashed,
+      joins: options.joins,
+      groupBy: options.groupBy
+    }, whereNodes);
+    const meta = buildPaginationMeta({ page, perPage, total });
+    if (total === 0) {
+      return { data: [], meta };
+    }
+    const offset = (page - 1) * perPage;
+    const data = await this.findAll({
+      ...queryOptions,
+      where,
+      whereNodes,
+      limit: perPage,
+      offset
+    });
+    return {
+      data,
+      meta
+    };
+  }
+  async chunk(count, callback, options = {}) {
+    if (!Number.isInteger(count) || count <= 0) {
+      throw new Error("Chunk size must be a positive integer.");
+    }
+    if (this.primaryKeySeekDirection(options) === "asc") {
+      const seekOptions = { ...options };
+      delete seekOptions.orderBy;
+      await this.chunkById(count, async (rows) => await callback(rows) === false ? false : undefined, seekOptions);
+      return;
+    }
+    let offset = 0;
+    while (true) {
+      const rows = await this.findAll({
+        ...options,
+        limit: count,
+        offset
+      });
+      if (rows.length === 0) {
+        return;
+      }
+      const shouldContinue = await callback(rows);
+      if (shouldContinue === false || rows.length < count) {
+        return;
+      }
+      offset += count;
+    }
+  }
+  async chunkById(count, callback, options = {}) {
+    if (!Number.isInteger(count) || count <= 0) {
+      throw new Error("Chunk size must be a positive integer.");
+    }
+    let cursor;
+    while (true) {
+      const { data, meta } = await this.cursorPaginate({
+        ...options,
+        perPage: count,
+        ...cursor === undefined ? {} : { cursor }
+      });
+      if (data.length === 0) {
+        return;
+      }
+      if (await callback(data) === false) {
+        return;
+      }
+      if (!meta.has_more || meta.next_cursor === null) {
+        return;
+      }
+      cursor = meta.next_cursor;
+    }
+  }
+  async cursorPaginate(options) {
+    const {
+      perPage,
+      cursor,
+      cursorColumn = this.table.primaryKey,
+      direction = "asc",
+      where = {},
+      whereNodes,
+      ...queryOptions
+    } = options;
+    if (!Number.isInteger(perPage) || perPage <= 0) {
+      throw new Error("Cursor page size must be a positive integer.");
+    }
+    const filters = [];
+    if (Object.keys(where).length > 0)
+      filters.push({ kind: "and", where });
+    filters.push(...whereNodes ?? []);
+    const cursorFilters = [{ kind: "and", group: filters }];
+    if (cursor !== undefined) {
+      const cursorWhere = {};
+      cursorWhere[cursorColumn] = direction === "asc" ? { gt: cursor } : { lt: cursor };
+      cursorFilters.push({ kind: "and", where: cursorWhere });
+    }
+    const rows = await this.findAll({
+      ...queryOptions,
+      where: {},
+      whereNodes: cursorFilters,
+      orderBy: { [cursorColumn]: direction },
+      limit: perPage + 1
+    });
+    const hasMore = rows.length > perPage;
+    const data = hasMore ? rows.slice(0, perPage) : rows;
+    const nextCursor = hasMore ? data[data.length - 1]?.[cursorColumn] ?? null : null;
+    const prevCursor = cursor ?? null;
+    return {
+      data,
+      meta: {
+        per_page: perPage,
+        next_cursor: nextCursor,
+        prev_cursor: prevCursor,
+        has_more: hasMore
+      }
+    };
+  }
+  async keysetPaginate(options) {
+    const order = validateKeyset(this.table, options);
+    if (options.joins?.length || options.groupBy || options.having || "offset" in options || "limit" in options)
+      throw new TypeError("Keyset pagination does not accept joined/grouped/offset/limited queries.");
+    if (options.select?.some((item) => item.as?.toLowerCase().startsWith(KEYSET_ALIAS_PREFIX)))
+      throw new TypeError("Projection conflicts with reserved keyset aliases.");
+    const filters = [...options.whereNodes ?? []];
+    if (options.where)
+      filters.push({ kind: "and", where: options.where });
+    const rows = await this.findAll({
+      ...options,
+      where: {},
+      whereNodes: [
+        { kind: "and", group: filters },
+        ...keysetBoundary(order, options.cursor)
+      ],
+      orderBy: order,
+      limit: options.perPage + 1,
+      select: [
+        ...options.select?.length ? options.select : this.table.columns.map((column) => ({
+          kind: "column",
+          table: this.table.name,
+          column
+        })),
+        ...order.map((item, i) => ({
+          kind: "textColumn",
+          table: this.table.name,
+          column: item.column,
+          as: `${KEYSET_ALIAS_PREFIX}${i}`
+        }))
+      ]
+    });
+    const entries = rows.map((row) => {
+      const record = { ...row };
+      const values = order.map((_, i) => {
+        const key = `${KEYSET_ALIAS_PREFIX}${i}`;
+        const value = record[key];
+        delete record[key];
+        if (typeof value !== "string" || value.length > 4096)
+          throw new TypeError("Keyset columns must contain non-null bounded scalar values.");
+        return value;
+      });
+      return { record, values };
+    });
+    const hasMore = entries.length > options.perPage;
+    const visible = entries.slice(0, options.perPage);
+    const last = visible.at(-1);
+    const nextCursor = hasMore && last ? { version: 1, order, values: last.values } : null;
+    const data = visible.map(({ record }) => record);
+    return {
+      data,
+      meta: {
+        per_page: options.perPage,
+        has_more: hasMore,
+        next_cursor: nextCursor,
+        prev_cursor: options.cursor ?? null
+      }
+    };
+  }
+  async findById(id) {
+    return await this.firstOrNull({
+      [this.table.primaryKey]: id
+    });
+  }
+  async findByIdOrThrow(id, errorFactory) {
+    const record = await this.findById(id);
+    if (record) {
+      return record;
+    }
+    throw errorFactory?.(id) ?? new Error(`${this.table.name} ${String(id)} was not found.`);
+  }
+  async findByIds(ids) {
+    const uniqueIds = [...new Set(ids)];
+    if (uniqueIds.length === 0) {
+      return [];
+    }
+    return await this.findWhere({
+      [this.table.primaryKey]: uniqueIds
+    });
+  }
+  async firstOrNull(where, options = {}) {
+    const [record] = await this.findAll({ ...options, where, limit: 1 });
+    return record ?? null;
+  }
+  async upsert(values, conflictColumns, updateColumns) {
+    return await withDatabaseErrorHandling(async () => {
+      const { text, params } = buildUpsertQuery(this.table, values, conflictColumns, updateColumns);
+      const [record] = await this.connection.unsafe(text, params);
+      return record ?? null;
+    });
+  }
+  async incrementById(id, column, amount = 1, extra = {}) {
+    return await withDatabaseErrorHandling(async () => {
+      const { text, params } = buildIncrementQuery(this.table, id, column, amount, extra);
+      const [record] = await this.connection.unsafe(text, params);
+      return record ?? null;
+    });
+  }
+  async decrementById(id, column, amount = 1, extra = {}) {
+    return await this.incrementById(id, column, -amount, extra);
+  }
+  async create(values) {
+    this.assertTransactionalEvent("created");
+    return await this.runModelMutation("created", () => withDatabaseErrorHandling(async () => {
+      const { text, params } = buildInsertQuery(this.table, values);
+      const [record] = await this.connection.unsafe(text, params);
+      if (!record) {
+        throw new Error(`Insert into ${this.table.name} did not return a record.`);
+      }
+      const entity = record;
+      await dispatchModelEvent(modelEventName(this.table.name, "created"), entity);
+      return entity;
+    }));
+  }
+  async updateWhere(changes, options) {
+    return this.executeConditionalWrite("update", changes, options);
+  }
+  async deleteWhere(options) {
+    return this.executeConditionalWrite("delete", {}, options);
+  }
+  async updateWhereReturning(changes, columns, options) {
+    const { text, params } = buildConditionalWriteQuery(this.table, "update", changes, options, columns);
+    return withDatabaseErrorHandling(() => this.connection.unsafe(text, params));
+  }
+  async executeConditionalWrite(operation, changes, options) {
+    const { text, params } = buildConditionalWriteQuery(this.table, operation, changes, options);
+    return withDatabaseErrorHandling(async () => {
+      const rows = await this.connection.unsafe(text, params);
+      if (currentSqlDialect().driver !== "mysql")
+        return rows.length;
+      const affected = rows[0]?.affectedRows;
+      if (!Number.isSafeInteger(affected) || affected === undefined || affected < 0)
+        throw new Error("MySQL conditional writes require affectedRows metadata from the framework adapter.");
+      return affected;
+    });
+  }
+  async updateById(id, changes) {
+    this.assertTransactionalEvent("updated");
+    return await this.runModelMutation("updated", () => withDatabaseErrorHandling(async () => {
+      const { text, params } = buildUpdateQuery(this.table, id, changes);
+      const [record] = await this.connection.unsafe(text, params);
+      const entity = record ?? null;
+      if (entity) {
+        await dispatchModelEvent(modelEventName(this.table.name, "updated"), entity);
+      }
+      return entity;
+    }));
+  }
+  async updateByIdOrThrow(id, changes, errorFactory) {
+    const record = await this.updateById(id, changes);
+    if (record) {
+      return record;
+    }
+    throw errorFactory?.(id) ?? new Error(`${this.table.name} ${String(id)} was not found.`);
+  }
+  async deleteById(id) {
+    if (resolveSoftDeleteColumn(this.table)) {
+      return await this.softDeleteById(id);
+    }
+    return await this.forceDeleteById(id);
+  }
+  async softDeleteById(id) {
+    this.assertTransactionalEvent("deleted");
+    return await this.runModelMutation("deleted", () => withDatabaseErrorHandling(async () => {
+      const { text, params } = buildSoftDeleteByIdQuery(this.table, id, new Date);
+      const [record] = await this.connection.unsafe(text, params);
+      if (!record) {
+        return false;
+      }
+      await dispatchModelEvent(modelEventName(this.table.name, "deleted"), record);
+      return true;
+    }));
+  }
+  async forceDeleteById(id) {
+    this.assertTransactionalEvent("force-deleted");
+    return await this.runModelMutation("force-deleted", () => withDatabaseErrorHandling(async () => {
+      const { text, params } = buildDeleteByIdQuery(this.table, id);
+      const [row] = await this.connection.unsafe(text, params);
+      if (!row) {
+        return false;
+      }
+      await dispatchModelEvent(modelEventName(this.table.name, "force-deleted"), {
+        id
+      });
+      return true;
+    }));
+  }
+  async restoreById(id) {
+    this.assertTransactionalEvent("restored");
+    return await this.runModelMutation("restored", () => withDatabaseErrorHandling(async () => {
+      const { text, params } = buildRestoreByIdQuery(this.table, id);
+      const [record] = await this.connection.unsafe(text, params);
+      if (!record) {
+        return null;
+      }
+      const entity = record;
+      await dispatchModelEvent(modelEventName(this.table.name, "restored"), entity);
+      return entity;
+    }));
+  }
+  primaryKeySeekDirection(options) {
+    if (options.joins?.length || options.groupBy || options.having || options.select?.length || options.offset !== undefined || options.limit !== undefined || options.lock) {
+      return null;
+    }
+    const orders = listOrders(options.orderBy ?? this.table.defaultOrderBy);
+    const order = orders[0];
+    if (orders.length !== 1 || !order || order.nulls || order.column !== this.table.primaryKey) {
+      return null;
+    }
+    return order.direction;
+  }
+  withConnection(connection) {
+    const clone = Object.create(Object.getPrototypeOf(this));
+    Object.assign(clone, this);
+    clone.connection = connection;
+    return clone;
+  }
+  getConnection() {
+    return this.connection;
+  }
+  getTable() {
+    return this.table;
+  }
+  query(where = {}) {
+    return new RepositoryQuery(this, where);
+  }
+  async findWhere(where, options = {}) {
+    return await this.findAll({ ...options, where });
+  }
+  async countWhere(where = {}, options = {}, whereNodes = []) {
+    const { text, params } = buildCountQuery(this.table, where, options, whereNodes);
+    const [row] = await this.connection.unsafe(text, params);
+    return Number(row?.count ?? 0);
+  }
+  async averageColumn(column, where = {}) {
+    const qualifiedColumn = qualifyColumn(this.table.name, column);
+    return await this.averageExpression(`AVG(${qualifiedColumn})`, "value", where);
+  }
+  async averageExpression(expression, alias, where = {}) {
+    const { text, params } = buildProjectionQuery(this.table, expression, alias, { where });
+    const [row] = await this.connection.unsafe(text, params);
+    return Number(row?.[alias] ?? 0);
+  }
+  async sumBy(groupColumn, column, options = {}) {
+    const { whereNodes, ...queryOptions } = options;
+    const { text, params } = buildGroupedSumQuery(this.table, groupColumn, column, queryOptions, whereNodes ?? []);
+    return withDatabaseErrorHandling(() => this.connection.unsafe(text, params));
+  }
+  async sum(column, where = {}) {
+    return await this.aggregateColumn("SUM", column, where);
+  }
+  async avg(column, where = {}) {
+    return await this.aggregateColumn("AVG", column, where);
+  }
+  async min(column, where = {}) {
+    return await this.aggregateColumn("MIN", column, where);
+  }
+  async max(column, where = {}) {
+    return await this.aggregateColumn("MAX", column, where);
+  }
+  async aggregateColumn(fn, column, where) {
+    const qualifiedColumn = qualifyColumn(this.table.name, column);
+    return await this.averageExpression(`${fn}(${qualifiedColumn})`, "value", where);
+  }
+  async pluckNumberValues(expression, alias, options = {}) {
+    const { text, params } = buildProjectionQuery(this.table, expression, alias, options);
+    const rows = await this.connection.unsafe(text, params);
+    return rows.flatMap((row) => {
+      const value = row[alias];
+      return value === null || value === undefined ? [] : [Number(value)];
+    });
+  }
+  async countGroupedBy(column, where = {}) {
+    const { text, params } = buildGroupedCountQuery(this.table, column, where);
+    const rows = await this.connection.unsafe(text, params);
+    return rows.map(({ value, count }) => ({
+      value,
+      count: Number(count)
+    }));
+  }
+  async findByHasManyRelation(relation, parentId, options = {}) {
+    return await this.findWhere({
+      [relation.foreignKey]: parentId
+    }, options);
+  }
+  async loadHasManyForParents(parents, relation, options = {}) {
+    if (parents.length === 0) {
+      return indexHasManyRelation(parents, [], relation);
+    }
+    const parentIds = [...new Set(parents.map((parent) => parent[relation.localKey]))];
+    const children = await this.findWhere({
+      [relation.foreignKey]: parentIds
+    }, options);
+    return indexHasManyRelation(parents, children, relation);
+  }
+  async findHasManyThrough(parentId, relation, options = {}) {
+    const grouped = await this.loadHasManyThroughForParents([{ [relation.localKey]: parentId }], relation, options);
+    return getByRelationKey(grouped, parentId) ?? [];
+  }
+  async loadHasManyThroughForParents(parents, relation, options = {}) {
+    if (parents.length === 0) {
+      return indexHasManyThroughRelation(parents, [], relation);
+    }
+    if (options.joins?.some((join) => join.table === relation.throughTable)) {
+      throw new Error("A related model scope joins the through table twice; use an explicitly aliased correlated predicate instead.");
+    }
+    const parentIds = [...new Set(parents.map((parent) => parent[relation.localKey]))];
+    const throughParentKey = relation.throughParentKey ?? "__through_parent_id";
+    const farTable = this.table.name;
+    const columns = this.table.columns.map((column) => `${qualifyColumn(farTable, column)}`).join(", ");
+    const placeholders = parentIds.map((_, index) => currentSqlDialect().placeholder(index + 1)).join(", ");
+    const { text: extraWhere, params: extraParams } = this.buildThroughWhere(options, parentIds);
+    const sql = `SELECT ${columns}, ${qualifyColumn(relation.throughTable, relation.firstKey)} AS ${throughParentKey} FROM ${quoteIdentifier(farTable)} INNER JOIN ${quoteIdentifier(relation.throughTable)} ON ${qualifyColumn(relation.throughTable, relation.secondLocalKey)} = ${qualifyColumn(farTable, relation.secondKey)}${buildJoinClause(options.joins)} WHERE ${qualifyColumn(relation.throughTable, relation.firstKey)} IN (${placeholders})${extraWhere}`;
+    const children = await this.connection.unsafe(sql, [
+      ...parentIds,
+      ...extraParams
+    ]);
+    return indexHasManyThroughRelation(parents, children, relation);
+  }
+  buildThroughWhere(options, parentIds) {
+    const parameters = [...parentIds];
+    const { clause } = buildQueryWhereClause(this.table, options, options.whereNodes, parameters);
+    return {
+      text: clause ? ` AND (${clause.replace(/^ WHERE /, "")})` : "",
+      params: parameters.slice(parentIds.length)
+    };
+  }
+  async loadBelongsToForParents(children, relation, parentRepository, options = {}) {
+    if (children.length === 0) {
+      return new Map;
+    }
+    const ownerIds = [...new Set(children.map((child) => child[relation.foreignKey]))];
+    const parents = await parentRepository.withConnection(this.connection).findWhere({
+      [relation.ownerKey]: ownerIds
+    }, options);
+    return indexBelongsToRelation(children, parents, relation);
+  }
+  async loadMorphManyForParents(parents, relation, options = {}) {
+    if (parents.length === 0) {
+      return indexMorphManyRelation(parents, [], relation);
+    }
+    const parentIds = [...new Set(parents.map((parent) => parent[relation.localKey]))];
+    const children = await this.findWhere({
+      [relation.morphTypeKey]: relation.morphType,
+      [relation.morphIdKey]: parentIds
+    }, options);
+    return indexMorphManyRelation(parents, children, relation);
+  }
+  async loadMorphOneForParents(parents, relation, options = {}) {
+    const grouped = await this.loadMorphManyForParents(parents, relation, options);
+    const result = new Map;
+    for (const parent of parents) {
+      const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
+      result.set(parent[relation.localKey], matches[0]);
+    }
+    return result;
+  }
+  async loadMorphToForChildren(children, relation, repositoriesByType, options = {}) {
+    if (children.length === 0) {
+      return new Map;
+    }
+    const idsByType = new Map;
+    for (const child of children) {
+      const morphType = String(child[relation.morphTypeKey]);
+      const morphId = child[relation.morphIdKey];
+      const ids = idsByType.get(morphType) ?? new Set;
+      ids.add(morphId);
+      idsByType.set(morphType, ids);
+    }
+    const parentsByType = new Map;
+    await Promise.all([...idsByType.entries()].map(async ([morphType, ids]) => {
+      const repository = repositoriesByType.get(morphType);
+      if (!repository) {
+        return;
+      }
+      const ownerKey = repository.getTable().primaryKey;
+      const parents = await repository.withConnection(this.connection).findWhere({
+        [ownerKey]: [...ids]
+      }, options);
+      const indexed = new Map;
+      for (const parent of parents) {
+        indexed.set(relationMatchKey(parent[ownerKey]), parent);
+      }
+      parentsByType.set(morphType, indexed);
+    }));
+    return indexMorphToRelation(children, parentsByType, relation);
+  }
+  async loadBelongsToManyForParents(parents, relation, relatedRepository, options = {}) {
+    if (parents.length === 0) {
+      return indexBelongsToManyRelation(parents, [], [], relation);
+    }
+    const parentIds = [...new Set(parents.map((parent) => parent[relation.parentKey]))];
+    const placeholders = parentIds.map((_, index) => currentSqlDialect().placeholder(index + 1)).join(", ");
+    const pivotRows = await this.connection.unsafe(`SELECT * FROM ${relation.pivotTable} WHERE ${String(relation.foreignPivotKey)} IN (${placeholders})`, parentIds);
+    if (pivotRows.length === 0) {
+      return indexBelongsToManyRelation(parents, [], [], relation);
+    }
+    const relatedIds = [
+      ...new Set(pivotRows.map((row) => row[relation.relatedPivotKey]))
+    ];
+    const relatedRows = await relatedRepository.withConnection(this.connection).findWhere({
+      [relation.relatedKey]: relatedIds
+    }, options);
+    return indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation);
+  }
+}
+
+// ../../src/core/database/table.ts
+function defineTable(definition) {
+  return definition;
+}
+
 // ../../src/core/tenant/resolveTenant.ts
 init_tenancyConfig();
-import { repositoryConnection as db } from "@getstrata/core/database/repositoryConnection";
+var tenants = new BaseRepository(defineTable({
+  name: "tenant",
+  primaryKey: "id",
+  columns: ["id", "slug"]
+}));
 async function resolveTenant(tenantId) {
   if (!isTenancyEnabled()) {
     return {
@@ -942,13 +3084,7 @@ async function resolveTenant(tenantId) {
       slug: "default"
     };
   }
-  const rows = await db`
-    SELECT id, slug
-    FROM tenant
-    WHERE id = ${tenantId}
-    LIMIT 1
-  `;
-  const row = rows[0];
+  const row = await tenants.findById(tenantId);
   return row ? { id: row.id, slug: row.slug } : null;
 }