@getstrata/core 2.2.31 → 2.2.33

package/dist/index.js

@@ -3660,1836 +3660,1034 @@ function resolveScimTenantFromToken(token) {
   return null;
 }
 
-// ../../src/core/tenant/resolveTenant.ts
-init_repositoryConnection();
-init_tenancyConfig();
-async function resolveTenant(tenantId) {
-  if (!isTenancyEnabled()) {
-    return {
-      id: tenantId,
-      slug: "default"
-    };
-  }
-  const rows = await repositoryConnection`
-    SELECT id, slug
-    FROM tenant
-    WHERE id = ${tenantId}
-    LIMIT 1
-  `;
-  const row = rows[0];
-  return row ? { id: row.id, slug: row.slug } : 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/auth/scimAuthMiddleware.ts
-init_tenantDatabaseScope();
-function createScimAuthMiddleware() {
-  return async (request, next) => {
-    const authorization = request.headers.get("authorization");
-    if (!authorization?.startsWith("Bearer ")) {
-      return jsonScimError("SCIM bearer token required.", 401);
-    }
-    const token = authorization.slice("Bearer ".length).trim();
-    const tenantId = resolveScimTenantFromToken(token);
-    if (tenantId === null) {
-      return jsonScimError("Invalid SCIM bearer token.", 401);
-    }
-    const tenant = await resolveTenant(tenantId);
-    if (!tenant) {
-      return jsonScimError("SCIM tenant not found.", 401);
-    }
-    return await runWithTenantDatabase(tenant, async () => {
-      bindDatabaseConnection(getActiveDatabaseConnection(getDefaultDatabasePool()));
-      try {
-        return await next();
-      } finally {
-        resetBoundDatabaseConnection();
-      }
-    });
+// ../../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
   };
 }
-function jsonScimError(detail, status) {
-  return Response.json({
-    schemas: ["urn:ietf:params:scim:api:messages:2.0:Error"],
-    detail,
-    status: String(status)
-  }, {
-    status,
-    headers: { "content-type": "application/scim+json" }
+
+// ../../src/core/database/baseRepository.ts
+init_connectionContext();
+init_dialect();
+
+// ../../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 };
   });
-}
-// ../../src/core/auth/tokenAbilityChecker.ts
-function tokenCan(user, ability) {
-  if (!user) {
-    return false;
+  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.");
   }
-  const abilities = user.abilities ?? [];
-  return abilities.includes("*") || abilities.includes(ability);
+  return order;
 }
-function createTokenAbilityChecker() {
-  return {
-    tokenCan,
-    requireAbility(user, ability) {
-      if (!tokenCan(user, ability)) {
-        throw new ForbiddenError(`Missing ability: ${ability}`);
+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
+init_dialect();
+function quoteIdentifier(identifier) {
+  return currentSqlDialect().quoteIdentifier(identifier);
+}
+function returningSuffix(columns) {
+  return currentSqlDialect().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);
 }
-// ../../src/core/cache/redisCacheStore.ts
-var {RedisClient } = globalThis.Bun;
-var CACHE_SCRIPT = `
-local expected = {'hash', 'zset', 'zset', 'hash', 'zset'}
-for i, key in ipairs(KEYS) do
-  local kind = redis.call('TYPE', key).ok
-  if kind ~= 'none' and kind ~= expected[i] then return redis.error_reply('Unexpected cache key type') end
-end
--- Redis eviction can remove one container without its companions. Never read
--- orphaned values or leases after losing the expiry/order/generation indexes.
-local entries = redis.call('HLEN', KEYS[1])
-local order = redis.call('ZCARD', KEYS[3])
-if redis.call('ZCARD', KEYS[2]) ~= order or entries ~= (order > 0 and order + 1 or 0) then
-  redis.call('DEL', KEYS[1], KEYS[2], KEYS[3])
-end
-if redis.call('HLEN', KEYS[4]) ~= redis.call('ZCARD', KEYS[5]) then
-  redis.call('DEL', KEYS[4], KEYS[5])
-end
-local r = cjson.decode(ARGV[1])
-local time = redis.call('TIME')
-local now = tonumber(time[1]) * 1000 + tonumber(time[2]) / 1000
-local function removeEntry(key)
-  local removed = redis.call('HDEL', KEYS[1], 'e:' .. key)
-  redis.call('ZREM', KEYS[2], key)
-  redis.call('ZREM', KEYS[3], key)
-  return removed
-end
-local function removeMeta(field)
-  redis.call('HDEL', KEYS[4], field)
-  redis.call('ZREM', KEYS[5], field)
-end
-for _, key in ipairs(redis.call('ZRANGEBYSCORE', KEYS[2], '-inf', now, 'LIMIT', 0, r.capacity)) do removeEntry(key) end
-for _, field in ipairs(redis.call('ZRANGEBYSCORE', KEYS[5], '-inf', now, 'LIMIT', 0, r.metadataLimit)) do removeMeta(field) end
-local function expireContainers()
-  local last = redis.call('ZREVRANGE', KEYS[2], 0, 0, 'WITHSCORES')
-  if #last == 0 then
-    redis.call('DEL', KEYS[1], KEYS[2], KEYS[3])
-  elseif last[2] == 'inf' then
-    for i = 1, 3 do redis.call('PERSIST', KEYS[i]) end
-  else
-    local ttl = math.max(1, math.ceil(tonumber(last[2]) - now))
-    for i = 1, 3 do redis.call('PEXPIRE', KEYS[i], ttl) end
-  end
-  for i = 4, 5 do redis.call('PEXPIRE', KEYS[i], r.metadataTtlMs) end
-end
-local function response(value)
-  expireContainers()
-  return cjson.encode(value)
-end
-local function addTags(existing, added)
-  local seen = {}
-  local result = {}
-  for _, tags in ipairs({existing, added}) do
-    for _, tag in ipairs(tags) do
-      if not seen[tag] then seen[tag] = true; table.insert(result, tag) end
-    end
-  end
-  if #result > 32 then error('Cache entries support at most 32 tags') end
-  return result
-end
-local function touch(key)
-  local sequence = redis.call('HINCRBY', KEYS[1], '_sequence', 1)
-  redis.call('ZADD', KEYS[3], sequence, key)
-end
-local function read(key, tags)
-  local raw = redis.call('HGET', KEYS[1], 'e:' .. key)
-  if not raw then return nil end
-  local entry = cjson.decode(raw)
-  if #tags > 0 then
-    entry.tags = addTags(entry.tags, tags)
-    redis.call('HSET', KEYS[1], 'e:' .. key, cjson.encode(entry))
-  end
-  touch(key)
-  return entry.payload
-end
-local function write(key, payload, tags)
-  local entry = {payload=payload, tags=tags}
-  redis.call('HSET', KEYS[1], 'e:' .. key, cjson.encode(entry))
-  redis.call('ZADD', KEYS[2], r.ttlMs == 0 and '+inf' or now + r.ttlMs, key)
-  touch(key)
-  local overflow = redis.call('ZCARD', KEYS[3]) - r.capacity
-  if overflow > 0 then
-    for _, victim in ipairs(redis.call('ZRANGE', KEYS[3], 0, overflow - 1)) do removeEntry(victim) end
-  end
-end
-local leaseField = 'l:' .. r.key
-local function lease()
-  local raw = redis.call('HGET', KEYS[4], leaseField)
-  if not raw then return nil end
-  local value = cjson.decode(raw)
-  if value.expires <= now or value.deadline <= now then removeMeta(leaseField); return nil end
-  return value
-end
-local function metadataSpace(count)
-  if redis.call('HLEN', KEYS[4]) + count > r.metadataLimit then
-    -- Pressure sheds generation/lease state. Every old owner is fenced; cached
-    -- entries remain valid because invalidation removes matching entries atomically.
-    redis.call('DEL', KEYS[4], KEYS[5])
-  end
-end
-local function putMeta(field, value, expires)
-  redis.call('HSET', KEYS[4], field, value)
-  redis.call('ZADD', KEYS[5], expires, field)
-end
-local function scopes()
-  local fields = {}
-  for _, tag in ipairs(r.tags) do table.insert(fields, 'g:tag:' .. tag) end
-  for _, prefix in ipairs(r.prefixes) do table.insert(fields, 'g:prefix:' .. prefix) end
-  return fields
-end
-local function matches(key, tags)
-  if r.op == 'invalidate' then return key == r.key end
-  if r.op == 'prefix' then return key == r.key or string.sub(key, 1, #r.key + 1) == r.key .. '?' end
-  if r.op == 'tags' then
-    for _, existing in ipairs(tags) do
-      for _, wanted in ipairs(r.tags) do if wanted == existing then return true end end
-    end
-  end
-  return false
-end
-if r.op == 'clear' then
-  redis.call('DEL', unpack(KEYS))
-  return cjson.encode({removed=0})
-elseif r.op == 'get' then
-  local payload = read(r.key, r.tags)
-  return response(payload and {kind='value', payload=payload} or {kind='missing'})
-elseif r.op == 'set' then
-  local old = redis.call('HGET', KEYS[1], 'e:' .. r.key)
-  local tags = old and cjson.decode(old).tags or {}
-  write(r.key, r.payload, tags)
-  removeMeta(leaseField)
-  return response({written=true})
-elseif r.op == 'attach' then
-  read(r.key, r.tags)
-  return response({written=true})
-elseif r.op == 'size' then
-  return response({size=redis.call('ZCARD', KEYS[3])})
-elseif r.op == 'tags' or r.op == 'prefix' or r.op == 'invalidate' then
-  local generationFields = {}
-  if r.op == 'tags' then
-    for _, tag in ipairs(r.tags) do table.insert(generationFields, 'g:tag:' .. tag) end
-  elseif r.op == 'prefix' then table.insert(generationFields, 'g:prefix:' .. r.key) end
-  metadataSpace(#generationFields)
-  for _, field in ipairs(generationFields) do putMeta(field, r.owner, now + r.metadataTtlMs) end
-  local removed = 0
-  for _, key in ipairs(redis.call('ZRANGE', KEYS[3], 0, -1)) do
-    local raw = redis.call('HGET', KEYS[1], 'e:' .. key)
-    if raw and matches(key, cjson.decode(raw).tags) then removed = removed + removeEntry(key) end
-  end
-  for _, field in ipairs(redis.call('HKEYS', KEYS[4])) do
-    if string.sub(field, 1, 2) == 'l:' then
-      local value = cjson.decode(redis.call('HGET', KEYS[4], field))
-      if matches(string.sub(field, 3), value.tags) then removeMeta(field) end
-    end
-  end
-  return response({removed=removed})
-elseif r.op == 'claim' then
-  local payload = read(r.key, r.tags)
-  if payload then return response({kind='value', payload=payload}) end
-  local current = lease()
-  if current then
-    local shared = addTags(current.tags, r.tags)
-    if #shared == #current.tags then return response({kind='wait'}) end
-    -- A newly requested tag must not inherit a fill started before that tag's
-    -- invalidation. Restart with the union of tags and a new owner.
-    r.tags = shared
-    removeMeta(leaseField)
-  end
-  local active = 0
-  for _, field in ipairs(redis.call('HKEYS', KEYS[4])) do if string.sub(field, 1, 2) == 'l:' then active = active + 1 end end
-  if active >= r.capacity then return response({kind='wait'}) end
-  local fields = scopes()
-  metadataSpace(#fields + 1)
-  local generations = {}
-  for _, field in ipairs(fields) do
-    local token = redis.call('HGET', KEYS[4], field) or r.owner
-    putMeta(field, token, now + r.metadataTtlMs)
-    generations[field] = token
-  end
-  local value = {owner=r.owner, tags=r.tags, generations=generations, deadline=now + r.fillTimeoutMs, expires=now + r.leaseMs}
-  putMeta(leaseField, cjson.encode(value), value.expires)
-  return response({kind='owner'})
-elseif r.op == 'renew' or r.op == 'publish' or r.op == 'release' then
-  local current = lease()
-  if not current or current.owner ~= r.owner then return response({owned=false}) end
-  if r.op == 'release' then removeMeta(leaseField); return response({owned=true}) end
-  for field, token in pairs(current.generations) do
-    if redis.call('HGET', KEYS[4], field) ~= token then removeMeta(leaseField); return response({owned=false}) end
-  end
-  if r.op == 'renew' then
-    current.expires = math.min(current.deadline, now + r.leaseMs)
-    putMeta(leaseField, cjson.encode(current), current.expires)
-  else
-    write(r.key, r.payload, current.tags)
-    removeMeta(leaseField)
-  end
-  return response({owned=true})
-end
-return redis.error_reply('Unknown cache operation')
-`;
-
-class RedisCacheStore {
-  redisUrl;
-  ttlMs;
-  maxEntries;
-  client;
-  keys;
-  options;
-  fills = new Set;
-  closed = false;
-  constructor(redisUrl, ttlMs, maxEntries, options = {}) {
-    this.redisUrl = redisUrl;
-    this.ttlMs = ttlMs;
-    this.maxEntries = maxEntries;
-    if (!Number.isSafeInteger(ttlMs) || ttlMs < 0)
-      throw new RangeError("ttlMs must be a non-negative safe integer.");
-    if (!Number.isInteger(maxEntries) || maxEntries < 1 || maxEntries > 1e4)
-      throw new RangeError("maxEntries must be between 1 and 10000.");
-    this.options = {
-      commandTimeoutMs: 5000,
-      leaseMs: 1e4,
-      fillTimeoutMs: 30000,
-      waitTimeoutMs: 35000,
-      pollMs: 25,
-      metadataTtlMs: 60000,
-      metadataLimit: 4096,
-      ...options
-    };
-    for (const [key, value] of Object.entries(this.options))
-      if (!Number.isSafeInteger(value) || value < 1)
-        throw new RangeError(`${key} must be a positive safe integer.`);
-    if (this.options.leaseMs < 30 || this.options.fillTimeoutMs < this.options.leaseMs || this.options.metadataTtlMs < this.options.fillTimeoutMs + this.options.leaseMs || this.options.metadataLimit < 66 || this.options.metadataLimit > 1e5)
-      throw new RangeError("Invalid Redis cache lease, deadline or metadata bounds.");
-    const namespace = namespacedRedisKey("cache:v3:");
-    const slot = new Bun.CryptoHasher("sha256").update(namespace).digest("hex");
-    this.keys = ["entries", "expiry", "order", "metadata", "metadata-expiry"].map((name) => `${namespace}{${slot}}:${name}`);
-    this.client = this.createClient();
+function parseQualifiedColumn(reference) {
+  const [table, column] = reference.split(".", 2);
+  if (!table || !column) {
+    throw new Error(`Join columns must be qualified as table.column: ${reference}`);
   }
-  createClient() {
-    return new RedisClient(this.redisUrl, {
-      connectionTimeout: this.options.commandTimeoutMs,
-      maxRetries: 1
-    });
+  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 currentSqlDialect().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";
   }
-  close() {
-    this.closed = true;
-    for (const fill of this.fills)
-      fill.abort(new Error("Redis cache store is closed."));
-    this.client?.close();
-    this.client = undefined;
+  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(", ")}.`);
   }
-  async get(key) {
-    const result = await this.execute("get", key);
-    return result.kind === "value" ? JSON.parse(result.payload ?? "null") : undefined;
+  if (operator.isNull === true) {
+    clauses.push(`${column} IS NULL`);
   }
-  async set(key, value, ttlMs) {
-    await this.execute("set", key, { payload: this.serialize(value), ttlMs: ttlMs ?? this.ttlMs });
+  if (operator.isNull === false) {
+    clauses.push(`${column} IS NOT NULL`);
   }
-  async getOrSet(key, loader, ttlMs) {
-    return this.getOrSetTagged(key, loader, [], ttlMs);
+  if (operator.eq !== undefined) {
+    if (operator.eq === null) {
+      clauses.push(`${column} IS NULL`);
+    } else {
+      clauses.push(`${column} = ${pushParam(params, operator.eq)}`);
+    }
   }
-  async getOrSetTagged(key, loader, tags, ttlMs) {
-    const owner = crypto.randomUUID();
-    const end = performance.now() + this.options.waitTimeoutMs;
-    while (!this.closed) {
-      const claim = await this.execute("claim", key, { owner, tags, ttlMs: ttlMs ?? this.ttlMs });
-      if (claim.kind === "value")
-        return JSON.parse(claim.payload ?? "null");
-      if (claim.kind === "owner")
-        return this.fill(key, owner, loader, ttlMs);
-      if (performance.now() >= end)
-        throw new Error("Redis cache fill wait deadline exceeded.");
-      await Bun.sleep(this.options.pollMs);
+  if (operator.ne !== undefined) {
+    if (operator.ne === null) {
+      clauses.push(`${column} IS NOT NULL`);
+    } else {
+      clauses.push(`${column} <> ${pushParam(params, operator.ne)}`);
     }
-    throw new Error("Redis cache store is closed.");
   }
-  async attachTags(key, tags) {
-    await this.execute("attach", key, { tags });
+  if (operator.in !== undefined) {
+    clauses.push(buildInClause(column, operator.in, params));
   }
-  async flushTags(tags) {
-    return (await this.execute("tags", "", { tags })).removed ?? 0;
+  if (operator.notIn !== undefined) {
+    clauses.push(buildInClause(column, operator.notIn, params, true));
   }
-  async invalidate(key) {
-    return ((await this.execute("invalidate", key)).removed ?? 0) > 0;
+  if (operator.gt !== undefined) {
+    clauses.push(`${column} > ${pushParam(params, operator.gt)}`);
   }
-  async invalidateByPrefix(prefix) {
-    return (await this.execute("prefix", prefix)).removed ?? 0;
+  if (operator.gte !== undefined) {
+    clauses.push(`${column} >= ${pushParam(params, operator.gte)}`);
   }
-  async clear() {
-    await this.execute("clear", "");
+  if (operator.lt !== undefined) {
+    clauses.push(`${column} < ${pushParam(params, operator.lt)}`);
   }
-  async size() {
-    return (await this.execute("size", "")).size ?? 0;
+  if (operator.lte !== undefined) {
+    clauses.push(`${column} <= ${pushParam(params, operator.lte)}`);
   }
-  async fill(key, owner, loader, ttlMs) {
-    if (this.fills.size >= this.maxEntries) {
-      await this.execute("release", key, { owner });
-      throw new Error("Redis cache local fill capacity exceeded.");
-    }
-    const controller = new AbortController;
-    this.fills.add(controller);
-    let done = false;
-    let renewing = false;
-    const renew = setInterval(() => {
-      if (renewing || done)
-        return;
-      renewing = true;
-      this.execute("renew", key, { owner }).then((result) => {
-        if (!result.owned)
-          clearInterval(renew);
-      }).catch((error) => {
-        if (!done)
-          controller.abort(error);
-      }).finally(() => {
-        renewing = false;
-      });
-    }, Math.max(10, Math.floor(this.options.leaseMs / 3)));
-    const timeout = setTimeout(() => controller.abort(new Error("Redis cache fill deadline exceeded.")), this.options.fillTimeoutMs);
-    let rejectAbort;
-    const aborted = new Promise((_, reject) => {
-      rejectAbort = () => reject(controller.signal.reason);
-      controller.signal.addEventListener("abort", rejectAbort, { once: true });
-    });
-    try {
-      const value = await Promise.race([
-        Promise.resolve().then(() => loader(controller.signal)),
-        aborted
-      ]);
-      controller.signal.throwIfAborted();
-      done = true;
-      clearInterval(renew);
-      await this.execute("publish", key, {
-        owner,
-        payload: this.serialize(value),
-        ttlMs: ttlMs ?? this.ttlMs
-      });
-      return value;
-    } finally {
-      done = true;
-      clearInterval(renew);
-      clearTimeout(timeout);
-      controller.signal.removeEventListener("abort", rejectAbort);
-      this.fills.delete(controller);
-      if (!this.closed)
-        await this.execute("release", key, { owner }).catch(() => {});
-    }
-  }
-  serialize(value) {
-    const payload = JSON.stringify(value);
-    if (typeof payload !== "string")
-      throw new TypeError("Redis cache values must be JSON serializable.");
-    return payload;
-  }
-  async execute(op, key, extra = {}) {
-    if (this.closed)
-      throw new Error("Redis cache store is closed.");
-    if (Buffer.byteLength(key) > 4096)
-      throw new RangeError("Invalid Redis cache identity.");
-    const tags = Array.from(new Set(extra.tags ?? []));
-    if (tags.length > 32 || tags.some((tag) => typeof tag !== "string" || Buffer.byteLength(tag) > 1024))
-      throw new RangeError("Redis cache supports at most 32 tags of 1024 bytes each.");
-    const prefixes = [key];
-    for (let i = 0;i < key.length; i++)
-      if (key[i] === "?")
-        prefixes.push(key.slice(0, i));
-    if (prefixes.length > 33)
-      throw new RangeError("Redis cache identities support at most 32 query separators.");
-    const ttlMs = extra.ttlMs ?? this.ttlMs;
-    if (typeof ttlMs !== "number" || !Number.isSafeInteger(ttlMs) || ttlMs < 0)
-      throw new RangeError("ttlMs must be a non-negative safe integer.");
-    if (!this.client)
-      this.client = this.createClient();
-    const client = this.client;
-    const retire = (reason) => {
-      if (this.client !== client)
-        return;
-      this.client = undefined;
-      for (const fill of this.fills)
-        fill.abort(reason);
-      client.close();
-    };
-    let timer;
-    const timeout = new Promise((_, reject) => {
-      timer = setTimeout(() => {
-        const error = new Error("Redis cache command deadline exceeded.");
-        reject(error);
-        retire(error);
-      }, this.options.commandTimeoutMs);
-    });
-    try {
-      const raw = await Promise.race([
-        client.send("EVAL", [
-          CACHE_SCRIPT,
-          String(this.keys.length),
-          ...this.keys,
-          JSON.stringify({
-            op,
-            key,
-            capacity: this.maxEntries,
-            owner: crypto.randomUUID(),
-            ...this.options,
-            ...extra,
-            tags,
-            prefixes,
-            ttlMs
-          })
-        ]),
-        timeout
-      ]);
-      if (this.closed || this.client !== client)
-        throw new Error("Redis cache connection was retired.");
-      return JSON.parse(String(raw));
-    } catch (error) {
-      if (error && typeof error === "object" && "code" in error && typeof error.code === "string" && error.code.startsWith("ERR_REDIS_CONNECTION"))
-        retire(error);
-      throw error;
-    } finally {
-      clearTimeout(timer);
+  if (operator.ilike !== undefined) {
+    clauses.push(`${column} ${currentSqlDialect().ilikeOperator()} ${pushParam(params, operator.ilike)}`);
+  }
+  if (operator.tsMatch !== undefined) {
+    if (currentSqlDialect().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;
 }
-var redisCacheStore_default = RedisCacheStore;
-
-// ../../src/core/cache/simpleCache.ts
-class SimpleCache {
-  ttlMs;
-  maxEntries;
-  cache = new Map;
-  inflight = new Map;
-  tagIndex = new Map;
-  keyTags = new Map;
-  constructor(ttlMs = 3600000, maxEntries = 100) {
-    this.ttlMs = ttlMs;
-    this.maxEntries = maxEntries;
-    if (!Number.isFinite(ttlMs) || ttlMs < 0) {
-      throw new RangeError("ttlMs must be a non-negative number.");
+function appendWhereParts(tableName, where, params) {
+  const clauses = [];
+  for (const [columnName, filterValue] of Object.entries(where)) {
+    if (filterValue === undefined) {
+      continue;
     }
-    if (!Number.isInteger(maxEntries) || maxEntries < 1) {
-      throw new RangeError("maxEntries must be a positive integer.");
+    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)}`);
   }
-  get(key) {
-    return this.getFreshEntry(key)?.value;
+  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(", ")})`;
   }
-  set(key, value, ttlMs) {
-    const now = Date.now();
-    const resolvedTtlMs = ttlMs ?? this.ttlMs;
-    this.cache.set(key, {
-      value,
-      expiresAt: now + resolvedTtlMs,
-      lastAccessedAt: now
-    });
-    this.evictOverflow();
+  if ("exists" in node) {
+    const body = remapExistsSql(node.exists.sql, node.exists.params, params);
+    return `${node.exists.not ? "NOT " : ""}EXISTS (${body})`;
   }
-  async getOrSet(key, loader, ttlMs) {
-    this.pruneExpired();
-    const cachedEntry = this.getFreshEntry(key);
-    if (cachedEntry) {
-      return cachedEntry.value;
-    }
-    const inflightRequest = this.inflight.get(key);
-    if (inflightRequest) {
-      return inflightRequest;
-    }
-    const pendingRequest = loader().then((value) => {
-      this.set(key, value, ttlMs);
-      return value;
-    }).finally(() => {
-      this.inflight.delete(key);
-    });
-    this.inflight.set(key, pendingRequest);
-    return pendingRequest;
+  if ("where" in node) {
+    return appendWhereParts(tableName, node.where, params);
   }
-  attachTags(key, tags) {
-    if (tags.length === 0) {
-      return;
-    }
-    let tagsForKey = this.keyTags.get(key);
-    if (!tagsForKey) {
-      tagsForKey = new Set;
-      this.keyTags.set(key, tagsForKey);
-    }
-    for (const tag of tags) {
-      tagsForKey.add(tag);
-      let keysForTag = this.tagIndex.get(tag);
-      if (!keysForTag) {
-        keysForTag = new Set;
-        this.tagIndex.set(tag, keysForTag);
-      }
-      keysForTag.add(key);
-    }
+  const grouped = buildWhereGroupClause(tableName, node.group, params);
+  if (!grouped) {
+    return "";
   }
-  flushTags(tags) {
-    const keysToRemove = new Set;
-    for (const tag of tags) {
-      const keys = this.tagIndex.get(tag);
-      if (!keys) {
-        continue;
-      }
-      for (const key of keys) {
-        keysToRemove.add(key);
-      }
-    }
-    let removed = 0;
-    for (const key of keysToRemove) {
-      if (this.invalidate(key)) {
-        removed += 1;
-      }
+  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;
     }
-    for (const tag of tags) {
-      this.tagIndex.delete(tag);
+    if (!result) {
+      result = part;
+      continue;
     }
-    return removed;
+    result = node.kind === "or" ? `${result} OR ${part}` : `${result} AND ${part}`;
   }
-  invalidate(key) {
-    const removed = this.cache.delete(key);
-    if (removed) {
-      this.detachKeyFromTags(key);
-    }
-    return removed;
-  }
-  invalidateByPrefix(prefix) {
-    let removed = 0;
-    for (const key of [...this.cache.keys()]) {
-      if (key === prefix || key.startsWith(`${prefix}?`)) {
-        if (this.invalidate(key)) {
-          removed += 1;
-        }
-      }
-    }
-    return removed;
-  }
-  clear() {
-    this.cache.clear();
-    this.inflight.clear();
-    this.tagIndex.clear();
-    this.keyTags.clear();
-  }
-  size() {
-    this.pruneExpired();
-    return this.cache.size;
-  }
-  detachKeyFromTags(key) {
-    const tags = this.keyTags.get(key);
-    if (!tags) {
-      return;
-    }
-    for (const tag of tags) {
-      const keys = this.tagIndex.get(tag);
-      if (!keys) {
-        continue;
-      }
-      keys.delete(key);
-      if (keys.size === 0) {
-        this.tagIndex.delete(tag);
-      }
-    }
-    this.keyTags.delete(key);
-  }
-  getFreshEntry(key) {
-    const entry = this.cache.get(key);
-    if (!entry) {
-      return;
-    }
-    if (entry.expiresAt <= Date.now()) {
-      this.invalidate(key);
-      return;
-    }
-    entry.lastAccessedAt = Date.now();
-    return entry;
-  }
-  pruneExpired() {
-    const now = Date.now();
-    for (const [key, entry] of this.cache.entries()) {
-      if (entry.expiresAt <= now) {
-        this.invalidate(key);
-      }
-    }
-  }
-  evictOverflow() {
-    while (this.cache.size > this.maxEntries) {
-      let oldestKey;
-      let oldestAccessTime = Number.POSITIVE_INFINITY;
-      for (const [key, entry] of this.cache.entries()) {
-        if (entry.lastAccessedAt < oldestAccessTime) {
-          oldestAccessTime = entry.lastAccessedAt;
-          oldestKey = key;
-        }
-      }
-      if (!oldestKey) {
-        return;
-      }
-      this.invalidate(oldestKey);
-    }
+  if (!result) {
+    return "";
   }
+  return result;
 }
-var simpleCache_default = SimpleCache;
-
-// ../../src/core/cache/simpleCacheStore.ts
-class SimpleCacheStore {
-  cache;
-  constructor(cache) {
-    this.cache = cache;
+function buildAdvancedWhereClause(tableName, where = {}, whereNodes = [], params = []) {
+  const nodes = [];
+  if (Object.keys(where).length > 0) {
+    nodes.push({ kind: "and", where });
   }
-  get(key) {
-    return Promise.resolve(this.cache.get(key));
+  nodes.push(...whereNodes);
+  const combined = buildWhereGroupClause(tableName, nodes, params);
+  return {
+    clause: combined ? ` WHERE ${combined}` : "",
+    params
+  };
+}
+function resolveSoftDeleteColumn(table) {
+  if (!table.softDeletes) {
+    return null;
   }
-  set(key, value, ttlMs) {
-    this.cache.set(key, value, ttlMs);
-    return Promise.resolve();
+  if (table.softDeletes === true) {
+    return "deleted_at";
   }
-  getOrSet(key, loader, ttlMs) {
-    return this.cache.getOrSet(key, loader, ttlMs);
+  return table.softDeletes.column ?? "deleted_at";
+}
+function appendSoftDeleteScope(table, options, clauses) {
+  const column = resolveSoftDeleteColumn(table);
+  if (!column) {
+    return;
   }
-  attachTags(key, tags) {
-    this.cache.attachTags(key, tags);
-    return Promise.resolve();
+  const qualifiedColumn = qualifyColumn(table.name, column);
+  if (options.onlyTrashed) {
+    clauses.push(`${qualifiedColumn} IS NOT NULL`);
+    return;
   }
-  flushTags(tags) {
-    return Promise.resolve(this.cache.flushTags(tags));
+  if (!options.withTrashed) {
+    clauses.push(`${qualifiedColumn} IS NULL`);
   }
-  invalidate(key) {
-    return Promise.resolve(this.cache.invalidate(key));
+}
+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 };
   }
-  invalidateByPrefix(prefix) {
-    return Promise.resolve(this.cache.invalidateByPrefix(prefix));
+  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 [];
   }
-  clear() {
-    this.cache.clear();
-    return Promise.resolve();
+  if (Array.isArray(orderBy)) {
+    return orderBy;
   }
-  size() {
-    return Promise.resolve(this.cache.size());
+  if (isQueryOrder(orderBy)) {
+    return [orderBy];
   }
+  return Object.entries(orderBy).map(([column, direction]) => ({
+    column,
+    direction
+  }));
 }
-var simpleCacheStore_default = SimpleCacheStore;
-
-// ../../src/core/cache/createCacheStore.ts
-function createCacheStore(options) {
-  if (options.driver === "redis") {
-    if (!options.redisUrl) {
-      throw new Error('CACHE_DRIVER="redis" requires REDIS_URL to be set.');
+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.");
     }
-    return new redisCacheStore_default(options.redisUrl, options.ttlMs, options.maxEntries, options.redis);
+    const reference = resolveQualifiedColumn(tableName, column);
+    const ordered = `${reference} ${normalizeDirection(direction)}`;
+    if (nulls === undefined)
+      return ordered;
+    if (currentSqlDialect().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 "";
   }
-  return new simpleCacheStore_default(new simpleCache_default(options.ttlMs, options.maxEntries));
+  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(", ")}` : "";
 }
-// ../../src/core/cache/taggedCache.ts
-class TaggedCache {
-  store;
-  tags;
-  constructor(store, tags) {
-    this.store = store;
-    this.tags = tags;
+function buildHavingClause(tableName, having, params) {
+  if (!having) {
+    return "";
   }
-  async remember(key, callback, ttlMs) {
-    if (this.store.getOrSetTagged)
-      return this.store.getOrSetTagged(key, callback, this.tags, ttlMs);
-    const value = await this.store.getOrSet(key, callback, ttlMs);
-    await this.store.attachTags(key, this.tags);
-    return value;
+  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 "";
   }
-  async flush() {
-    return this.store.flushTags(this.tags);
+  if (!Number.isInteger(limit) || limit <= 0) {
+    throw new Error("Query limit must be a positive integer.");
   }
+  return ` LIMIT ${limit}`;
 }
-var taggedCache_default = TaggedCache;
-
-// ../../src/core/cache/repository.ts
-class CacheRepository {
-  store;
-  constructor(store) {
-    this.store = store;
+function buildOffsetClause(offset) {
+  if (offset === undefined) {
+    return "";
   }
-  async close() {
-    await this.store.close?.();
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw new Error("Query offset must be a non-negative integer.");
   }
-  async get(key) {
-    return this.store.get(key);
+  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);
   }
-  async remember(key, callback, ttlMs) {
-    return this.store.getOrSet(key, callback, ttlMs);
-  }
-  async forget(key) {
-    return this.store.invalidate(key);
-  }
-  async flush() {
-    await this.store.clear();
-  }
-  tags(...names) {
-    return new taggedCache_default(this.store, names);
-  }
-  async getOrSet(key, loader, ttlMs) {
-    return this.remember(key, loader, ttlMs);
-  }
-  async invalidate(key) {
-    return this.forget(key);
-  }
-  async invalidateByPrefix(prefix) {
-    return this.store.invalidateByPrefix(prefix);
-  }
-  async clear() {
-    await this.flush();
-  }
-  async size() {
-    return this.store.size();
-  }
-}
-var repository_default = CacheRepository;
-// ../../src/core/cache/tags.ts
-var CACHE_TAGS = {
-  organizations: "organizations",
-  projects: "projects",
-  tasks: "tasks",
-  comments: "comments",
-  attachments: "attachments",
-  reports: "reports",
-  users: "users",
-  departments: "departments",
-  positions: "positions",
-  applications: "applications",
-  careers: "careers",
-  offers: "offers"
-};
-// ../../src/core/crypto/fieldEncryptionRotation.ts
-import { createHash as createHash3, randomUUID } from "crypto";
-
-// ../../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
-  };
+  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 = currentSqlDialect();
+      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 `${currentSqlDialect().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(", ");
 }
-
-// ../../src/core/database/baseRepository.ts
-init_connectionContext();
-init_dialect();
-
-// ../../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 };
+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]];
   });
-  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]
-        }
-      }
-    ];
+function buildSelectLock(table, options) {
+  const lock = options.lock;
+  if (!lock)
+    return "";
+  const driver = currentSqlDialect().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 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 }];
+  const wait = lock.wait === "nowait" ? " NOWAIT" : lock.wait === "skipLocked" ? " SKIP LOCKED" : "";
+  return ` FOR ${lock.mode === "update" ? "UPDATE" : "SHARE"}${target}${wait}`;
 }
-
-// ../../src/core/database/query.ts
-init_dialect();
-function quoteIdentifier(identifier) {
-  return currentSqlDialect().quoteIdentifier(identifier);
+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 returningSuffix(columns) {
-  return currentSqlDialect().returningClause(columns);
+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 qualifyColumn(tableName, column) {
-  return `${quoteIdentifier(tableName)}.${quoteIdentifier(column)}`;
+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
+  };
 }
-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);
+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}`);
   }
-  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 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 = currentSqlDialect().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 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 currentSqlDialect().placeholder(values.length);
+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
+  };
 }
-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";
+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 placeholders = values.map((value) => pushParam(params, value)).join(", ");
-  return `${column}${negated ? " NOT" : ""} IN (${placeholders})`;
+  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 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} ${currentSqlDialect().ilikeOperator()} ${pushParam(params, operator.ilike)}`);
-  }
-  if (operator.tsMatch !== undefined) {
-    if (currentSqlDialect().driver !== "pgsql") {
-      throw new Error("Full-text search (tsMatch) is only available on PostgreSQL.");
-    }
-    clauses.push(`${column} @@ plainto_tsquery('english', ${pushParam(params, operator.tsMatch)})`);
+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.`);
   }
