@querykitjs/prisma-pg 1.0.0

package/dist/index.js

@@ -0,0 +1,837 @@
+import { TEXT_FILTER_OPERATORS, QueryKitError, DEFAULT_MAX_LIMIT, DEFAULT_MAX_PER_PAGE, DEFAULT_LIMIT, DEFAULT_PER_PAGE, createFilters as createFilters$1 } from '@querykitjs/core';
+export { f } from '@querykitjs/core';
+import { AsyncLocalStorage } from 'async_hooks';
+
+// src/registry.ts
+
+// src/internal/fields.ts
+function isDelegate(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const d = value;
+  return typeof d.findMany === "function" && typeof d.findFirst === "function" && typeof d.count === "function";
+}
+function delegateKeys(client) {
+  return Object.keys(client).filter((key) => !key.startsWith("$") && !key.startsWith("_") && key !== "constructor" && isDelegate(client[key]));
+}
+var uncapitalize = (name) => name ? name[0].toLowerCase() + name.slice(1) : name;
+var KINDS = /* @__PURE__ */ new Set(["scalar", "enum", "object", "unsupported"]);
+var normalizeKind = (kind) => typeof kind === "string" && KINDS.has(kind) ? kind : "scalar";
+function fromRuntimeDataModel(client, delegateKey) {
+  const rdm = client._runtimeDataModel;
+  const models = rdm?.models;
+  if (!models || typeof models !== "object") return void 0;
+  const modelName = Object.keys(models).find((name) => uncapitalize(name) === delegateKey);
+  if (!modelName) return void 0;
+  const raw = models[modelName]?.fields;
+  if (!Array.isArray(raw)) return void 0;
+  const fields = [];
+  for (const field of raw) {
+    if (typeof field?.name !== "string") continue;
+    fields.push({
+      name: field.name,
+      type: typeof field.type === "string" ? field.type : "",
+      kind: normalizeKind(field.kind),
+      isId: field.isId === true,
+      isUpdatedAt: field.isUpdatedAt === true,
+      isList: field.isList === true,
+      ...typeof field.dbName === "string" && field.dbName ? { dbName: field.dbName } : {}
+    });
+  }
+  return fields.length ? { name: modelName, fields, primaryKey: models[modelName]?.primaryKey ?? null } : void 0;
+}
+function fromDelegateFields(delegate, delegateKey) {
+  const refs = delegate?.fields;
+  if (!refs || typeof refs !== "object") return void 0;
+  const fields = [];
+  let modelName;
+  for (const ref of Object.values(refs)) {
+    const r = ref;
+    if (typeof r.name !== "string") continue;
+    if (typeof r.modelName === "string") modelName ??= r.modelName;
+    fields.push({
+      name: r.name,
+      type: typeof r.typeName === "string" ? r.typeName : "",
+      kind: r.isEnum === true ? "enum" : "scalar",
+      isId: r.name === "id",
+      isUpdatedAt: false,
+      isList: r.isList === true
+    });
+  }
+  return fields.length ? { name: modelName ?? delegateKey, fields } : void 0;
+}
+function readModelMeta(client, delegateKey, override) {
+  const delegate = client[delegateKey];
+  if (!isDelegate(delegate)) {
+    const available = delegateKeys(client);
+    throw new Error(
+      `createRegistry: "${delegateKey}" is not a model delegate on this Prisma client. Available models: ${available.join(", ") || "(none)"}. Note the key is camelCase \u2014 model "LegalEntity" is "legalEntity".`
+    );
+  }
+  const discovered = fromRuntimeDataModel(client, delegateKey) ?? fromDelegateFields(delegate, delegateKey);
+  const source = override?.length ? { name: discovered?.name ?? delegateKey, fields: [...override] } : discovered;
+  if (!source) {
+    throw new Error(
+      `createRegistry: could not read field metadata for model "${delegateKey}". This adapter reads it from the Prisma client at runtime (\`_runtimeDataModel\`, then \`delegate.fields\`); both were unavailable, which usually means an unsupported @prisma/client version (>=5 expected). Pass \`fields\` in the repository options to supply it explicitly.`
+    );
+  }
+  const fields = /* @__PURE__ */ new Map();
+  const byDbName = /* @__PURE__ */ new Map();
+  for (const field of source.fields) {
+    fields.set(field.name, field);
+    if (field.dbName && field.dbName !== field.name) byDbName.set(field.dbName, field.name);
+  }
+  for (const name of fields.keys()) byDbName.delete(name);
+  const idField = fields.get("id")?.name ?? [...fields.values()].find((f2) => f2.isId)?.name;
+  const updatedAt = fields.get("updatedAt");
+  const compositeRaw = source.primaryKey;
+  const compositeFields = Array.isArray(compositeRaw?.fields) ? compositeRaw.fields.filter((f2) => typeof f2 === "string") : [];
+  const primaryKey = idField ? [idField] : compositeFields.filter((f2) => fields.has(f2));
+  const primaryKeyName = idField ? void 0 : (typeof compositeRaw?.name === "string" && compositeRaw.name ? compositeRaw.name : primaryKey.join("_")) || void 0;
+  return {
+    name: source.name,
+    fields,
+    byDbName,
+    primaryKey,
+    primaryKeyName,
+    idField,
+    hasDeletedAt: fields.has("deletedAt"),
+    // Prisma maintains `@updatedAt` itself; stamping it again would be redundant
+    // (mongoose does the same dance around schema `timestamps`).
+    stampUpdatedAt: updatedAt && !updatedAt.isUpdatedAt ? updatedAt.name : void 0,
+    hasCreatedAt: fields.has("createdAt")
+  };
+}
+function resolveField(meta, key) {
+  if (key === "id") return meta.fields.has("id") ? "id" : meta.idField;
+  if (meta.fields.has(key)) return key;
+  return meta.byDbName.get(key);
+}
+function fieldMeta(meta, field) {
+  return meta.fields.get(field);
+}
+function isDateField(meta, field) {
+  return meta.fields.get(field)?.type === "DateTime";
+}
+function isStringField(meta, field) {
+  return meta.fields.get(field)?.type === "String";
+}
+function castValue(meta, field, value) {
+  if (!isDateField(meta, field)) return value;
+  if (value === null || value === void 0 || value instanceof Date) return value;
+  if (typeof value !== "string" && typeof value !== "number") return value;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? value : date;
+}
+function reportSkip(diag, info) {
+  if (!diag) return;
+  const full = { ...info, source: diag.source };
+  if (diag.strict) throw new QueryKitError(full);
+  diag.onSkipped?.(full);
+}
+
+// src/internal/projection.ts
+function truthyKeys(selection) {
+  return Object.entries(selection).filter(([, on]) => on).map(([key]) => key);
+}
+function pickColumns(guard, columns) {
+  if (guard.forcedKeys) return guard.forcedKeys;
+  const requested = columns ? truthyKeys(columns) : [];
+  if (!guard.allowed) return requested.length > 0 ? requested : void 0;
+  const intersection = requested.filter((key) => guard.allowed.has(key));
+  return intersection.length > 0 ? intersection : [...guard.allowed];
+}
+function buildProjection(meta, guard, columns, withRelations, forceKeys = []) {
+  const relations = {};
+  if (withRelations) {
+    for (const [key, value] of Object.entries(withRelations)) {
+      if (value) relations[key] = value;
+    }
+  }
+  const hasRelations = Object.keys(relations).length > 0;
+  const keys = pickColumns(guard, columns);
+  const select = {};
+  if (keys) {
+    for (const key of [...keys, ...forceKeys]) {
+      const field = resolveField(meta, key);
+      if (field) select[field] = true;
+    }
+  }
+  const hasSelect = Object.keys(select).length > 0;
+  if (!hasSelect) return hasRelations ? { include: relations } : {};
+  if (hasRelations) return { select: { ...select, ...relations } };
+  return { select };
+}
+
+// src/internal/cursor.ts
+function encodeCursor(value) {
+  const normalized = value instanceof Date ? value.toISOString() : value;
+  const json = JSON.stringify({ v: normalized });
+  return Buffer.from(json, "utf8").toString("base64url");
+}
+function decodeCursor(cursor) {
+  if (!cursor) return void 0;
+  try {
+    const json = Buffer.from(cursor, "base64url").toString("utf8");
+    const payload = JSON.parse(json);
+    return payload.v;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/internal/order-by.ts
+function normalize(sort) {
+  if (!sort) return [];
+  return sort.filter((item) => item && item.key).map((item) => ({ key: item.key, direction: item.direction ?? "asc" }));
+}
+function buildOrderBy(meta, sort, diag) {
+  const orderBy = [];
+  for (const { key, direction } of normalize(sort)) {
+    const field = resolveField(meta, key);
+    if (field) orderBy.push({ [field]: direction });
+    else reportSkip(diag, { site: "sort", key, reason: "unknown-key" });
+  }
+  if (orderBy.length > 0) return orderBy;
+  if (meta.hasCreatedAt) return [{ createdAt: "desc" }];
+  return meta.idField ? [{ [meta.idField]: "desc" }] : [];
+}
+var TEXT_OPERATORS = new Set(TEXT_FILTER_OPERATORS);
+var INVALID_VALUE = /* @__PURE__ */ Symbol("querykit.invalid-value");
+var isTextOperator = (operator) => TEXT_OPERATORS.has(operator);
+function castForField(meta, field, value) {
+  if (value === null || value === void 0) return value;
+  const type = fieldMeta(meta, field)?.type;
+  if (type === "DateTime") {
+    if (value instanceof Date) return Number.isNaN(value.getTime()) ? INVALID_VALUE : value;
+    const cast = castValue(meta, field, value);
+    if (cast instanceof Date) return Number.isNaN(cast.getTime()) ? INVALID_VALUE : cast;
+    return INVALID_VALUE;
+  }
+  if (type === "Int" || type === "BigInt") {
+    if (typeof value === "number") return Number.isInteger(value) ? value : INVALID_VALUE;
+    if (typeof value === "bigint") return value;
+    if (typeof value === "string" && value.trim() !== "") {
+      const n = Number(value);
+      return Number.isInteger(n) ? n : INVALID_VALUE;
+    }
+    return INVALID_VALUE;
+  }
+  if (type === "Float" || type === "Decimal") {
+    if (typeof value === "number") return Number.isFinite(value) ? value : INVALID_VALUE;
+    if (typeof value === "string" && value.trim() !== "") {
+      const n = Number(value);
+      return Number.isFinite(n) ? n : INVALID_VALUE;
+    }
+    return INVALID_VALUE;
+  }
+  if (type === "Boolean") {
+    if (typeof value === "boolean") return value;
+    if (value === "true" || value === "1" || value === 1) return true;
+    if (value === "false" || value === "0" || value === 0) return false;
+    return INVALID_VALUE;
+  }
+  return value;
+}
+function coerceCondition(meta, field, operator, value) {
+  if (value === void 0 || TEXT_OPERATORS.has(operator)) return value;
+  if (Array.isArray(value)) {
+    const items = [];
+    for (const item of value) {
+      const cast2 = castForField(meta, field, item);
+      if (cast2 === INVALID_VALUE) return INVALID_VALUE;
+      items.push(cast2);
+    }
+    return items;
+  }
+  const cast = castForField(meta, field, value);
+  return cast === INVALID_VALUE ? INVALID_VALUE : cast;
+}
+
+// src/internal/operators.ts
+var isWhereFragment = (value) => typeof value?.buildFor === "function";
+var text = (value) => String(value ?? "");
+var asTuple = (value) => Array.isArray(value) && value.length === 2 ? [value[0], value[1]] : void 0;
+var insensitive = (fragment, ctx) => ctx.isString ? { ...fragment, mode: "insensitive" } : fragment;
+function tokenizeLike(pattern) {
+  const tokens = [];
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "\\") {
+      const next = pattern[i + 1];
+      if (next === void 0) return void 0;
+      tokens.push({ kind: "lit", char: next });
+      i++;
+      continue;
+    }
+    if (ch === "%") tokens.push({ kind: "any", char: "%" });
+    else if (ch === "_") tokens.push({ kind: "one", char: "_" });
+    else tokens.push({ kind: "lit", char: ch });
+  }
+  return tokens;
+}
+var renderPattern = (tokens) => tokens.map((t) => t.kind === "lit" && (t.char === "%" || t.char === "_" || t.char === "\\") ? `\\${t.char}` : t.char).join("");
+function parseLikePattern(pattern) {
+  const tokens = tokenizeLike(pattern);
+  if (!tokens) return void 0;
+  let start = 0;
+  let end = tokens.length;
+  let leading = false;
+  let trailing = false;
+  while (start < end && tokens[start].kind === "any") {
+    leading = true;
+    start++;
+  }
+  while (end > start && tokens[end - 1].kind === "any") {
+    trailing = true;
+    end--;
+  }
+  const core = tokens.slice(start, end);
+  if (core.some((t) => t.kind !== "lit")) return void 0;
+  const value = core.map((t) => t.char).join("");
+  const op = leading && trailing ? "contains" : leading ? "endsWith" : trailing ? "startsWith" : "equals";
+  if (op !== "equals" && /[%_]/.test(value)) return void 0;
+  return { op, value };
+}
+function rawLikePlan(pattern, ctx, caseInsensitive) {
+  const tokens = tokenizeLike(pattern);
+  if (!tokens) return void 0;
+  const mode = (fragment) => caseInsensitive ? insensitive(fragment, ctx) : fragment;
+  const raw = renderPattern(tokens);
+  return {
+    buildFor(field) {
+      if (tokens[tokens.length - 1]?.kind === "any") {
+        return { [field]: mode({ startsWith: raw.replace(/%$/, "") }) };
+      }
+      const lastAny = tokens.map((t) => t.kind).lastIndexOf("any");
+      if (lastAny >= 0) {
+        const tail = renderPattern(tokens.slice(lastAny + 1));
+        return { AND: [{ [field]: mode({ startsWith: raw }) }, { [field]: mode({ endsWith: tail }) }] };
+      }
+      return { AND: [{ [field]: mode({ startsWith: raw }) }, { NOT: { [field]: mode({ startsWith: `${raw}_` }) } }] };
+    }
+  };
+}
+var likeFragment = (value, ctx, caseInsensitive) => {
+  const pattern = text(value);
+  const shape = parseLikePattern(pattern);
+  if (shape) {
+    const fragment = { [shape.op]: shape.value };
+    return caseInsensitive ? insensitive(fragment, ctx) : fragment;
+  }
+  return rawLikePlan(pattern, ctx, caseInsensitive);
+};
+var operators = {
+  "=": (v) => ({ equals: v }),
+  eq: (v) => ({ equals: v }),
+  "!=": (v) => ({ not: v }),
+  ne: (v) => ({ not: v }),
+  ">": (v) => ({ gt: v }),
+  gt: (v) => ({ gt: v }),
+  ">=": (v) => ({ gte: v }),
+  gte: (v) => ({ gte: v }),
+  "<": (v) => ({ lt: v }),
+  lt: (v) => ({ lt: v }),
+  "<=": (v) => ({ lte: v }),
+  lte: (v) => ({ lte: v }),
+  contains: (v, ctx) => insensitive({ contains: text(v) }, ctx),
+  "%_%": (v, ctx) => insensitive({ contains: text(v) }, ctx),
+  startsWith: (v, ctx) => insensitive({ startsWith: text(v) }, ctx),
+  "%_": (v, ctx) => insensitive({ startsWith: text(v) }, ctx),
+  endsWith: (v, ctx) => insensitive({ endsWith: text(v) }, ctx),
+  "_%": (v, ctx) => insensitive({ endsWith: text(v) }, ctx),
+  like: (v, ctx) => likeFragment(v, ctx, false),
+  ilike: (v, ctx) => likeFragment(v, ctx, true),
+  notLike: (v, ctx) => {
+    const inner = likeFragment(v, ctx, false);
+    if (!inner) return void 0;
+    if (isWhereFragment(inner)) return { buildFor: (field) => ({ NOT: inner.buildFor(field) }) };
+    return { not: inner };
+  },
+  in: (v) => Array.isArray(v) ? { in: v } : void 0,
+  notIn: (v) => Array.isArray(v) ? { notIn: v } : void 0,
+  between: (v) => {
+    const t = asTuple(v);
+    return t ? { gte: t[0], lte: t[1] } : void 0;
+  },
+  notBetween: (v) => {
+    const t = asTuple(v);
+    return t ? { not: { gte: t[0], lte: t[1] } } : void 0;
+  },
+  isNull: () => ({ equals: null }),
+  isNotNull: () => ({ not: null })
+};
+
+// src/internal/where.ts
+var isObject = (node) => typeof node === "object" && node !== null;
+var isFieldCondition = (node) => isObject(node) && "key" in node && !("and" in node) && !("or" in node) && !("not" in node);
+function combine(kind, parts) {
+  const valid = parts.filter((part) => part !== void 0);
+  if (valid.length === 0) return void 0;
+  if (valid.length === 1) return valid[0];
+  return { [kind]: valid };
+}
+function buildCondition(meta, condition, diag) {
+  const operator = condition.operation ?? "=";
+  const build = operators[operator];
+  if (!build) throw new Error(`Unsupported filter operator: "${operator}"`);
+  const field = resolveField(meta, condition.key);
+  if (!field) {
+    reportSkip(diag, { site: "filter", key: condition.key, operation: operator, reason: "unknown-key" });
+    return void 0;
+  }
+  const isString = isStringField(meta, field);
+  if (isTextOperator(operator) && !isString) {
+    reportSkip(diag, { site: "filter", key: condition.key, operation: operator, reason: "invalid-value" });
+    return void 0;
+  }
+  const value = coerceCondition(meta, field, operator, condition.value);
+  if (value === INVALID_VALUE) {
+    reportSkip(diag, { site: "filter", key: condition.key, operation: operator, reason: "invalid-value" });
+    return void 0;
+  }
+  const fragment = build(value, { isString });
+  if (fragment === void 0) {
+    reportSkip(diag, { site: "filter", key: condition.key, operation: operator, reason: "invalid-value" });
+    return void 0;
+  }
+  if (isWhereFragment(fragment)) return fragment.buildFor(field);
+  return { [field]: fragment };
+}
+function buildNode(meta, node, diag) {
+  if (isFieldCondition(node)) return buildCondition(meta, node, diag);
+  if (!isObject(node)) return void 0;
+  if ("and" in node) {
+    return combine(
+      "AND",
+      node.and.map((child) => buildNode(meta, child, diag))
+    );
+  }
+  if ("or" in node) {
+    return combine(
+      "OR",
+      node.or.map((child) => buildNode(meta, child, diag))
+    );
+  }
+  if ("not" in node) {
+    const inner = buildNode(meta, node.not, diag);
+    return inner ? { NOT: inner } : void 0;
+  }
+  return node;
+}
+function buildWhere(meta, filter, diag) {
+  if (filter === void 0) return void 0;
+  if (Array.isArray(filter)) {
+    return combine(
+      "AND",
+      filter.map((node) => buildNode(meta, node, diag))
+    );
+  }
+  return buildNode(meta, filter, diag);
+}
+function andWhere(parts) {
+  return combine("AND", parts);
+}
+
+// src/repository.ts
+var CHUNK_SIZE = 1e3;
+var clampPageSize = (requested, fallback, max) => Math.min(max, Math.max(1, Math.trunc(requested ?? fallback)));
+var toArray = (value) => value === void 0 ? [] : Array.isArray(value) ? value : [value];
+function buildRepository(runtime, modelKey, config = {}) {
+  const meta = readModelMeta(runtime.baseClient, modelKey, config.fields);
+  const delegate = () => runtime.getExecutor()[modelKey];
+  const diag = {
+    source: meta.name,
+    strict: runtime.strict,
+    onSkipped: runtime.onSkippedCondition
+  };
+  const requirePrimaryKey = (method) => {
+    if (meta.primaryKey.length === 0) {
+      throw new Error(
+        `${method}: model "${meta.name}" has no primary key, so a row cannot be addressed individually. Use updateWhere/deleteWhere with an explicit filter instead.`
+      );
+    }
+    return meta.primaryKey;
+  };
+  const keySelect = (key) => Object.fromEntries(key.map((field) => [field, true]));
+  const uniqueWhere = (key, row) => {
+    if (key.length === 1) return { [key[0]]: row[key[0]] };
+    return { [meta.primaryKeyName ?? key.join("_")]: Object.fromEntries(key.map((field) => [field, row[field]])) };
+  };
+  const keyedIn = (key, rows) => {
+    if (key.length === 1) return { [key[0]]: { in: rows.map((row) => row[key[0]]) } };
+    return { OR: rows.map((row) => Object.fromEntries(key.map((field) => [field, row[field]]))) };
+  };
+  const scopeConditions = config.scope ? Object.entries(config.scope).map(([key, value]) => ({ key, operation: "=", value })) : [];
+  for (const condition of scopeConditions) {
+    if (!resolveField(meta, condition.key)) {
+      throw new QueryKitError({ source: meta.name, site: "filter", key: condition.key, reason: "unknown-key" });
+    }
+  }
+  const scopeWhere = scopeConditions.length ? buildWhere(meta, scopeConditions) : void 0;
+  const composeWhere = (userFilter, withDeleted) => andWhere([buildWhere(meta, userFilter, diag), scopeWhere, meta.hasDeletedAt && !withDeleted ? { deletedAt: null } : void 0]);
+  const withId = (filter, idKey, id) => {
+    if (!resolveField(meta, idKey)) {
+      throw new QueryKitError({ source: meta.name, site: "filter", key: idKey, reason: "unknown-key" });
+    }
+    const idCondition = { key: idKey, operation: "=", value: id };
+    if (!filter) return [idCondition];
+    if (Array.isArray(filter)) return [...filter, idCondition];
+    return { and: [filter, idCondition] };
+  };
+  const forcedKeys = config.forcedColumns ? truthyKeys(config.forcedColumns) : void 0;
+  if (config.forcedColumns && forcedKeys.length === 0) {
+    throw new Error("buildRepository: forcedColumns must select at least one field (an empty selection would return the full row).");
+  }
+  const allowed = config.allowedColumns ? new Set(config.allowedColumns) : void 0;
+  if (config.allowedColumns && allowed.size === 0) {
+    throw new Error("buildRepository: allowedColumns must list at least one field (an empty allowlist would return the full row).");
+  }
+  const guard = { forcedKeys, allowed };
+  const guarded = Boolean(forcedKeys ?? allowed);
+  const permits = (key) => forcedKeys ? forcedKeys.includes(key) : allowed ? allowed.has(key) : true;
+  const projection = (columns, withRelations, forceKeys) => buildProjection(meta, guard, columns, withRelations, forceKeys);
+  const forInsert = (values) => ({
+    ...config.scope,
+    ...values,
+    ...config.scope
+  });
+  const forUpdate = (patch) => {
+    const stamped = { ...patch };
+    if (meta.stampUpdatedAt) stamped[meta.stampUpdatedAt] = /* @__PURE__ */ new Date();
+    return stamped;
+  };
+  const countWhere = (where) => delegate().count({ where });
+  const upsertWhere = (targets, values) => {
+    const fields = targets.map((key) => {
+      const field = resolveField(meta, key);
+      if (!field) throw new Error(`upsert: unknown target field "${key}".`);
+      return field;
+    });
+    if (fields.length === 1) return { [fields[0]]: values[fields[0]] };
+    return { [fields.join("_")]: Object.fromEntries(fields.map((field) => [field, values[field]])) };
+  };
+  const defaultConflictSet = (values, targetKeys) => {
+    const skip = /* @__PURE__ */ new Set([...targetKeys, "createdAt"]);
+    const set = {};
+    for (const [key, value] of Object.entries(values)) {
+      if (!skip.has(key)) set[key] = value;
+    }
+    return forUpdate(set);
+  };
+  const repository = {
+    get delegate() {
+      return delegate();
+    },
+    async findAll(params = {}) {
+      const rows = await delegate().findMany({
+        where: composeWhere(params.filter, params.withDeleted),
+        orderBy: buildOrderBy(meta, params.sort, diag),
+        ...projection(params.columns, params.with)
+      });
+      return rows;
+    },
+    async findOne(params = {}) {
+      const row = await delegate().findFirst({
+        where: composeWhere(params.filter, params.withDeleted),
+        orderBy: buildOrderBy(meta, params.sort, diag),
+        ...projection(params.columns, params.with)
+      });
+      return row ?? void 0;
+    },
+    async findById(id, params = {}) {
+      const { idKey = "id", filter } = params;
+      const row = await delegate().findFirst({
+        where: composeWhere(withId(filter, idKey, id), params.withDeleted),
+        ...projection(params.columns, params.with)
+      });
+      return row ?? void 0;
+    },
+    async findList(params = {}) {
+      const page = Math.max(1, Math.trunc(params.page ?? 1));
+      const perPage = clampPageSize(params.perPage, runtime.defaultPerPage, runtime.maxPerPage);
+      const where = composeWhere(params.filter, params.withDeleted);
+      const [data, total_items] = await Promise.all([
+        delegate().findMany({
+          where,
+          orderBy: buildOrderBy(meta, params.sort, diag),
+          take: perPage,
+          skip: (page - 1) * perPage,
+          ...projection(params.columns, params.with)
+        }),
+        countWhere(where)
+      ]);
+      const total_pages = Math.ceil(total_items / perPage);
+      return {
+        data,
+        meta: {
+          total_items,
+          total_pages,
+          current_page: page,
+          per_page: perPage,
+          has_next: page < total_pages,
+          has_prev: page > 1
+        }
+      };
+    },
+    async findInfinite(params = {}) {
+      const limit = clampPageSize(params.limit, runtime.defaultLimit, runtime.maxLimit);
+      const offset = Math.max(0, Math.trunc(params.offset ?? 0));
+      const rows = await delegate().findMany({
+        where: composeWhere(params.filter, params.withDeleted),
+        orderBy: buildOrderBy(meta, params.sort, diag),
+        take: limit + 1,
+        skip: offset,
+        ...projection(params.columns, params.with)
+      });
+      const has_more = rows.length > limit;
+      const data = has_more ? rows.slice(0, limit) : rows;
+      return {
+        data,
+        meta: { limit, offset, count: data.length, has_more, next_offset: has_more ? offset + limit : null }
+      };
+    },
+    async findCursor(params = {}) {
+      const limit = clampPageSize(params.limit, runtime.defaultLimit, runtime.maxLimit);
+      const cursorKey = params.cursorKey ?? "id";
+      const order = params.order ?? "asc";
+      const direction = params.direction ?? "forward";
+      const field = resolveField(meta, cursorKey);
+      if (!field) throw new QueryKitError({ source: diag.source, site: "cursorKey", key: cursorKey, reason: "unknown-key" });
+      const decoded = decodeCursor(params.cursor);
+      const cursorValue = decoded === void 0 ? void 0 : castValue(meta, field, decoded);
+      const baseWhere = composeWhere(params.filter, params.withDeleted);
+      const ascInQuery = direction === "forward" ? order === "asc" : order === "desc";
+      const seek = cursorValue !== void 0 ? { [field]: ascInQuery ? { gt: cursorValue } : { lt: cursorValue } } : void 0;
+      const where = andWhere([baseWhere, seek]);
+      const selected = pickColumns(guard, params.columns);
+      const leaksCursorField = guarded && selected !== void 0 && !permits(cursorKey) && !permits(field);
+      const rows = await delegate().findMany({
+        where,
+        orderBy: [{ [field]: ascInQuery ? "asc" : "desc" }],
+        take: limit + 1,
+        ...projection(params.columns, params.with, [field])
+      });
+      const hasExtra = rows.length > limit;
+      let page = hasExtra ? rows.slice(0, limit) : rows;
+      if (direction === "backward") page = [...page].reverse();
+      const first = page[0];
+      const last = page[page.length - 1];
+      const has_next = direction === "forward" ? hasExtra : cursorValue !== void 0;
+      const has_prev = direction === "forward" ? cursorValue !== void 0 : hasExtra;
+      const meta_ = {
+        limit,
+        has_next,
+        has_prev,
+        next_cursor: has_next && last ? encodeCursor(last[field]) : null,
+        prev_cursor: has_prev && first ? encodeCursor(first[field]) : null
+      };
+      if (leaksCursorField) {
+        page = page.map((row) => {
+          const { [field]: _cursor, ...rest } = row;
+          return rest;
+        });
+      }
+      return { data: page, meta: meta_ };
+    },
+    count(filter) {
+      return countWhere(composeWhere(filter));
+    },
+    async exists(filter) {
+      return await countWhere(composeWhere(filter)) > 0;
+    },
+    /* ------------------------------- writes ------------------------------- */
+    async create(values) {
+      const row = await delegate().create({ data: forInsert(values) });
+      return row;
+    },
+    async createMany(values) {
+      if (values.length === 0) return [];
+      const data = values.map((v) => forInsert(v));
+      const d = delegate();
+      if (typeof d.createManyAndReturn === "function") {
+        return await d.createManyAndReturn({ data });
+      }
+      const out = [];
+      for (const item of data) out.push(await d.create({ data: item }));
+      return out;
+    },
+    async upsert(values, options) {
+      const targetKeys = toArray(options.target);
+      const inserted = forInsert(values);
+      const update = options.set ? forUpdate(options.set) : defaultConflictSet(inserted, targetKeys);
+      const row = await delegate().upsert({
+        where: upsertWhere(targetKeys, inserted),
+        create: inserted,
+        update
+      });
+      return row;
+    },
+    async upsertMany(values, options) {
+      if (values.length === 0) return [];
+      const targetKeys = toArray(options.target);
+      const out = [];
+      for (let i = 0; i < values.length; i += CHUNK_SIZE) {
+        for (const value of values.slice(i, i + CHUNK_SIZE)) {
+          const inserted = forInsert(value);
+          const update = options.set ? forUpdate(options.set) : defaultConflictSet(inserted, targetKeys);
+          out.push(
+            await delegate().upsert({
+              where: upsertWhere(targetKeys, inserted),
+              create: inserted,
+              update
+            })
+          );
+        }
+      }
+      return out;
+    },
+    async updateById(id, patch, idKey = "id") {
+      return updateOne(composeWhere(withId(void 0, idKey, id)), forUpdate(patch), "updateById");
+    },
+    async updateWhere(filter, patch) {
+      const key = requirePrimaryKey("updateWhere");
+      const where = composeWhere(filter);
+      const d = delegate();
+      const found = await d.findMany({ where, select: keySelect(key) });
+      if (found.length === 0) return [];
+      const keyed = keyedIn(key, found);
+      await d.updateMany({ where: keyed, data: forUpdate(patch) });
+      return await d.findMany({ where: keyed });
+    },
+    async deleteById(id, idKey = "id") {
+      const key = requirePrimaryKey("deleteById");
+      const d = delegate();
+      const target = await d.findFirst({ where: composeWhere(withId(void 0, idKey, id)) });
+      if (!target) return void 0;
+      return await d.delete({ where: uniqueWhere(key, target) });
+    },
+    async deleteWhere(filter) {
+      const key = requirePrimaryKey("deleteWhere");
+      const d = delegate();
+      const where = composeWhere(filter);
+      const rows = await d.findMany({ where });
+      if (rows.length === 0) return [];
+      await d.deleteMany({ where: keyedIn(key, rows) });
+      return rows;
+    },
+    async softDelete(id, idKey = "id") {
+      if (!meta.hasDeletedAt) throw new Error("softDelete: model has no deletedAt field.");
+      return updateOne(composeWhere(withId(void 0, idKey, id), false), forUpdate({ deletedAt: /* @__PURE__ */ new Date() }), "softDelete");
+    },
+    async restore(id, idKey = "id") {
+      if (!meta.hasDeletedAt) throw new Error("restore: model has no deletedAt field.");
+      return updateOne(composeWhere(withId(void 0, idKey, id), true), forUpdate({ deletedAt: null }), "restore");
+    },
+    async aggregate(spec) {
+      const aggregable = (key) => {
+        const field = permits(key) ? resolveField(meta, key) : void 0;
+        if (!field) reportSkip(diag, { site: "aggregate", key, reason: "unknown-key" });
+        return field;
+      };
+      const groupFields = toArray(spec.groupBy).map(aggregable).filter((field) => Boolean(field));
+      const selectionFor = (keys) => {
+        const picked = {};
+        for (const key of keys) {
+          const field = aggregable(key);
+          if (field) picked[field] = true;
+        }
+        return Object.keys(picked).length ? picked : void 0;
+      };
+      const sum = selectionFor(toArray(spec.sum));
+      const avg = selectionFor(toArray(spec.avg));
+      const min = selectionFor(toArray(spec.min));
+      const max = selectionFor(toArray(spec.max));
+      const args = { where: composeWhere(spec.filter, spec.withDeleted) };
+      if (spec.count) args._count = true;
+      if (sum) args._sum = sum;
+      if (avg) args._avg = avg;
+      if (min) args._min = min;
+      if (max) args._max = max;
+      const flatten = (row) => {
+        const out = {};
+        for (const [key, value] of Object.entries(row)) {
+          if (!key.startsWith("_")) {
+            out[key] = value;
+            continue;
+          }
+          if (key === "_count") {
+            if (typeof value === "number") out.count = value;
+            continue;
+          }
+          const prefix = key.slice(1);
+          for (const [field, aggregated] of Object.entries(value ?? {})) {
+            if (aggregated !== void 0) out[`${prefix}_${field}`] = aggregated;
+          }
+        }
+        return out;
+      };
+      if (groupFields.length > 0) {
+        const rows = await delegate().groupBy({ ...args, by: groupFields });
+        return rows.map(flatten);
+      }
+      return [flatten(await delegate().aggregate(args))];
+    },
+    scoped(scope) {
+      return buildRepository(runtime, modelKey, { ...config, scope: { ...config.scope, ...scope } });
+    }
+  };
+  async function updateOne(where, data, method) {
+    const key = requirePrimaryKey(method);
+    const d = delegate();
+    const target = await d.findFirst({ where, select: keySelect(key) });
+    if (!target) return void 0;
+    return await d.update({ where: uniqueWhere(key, target), data });
+  }
+  return repository;
+}
+function createContextStore() {
+  const als = new AsyncLocalStorage();
+  return {
+    get: () => als.getStore(),
+    run: (patch, fn) => als.run({ ...als.getStore(), ...patch }, fn)
+  };
+}
+
+// src/registry.ts
+function resolveModelKey(client, model) {
+  if (typeof model === "string") return model;
+  const keys = delegateKeys(client);
+  const found = keys.find((key) => client[key] === model);
+  if (!found) {
+    throw new Error(
+      `createRegistry: the given delegate does not belong to this Prisma client. Pass a model from the same client you passed to createRegistry (available: ${keys.join(", ") || "(none)"}), or use its name, e.g. repository("user").`
+    );
+  }
+  return found;
+}
+function createRegistry(prisma, options = {}) {
+  const ctx = createContextStore();
+  const runtime = {
+    baseClient: prisma,
+    getExecutor: () => ctx.get()?.executor ?? prisma,
+    defaultPerPage: options.defaultPerPage ?? DEFAULT_PER_PAGE,
+    defaultLimit: options.defaultLimit ?? DEFAULT_LIMIT,
+    maxPerPage: options.maxPerPage ?? DEFAULT_MAX_PER_PAGE,
+    maxLimit: options.maxLimit ?? DEFAULT_MAX_LIMIT,
+    strict: options.strict ?? false,
+    onSkippedCondition: options.onSkippedCondition
+  };
+  function repository(model, arg2, arg3) {
+    const repoOptions = typeof arg2 === "function" ? void 0 : arg2;
+    const extend = typeof arg2 === "function" ? arg2 : arg3;
+    const base = buildRepository(runtime, resolveModelKey(prisma, model), repoOptions);
+    return extend ? { ...base, ...extend(base) } : base;
+  }
+  const transaction = (fn) => {
+    if (ctx.get()?.executor) return fn();
+    return prisma.$transaction((tx) => ctx.run({ executor: tx }, fn));
+  };
+  return { client: prisma, repository, transaction };
+}
+function createFilters() {
+  return createFilters$1();
+}
+
+export { buildRepository, createFilters, createRegistry };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map