@nest-admin/nestjs 0.11.0

package/dist/prisma.js

@@ -0,0 +1,995 @@
+import {
+  AdapterError,
+  ConstraintError,
+  FieldNotFoundError,
+  InvalidQueryError,
+  ModelNotFoundError,
+  NestAdminError,
+  RecordNotFoundError,
+  __name,
+  displayFieldFor,
+  inverseRelationField,
+  isNestAdminError
+} from "./chunk-7IXLRGGQ.js";
+
+// ../prisma/dist/index.js
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join, resolve } from "path";
+import { getDMMF } from "@prisma/get-dmmf";
+var REQUIRED_METHODS = [
+  "findMany",
+  "findUnique",
+  "count",
+  "create",
+  "update",
+  "delete"
+];
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function toDelegateKey(modelName) {
+  if (modelName.length === 0) return modelName;
+  return modelName.charAt(0).toLowerCase() + modelName.slice(1);
+}
+__name(toDelegateKey, "toDelegateKey");
+function resolveDelegate(client, modelName, knownModels) {
+  if (!knownModels.includes(modelName)) {
+    throw new ModelNotFoundError(modelName, knownModels);
+  }
+  const key = toDelegateKey(modelName);
+  if (FORBIDDEN_KEYS.has(key)) {
+    throw new ModelNotFoundError(modelName, knownModels);
+  }
+  if (typeof client !== "object" || client === null) {
+    throw new AdapterError(`PrismaAdapter requires a constructed Prisma Client instance. Received ${client === null ? "null" : typeof client}.`);
+  }
+  const candidate = client[key];
+  if (typeof candidate !== "object" || candidate === null) {
+    throw new AdapterError(`The Prisma Client has no delegate "${key}" for model "${modelName}". This usually means the client was generated from a different schema than the one Nest Admin read - re-run \`prisma generate\`.`);
+  }
+  const delegate = candidate;
+  const missing = REQUIRED_METHODS.filter((method) => typeof delegate[method] !== "function");
+  if (missing.length > 0) {
+    throw new AdapterError(`Prisma Client delegate "${key}" is missing expected methods: ${missing.join(", ")}.`);
+  }
+  return candidate;
+}
+__name(resolveDelegate, "resolveDelegate");
+var SUPPORTED_PRISMA_MAJORS = [
+  7
+];
+var PrismaVersionUnsupportedError = class extends NestAdminError {
+  static {
+    __name(this, "PrismaVersionUnsupportedError");
+  }
+  constructor(clientVersion, supportedMajors) {
+    super(`Nest Admin ships a Prisma ${supportedMajors.join("/")} schema parser, but this application uses Prisma Client ${clientVersion}. Schema parsing would likely fail with a misleading error, so it was stopped here instead. Align the versions, or open an issue if Prisma ${clientVersion.split(".")[0]} should be supported.`);
+    this.clientVersion = clientVersion;
+    this.supportedMajors = supportedMajors;
+  }
+  clientVersion;
+  supportedMajors;
+};
+function readClientVersion(client) {
+  if (typeof client !== "object" || client === null) return void 0;
+  const version = client["_clientVersion"];
+  return typeof version === "string" && version !== "" ? version : void 0;
+}
+__name(readClientVersion, "readClientVersion");
+function majorOf(version) {
+  const major = Number(version.split(".")[0]);
+  return Number.isInteger(major) ? major : void 0;
+}
+__name(majorOf, "majorOf");
+function assertSupportedPrismaVersion(client, supportedMajors = SUPPORTED_PRISMA_MAJORS) {
+  const version = readClientVersion(client);
+  if (version === void 0) return;
+  const major = majorOf(version);
+  if (major === void 0) return;
+  if (!supportedMajors.includes(major)) {
+    throw new PrismaVersionUnsupportedError(version, supportedMajors);
+  }
+}
+__name(assertSupportedPrismaVersion, "assertSupportedPrismaVersion");
+var DEFAULT_SCHEMA_CANDIDATES = [
+  "prisma/schema.prisma",
+  "prisma/schema",
+  "schema.prisma"
+];
+var PrismaSchemaNotFoundError = class extends NestAdminError {
+  static {
+    __name(this, "PrismaSchemaNotFoundError");
+  }
+  constructor(triedPaths, explicit) {
+    super(explicit ? `Prisma schema not found at "${triedPaths[0]}".` : `Could not locate a Prisma schema. Tried: ${triedPaths.join(", ")}. Pass \`schemaPath\` to PrismaAdapter if your schema lives elsewhere.`);
+    this.triedPaths = triedPaths;
+  }
+  triedPaths;
+};
+var PrismaSchemaInvalidError = class extends NestAdminError {
+  static {
+    __name(this, "PrismaSchemaInvalidError");
+  }
+  constructor(prismaMessage, options) {
+    super(`Prisma rejected the schema:
+${prismaMessage}`, options);
+    this.prismaMessage = prismaMessage;
+  }
+  prismaMessage;
+};
+function locateSchema(schemaPath, cwd) {
+  if (schemaPath !== void 0) {
+    const absolute = resolve(cwd, schemaPath);
+    if (!existsSync(absolute)) throw new PrismaSchemaNotFoundError([
+      absolute
+    ], true);
+    return absolute;
+  }
+  const tried = [];
+  for (const candidate of DEFAULT_SCHEMA_CANDIDATES) {
+    const absolute = resolve(cwd, candidate);
+    tried.push(absolute);
+    if (existsSync(absolute)) return absolute;
+  }
+  throw new PrismaSchemaNotFoundError(tried, false);
+}
+__name(locateSchema, "locateSchema");
+function readSchemaFiles(absolutePath) {
+  if (statSync(absolutePath).isDirectory()) {
+    const files = readdirSync(absolutePath).filter((name) => name.endsWith(".prisma")).sort();
+    if (files.length === 0) {
+      throw new PrismaSchemaNotFoundError([
+        join(absolutePath, "*.prisma")
+      ], true);
+    }
+    return files.map((name) => {
+      const file = join(absolutePath, name);
+      return [
+        file,
+        readFileSync(file, "utf8")
+      ];
+    });
+  }
+  return [
+    [
+      absolutePath,
+      readFileSync(absolutePath, "utf8")
+    ]
+  ];
+}
+__name(readSchemaFiles, "readSchemaFiles");
+function readPrismaDmmf(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const absolutePath = locateSchema(options.schemaPath, cwd);
+  let files;
+  try {
+    files = readSchemaFiles(absolutePath);
+  } catch (cause) {
+    if (isNestAdminError(cause)) throw cause;
+    throw new AdapterError(`Failed to read the Prisma schema at "${absolutePath}".`, {
+      cause
+    });
+  }
+  const result = getDMMF({
+    datamodel: files
+  });
+  if (!isDmmfDocument(result)) {
+    throw new PrismaSchemaInvalidError(extractPrismaMessage(result), {
+      cause: result.error
+    });
+  }
+  return result;
+}
+__name(readPrismaDmmf, "readPrismaDmmf");
+function readDatasourceProvider(options = {}) {
+  try {
+    const files = readSchemaFiles(locateSchema(options.schemaPath, options.cwd ?? process.cwd()));
+    for (const [, content] of files) {
+      const declared = /datasources+w+s*{[^}]*?providers*=s*"([a-z]+)"/i.exec(content);
+      if (declared?.[1] !== void 0) return declared[1].toLowerCase();
+    }
+  } catch {
+  }
+  return void 0;
+}
+__name(readDatasourceProvider, "readDatasourceProvider");
+function isDmmfDocument(value) {
+  return "datamodel" in value;
+}
+__name(isDmmfDocument, "isDmmfDocument");
+function extractPrismaMessage(result) {
+  const raw = result.error?.message ?? result.reason;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && "message" in parsed) {
+      const message = parsed.message;
+      if (typeof message === "string") return stripAnsi(message);
+    }
+  } catch {
+  }
+  return stripAnsi(raw);
+}
+__name(extractPrismaMessage, "extractPrismaMessage");
+var ANSI_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+function stripAnsi(value) {
+  return value.replace(ANSI_PATTERN, "");
+}
+__name(stripAnsi, "stripAnsi");
+var SCALAR_KINDS = {
+  String: "string",
+  Int: "number",
+  Float: "number",
+  Boolean: "boolean",
+  DateTime: "datetime",
+  Json: "json"
+};
+function toFieldKind(field) {
+  if (field.kind === "object") return "relation";
+  if (field.kind === "enum") return "enum";
+  if (field.kind === "scalar") return SCALAR_KINDS[field.type] ?? "unknown";
+  return "unknown";
+}
+__name(toFieldKind, "toFieldKind");
+function isFunctionDefault(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "name" in value;
+}
+__name(isFunctionDefault, "isFunctionDefault");
+function toFieldMetadata(field, enums) {
+  const kind = toFieldKind(field);
+  const isGenerated = field.isUpdatedAt === true || isFunctionDefault(field.default);
+  const hasLiteralDefault = field.hasDefaultValue === true && !isFunctionDefault(field.default);
+  const base = {
+    name: field.name,
+    kind,
+    isId: field.isId === true,
+    isRequired: field.isRequired === true,
+    isUnique: field.isUnique === true,
+    isList: field.isList === true,
+    isGenerated
+  };
+  return {
+    ...base,
+    ...hasLiteralDefault ? {
+      defaultValue: field.default
+    } : {},
+    ...kind === "enum" ? {
+      enumValues: enums.get(field.type) ?? []
+    } : {},
+    ...kind === "relation" ? {
+      relation: {
+        targetModel: field.type,
+        // Cardinality follows directly from isList - the single attribute
+        // the generated Prisma Client does not expose at runtime, which is
+        // why metadata comes from the schema rather than the client.
+        cardinality: field.isList === true ? "many" : "one",
+        // Present only on the owning side of a to-one relation. Prisma
+        // gives both sides a relation field but only one of them a column,
+        // and these arrays are empty on the side that has none - so an
+        // empty array means "no foreign key here", not "unknown".
+        ...field.relationFromFields?.[0] !== void 0 ? {
+          from: field.relationFromFields[0]
+        } : {},
+        ...field.relationToFields?.[0] !== void 0 ? {
+          to: field.relationToFields[0]
+        } : {},
+        // Shared by both halves, so the other side can be found. Prisma
+        // generates one when the schema does not name it.
+        ...field.relationName !== void 0 ? {
+          name: field.relationName
+        } : {}
+      }
+    } : {}
+  };
+}
+__name(toFieldMetadata, "toFieldMetadata");
+function toPrimaryKey(model) {
+  const compositeFields = model.primaryKey?.fields;
+  if (compositeFields && compositeFields.length > 0) return [
+    ...compositeFields
+  ];
+  return model.fields.filter((field) => field.isId === true).map((field) => field.name);
+}
+__name(toPrimaryKey, "toPrimaryKey");
+function toModelMetadata(dmmf) {
+  const enums = new Map(dmmf.datamodel.enums.map((enumType) => [
+    enumType.name,
+    enumType.values.map((value) => value.name)
+  ]));
+  return dmmf.datamodel.models.map((model) => ({
+    name: model.name,
+    primaryKey: toPrimaryKey(model),
+    fields: model.fields.map((field) => toFieldMetadata(field, enums))
+  }));
+}
+__name(toModelMetadata, "toModelMetadata");
+function toIncludeClause(model, models) {
+  const include = {};
+  for (const field of model.fields) {
+    const relation = field.relation;
+    if (!relation || relation.cardinality !== "one" || relation.from === void 0) continue;
+    const target = models.find((candidate) => candidate.name === relation.targetModel);
+    if (!target) continue;
+    const select = {};
+    for (const key of target.primaryKey) select[key] = true;
+    select[displayFieldFor(target)] = true;
+    include[field.name] = {
+      select
+    };
+  }
+  return Object.keys(include).length > 0 ? include : void 0;
+}
+__name(toIncludeClause, "toIncludeClause");
+var CONSTRAINT_CODES = {
+  P2002: "unique",
+  P2003: "foreign-key",
+  P2014: "foreign-key",
+  P2011: "required",
+  P2012: "required",
+  P2013: "required"
+};
+function isPrismaKnownError(value) {
+  return typeof value === "object" && value !== null && "code" in value && typeof value.code === "string";
+}
+__name(isPrismaKnownError, "isPrismaKnownError");
+function fieldsFrom(meta) {
+  if (!meta) return [];
+  const nested = meta["driverAdapterError"]?.cause?.constraint;
+  const candidate = nested?.fields ?? meta["target"] ?? meta["field_name"] ?? meta["constraint"];
+  if (Array.isArray(candidate)) {
+    return candidate.filter((entry) => typeof entry === "string");
+  }
+  if (typeof candidate !== "string") return [];
+  const index = /^(.+?)_(.+)_key$/.exec(candidate);
+  if (index?.[2] !== void 0) return index[2].split("_");
+  return [
+    candidate
+  ];
+}
+__name(fieldsFrom, "fieldsFrom");
+function missingArguments(cause) {
+  if (!(cause instanceof Error) || cause.constructor.name !== "PrismaClientValidationError") {
+    return [];
+  }
+  const names = [];
+  for (const match of cause.message.matchAll(/Argument `([A-Za-z0-9_]+)` is missing/g)) {
+    if (match[1] !== void 0) names.push(match[1]);
+  }
+  return names;
+}
+__name(missingArguments, "missingArguments");
+function toConstraintError(cause, model) {
+  const missing = missingArguments(cause);
+  if (missing.length > 0) return new ConstraintError("required", model, missing);
+  if (!isPrismaKnownError(cause)) return void 0;
+  const constraint = CONSTRAINT_CODES[cause.code];
+  if (!constraint) return void 0;
+  return new ConstraintError(constraint, model, fieldsFrom(cause.meta));
+}
+__name(toConstraintError, "toConstraintError");
+function toRelatedWhere(parent, relationFieldName, parentId, models) {
+  const field = parent.fields.find((candidate) => candidate.name === relationFieldName);
+  if (!field?.relation) {
+    throw new FieldNotFoundError(parent.name, relationFieldName, "Only a relation field can be listed this way.");
+  }
+  if (field.relation.cardinality !== "many") {
+    throw new FieldNotFoundError(parent.name, relationFieldName, "This is a to-one relation. It arrives with the record itself.");
+  }
+  const target = models.find((candidate) => candidate.name === field.relation?.targetModel);
+  if (!target) {
+    throw new FieldNotFoundError(parent.name, relationFieldName, `${field.relation.targetModel} is not available.`);
+  }
+  const inverse = inverseRelationField(field, models);
+  if (!inverse) {
+    throw new FieldNotFoundError(parent.name, relationFieldName, "The other half of this relation could not be resolved.");
+  }
+  const [parentKey] = parent.primaryKey;
+  if (parentKey === void 0) {
+    throw new FieldNotFoundError(parent.name, relationFieldName, `${parent.name} has no primary key.`);
+  }
+  const match = {
+    [parentKey]: parentId
+  };
+  return {
+    target,
+    where: {
+      [inverse.name]: inverse.relation?.cardinality === "many" ? {
+        some: match
+      } : {
+        is: match
+      }
+    }
+  };
+}
+__name(toRelatedWhere, "toRelatedWhere");
+var DEFAULT_PER_PAGE = 25;
+var MAX_PER_PAGE = 100;
+var STRING_ONLY_OPERATORS = /* @__PURE__ */ new Set([
+  "contains",
+  "startsWith",
+  "endsWith"
+]);
+var COMPARISON_OPERATORS = /* @__PURE__ */ new Set([
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+]);
+function findQueryableField(model, fieldName, purpose) {
+  const field = model.fields.find((candidate) => candidate.name === fieldName);
+  if (!field) {
+    throw new FieldNotFoundError(model.name, fieldName);
+  }
+  if (field.kind === "relation") {
+    const owned = field.relation?.from;
+    if (owned !== void 0 && field.relation?.cardinality === "one") {
+      if (purpose === "filter") return findQueryableField(model, owned, purpose);
+      throw new FieldNotFoundError(model.name, fieldName, `Sorting by a relation is not supported in this version. Sorting by "${owned}" would order by an opaque key rather than by anything readable.`);
+    }
+    throw new FieldNotFoundError(model.name, fieldName, "Relation fields cannot be filtered or sorted in this version.");
+  }
+  if (field.isList) {
+    throw new FieldNotFoundError(model.name, fieldName, "List fields cannot be filtered or sorted in this version.");
+  }
+  return field;
+}
+__name(findQueryableField, "findQueryableField");
+function toPrismaCondition(model, rule) {
+  const field = findQueryableField(model, rule.field, "filter");
+  if (STRING_ONLY_OPERATORS.has(rule.operator) && field.kind !== "string") {
+    throw new InvalidQueryError(`Operator "${rule.operator}" requires a string field, but "${model.name}.${field.name}" is of kind "${field.kind}".`);
+  }
+  if (COMPARISON_OPERATORS.has(rule.operator) && field.kind === "boolean") {
+    throw new InvalidQueryError(`Operator "${rule.operator}" cannot be applied to boolean field "${model.name}.${field.name}".`);
+  }
+  if (rule.operator === "in") {
+    if (!Array.isArray(rule.value)) {
+      throw new InvalidQueryError(`Operator "in" requires an array value for "${model.name}.${field.name}".`);
+    }
+    return {
+      [field.name]: {
+        in: rule.value
+      }
+    };
+  }
+  if (rule.operator === "eq") return {
+    [field.name]: {
+      equals: rule.value
+    }
+  };
+  if (rule.operator === "ne") return {
+    [field.name]: {
+      not: rule.value
+    }
+  };
+  return {
+    [field.name]: {
+      [rule.operator]: rule.value
+    }
+  };
+}
+__name(toPrismaCondition, "toPrismaCondition");
+var INSENSITIVE_MODE_PROVIDERS = /* @__PURE__ */ new Set([
+  "postgresql",
+  "postgres",
+  "mongodb"
+]);
+function insensitively(provider) {
+  return provider !== void 0 && INSENSITIVE_MODE_PROVIDERS.has(provider) ? {
+    mode: "insensitive"
+  } : {};
+}
+__name(insensitively, "insensitively");
+var TEXTUAL_OPERATORS = /* @__PURE__ */ new Set([
+  "contains",
+  "startsWith",
+  "endsWith"
+]);
+function toSearchCondition(model, term, provider) {
+  const foreignKeys = new Set(model.fields.map((field) => field.relation?.from).filter((name) => name !== void 0));
+  const stringFields = model.fields.filter((field) => field.kind === "string" && !field.isList && !field.isGenerated && !foreignKeys.has(field.name));
+  if (stringFields.length === 0) return void 0;
+  return {
+    OR: stringFields.map((field) => ({
+      [field.name]: {
+        contains: term,
+        ...insensitively(provider)
+      }
+    }))
+  };
+}
+__name(toSearchCondition, "toSearchCondition");
+function buildWhere(model, query, provider) {
+  const conditions = [];
+  for (const rule of query.filters ?? []) {
+    const condition = toPrismaCondition(model, rule);
+    conditions.push(TEXTUAL_OPERATORS.has(rule.operator) ? insensitive(condition, provider) : condition);
+  }
+  const search = query.search?.trim();
+  if (search) {
+    const searchCondition = toSearchCondition(model, search, provider);
+    if (searchCondition) conditions.push(searchCondition);
+  }
+  if (conditions.length === 0) return void 0;
+  if (conditions.length === 1) return conditions[0];
+  return {
+    AND: conditions
+  };
+}
+__name(buildWhere, "buildWhere");
+function buildOrderBy(model, query) {
+  const rules = query.sort ?? [];
+  if (rules.length === 0) return void 0;
+  return rules.map((rule) => {
+    const field = findQueryableField(model, rule.field, "sort");
+    return {
+      [field.name]: rule.direction
+    };
+  });
+}
+__name(buildOrderBy, "buildOrderBy");
+function resolvePagination(query) {
+  const rawPage = query.page ?? 1;
+  if (!Number.isInteger(rawPage) || rawPage < 1) {
+    throw new InvalidQueryError(`"page" must be an integer >= 1, received ${JSON.stringify(query.page)}.`);
+  }
+  const rawPerPage = query.perPage ?? DEFAULT_PER_PAGE;
+  if (!Number.isInteger(rawPerPage) || rawPerPage < 1) {
+    throw new InvalidQueryError(`"perPage" must be an integer >= 1, received ${JSON.stringify(query.perPage)}.`);
+  }
+  const perPage = Math.min(rawPerPage, MAX_PER_PAGE);
+  return {
+    page: rawPage,
+    perPage,
+    skip: (rawPage - 1) * perPage,
+    take: perPage
+  };
+}
+__name(resolvePagination, "resolvePagination");
+function insensitive(condition, provider) {
+  const mode = insensitively(provider);
+  if (mode.mode === void 0) return condition;
+  const entries = Object.entries(condition).map(([field, comparison]) => [
+    field,
+    typeof comparison === "object" && comparison !== null ? {
+      ...comparison,
+      ...mode
+    } : comparison
+  ]);
+  return Object.fromEntries(entries);
+}
+__name(insensitive, "insensitive");
+function toFindManyArgs(model, query, provider) {
+  const { skip, take } = resolvePagination(query);
+  const where = buildWhere(model, query, provider);
+  const orderBy = buildOrderBy(model, query);
+  return {
+    ...where ? {
+      where
+    } : {},
+    ...orderBy ? {
+      orderBy
+    } : {},
+    skip,
+    take
+  };
+}
+__name(toFindManyArgs, "toFindManyArgs");
+var PRISMA_RECORD_NOT_FOUND = "P2025";
+var PrismaAdapter = class {
+  static {
+    __name(this, "PrismaAdapter");
+  }
+  name = "prisma";
+  #client;
+  #schemaPath;
+  #cwd;
+  /**
+  * Metadata is derived from a static schema, so it is read once and reused.
+  * Every operation validates against it, which would otherwise re-parse the
+  * schema on each call.
+  */
+  #models;
+  /**
+  * Which database this is, so a search can ignore capitalisation the way that
+  * database allows. Read alongside the metadata, and `undefined` when the
+  * schema does not say - see `insensitively` in `to-prisma-args.ts`.
+  */
+  #provider;
+  constructor(options) {
+    if (options.client === null || options.client === void 0) {
+      throw new AdapterError("PrismaAdapter requires a constructed Prisma Client. Pass one via `new PrismaAdapter({ client })`.");
+    }
+    this.#client = options.client;
+    this.#schemaPath = options.schemaPath;
+    this.#cwd = options.cwd;
+  }
+  async getModels() {
+    if (this.#models) return this.#models;
+    assertSupportedPrismaVersion(this.#client);
+    const dmmf = readPrismaDmmf({
+      ...this.#schemaPath !== void 0 ? {
+        schemaPath: this.#schemaPath
+      } : {},
+      ...this.#cwd !== void 0 ? {
+        cwd: this.#cwd
+      } : {}
+    });
+    this.#models = toModelMetadata(dmmf);
+    this.#provider = readDatasourceProvider({
+      ...this.#schemaPath !== void 0 ? {
+        schemaPath: this.#schemaPath
+      } : {},
+      ...this.#cwd !== void 0 ? {
+        cwd: this.#cwd
+      } : {}
+    });
+    return this.#models;
+  }
+  async list(model, query) {
+    const declared = await this.#requireModel(model);
+    const delegate = await this.#delegate(model);
+    const metadata = narrowFields(declared, query.fields);
+    const args = toFindManyArgs(metadata, query, this.#provider);
+    const include = toIncludeClause(metadata, await this.getModels());
+    const omit = omitClause(declared, query.fields);
+    const withRelations = {
+      ...args,
+      ...include ? {
+        include
+      } : {},
+      ...omit ? {
+        omit
+      } : {}
+    };
+    const { page, perPage } = resolvePagination(query);
+    const [rows, total] = await this.#run(model, () => Promise.all([
+      delegate.findMany(withRelations),
+      delegate.count(args.where ? {
+        where: args.where
+      } : {})
+    ]));
+    return {
+      data: rows,
+      total,
+      page,
+      perPage
+    };
+  }
+  async findOne(model, id) {
+    const metadata = await this.#requireModel(model);
+    const delegate = await this.#delegate(model);
+    const where = this.#whereById(metadata, id);
+    const include = toIncludeClause(metadata, await this.getModels());
+    const record = await this.#run(model, () => delegate.findUnique(include ? {
+      where,
+      include
+    } : {
+      where
+    }));
+    return record ?? null;
+  }
+  async create(model, data) {
+    const metadata = await this.#requireModel(model);
+    const delegate = await this.#delegate(model);
+    const writable = this.#validateWritableData(metadata, data);
+    const created = await this.#run(model, () => delegate.create({
+      data: writable
+    }));
+    return created;
+  }
+  async update(model, id, data) {
+    const metadata = await this.#requireModel(model);
+    const delegate = await this.#delegate(model);
+    const where = this.#whereById(metadata, id);
+    const writable = this.#validateWritableData(metadata, data);
+    const updated = await this.#run(model, () => delegate.update({
+      where,
+      data: writable
+    }), id);
+    return updated;
+  }
+  async delete(model, id) {
+    const metadata = await this.#requireModel(model);
+    const delegate = await this.#delegate(model);
+    const where = this.#whereById(metadata, id);
+    await this.#run(model, () => delegate.delete({
+      where
+    }), id);
+  }
+  /**
+  * A page of the records on the far side of a to-many relation.
+  *
+  * Implemented as an ordinary list of the *target* model with one extra
+  * condition, so pagination, sorting, filtering and relation loading all
+  * behave exactly as they do on a top-level list. See `to-related-where.ts`.
+  */
+  async listRelated(model, id, relationField, query) {
+    const metadata = await this.#requireModel(model);
+    const models = await this.getModels();
+    const { target, where } = toRelatedWhere(metadata, relationField, id, models);
+    await this.#requireRecord(model, metadata, id);
+    const delegate = await this.#delegate(target.name);
+    const narrowed = narrowFields(target, query.fields);
+    const args = toFindManyArgs(narrowed, query, this.#provider);
+    const combined = args.where ? {
+      AND: [
+        args.where,
+        where
+      ]
+    } : where;
+    const include = toIncludeClause(narrowed, models);
+    const omit = omitClause(target, query.fields);
+    const { page, perPage } = resolvePagination(query);
+    const [rows, total] = await this.#run(target.name, () => Promise.all([
+      delegate.findMany({
+        ...args,
+        where: combined,
+        ...include ? {
+          include
+        } : {},
+        ...omit ? {
+          omit
+        } : {}
+      }),
+      delegate.count({
+        where: combined
+      })
+    ]));
+    return {
+      data: rows,
+      total,
+      page,
+      perPage
+    };
+  }
+  async attachRelated(model, id, relationField, targetId) {
+    await this.#link(model, id, relationField, targetId, "connect");
+  }
+  async detachRelated(model, id, relationField, targetId) {
+    await this.#link(model, id, relationField, targetId, "disconnect");
+  }
+  // ---------------------------------------------------------------- internals
+  /**
+  * Add or remove one link, from the parent's side.
+  *
+  * Prisma expresses both the same way and works out where the link is stored -
+  * a join-table row for a many-to-many, the child's foreign key for a
+  * one-to-many. Whether the operation is allowed is the caller's decision;
+  * this performs it.
+  */
+  async #link(model, id, relationField, targetId, operation) {
+    const metadata = await this.#requireModel(model);
+    const models = await this.getModels();
+    const { target } = toRelatedWhere(metadata, relationField, id, models);
+    const [targetKey] = target.primaryKey;
+    if (targetKey === void 0) {
+      throw new FieldNotFoundError(target.name, relationField, "The target has no primary key.");
+    }
+    const delegate = await this.#delegate(model);
+    await this.#run(model, () => delegate.update({
+      where: this.#whereById(metadata, id),
+      data: {
+        [relationField]: {
+          [operation]: {
+            [targetKey]: targetId
+          }
+        }
+      }
+    }), id);
+  }
+  /** Throw `RecordNotFoundError` unless the record exists. */
+  async #requireRecord(model, metadata, id) {
+    const delegate = await this.#delegate(model);
+    const found = await this.#run(model, () => delegate.findUnique({
+      where: this.#whereById(metadata, id)
+    }), id);
+    if (found === null || found === void 0) throw new RecordNotFoundError(model, id);
+  }
+  async #requireModel(model) {
+    const models = await this.getModels();
+    const found = models.find((candidate) => candidate.name === model);
+    if (!found) {
+      throw new ModelNotFoundError(model, models.map((candidate) => candidate.name));
+    }
+    return found;
+  }
+  async #delegate(model) {
+    const models = await this.getModels();
+    return resolveDelegate(this.#client, model, models.map((candidate) => candidate.name));
+  }
+  /**
+  * Build a `where` clause addressing a single record by primary key.
+  *
+  * Composite keys are represented in metadata but not supported here: a
+  * `RecordId` is a single scalar, so there is nothing to map the second
+  * column from. Rejected explicitly rather than silently mis-querying.
+  */
+  #whereById(model, id) {
+    const [primaryKeyField, ...rest] = model.primaryKey;
+    if (primaryKeyField === void 0) {
+      throw new InvalidQueryError(`Model "${model.name}" has no primary key, so records cannot be addressed by id.`);
+    }
+    if (rest.length > 0) {
+      throw new InvalidQueryError(`Model "${model.name}" has a composite primary key (${model.primaryKey.join(", ")}), which is not supported in this version.`);
+    }
+    return {
+      [primaryKeyField]: this.#coerceId(model, primaryKeyField, id)
+    };
+  }
+  /**
+  * Coerce an id to the type the schema declares.
+  *
+  * Ids arriving from a URL are always strings, but a Prisma `Int @id` column
+  * must be queried with a number or Prisma rejects the argument.
+  */
+  #coerceId(model, fieldName, id) {
+    const field = model.fields.find((candidate) => candidate.name === fieldName);
+    if (field?.kind !== "number" || typeof id === "number") return id;
+    const numeric = Number(id);
+    if (!Number.isFinite(numeric)) {
+      throw new InvalidQueryError(`Invalid id ${JSON.stringify(id)} for numeric primary key "${model.name}.${fieldName}".`);
+    }
+    return numeric;
+  }
+  /**
+  * Reject anything the caller has no business writing.
+  *
+  * Unknown keys are an error rather than silently dropped: quietly discarding
+  * a field the user filled in is worse than telling them it does not exist.
+  * Relation and list fields are rejected because nested writes are not
+  * implemented - see the Phase 2 report.
+  */
+  #validateWritableData(model, data) {
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+      throw new InvalidQueryError(`Write payload for "${model.name}" must be an object.`);
+    }
+    const writable = {};
+    for (const [key, value] of Object.entries(data)) {
+      const field = model.fields.find((candidate) => candidate.name === key);
+      if (!field) {
+        throw new FieldNotFoundError(model.name, key);
+      }
+      if (field.kind === "relation") {
+        throw new FieldNotFoundError(model.name, key, "Writing relation fields is not supported in this version.");
+      }
+      if (field.isList) {
+        throw new FieldNotFoundError(model.name, key, "Writing list fields is not supported in this version.");
+      }
+      writable[key] = value;
+    }
+    return writable;
+  }
+  /**
+  * Run a client call, translating Prisma failures into Core errors.
+  *
+  * Prisma error types are identified by their `code` property rather than
+  * `instanceof`. Importing `@prisma/client` to get the error classes would
+  * mean loading a second copy of a package the consumer owns, and would tie
+  * us to their Prisma version.
+  */
+  async #run(model, operation, id) {
+    try {
+      return await operation();
+    } catch (cause) {
+      if (isNestAdminError(cause)) throw cause;
+      if (isPrismaError(cause) && cause.code === PRISMA_RECORD_NOT_FOUND && id !== void 0) {
+        throw new RecordNotFoundError(model, id);
+      }
+      const constraint = toConstraintError(cause, model);
+      if (constraint) throw constraint;
+      const detail = cause instanceof Error ? cause.message : String(cause);
+      throw new AdapterError(`Prisma operation failed for model "${model}": ${detail}`, {
+        cause
+      });
+    }
+  }
+};
+function isPrismaError(value) {
+  return typeof value === "object" && value !== null && "code" in value && typeof value.code === "string";
+}
+__name(isPrismaError, "isPrismaError");
+function narrowFields(model, fields) {
+  if (!fields) return model;
+  const allowed = new Set(fields);
+  return {
+    ...model,
+    fields: model.fields.filter((field) => allowed.has(field.name))
+  };
+}
+__name(narrowFields, "narrowFields");
+function omitClause(model, fields) {
+  if (!fields) return void 0;
+  const allowed = new Set(fields);
+  const omitted = {};
+  for (const field of model.fields) {
+    if (!allowed.has(field.name) && field.kind !== "relation") omitted[field.name] = true;
+  }
+  return Object.keys(omitted).length > 0 ? omitted : void 0;
+}
+__name(omitClause, "omitClause");
+var DEFAULTS = {
+  id: "id",
+  email: "email",
+  name: "name",
+  passwordHash: "passwordHash",
+  disabled: "disabled",
+  lastLoginAt: "lastLoginAt"
+};
+function prismaAccountStore(options) {
+  const model = options.model ?? "AdminAccount";
+  const column = {
+    ...DEFAULTS,
+    ...options.fields
+  };
+  const delegate = /* @__PURE__ */ __name(() => resolveDelegate(options.client, model, [
+    model
+  ]), "delegate");
+  const toAccount = /* @__PURE__ */ __name((row) => {
+    if (typeof row !== "object" || row === null) return null;
+    const record = row;
+    const id = record[column.id];
+    const email = record[column.email];
+    const hash = record[column.passwordHash];
+    if (typeof id !== "string" && typeof id !== "number") return null;
+    if (typeof email !== "string") return null;
+    if (typeof hash !== "string" || hash === "") return null;
+    const name = record[column.name];
+    const disabled = record[column.disabled];
+    return {
+      id: String(id),
+      email,
+      passwordHash: hash,
+      ...typeof name === "string" && name !== "" ? {
+        name
+      } : {},
+      ...typeof disabled === "boolean" ? {
+        disabled
+      } : {}
+    };
+  }, "toAccount");
+  return {
+    describes: model,
+    async findByEmail(email) {
+      const rows = await delegate().findMany({
+        where: {
+          [column.email]: email
+        },
+        take: 1
+      });
+      return toAccount(rows[0]);
+    },
+    async findById(id) {
+      const rows = await delegate().findMany({
+        where: {
+          [column.id]: id
+        },
+        take: 1
+      });
+      return toAccount(rows[0]);
+    },
+    async count() {
+      return delegate().count();
+    },
+    async recordLogin(id) {
+      await delegate().update({
+        where: {
+          [column.id]: id
+        },
+        data: {
+          [column.lastLoginAt]: /* @__PURE__ */ new Date()
+        }
+      });
+    }
+  };
+}
+__name(prismaAccountStore, "prismaAccountStore");
+export {
+  PrismaAdapter,
+  PrismaSchemaInvalidError,
+  PrismaSchemaNotFoundError,
+  PrismaVersionUnsupportedError,
+  prismaAccountStore
+};
+//# sourceMappingURL=prisma.js.map