-  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)}`);
+  if (conflictColumns.length === 0) {
+    throw new Error(`Cannot upsert into ${table.name} without any conflict columns.`);
   }
-  return clauses.join(" AND ");
-}
-function buildWhereClause(tableName, where = {}) {
+  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 body = appendWhereParts(tableName, where, params);
+  const columns = entries.map(([column]) => quoteIdentifier(column)).join(", ");
+  const placeholders = entries.map(([, value]) => pushParam(params, value)).join(", ");
+  const returningColumns = buildReturningColumns(table);
+  const suffix = currentSqlDialect().upsertSuffix(conflictColumns, updatable);
   return {
-    clause: body.length > 0 ? ` WHERE ${body}` : "",
+    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders})${suffix}${returningSuffix(returningColumns)}`,
     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})`;
+function buildIncrementQuery(table, id, column, amount, extra = {}) {
+  if (!Number.isFinite(amount)) {
+    throw new Error("Increment amount must be a finite number.");
   }
-  if ("where" in node) {
-    return appendWhereParts(tableName, node.where, params);
+  if (!table.columns.includes(column)) {
+    throw new Error(`Unknown column ${String(column)} on ${table.name}.`);
   }
-  const grouped = buildWhereGroupClause(tableName, node.group, params);
-  if (!grouped) {
-    return "";
+  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)}`);
   }
-  return grouped.includes(" OR ") ? `(${grouped})` : grouped;
+  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 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 "";
+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.`);
   }
-  return result;
+  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 buildAdvancedWhereClause(tableName, where = {}, whereNodes = [], params = []) {
-  const nodes = [];
-  if (Object.keys(where).length > 0) {
-    nodes.push({ kind: "and", where });
+function buildSoftDeleteByIdQuery(table, id, deletedAt) {
+  const deletedAtColumn = resolveSoftDeleteColumn(table);
+  if (!deletedAtColumn) {
+    throw new Error(`Table ${table.name} does not support soft deletes.`);
   }
-  nodes.push(...whereNodes);
-  const combined = buildWhereGroupClause(tableName, nodes, params);
+  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 {
-    clause: combined ? ` WHERE ${combined}` : "",
+    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = ${deletedAtPlaceholder} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
     params
   };
 }
-function resolveSoftDeleteColumn(table) {
-  if (!table.softDeletes) {
-    return null;
-  }
-  if (table.softDeletes === true) {
-    return "deleted_at";
+function buildRestoreByIdQuery(table, id) {
+  const deletedAtColumn = resolveSoftDeleteColumn(table);
+  if (!deletedAtColumn) {
+    throw new Error(`Table ${table.name} does not support soft deletes.`);
   }
-  return table.softDeletes.column ?? "deleted_at";
+  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 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 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 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 };
+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 base = clause.replace(/^ WHERE /, "");
-  const scope = softDeleteClauses.join(" AND ");
+  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 && currentSqlDialect().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 {
-    clause: base ? ` WHERE (${base}) AND ${scope}` : ` WHERE ${scope}`,
-    params: whereParams
+    text: prefix + clause + returningSuffix(columns.map(quoteIdentifier).join(", ")),
+    params
   };
 }
-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
-  }));
+
+// ../../src/core/database/relationships.ts
+function hasMany(definition) {
+  return {
+    type: "hasMany",
+    ...definition
+  };
 }
-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 (currentSqlDialect().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 hasOne(definition) {
+  return {
+    type: "hasOne",
+    ...definition
+  };
 }
-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 belongsTo(definition) {
+  return {
+    type: "belongsTo",
+    ...definition
+  };
 }
-function buildHavingClause(tableName, having, params) {
-  if (!having) {
-    return "";
-  }
-  const body = appendWhereParts(tableName, having, params);
-  return body.length > 0 ? ` HAVING ${body}` : "";
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
 }
-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 belongsToMany(definition) {
+  return {
+    type: "belongsToMany",
+    ...definition
+  };
 }
-function buildLimitClause(limit) {
-  if (limit === undefined) {
+function relationMatchKey(value) {
+  if (value === null || value === undefined) {
     return "";
   }
-  if (!Number.isInteger(limit) || limit <= 0) {
-    throw new Error("Query limit must be a positive integer.");
+  if (typeof value === "bigint") {
+    return value.toString();
   }
-  return ` LIMIT ${limit}`;
-}
-function buildOffsetClause(offset) {
-  if (offset === undefined) {
-    return "";
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
   }
-  if (!Number.isInteger(offset) || offset < 0) {
-    throw new Error("Query offset must be a non-negative integer.");
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return BigInt(value).toString();
   }
-  return ` OFFSET ${offset}`;
+  return String(value);
 }
-function buildReturningColumns(table) {
-  return table.columns.map((column) => qualifyColumn(table.name, column)).join(", ");
+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 buildSelectList(table, select, params = []) {
-  if (!select || select.length === 0) {
-    return buildReturningColumns(table);
+function getByRelationKey(map, key) {
+  if (map.has(key)) {
+    return map.get(key);
   }
-  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 = currentSqlDialect();
-      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)}`;
+  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]);
     }
-    if (item.kind === "literalText") {
-      return `${currentSqlDialect().castToText(pushParam(params, item.value))} AS ${quoteIdentifier(item.as)}`;
+  }
+  for (const child of children) {
+    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
+    if (!group) {
+      continue;
     }
-    if (item.kind === "subqueryCount") {
-      const body = remapExistsSql(item.sql, item.params, params);
-      return `(${body}) AS ${quoteIdentifier(item.as)}`;
+    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);
     }
-    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(", ");
+  }
+  return result;
 }
-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 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 buildSelectLock(table, options) {
-  const lock = options.lock;
-  if (!lock)
-    return "";
-  const driver = currentSqlDialect().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(", ")}`;
+function indexBelongsToRelation(children, parents, relation) {
+  const parentsById = new Map;
+  for (const parent of parents) {
+    parentsById.set(relationMatchKey(parent[relation.ownerKey]), parent);
   }
-  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
-  };
+  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;
 }
-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 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 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 = currentSqlDialect().castToText(`SUM(${qualifyColumn(table.name, column)})`);
-  const { clause, params } = buildQueryWhereClause(table, options, whereNodes);
+function morphMany(definition) {
   return {
-    text: `SELECT ${group} AS ${quoteIdentifier("value")}, ${total} AS ${quoteIdentifier("sum")} FROM ${quoteIdentifier(table.name)}${clause} GROUP BY ${group} ORDER BY ${group} ASC`,
-    params
+    type: "morphMany",
+    ...definition
   };
 }
-function buildGroupedCountQuery(table, column, where = {}, options = {}) {
-  const qualifiedColumn = qualifyColumn(table.name, column);
-  const { clause, params } = buildQueryWhereClause(table, {
-    where,
-    ...options
-  });
+function morphOne(definition) {
   return {
-    text: `SELECT ${qualifiedColumn} AS ${quoteIdentifier("value")}, COUNT(*) AS ${quoteIdentifier("count")} FROM ${quoteIdentifier(table.name)}${clause} GROUP BY ${qualifiedColumn} ORDER BY ${qualifiedColumn} ASC`,
-    params
+    type: "morphOne",
+    ...definition
   };
 }
-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);
+function morphTo(definition) {
   return {
-    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders})${returningSuffix(returningColumns)}`,
-    params
+    type: "morphTo",
+    ...definition
   };
 }
-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.`);
+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]);
+    }
   }
-  if (conflictColumns.length === 0) {
-    throw new Error(`Cannot upsert into ${table.name} without any conflict columns.`);
+  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 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 = currentSqlDialect().upsertSuffix(conflictColumns, updatable);
-  return {
-    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders})${suffix}${returningSuffix(returningColumns)}`,
-    params
-  };
+  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 buildIncrementQuery(table, id, column, amount, extra = {}) {
-  if (!Number.isFinite(amount)) {
-    throw new Error("Increment amount must be a finite number.");
+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]);
   }
-  if (!table.columns.includes(column)) {
-    throw new Error(`Unknown column ${String(column)} on ${table.name}.`);
+  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 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 result = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    result.set(parent[relation.localKey], grouped.get(key) ?? []);
   }
-  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
-  };
+  return result;
 }
-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}.`);
+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);
+    }
   }
-  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 && currentSqlDialect().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
-  };
+  return result;
 }
 
-// ../../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();
+// ../../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 });
   }
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return String(value);
+  return select;
+}
+function projectPluck(rows, column, keyBy) {
+  if (keyBy === undefined) {
+    return rows.map((row) => row[column]);
   }
-  if (typeof value === "string" && /^-?\d+$/.test(value)) {
-    return BigInt(value).toString();
+  const keyed = new Map;
+  for (const row of rows) {
+    keyed.set(row[keyBy], row[column]);
   }
-  return String(value);
+  return keyed;
 }
-var relationLookupCache = new WeakMap;
-function indexedRelationLookup(map) {
-  const cached = relationLookupCache.get(map);
-  if (cached) {
-    return cached;
+
+// ../../src/core/database/whereBuilder.ts
+class WhereBuilder {
+  nodes = [];
+  where(where) {
+    this.nodes.push({ kind: "and", where });
+    return this;
   }
-  const indexed = new Map;
-  for (const [existing, value] of map) {
-    indexed.set(relationMatchKey(existing), value);
+  orWhere(where) {
+    this.nodes.push({ kind: "or", where });
+    return this;
   }
-  relationLookupCache.set(map, indexed);
-  return indexed;
-}
-function getByRelationKey(map, key) {
-  if (map.has(key)) {
-    return map.get(key);
+  whereGroup(fn) {
+    const nested = new WhereBuilder;
+    fn(nested);
+    if (nested.nodes.length > 0) {
+      this.nodes.push({ kind: "and", group: nested.nodes });
+    }
+    return this;
   }
-  const want = relationMatchKey(key);
-  if (want === "") {
-    return;
+  orWhereGroup(fn) {
+    const nested = new WhereBuilder;
+    fn(nested);
+    if (nested.nodes.length > 0) {
+      this.nodes.push({ kind: "or", group: nested.nodes });
+    }
+    return this;
   }
-  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]);
-    }
+
+// ../../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;
   }
-  for (const child of children) {
-    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
-    if (!group) {
-      continue;
+  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;
     }
-    group.push(child);
+    this.whereNodes.push({ kind: "and", where: { ...input } });
+    return this;
   }
-  const result = new Map;
-  for (const [key, group] of groups) {
-    const original = originalKeys.get(key);
-    if (original !== undefined) {
-      result.set(original, group);
+  protectWhere() {
+    const nodes = [];
+    if (Object.keys(this.whereClause).length > 0) {
+      nodes.push({ kind: "and", where: this.whereClause });
     }
-  }
-  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;
+    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") {
@@ -6114,356 +5312,1159 @@ class BaseRepository {
       }
     };
   }
-  async findById(id) {
-    return await this.firstOrNull({
-      [this.table.primaryKey]: id
+  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);
+  }
+}
+var baseRepository_default = BaseRepository;
+
+// ../../src/core/database/table.ts
+function defineTable(definition) {
+  return definition;
+}
+
+// ../../src/core/tenant/resolveTenant.ts
+init_tenancyConfig();
+var tenants = new BaseRepository(defineTable({
+  name: "tenant",
+  primaryKey: "id",
+  columns: ["id", "slug"]
+}));
+async function resolveTenant(tenantId) {
+  if (!isTenancyEnabled()) {
+    return {
+      id: tenantId,
+      slug: "default"
+    };
+  }
+  const row = await tenants.findById(tenantId);
+  return row ? { id: row.id, slug: row.slug } : null;
+}
+
+// ../../src/core/auth/scimAuthMiddleware.ts
+init_tenantDatabaseScope();
+function createScimAuthMiddleware() {
+  return async (request, next) => {
+    const authorization = request.headers.get("authorization");
+    if (!authorization?.startsWith("Bearer ")) {
+      return jsonScimError("SCIM bearer token required.", 401);
+    }
+    const token = authorization.slice("Bearer ".length).trim();
+    const tenantId = resolveScimTenantFromToken(token);
+    if (tenantId === null) {
+      return jsonScimError("Invalid SCIM bearer token.", 401);
+    }
+    const tenant = await resolveTenant(tenantId);
+    if (!tenant) {
+      return jsonScimError("SCIM tenant not found.", 401);
+    }
+    return await runWithTenantDatabase(tenant, async () => {
+      bindDatabaseConnection(getActiveDatabaseConnection(getDefaultDatabasePool()));
+      try {
+        return await next();
+      } finally {
+        resetBoundDatabaseConnection();
+      }
+    });
+  };
+}
+function jsonScimError(detail, status) {
+  return Response.json({
+    schemas: ["urn:ietf:params:scim:api:messages:2.0:Error"],
+    detail,
+    status: String(status)
+  }, {
+    status,
+    headers: { "content-type": "application/scim+json" }
+  });
+}
+// ../../src/core/auth/tokenAbilityChecker.ts
+function tokenCan(user, ability) {
+  if (!user) {
+    return false;
+  }
+  const abilities = user.abilities ?? [];
+  return abilities.includes("*") || abilities.includes(ability);
+}
+function createTokenAbilityChecker() {
+  return {
+    tokenCan,
+    requireAbility(user, ability) {
+      if (!tokenCan(user, ability)) {
+        throw new ForbiddenError(`Missing ability: ${ability}`);
+      }
+    }
+  };
+}
+// ../../src/core/cache/redisCacheStore.ts
+var {RedisClient } = globalThis.Bun;
+var CACHE_SCRIPT = `
+local expected = {'hash', 'zset', 'zset', 'hash', 'zset'}
+for i, key in ipairs(KEYS) do
+  local kind = redis.call('TYPE', key).ok
+  if kind ~= 'none' and kind ~= expected[i] then return redis.error_reply('Unexpected cache key type') end
+end
+-- Redis eviction can remove one container without its companions. Never read
+-- orphaned values or leases after losing the expiry/order/generation indexes.
+local entries = redis.call('HLEN', KEYS[1])
+local order = redis.call('ZCARD', KEYS[3])
+if redis.call('ZCARD', KEYS[2]) ~= order or entries ~= (order > 0 and order + 1 or 0) then
+  redis.call('DEL', KEYS[1], KEYS[2], KEYS[3])
+end
+if redis.call('HLEN', KEYS[4]) ~= redis.call('ZCARD', KEYS[5]) then
+  redis.call('DEL', KEYS[4], KEYS[5])
+end
+local r = cjson.decode(ARGV[1])
+local time = redis.call('TIME')
+local now = tonumber(time[1]) * 1000 + tonumber(time[2]) / 1000
+local function removeEntry(key)
+  local removed = redis.call('HDEL', KEYS[1], 'e:' .. key)
+  redis.call('ZREM', KEYS[2], key)
+  redis.call('ZREM', KEYS[3], key)
+  return removed
+end
+local function removeMeta(field)
+  redis.call('HDEL', KEYS[4], field)
+  redis.call('ZREM', KEYS[5], field)
+end
+for _, key in ipairs(redis.call('ZRANGEBYSCORE', KEYS[2], '-inf', now, 'LIMIT', 0, r.capacity)) do removeEntry(key) end
+for _, field in ipairs(redis.call('ZRANGEBYSCORE', KEYS[5], '-inf', now, 'LIMIT', 0, r.metadataLimit)) do removeMeta(field) end
+local function expireContainers()
+  local last = redis.call('ZREVRANGE', KEYS[2], 0, 0, 'WITHSCORES')
+  if #last == 0 then
+    redis.call('DEL', KEYS[1], KEYS[2], KEYS[3])
+  elseif last[2] == 'inf' then
+    for i = 1, 3 do redis.call('PERSIST', KEYS[i]) end
+  else
+    local ttl = math.max(1, math.ceil(tonumber(last[2]) - now))
+    for i = 1, 3 do redis.call('PEXPIRE', KEYS[i], ttl) end
+  end
+  for i = 4, 5 do redis.call('PEXPIRE', KEYS[i], r.metadataTtlMs) end
+end
+local function response(value)
+  expireContainers()
+  return cjson.encode(value)
+end
+local function addTags(existing, added)
+  local seen = {}
+  local result = {}
+  for _, tags in ipairs({existing, added}) do
+    for _, tag in ipairs(tags) do
+      if not seen[tag] then seen[tag] = true; table.insert(result, tag) end
+    end
+  end
+  if #result > 32 then error('Cache entries support at most 32 tags') end
+  return result
+end
+local function touch(key)
+  local sequence = redis.call('HINCRBY', KEYS[1], '_sequence', 1)
+  redis.call('ZADD', KEYS[3], sequence, key)
+end
+local function read(key, tags)
+  local raw = redis.call('HGET', KEYS[1], 'e:' .. key)
+  if not raw then return nil end
+  local entry = cjson.decode(raw)
+  if #tags > 0 then
+    entry.tags = addTags(entry.tags, tags)
+    redis.call('HSET', KEYS[1], 'e:' .. key, cjson.encode(entry))
+  end
+  touch(key)
+  return entry.payload
+end
+local function write(key, payload, tags)
+  local entry = {payload=payload, tags=tags}
+  redis.call('HSET', KEYS[1], 'e:' .. key, cjson.encode(entry))
+  redis.call('ZADD', KEYS[2], r.ttlMs == 0 and '+inf' or now + r.ttlMs, key)
+  touch(key)
+  local overflow = redis.call('ZCARD', KEYS[3]) - r.capacity
+  if overflow > 0 then
+    for _, victim in ipairs(redis.call('ZRANGE', KEYS[3], 0, overflow - 1)) do removeEntry(victim) end
+  end
+end
+local leaseField = 'l:' .. r.key
+local function lease()
+  local raw = redis.call('HGET', KEYS[4], leaseField)
+  if not raw then return nil end
+  local value = cjson.decode(raw)
+  if value.expires <= now or value.deadline <= now then removeMeta(leaseField); return nil end
+  return value
+end
+local function metadataSpace(count)
+  if redis.call('HLEN', KEYS[4]) + count > r.metadataLimit then
+    -- Pressure sheds generation/lease state. Every old owner is fenced; cached
+    -- entries remain valid because invalidation removes matching entries atomically.
+    redis.call('DEL', KEYS[4], KEYS[5])
+  end
+end
+local function putMeta(field, value, expires)
+  redis.call('HSET', KEYS[4], field, value)
+  redis.call('ZADD', KEYS[5], expires, field)
+end
+local function scopes()
+  local fields = {}
+  for _, tag in ipairs(r.tags) do table.insert(fields, 'g:tag:' .. tag) end
+  for _, prefix in ipairs(r.prefixes) do table.insert(fields, 'g:prefix:' .. prefix) end
+  return fields
+end
+local function matches(key, tags)
+  if r.op == 'invalidate' then return key == r.key end
+  if r.op == 'prefix' then return key == r.key or string.sub(key, 1, #r.key + 1) == r.key .. '?' end
+  if r.op == 'tags' then
+    for _, existing in ipairs(tags) do
+      for _, wanted in ipairs(r.tags) do if wanted == existing then return true end end
+    end
+  end
+  return false
+end
+if r.op == 'clear' then
+  redis.call('DEL', unpack(KEYS))
+  return cjson.encode({removed=0})
+elseif r.op == 'get' then
+  local payload = read(r.key, r.tags)
+  return response(payload and {kind='value', payload=payload} or {kind='missing'})
+elseif r.op == 'set' then
+  local old = redis.call('HGET', KEYS[1], 'e:' .. r.key)
+  local tags = old and cjson.decode(old).tags or {}
+  write(r.key, r.payload, tags)
+  removeMeta(leaseField)
+  return response({written=true})
+elseif r.op == 'attach' then
+  read(r.key, r.tags)
+  return response({written=true})
+elseif r.op == 'size' then
+  return response({size=redis.call('ZCARD', KEYS[3])})
+elseif r.op == 'tags' or r.op == 'prefix' or r.op == 'invalidate' then
+  local generationFields = {}
+  if r.op == 'tags' then
+    for _, tag in ipairs(r.tags) do table.insert(generationFields, 'g:tag:' .. tag) end
+  elseif r.op == 'prefix' then table.insert(generationFields, 'g:prefix:' .. r.key) end
+  metadataSpace(#generationFields)
+  for _, field in ipairs(generationFields) do putMeta(field, r.owner, now + r.metadataTtlMs) end
+  local removed = 0
+  for _, key in ipairs(redis.call('ZRANGE', KEYS[3], 0, -1)) do
+    local raw = redis.call('HGET', KEYS[1], 'e:' .. key)
+    if raw and matches(key, cjson.decode(raw).tags) then removed = removed + removeEntry(key) end
+  end
+  for _, field in ipairs(redis.call('HKEYS', KEYS[4])) do
+    if string.sub(field, 1, 2) == 'l:' then
+      local value = cjson.decode(redis.call('HGET', KEYS[4], field))
+      if matches(string.sub(field, 3), value.tags) then removeMeta(field) end
+    end
+  end
+  return response({removed=removed})
+elseif r.op == 'claim' then
+  local payload = read(r.key, r.tags)
+  if payload then return response({kind='value', payload=payload}) end
+  local current = lease()
+  if current then
+    local shared = addTags(current.tags, r.tags)
+    if #shared == #current.tags then return response({kind='wait'}) end
+    -- A newly requested tag must not inherit a fill started before that tag's
+    -- invalidation. Restart with the union of tags and a new owner.
+    r.tags = shared
+    removeMeta(leaseField)
+  end
+  local active = 0
+  for _, field in ipairs(redis.call('HKEYS', KEYS[4])) do if string.sub(field, 1, 2) == 'l:' then active = active + 1 end end
+  if active >= r.capacity then return response({kind='wait'}) end
+  local fields = scopes()
+  metadataSpace(#fields + 1)
+  local generations = {}
+  for _, field in ipairs(fields) do
+    local token = redis.call('HGET', KEYS[4], field) or r.owner
+    putMeta(field, token, now + r.metadataTtlMs)
+    generations[field] = token
+  end
+  local value = {owner=r.owner, tags=r.tags, generations=generations, deadline=now + r.fillTimeoutMs, expires=now + r.leaseMs}
+  putMeta(leaseField, cjson.encode(value), value.expires)
+  return response({kind='owner'})
+elseif r.op == 'renew' or r.op == 'publish' or r.op == 'release' then
+  local current = lease()
+  if not current or current.owner ~= r.owner then return response({owned=false}) end
+  if r.op == 'release' then removeMeta(leaseField); return response({owned=true}) end
+  for field, token in pairs(current.generations) do
+    if redis.call('HGET', KEYS[4], field) ~= token then removeMeta(leaseField); return response({owned=false}) end
+  end
+  if r.op == 'renew' then
+    current.expires = math.min(current.deadline, now + r.leaseMs)
+    putMeta(leaseField, cjson.encode(current), current.expires)
+  else
+    write(r.key, r.payload, current.tags)
+    removeMeta(leaseField)
+  end
+  return response({owned=true})
+end
+return redis.error_reply('Unknown cache operation')
+`;
+
+class RedisCacheStore {
+  redisUrl;
+  ttlMs;
+  maxEntries;
+  client;
+  keys;
+  options;
+  fills = new Set;
+  closed = false;
+  constructor(redisUrl, ttlMs, maxEntries, options = {}) {
+    this.redisUrl = redisUrl;
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+    if (!Number.isSafeInteger(ttlMs) || ttlMs < 0)
+      throw new RangeError("ttlMs must be a non-negative safe integer.");
+    if (!Number.isInteger(maxEntries) || maxEntries < 1 || maxEntries > 1e4)
+      throw new RangeError("maxEntries must be between 1 and 10000.");
+    this.options = {
+      commandTimeoutMs: 5000,
+      leaseMs: 1e4,
+      fillTimeoutMs: 30000,
+      waitTimeoutMs: 35000,
+      pollMs: 25,
+      metadataTtlMs: 60000,
+      metadataLimit: 4096,
+      ...options
+    };
+    for (const [key, value] of Object.entries(this.options))
+      if (!Number.isSafeInteger(value) || value < 1)
+        throw new RangeError(`${key} must be a positive safe integer.`);
+    if (this.options.leaseMs < 30 || this.options.fillTimeoutMs < this.options.leaseMs || this.options.metadataTtlMs < this.options.fillTimeoutMs + this.options.leaseMs || this.options.metadataLimit < 66 || this.options.metadataLimit > 1e5)
+      throw new RangeError("Invalid Redis cache lease, deadline or metadata bounds.");
+    const namespace = namespacedRedisKey("cache:v3:");
+    const slot = new Bun.CryptoHasher("sha256").update(namespace).digest("hex");
+    this.keys = ["entries", "expiry", "order", "metadata", "metadata-expiry"].map((name) => `${namespace}{${slot}}:${name}`);
+    this.client = this.createClient();
+  }
+  createClient() {
+    return new RedisClient(this.redisUrl, {
+      connectionTimeout: this.options.commandTimeoutMs,
+      maxRetries: 1
     });
   }
-  async findByIdOrThrow(id, errorFactory) {
-    const record = await this.findById(id);
-    if (record) {
-      return record;
+  close() {
+    this.closed = true;
+    for (const fill of this.fills)
+      fill.abort(new Error("Redis cache store is closed."));
+    this.client?.close();
+    this.client = undefined;
+  }
+  async get(key) {
+    const result = await this.execute("get", key);
+    return result.kind === "value" ? JSON.parse(result.payload ?? "null") : undefined;
+  }
+  async set(key, value, ttlMs) {
+    await this.execute("set", key, { payload: this.serialize(value), ttlMs: ttlMs ?? this.ttlMs });
+  }
+  async getOrSet(key, loader, ttlMs) {
+    return this.getOrSetTagged(key, loader, [], ttlMs);
+  }
+  async getOrSetTagged(key, loader, tags, ttlMs) {
+    const owner = crypto.randomUUID();
+    const end = performance.now() + this.options.waitTimeoutMs;
+    while (!this.closed) {
+      const claim = await this.execute("claim", key, { owner, tags, ttlMs: ttlMs ?? this.ttlMs });
+      if (claim.kind === "value")
+        return JSON.parse(claim.payload ?? "null");
+      if (claim.kind === "owner")
+        return this.fill(key, owner, loader, ttlMs);
+      if (performance.now() >= end)
+        throw new Error("Redis cache fill wait deadline exceeded.");
+      await Bun.sleep(this.options.pollMs);
     }
-    throw errorFactory?.(id) ?? new Error(`${this.table.name} ${String(id)} was not found.`);
+    throw new Error("Redis cache store is closed.");
   }
-  async findByIds(ids) {
-    const uniqueIds = [...new Set(ids)];
-    if (uniqueIds.length === 0) {
-      return [];
+  async attachTags(key, tags) {
+    await this.execute("attach", key, { tags });
+  }
+  async flushTags(tags) {
+    return (await this.execute("tags", "", { tags })).removed ?? 0;
+  }
+  async invalidate(key) {
+    return ((await this.execute("invalidate", key)).removed ?? 0) > 0;
+  }
+  async invalidateByPrefix(prefix) {
+    return (await this.execute("prefix", prefix)).removed ?? 0;
+  }
+  async clear() {
+    await this.execute("clear", "");
+  }
+  async size() {
+    return (await this.execute("size", "")).size ?? 0;
+  }
+  async fill(key, owner, loader, ttlMs) {
+    if (this.fills.size >= this.maxEntries) {
+      await this.execute("release", key, { owner });
+      throw new Error("Redis cache local fill capacity exceeded.");
     }
-    return await this.findWhere({
-      [this.table.primaryKey]: uniqueIds
+    const controller = new AbortController;
+    this.fills.add(controller);
+    let done = false;
+    let renewing = false;
+    const renew = setInterval(() => {
+      if (renewing || done)
+        return;
+      renewing = true;
+      this.execute("renew", key, { owner }).then((result) => {
+        if (!result.owned)
+          clearInterval(renew);
+      }).catch((error) => {
+        if (!done)
+          controller.abort(error);
+      }).finally(() => {
+        renewing = false;
+      });
+    }, Math.max(10, Math.floor(this.options.leaseMs / 3)));
+    const timeout = setTimeout(() => controller.abort(new Error("Redis cache fill deadline exceeded.")), this.options.fillTimeoutMs);
+    let rejectAbort;
+    const aborted = new Promise((_, reject) => {
+      rejectAbort = () => reject(controller.signal.reason);
+      controller.signal.addEventListener("abort", rejectAbort, { once: true });
     });
+    try {
+      const value = await Promise.race([
+        Promise.resolve().then(() => loader(controller.signal)),
+        aborted
+      ]);
+      controller.signal.throwIfAborted();
+      done = true;
+      clearInterval(renew);
+      await this.execute("publish", key, {
+        owner,
+        payload: this.serialize(value),
+        ttlMs: ttlMs ?? this.ttlMs
+      });
+      return value;
+    } finally {
+      done = true;
+      clearInterval(renew);
+      clearTimeout(timeout);
+      controller.signal.removeEventListener("abort", rejectAbort);
+      this.fills.delete(controller);
+      if (!this.closed)
+        await this.execute("release", key, { owner }).catch(() => {});
+    }
   }
-  async firstOrNull(where, options = {}) {
-    const [record] = await this.findAll({ ...options, where, limit: 1 });
-    return record ?? null;
+  serialize(value) {
+    const payload = JSON.stringify(value);
+    if (typeof payload !== "string")
+      throw new TypeError("Redis cache values must be JSON serializable.");
+    return payload;
   }
-  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 execute(op, key, extra = {}) {
+    if (this.closed)
+      throw new Error("Redis cache store is closed.");
+    if (Buffer.byteLength(key) > 4096)
+      throw new RangeError("Invalid Redis cache identity.");
+    const tags = Array.from(new Set(extra.tags ?? []));
+    if (tags.length > 32 || tags.some((tag) => typeof tag !== "string" || Buffer.byteLength(tag) > 1024))
+      throw new RangeError("Redis cache supports at most 32 tags of 1024 bytes each.");
+    const prefixes = [key];
+    for (let i = 0;i < key.length; i++)
+      if (key[i] === "?")
+        prefixes.push(key.slice(0, i));
+    if (prefixes.length > 33)
+      throw new RangeError("Redis cache identities support at most 32 query separators.");
+    const ttlMs = extra.ttlMs ?? this.ttlMs;
+    if (typeof ttlMs !== "number" || !Number.isSafeInteger(ttlMs) || ttlMs < 0)
+      throw new RangeError("ttlMs must be a non-negative safe integer.");
+    if (!this.client)
+      this.client = this.createClient();
+    const client = this.client;
+    const retire = (reason) => {
+      if (this.client !== client)
+        return;
+      this.client = undefined;
+      for (const fill of this.fills)
+        fill.abort(reason);
+      client.close();
+    };
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        const error = new Error("Redis cache command deadline exceeded.");
+        reject(error);
+        retire(error);
+      }, this.options.commandTimeoutMs);
+    });
+    try {
+      const raw = await Promise.race([
+        client.send("EVAL", [
+          CACHE_SCRIPT,
+          String(this.keys.length),
+          ...this.keys,
+          JSON.stringify({
+            op,
+            key,
+            capacity: this.maxEntries,
+            owner: crypto.randomUUID(),
+            ...this.options,
+            ...extra,
+            tags,
+            prefixes,
+            ttlMs
+          })
+        ]),
+        timeout
+      ]);
+      if (this.closed || this.client !== client)
+        throw new Error("Redis cache connection was retired.");
+      return JSON.parse(String(raw));
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && typeof error.code === "string" && error.code.startsWith("ERR_REDIS_CONNECTION"))
+        retire(error);
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+var redisCacheStore_default = RedisCacheStore;
+
+// ../../src/core/cache/simpleCache.ts
+class SimpleCache {
+  ttlMs;
+  maxEntries;
+  cache = new Map;
+  inflight = new Map;
+  tagIndex = new Map;
+  keyTags = new Map;
+  constructor(ttlMs = 3600000, maxEntries = 100) {
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+    if (!Number.isFinite(ttlMs) || ttlMs < 0) {
+      throw new RangeError("ttlMs must be a non-negative number.");
+    }
+    if (!Number.isInteger(maxEntries) || maxEntries < 1) {
+      throw new RangeError("maxEntries must be a positive integer.");
+    }
+  }
+  get(key) {
+    return this.getFreshEntry(key)?.value;
+  }
+  set(key, value, ttlMs) {
+    const now = Date.now();
+    const resolvedTtlMs = ttlMs ?? this.ttlMs;
+    this.cache.set(key, {
+      value,
+      expiresAt: now + resolvedTtlMs,
+      lastAccessedAt: now
     });
+    this.evictOverflow();
   }
-  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 getOrSet(key, loader, ttlMs) {
+    this.pruneExpired();
+    const cachedEntry = this.getFreshEntry(key);
+    if (cachedEntry) {
+      return cachedEntry.value;
+    }
+    const inflightRequest = this.inflight.get(key);
+    if (inflightRequest) {
+      return inflightRequest;
+    }
+    const pendingRequest = loader().then((value) => {
+      this.set(key, value, ttlMs);
+      return value;
+    }).finally(() => {
+      this.inflight.delete(key);
     });
+    this.inflight.set(key, pendingRequest);
+    return pendingRequest;
   }
-  async decrementById(id, column, amount = 1, extra = {}) {
-    return await this.incrementById(id, column, -amount, extra);
+  attachTags(key, tags) {
+    if (tags.length === 0) {
+      return;
+    }
+    let tagsForKey = this.keyTags.get(key);
+    if (!tagsForKey) {
+      tagsForKey = new Set;
+      this.keyTags.set(key, tagsForKey);
+    }
+    for (const tag of tags) {
+      tagsForKey.add(tag);
+      let keysForTag = this.tagIndex.get(tag);
+      if (!keysForTag) {
+        keysForTag = new Set;
+        this.tagIndex.set(tag, keysForTag);
+      }
+      keysForTag.add(key);
+    }
   }
-  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.`);
+  flushTags(tags) {
+    const keysToRemove = new Set;
+    for (const tag of tags) {
+      const keys = this.tagIndex.get(tag);
+      if (!keys) {
+        continue;
       }
-      const entity = record;
-      await dispatchModelEvent(modelEventName(this.table.name, "created"), entity);
-      return entity;
-    }));
+      for (const key of keys) {
+        keysToRemove.add(key);
+      }
+    }
+    let removed = 0;
+    for (const key of keysToRemove) {
+      if (this.invalidate(key)) {
+        removed += 1;
+      }
+    }
+    for (const tag of tags) {
+      this.tagIndex.delete(tag);
+    }
+    return removed;
   }
-  async updateWhere(changes, options) {
-    return this.executeConditionalWrite("update", changes, options);
+  invalidate(key) {
+    const removed = this.cache.delete(key);
+    if (removed) {
+      this.detachKeyFromTags(key);
+    }
+    return removed;
   }
-  async deleteWhere(options) {
-    return this.executeConditionalWrite("delete", {}, options);
+  invalidateByPrefix(prefix) {
+    let removed = 0;
+    for (const key of [...this.cache.keys()]) {
+      if (key === prefix || key.startsWith(`${prefix}?`)) {
+        if (this.invalidate(key)) {
+          removed += 1;
+        }
+      }
+    }
+    return removed;
   }
-  async updateWhereReturning(changes, columns, options) {
-    const { text, params } = buildConditionalWriteQuery(this.table, "update", changes, options, columns);
-    return withDatabaseErrorHandling(() => this.connection.unsafe(text, params));
+  clear() {
+    this.cache.clear();
+    this.inflight.clear();
+    this.tagIndex.clear();
+    this.keyTags.clear();
   }
-  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;
-    });
+  size() {
+    this.pruneExpired();
+    return this.cache.size;
   }
-  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);
+  detachKeyFromTags(key) {
+    const tags = this.keyTags.get(key);
+    if (!tags) {
+      return;
+    }
+    for (const tag of tags) {
+      const keys = this.tagIndex.get(tag);
+      if (!keys) {
+        continue;
+      }
+      keys.delete(key);
+      if (keys.size === 0) {
+        this.tagIndex.delete(tag);
       }
-      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.`);
+    this.keyTags.delete(key);
   }
-  async deleteById(id) {
-    if (resolveSoftDeleteColumn(this.table)) {
-      return await this.softDeleteById(id);
+  getFreshEntry(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return;
     }
-    return await this.forceDeleteById(id);
+    if (entry.expiresAt <= Date.now()) {
+      this.invalidate(key);
+      return;
+    }
+    entry.lastAccessedAt = Date.now();
+    return entry;
   }
-  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;
+  pruneExpired() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.expiresAt <= now) {
+        this.invalidate(key);
       }
-      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;
+  evictOverflow() {
+    while (this.cache.size > this.maxEntries) {
+      let oldestKey;
+      let oldestAccessTime = Number.POSITIVE_INFINITY;
+      for (const [key, entry] of this.cache.entries()) {
+        if (entry.lastAccessedAt < oldestAccessTime) {
+          oldestAccessTime = entry.lastAccessedAt;
+          oldestKey = key;
+        }
       }
-      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;
+      if (!oldestKey) {
+        return;
       }
-      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;
+      this.invalidate(oldestKey);
     }
-    return order.direction;
   }
-  withConnection(connection) {
-    const clone = Object.create(Object.getPrototypeOf(this));
-    Object.assign(clone, this);
-    clone.connection = connection;
-    return clone;
+}
+var simpleCache_default = SimpleCache;
+
+// ../../src/core/cache/simpleCacheStore.ts
+class SimpleCacheStore {
+  cache;
+  constructor(cache) {
+    this.cache = cache;
   }
-  getConnection() {
-    return this.connection;
+  get(key) {
+    return Promise.resolve(this.cache.get(key));
   }
-  getTable() {
-    return this.table;
+  set(key, value, ttlMs) {
+    this.cache.set(key, value, ttlMs);
+    return Promise.resolve();
   }
-  query(where = {}) {
-    return new RepositoryQuery(this, where);
+  getOrSet(key, loader, ttlMs) {
+    return this.cache.getOrSet(key, loader, ttlMs);
   }
-  async findWhere(where, options = {}) {
-    return await this.findAll({ ...options, where });
+  attachTags(key, tags) {
+    this.cache.attachTags(key, tags);
+    return Promise.resolve();
   }
-  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);
+  flushTags(tags) {
+    return Promise.resolve(this.cache.flushTags(tags));
   }
-  async averageColumn(column, where = {}) {
-    const qualifiedColumn = qualifyColumn(this.table.name, column);
-    return await this.averageExpression(`AVG(${qualifiedColumn})`, "value", where);
+  invalidate(key) {
+    return Promise.resolve(this.cache.invalidate(key));
   }
-  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);
+  invalidateByPrefix(prefix) {
+    return Promise.resolve(this.cache.invalidateByPrefix(prefix));
   }
-  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));
+  clear() {
+    this.cache.clear();
+    return Promise.resolve();
   }
-  async sum(column, where = {}) {
-    return await this.aggregateColumn("SUM", column, where);
+  size() {
+    return Promise.resolve(this.cache.size());
   }
-  async avg(column, where = {}) {
-    return await this.aggregateColumn("AVG", column, where);
+}
+var simpleCacheStore_default = SimpleCacheStore;
+
+// ../../src/core/cache/createCacheStore.ts
+function createCacheStore(options) {
+  if (options.driver === "redis") {
+    if (!options.redisUrl) {
+      throw new Error('CACHE_DRIVER="redis" requires REDIS_URL to be set.');
+    }
+    return new redisCacheStore_default(options.redisUrl, options.ttlMs, options.maxEntries, options.redis);
   }
-  async min(column, where = {}) {
-    return await this.aggregateColumn("MIN", column, where);
+  return new simpleCacheStore_default(new simpleCache_default(options.ttlMs, options.maxEntries));
+}
+// ../../src/core/cache/taggedCache.ts
+class TaggedCache {
+  store;
+  tags;
+  constructor(store, tags) {
+    this.store = store;
+    this.tags = tags;
   }
-  async max(column, where = {}) {
-    return await this.aggregateColumn("MAX", column, where);
+  async remember(key, callback, ttlMs) {
+    if (this.store.getOrSetTagged)
+      return this.store.getOrSetTagged(key, callback, this.tags, ttlMs);
+    const value = await this.store.getOrSet(key, callback, ttlMs);
+    await this.store.attachTags(key, this.tags);
+    return value;
   }
-  async aggregateColumn(fn, column, where) {
-    const qualifiedColumn = qualifyColumn(this.table.name, column);
-    return await this.averageExpression(`${fn}(${qualifiedColumn})`, "value", where);
+  async flush() {
+    return this.store.flushTags(this.tags);
   }
-  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)];
-    });
+}
+var taggedCache_default = TaggedCache;
+
+// ../../src/core/cache/repository.ts
+class CacheRepository {
+  store;
+  constructor(store) {
+    this.store = store;
   }
-  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 close() {
+    await this.store.close?.();
   }
-  async findByHasManyRelation(relation, parentId, options = {}) {
-    return await this.findWhere({
-      [relation.foreignKey]: parentId
-    }, options);
+  async get(key) {
+    return this.store.get(key);
   }
-  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 remember(key, callback, ttlMs) {
+    return this.store.getOrSet(key, callback, ttlMs);
   }
-  async findHasManyThrough(parentId, relation, options = {}) {
-    const grouped = await this.loadHasManyThroughForParents([{ [relation.localKey]: parentId }], relation, options);
-    return getByRelationKey(grouped, parentId) ?? [];
+  async forget(key) {
+    return this.store.invalidate(key);
   }
-  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);
+  async flush() {
+    await this.store.clear();
   }
-  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)
-    };
+  tags(...names) {
+    return new taggedCache_default(this.store, names);
   }
-  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 getOrSet(key, loader, ttlMs) {
+    return this.remember(key, loader, ttlMs);
   }
-  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 invalidate(key) {
+    return this.forget(key);
   }
-  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 invalidateByPrefix(prefix) {
+    return this.store.invalidateByPrefix(prefix);
   }
-  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 clear() {
+    await this.flush();
   }
-  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);
+  async size() {
+    return this.store.size();
   }
 }
-var baseRepository_default = BaseRepository;
-
+var repository_default = CacheRepository;
+// ../../src/core/cache/tags.ts
+var CACHE_TAGS = {
+  organizations: "organizations",
+  projects: "projects",
+  tasks: "tasks",
+  comments: "comments",
+  attachments: "attachments",
+  reports: "reports",
+  users: "users",
+  departments: "departments",
+  positions: "positions",
+  applications: "applications",
+  careers: "careers",
+  offers: "offers"
+};
 // ../../src/core/crypto/fieldEncryptionRotation.ts
+import { createHash as createHash3, randomUUID } from "crypto";
 init_boundConnection();
 
 // ../../src/core/database/migrations/rollbackGuard.ts
@@ -7128,11 +7129,6 @@ function createSchemaBuilder(db, driver) {
     }
   });
 }
-// ../../src/core/database/table.ts
-function defineTable(definition) {
-  return definition;
-}
-
 // ../../src/core/crypto/fieldEncryptionRotation.ts
 init_transaction();
 
@@ -15929,7 +15925,6 @@ init_tenantDatabaseScope();
 
 // ../../src/core/tenant/tenantMiddleware.ts
 import { createHash as createHash8 } from "crypto";
-init_repositoryConnection();
 init_databaseTenantContext();
 
 // ../../src/core/tenant/publicTenantHost.ts
@@ -15985,18 +15980,18 @@ var DEFAULT_TENANT = {
   id: 1,
   slug: "default"
 };
+var userTenants = new BaseRepository(defineTable({
+  name: "users",
+  primaryKey: "id",
+  columns: ["id", "tenant_id"]
+}));
 async function resolveUserTenantId(userId) {
   if (!isTenancyEnabled()) {
     return DEFAULT_TENANT.id;
   }
   return await runWithMigrationBypassForIdentifier(userId, async () => {
-    const rows = await repositoryConnection`
-      SELECT tenant_id
-      FROM users
-      WHERE id = ${userId}
-      LIMIT 1
-    `;
-    return rows[0]?.tenant_id ?? DEFAULT_TENANT.id;
+    const tenantId = await userTenants.query().where({ id: userId }).value("tenant_id");
+    return tenantId ?? DEFAULT_TENANT.id;
   });
 }
 function auditChecksum(payload) {