@nest-admin/nestjs 0.11.0

package/dist/drizzle.cjs

@@ -0,0 +1,895 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc2) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/drizzle.ts
+var drizzle_exports = {};
+__export(drizzle_exports, {
+  DEFAULT_PER_PAGE: () => DEFAULT_PER_PAGE,
+  DrizzleAdapter: () => DrizzleAdapter,
+  MAX_PER_PAGE: () => MAX_PER_PAGE
+});
+module.exports = __toCommonJS(drizzle_exports);
+
+// ../core/dist/index.js
+var BRAND = /* @__PURE__ */ Symbol.for("nest-admin.error");
+var NestAdminError = class extends Error {
+  static {
+    __name(this, "NestAdminError");
+  }
+  /**
+  * Which error this is.
+  *
+  * Subclasses override it with a literal. The base value covers anything that
+  * extends this class without declaring one - the Prisma schema errors, for
+  * instance - which the transport layer treats as internal.
+  */
+  kind = "unknown";
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    Object.defineProperty(this, BRAND, {
+      value: true,
+      enumerable: false
+    });
+  }
+};
+function isNestAdminError(value) {
+  return typeof value === "object" && value !== null && value[BRAND] === true;
+}
+__name(isNestAdminError, "isNestAdminError");
+var ModelNotFoundError = class extends NestAdminError {
+  static {
+    __name(this, "ModelNotFoundError");
+  }
+  constructor(model, availableModels = []) {
+    const known = availableModels.length > 0 ? ` Known models: ${availableModels.join(", ")}.` : "";
+    super(`Unknown model "${model}".${known}`);
+    this.model = model;
+    this.availableModels = availableModels;
+  }
+  model;
+  availableModels;
+  kind = "model-not-found";
+};
+var FieldNotFoundError = class extends NestAdminError {
+  static {
+    __name(this, "FieldNotFoundError");
+  }
+  constructor(model, field, reason) {
+    super(`Unknown field "${field}" on model "${model}".${reason ? ` ${reason}` : ""}`);
+    this.model = model;
+    this.field = field;
+  }
+  model;
+  field;
+  kind = "field-not-found";
+};
+var RecordNotFoundError = class extends NestAdminError {
+  static {
+    __name(this, "RecordNotFoundError");
+  }
+  constructor(model, id) {
+    super(`No ${model} record found for id ${JSON.stringify(id)}.`);
+    this.model = model;
+    this.id = id;
+  }
+  model;
+  id;
+  kind = "record-not-found";
+};
+var InvalidQueryError = class extends NestAdminError {
+  static {
+    __name(this, "InvalidQueryError");
+  }
+  kind = "invalid-query";
+};
+var ConstraintError = class extends NestAdminError {
+  static {
+    __name(this, "ConstraintError");
+  }
+  constructor(constraint, model, fields = []) {
+    super(describeConstraint(constraint, model, fields));
+    this.constraint = constraint;
+    this.model = model;
+    this.fields = fields;
+  }
+  constraint;
+  model;
+  fields;
+  kind = "constraint";
+};
+function describeConstraint(constraint, model, fields) {
+  const named = fields.length > 0 ? fields.join(", ") : void 0;
+  switch (constraint) {
+    case "unique":
+      return named ? `Another ${model} already has this ${named}.` : `Another ${model} already has one of these values.`;
+    case "foreign-key":
+      return named ? `The ${named} does not refer to an existing record, or the record it refers to is still in use.` : `A reference on this ${model} does not point at an existing record, or is still in use.`;
+    case "required":
+      return named ? `${named} is required.` : `A required value on this ${model} is missing.`;
+  }
+}
+__name(describeConstraint, "describeConstraint");
+var AdapterError = class extends NestAdminError {
+  static {
+    __name(this, "AdapterError");
+  }
+  kind = "adapter";
+  constructor(message, options) {
+    super(message, options);
+  }
+};
+
+// ../drizzle/dist/index.js
+var import_drizzle_orm = require("drizzle-orm");
+var import_drizzle_orm2 = require("drizzle-orm");
+var import_drizzle_orm3 = require("drizzle-orm");
+var import_drizzle_orm4 = require("drizzle-orm");
+function driverErrorOf(cause) {
+  if (typeof cause !== "object" || cause === null) return void 0;
+  const error = cause;
+  const inner = error.cause;
+  if (typeof error.code !== "string" && typeof inner === "object" && inner !== null) {
+    return inner;
+  }
+  return error;
+}
+__name(driverErrorOf, "driverErrorOf");
+var SQLITE_KINDS = {
+  SQLITE_CONSTRAINT_UNIQUE: "unique",
+  SQLITE_CONSTRAINT_PRIMARYKEY: "unique",
+  SQLITE_CONSTRAINT_NOTNULL: "required",
+  SQLITE_CONSTRAINT_FOREIGNKEY: "foreign-key",
+  SQLITE_CONSTRAINT_TRIGGER: "foreign-key"
+};
+var CODE_KINDS = {
+  // Postgres
+  "23505": "unique",
+  "23503": "foreign-key",
+  "23502": "required",
+  // MySQL
+  ER_DUP_ENTRY: "unique",
+  ER_NO_REFERENCED_ROW_2: "foreign-key",
+  ER_ROW_IS_REFERENCED_2: "foreign-key",
+  ER_BAD_NULL_ERROR: "required"
+};
+function sqliteColumns(message) {
+  const listed = /constraint failed: (.+)$/i.exec(message)?.[1];
+  if (listed === void 0) return [];
+  return listed.split(",").map((entry) => entry.trim().split(".").at(-1) ?? "").filter((entry) => entry !== "");
+}
+__name(sqliteColumns, "sqliteColumns");
+function postgresColumns(error) {
+  if (typeof error.column === "string" && error.column !== "") return [
+    error.column
+  ];
+  if (typeof error.detail === "string") {
+    const key = /^Key \(([^)]+)\)=/.exec(error.detail)?.[1];
+    if (key !== void 0) return key.split(",").map((entry) => entry.trim());
+  }
+  if (typeof error.constraint === "string") {
+    const index = /^(.+?)_(.+)_(key|pkey|fkey)$/.exec(error.constraint);
+    if (index?.[2] !== void 0) return index[2].split("_");
+  }
+  return [];
+}
+__name(postgresColumns, "postgresColumns");
+function toConstraintError(cause, model, toFieldNames) {
+  const error = driverErrorOf(cause);
+  if (error === void 0) return void 0;
+  const code = typeof error.code === "string" ? error.code : void 0;
+  const message = typeof error.message === "string" ? error.message : "";
+  if (code !== void 0 && code in SQLITE_KINDS) {
+    return new ConstraintError(SQLITE_KINDS[code], model, toFieldNames(sqliteColumns(message)));
+  }
+  if (code !== void 0 && code in CODE_KINDS) {
+    return new ConstraintError(CODE_KINDS[code], model, toFieldNames(postgresColumns(error)));
+  }
+  if (code === "SQLITE_CONSTRAINT" || code === void 0 && /constraint failed/i.test(message)) {
+    const kind = /UNIQUE/i.test(message) ? "unique" : /NOT NULL/i.test(message) ? "required" : "foreign-key";
+    return new ConstraintError(kind, model, toFieldNames(sqliteColumns(message)));
+  }
+  return void 0;
+}
+__name(toConstraintError, "toConstraintError");
+var KINDS = {
+  string: "string",
+  number: "number",
+  boolean: "boolean",
+  date: "datetime",
+  json: "json",
+  bigint: "string",
+  buffer: "unknown",
+  array: "unknown",
+  custom: "unknown"
+};
+function kindOf(column) {
+  if (column.enumValues !== void 0 && column.enumValues.length > 0) return "enum";
+  return KINDS[column.dataType] ?? "unknown";
+}
+__name(kindOf, "kindOf");
+function isGenerated(column) {
+  return column.autoIncrement === true || typeof column.defaultFn === "function" || typeof column.onUpdateFn === "function" || (0, import_drizzle_orm2.is)(column.default, import_drizzle_orm2.SQL);
+}
+__name(isGenerated, "isGenerated");
+function literalDefault(column) {
+  if (!column.hasDefault || isGenerated(column)) return void 0;
+  return column.default;
+}
+__name(literalDefault, "literalDefault");
+function toField(key, column, primaryKey) {
+  const isId = primaryKey.includes(key);
+  const defaultValue = literalDefault(column);
+  return {
+    name: key,
+    kind: kindOf(column),
+    isId,
+    isRequired: column.notNull,
+    // A primary key is unique whether or not anyone said so.
+    isUnique: column.isUnique || isId,
+    // Drizzle has no list columns outside Postgres arrays, which arrive as
+    // `dataType: 'array'` and are mapped to `unknown` above.
+    isList: false,
+    isGenerated: isGenerated(column),
+    ...defaultValue !== void 0 ? {
+      defaultValue
+    } : {},
+    ...column.enumValues !== void 0 && column.enumValues.length > 0 ? {
+      enumValues: [
+        ...column.enumValues
+      ]
+    } : {}
+  };
+}
+__name(toField, "toField");
+function primaryKeyOf(entry, composite) {
+  const declared = composite.get(entry.model);
+  if (declared && declared.length > 0) return declared;
+  const inline = [];
+  for (const [key, column] of entry.columns) {
+    if (column.primary) inline.push(key);
+  }
+  return inline;
+}
+__name(primaryKeyOf, "primaryKeyOf");
+function toModelMetadata(input) {
+  const { schema, compositeKeys } = input;
+  return schema.tables.map((entry) => {
+    const primaryKey = primaryKeyOf(entry, compositeKeys);
+    const columns = [];
+    for (const [key, column] of entry.columns) {
+      columns.push(toField(key, column, primaryKey));
+    }
+    const relations = schema.relations.filter((relation) => relation.model === entry.model).map((relation) => ({
+      name: relation.field,
+      kind: "relation",
+      isId: false,
+      // A to-one is required exactly when its foreign key is. A to-many never
+      // is: a parent with no children is a parent.
+      isRequired: relation.cardinality === "one" && relation.from !== void 0 ? entry.columns.get(relation.from)?.notNull ?? false : false,
+      isUnique: false,
+      isList: relation.cardinality === "many",
+      isGenerated: false,
+      relation: {
+        targetModel: relation.targetModel,
+        cardinality: relation.cardinality,
+        name: relation.name,
+        ...relation.from !== void 0 ? {
+          from: relation.from
+        } : {},
+        ...relation.to !== void 0 ? {
+          to: relation.to
+        } : {}
+      }
+    }));
+    return {
+      name: entry.model,
+      primaryKey,
+      fields: [
+        ...columns,
+        ...relations
+      ]
+    };
+  });
+}
+__name(toModelMetadata, "toModelMetadata");
+var DEFAULT_PER_PAGE = 25;
+var MAX_PER_PAGE = 100;
+var STRING_ONLY = /* @__PURE__ */ new Set([
+  "contains",
+  "startsWith",
+  "endsWith"
+]);
+var COMPARISON = /* @__PURE__ */ new Set([
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+]);
+function queryable(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 queryable(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(queryable, "queryable");
+function columnOf(entry, field) {
+  const column = entry.columns.get(field.name);
+  if (column === void 0) {
+    throw new FieldNotFoundError(entry.model, field.name);
+  }
+  return column;
+}
+__name(columnOf, "columnOf");
+function escapeLike(term) {
+  return term.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+__name(escapeLike, "escapeLike");
+function insensitiveLike(column, pattern) {
+  return import_drizzle_orm3.sql`lower(${column}) LIKE lower(${pattern}) ESCAPE '\\'`;
+}
+__name(insensitiveLike, "insensitiveLike");
+function condition(model, entry, rule) {
+  const field = queryable(model, rule.field, "filter");
+  const column = columnOf(entry, field);
+  if (STRING_ONLY.has(rule.operator) && field.kind !== "string" && field.kind !== "enum") {
+    throw new InvalidQueryError(`Operator "${rule.operator}" requires a string field, but "${model.name}.${field.name}" is of kind "${field.kind}".`);
+  }
+  if (COMPARISON.has(rule.operator) && field.kind === "boolean") {
+    throw new InvalidQueryError(`Operator "${rule.operator}" cannot be applied to boolean field "${model.name}.${field.name}".`);
+  }
+  const value = coerce(field, rule.value, model.name);
+  switch (rule.operator) {
+    case "in": {
+      if (!Array.isArray(rule.value)) {
+        throw new InvalidQueryError(`Operator "in" requires an array value for "${model.name}.${field.name}".`);
+      }
+      return (0, import_drizzle_orm3.inArray)(column, rule.value.map((entryValue) => coerce(field, entryValue, model.name)));
+    }
+    case "eq":
+      return (0, import_drizzle_orm3.eq)(column, value);
+    case "ne":
+      return (0, import_drizzle_orm3.ne)(column, value);
+    case "gt":
+      return (0, import_drizzle_orm3.gt)(column, value);
+    case "gte":
+      return (0, import_drizzle_orm3.gte)(column, value);
+    case "lt":
+      return (0, import_drizzle_orm3.lt)(column, value);
+    case "lte":
+      return (0, import_drizzle_orm3.lte)(column, value);
+    case "contains":
+      return insensitiveLike(column, `%${escapeLike(String(rule.value))}%`);
+    case "startsWith":
+      return insensitiveLike(column, `${escapeLike(String(rule.value))}%`);
+    case "endsWith":
+      return insensitiveLike(column, `%${escapeLike(String(rule.value))}`);
+  }
+}
+__name(condition, "condition");
+function coerce(field, value, model) {
+  if (value === null || value === void 0) return value;
+  if (field.kind === "datetime" && !(value instanceof Date)) {
+    const parsed = new Date(String(value));
+    if (Number.isNaN(parsed.getTime())) {
+      throw new InvalidQueryError(`"${value}" is not a date, for "${model}.${field.name}".`);
+    }
+    return parsed;
+  }
+  return value;
+}
+__name(coerce, "coerce");
+function searchCondition(model, entry, term) {
+  const foreignKeys = new Set(model.fields.map((field) => field.relation?.from).filter((name) => name !== void 0));
+  const searchable = model.fields.filter((field) => (field.kind === "string" || field.kind === "enum") && !field.isList && !field.isGenerated && !foreignKeys.has(field.name) && entry.columns.has(field.name));
+  if (searchable.length === 0) return void 0;
+  const pattern = `%${escapeLike(term)}%`;
+  return (0, import_drizzle_orm3.or)(...searchable.map((field) => insensitiveLike(columnOf(entry, field), pattern)));
+}
+__name(searchCondition, "searchCondition");
+function buildWhere(model, entry, query) {
+  const conditions = [];
+  for (const rule of query.filters ?? []) {
+    conditions.push(condition(model, entry, rule));
+  }
+  const term = query.search?.trim();
+  if (term) {
+    const search = searchCondition(model, entry, term);
+    if (search) conditions.push(search);
+  }
+  if (conditions.length === 0) return void 0;
+  return conditions.length === 1 ? conditions[0] : (0, import_drizzle_orm3.and)(...conditions);
+}
+__name(buildWhere, "buildWhere");
+function buildOrderBy(model, entry, rules) {
+  return (rules ?? []).map((rule) => {
+    const field = queryable(model, rule.field, "sort");
+    const column = columnOf(entry, field);
+    return rule.direction === "desc" ? (0, import_drizzle_orm3.desc)(column) : (0, import_drizzle_orm3.asc)(column);
+  });
+}
+__name(buildOrderBy, "buildOrderBy");
+function resolvePagination(query) {
+  const rawPage = query.page ?? 1;
+  const rawPerPage = query.perPage ?? DEFAULT_PER_PAGE;
+  const page = Number.isFinite(rawPage) && rawPage >= 1 ? Math.floor(rawPage) : 1;
+  const perPage = Number.isFinite(rawPerPage) && rawPerPage >= 1 ? Math.min(Math.floor(rawPerPage), MAX_PER_PAGE) : DEFAULT_PER_PAGE;
+  return {
+    page,
+    perPage,
+    offset: (page - 1) * perPage,
+    limit: perPage
+  };
+}
+__name(resolvePagination, "resolvePagination");
+function dialectOf(tables) {
+  for (const entry of tables) {
+    for (const column of entry.columns.values()) {
+      if (column.columnType.startsWith("SQLite")) return "sqlite";
+      if (column.columnType.startsWith("Pg")) return "pg";
+      if (column.columnType.startsWith("MySql")) return "mysql";
+    }
+  }
+  throw new AdapterError("Could not tell which SQL dialect this Drizzle schema uses. Pass a schema containing at least one table with at least one column.");
+}
+__name(dialectOf, "dialectOf");
+var CORES = {
+  sqlite: "drizzle-orm/sqlite-core",
+  pg: "drizzle-orm/pg-core",
+  mysql: "drizzle-orm/mysql-core"
+};
+async function configReader(dialect) {
+  const core = await import(CORES[dialect]);
+  return core.getTableConfig;
+}
+__name(configReader, "configReader");
+function keyOf(entry, column) {
+  for (const [key, candidate] of entry.columns) {
+    if (candidate.name === column.name) return key;
+  }
+  return void 0;
+}
+__name(keyOf, "keyOf");
+function declaredRelations(schema, tables, nameOfFk) {
+  const byTable = new Map(tables.map((entry) => [
+    entry.table,
+    entry
+  ]));
+  const found = [];
+  for (const value of Object.values(schema)) {
+    if (!(0, import_drizzle_orm4.is)(value, import_drizzle_orm4.Relations)) continue;
+    const owner = byTable.get(value.table);
+    if (owner === void 0) continue;
+    const built = value.config((0, import_drizzle_orm4.createTableRelationsHelpers)(value.table));
+    for (const [field, relation] of Object.entries(built)) {
+      const one = (0, import_drizzle_orm4.is)(relation, import_drizzle_orm4.One);
+      if (!one && !(0, import_drizzle_orm4.is)(relation, import_drizzle_orm4.Many)) continue;
+      const target = byTable.get(relation.referencedTable);
+      if (target === void 0) continue;
+      if (!one) {
+        found.push({
+          model: owner.model,
+          field,
+          targetModel: target.model,
+          cardinality: "many",
+          name: ""
+        });
+        continue;
+      }
+      const config = relation.config;
+      const fk = config?.fields?.[0];
+      const reference = relation.config?.references?.[0];
+      const fkKey = fk ? keyOf(owner, fk) : void 0;
+      const refKey = reference ? keyOf(target, reference) : void 0;
+      found.push({
+        model: owner.model,
+        field,
+        targetModel: target.model,
+        cardinality: "one",
+        name: fkKey ? nameOfFk(owner.model, fkKey) : "",
+        ...fkKey !== void 0 ? {
+          from: fkKey
+        } : {},
+        ...refKey !== void 0 ? {
+          to: refKey
+        } : {}
+      });
+    }
+  }
+  return found;
+}
+__name(declaredRelations, "declaredRelations");
+async function readSchema(schema) {
+  const tables = [];
+  for (const [model, value] of Object.entries(schema)) {
+    if (!(0, import_drizzle_orm4.is)(value, import_drizzle_orm4.Table)) continue;
+    const columns = new Map(Object.entries((0, import_drizzle_orm4.getTableColumns)(value)));
+    tables.push({
+      model,
+      sqlName: (0, import_drizzle_orm4.getTableName)(value),
+      table: value,
+      columns
+    });
+  }
+  if (tables.length === 0) {
+    throw new AdapterError("This Drizzle schema exports no tables. Pass the schema module itself, for example `new DrizzleAdapter({ db, schema })` after `import * as schema from './schema.js'`.");
+  }
+  const dialect = dialectOf(tables);
+  const getTableConfig = await configReader(dialect);
+  const byTable = new Map(tables.map((entry) => [
+    entry.table,
+    entry
+  ]));
+  const nameOfFk = /* @__PURE__ */ __name((child, fk) => `${child}.${fk}`, "nameOfFk");
+  const declared = declaredRelations(schema, tables, nameOfFk);
+  const declaredOn = new Set(declared.map((relation) => `${relation.model}.${relation.field}`));
+  const relations = [];
+  for (const child of tables) {
+    for (const foreign of getTableConfig(child.table).foreignKeys) {
+      const reference = foreign.reference();
+      const parent = byTable.get(reference.foreignTable);
+      const column = reference.columns[0];
+      const target = reference.foreignColumns[0];
+      if (parent === void 0 || column === void 0 || target === void 0) continue;
+      const fkKey = keyOf(child, column);
+      const refKey = keyOf(parent, target);
+      if (fkKey === void 0 || refKey === void 0) continue;
+      const name = nameOfFk(child.model, fkKey);
+      const declaredOne = declared.find((relation) => relation.cardinality === "one" && relation.name === name);
+      if (declaredOne === void 0) {
+        relations.push({
+          model: child.model,
+          // `authorId` describes a column; `author` describes the thing on the
+          // other end, which is what a person reading a record wants named.
+          field: relationFieldName(fkKey, child.columns),
+          targetModel: parent.model,
+          cardinality: "one",
+          name,
+          from: fkKey,
+          to: refKey
+        });
+      }
+      const declaredMany = declared.find((relation) => relation.cardinality === "many" && relation.model === parent.model && relation.targetModel === child.model && relation.name === "");
+      if (declaredMany === void 0) {
+        relations.push({
+          model: parent.model,
+          field: manyFieldName(child.model, parent, declaredOn),
+          targetModel: child.model,
+          cardinality: "many",
+          name
+        });
+      } else {
+        relations.push({
+          ...declaredMany,
+          name
+        });
+      }
+    }
+  }
+  for (const relation of declared) {
+    if (relation.cardinality === "one" && relation.name !== "") relations.push(relation);
+  }
+  return {
+    dialect,
+    tables,
+    relations
+  };
+}
+__name(readSchema, "readSchema");
+function relationFieldName(fkKey, columns) {
+  const stripped = /^(.+?)(Id|_id|ID)$/.exec(fkKey)?.[1];
+  if (stripped === void 0 || stripped === "") return `${fkKey}Ref`;
+  return columns.has(stripped) ? `${fkKey}Ref` : stripped;
+}
+__name(relationFieldName, "relationFieldName");
+function manyFieldName(childModel, parent, declaredOn) {
+  const base = `${childModel.charAt(0).toLowerCase()}${childModel.slice(1)}`;
+  const plural = base.endsWith("s") ? base : `${base}s`;
+  const taken = parent.columns.has(plural) || declaredOn.has(`${parent.model}.${plural}`);
+  return taken ? `${plural}Related` : plural;
+}
+__name(manyFieldName, "manyFieldName");
+var DrizzleAdapter = class {
+  static {
+    __name(this, "DrizzleAdapter");
+  }
+  name = "drizzle";
+  #db;
+  #schemaModule;
+  #schema;
+  #models;
+  constructor(options) {
+    if (options.db === null || options.db === void 0) {
+      throw new AdapterError("DrizzleAdapter requires a constructed Drizzle database. Pass one via `new DrizzleAdapter({ db, schema })`.");
+    }
+    if (options.schema === null || options.schema === void 0) {
+      throw new AdapterError("DrizzleAdapter requires the schema module. Import it with `import * as schema from './schema.js'` and pass it as `schema`.");
+    }
+    this.#db = options.db;
+    this.#schemaModule = options.schema;
+  }
+  async getModels() {
+    if (this.#models) return this.#models;
+    const schema = await readSchema(this.#schemaModule);
+    if (schema.dialect === "mysql") {
+      throw new AdapterError("The Drizzle adapter does not support MySQL yet, because MySQL has no RETURNING clause and writes could not report the stored row. SQLite and PostgreSQL are supported.");
+    }
+    this.#schema = schema;
+    this.#models = toModelMetadata({
+      schema,
+      compositeKeys: await this.#compositeKeys(schema)
+    });
+    return this.#models;
+  }
+  async list(model, query) {
+    const { metadata, entry } = await this.#require(model);
+    const where = buildWhere(metadata, entry, query);
+    const orderBy = buildOrderBy(metadata, entry, query.sort);
+    const { page, perPage, offset, limit } = resolvePagination(query);
+    return this.#run(model, async () => {
+      let rows = this.#db.select().from(entry.table).where(where);
+      if (orderBy.length > 0) rows = rows.orderBy(...orderBy);
+      const [data, totals] = await Promise.all([
+        rows.limit(limit).offset(offset),
+        this.#db.select({
+          value: (0, import_drizzle_orm.count)()
+        }).from(entry.table).where(where)
+      ]);
+      const total = Number(totals[0]?.["value"] ?? 0);
+      return {
+        data,
+        total,
+        page,
+        perPage
+      };
+    });
+  }
+  async findOne(model, id) {
+    const { metadata, entry } = await this.#require(model);
+    const rows = await this.#run(model, () => this.#db.select().from(entry.table).where(this.#byId(metadata, entry, id)).limit(1));
+    return rows[0] ?? null;
+  }
+  async create(model, data) {
+    const { metadata, entry } = await this.#require(model);
+    const writable = this.#writable(metadata, entry, data);
+    const rows = await this.#run(model, () => this.#db.insert(entry.table).values(writable).returning());
+    const created = rows[0];
+    if (created === void 0) {
+      throw new AdapterError(`Creating a ${model} returned no row.`);
+    }
+    return created;
+  }
+  async update(model, id, data) {
+    const { metadata, entry } = await this.#require(model);
+    const writable = this.#writable(metadata, entry, data);
+    if (Object.keys(writable).length === 0) {
+      const existing = await this.findOne(model, id);
+      if (existing === null) throw new RecordNotFoundError(model, id);
+      return existing;
+    }
+    const rows = await this.#run(model, () => this.#db.update(entry.table).set(writable).where(this.#byId(metadata, entry, id)).returning());
+    const updated = rows[0];
+    if (updated === void 0) throw new RecordNotFoundError(model, id);
+    return updated;
+  }
+  async delete(model, id) {
+    const { metadata, entry } = await this.#require(model);
+    const rows = await this.#run(model, () => this.#db.delete(entry.table).where(this.#byId(metadata, entry, id)).returning());
+    if (rows.length === 0) throw new RecordNotFoundError(model, id);
+  }
+  async listRelated(model, id, relationField, query) {
+    const link = await this.#link(model, relationField);
+    const { metadata: targetMetadata, entry: target } = await this.#require(link.targetModel);
+    const parentValue = await this.#referencedValue(model, id, link.to);
+    const foreignKey = target.columns.get(link.from);
+    if (foreignKey === void 0) {
+      throw new FieldNotFoundError(link.targetModel, link.from);
+    }
+    const declared = buildWhere(targetMetadata, target, query);
+    const belongs = (0, import_drizzle_orm.eq)(foreignKey, parentValue);
+    const where = declared ? (0, import_drizzle_orm.and)(belongs, declared) : belongs;
+    const orderBy = buildOrderBy(targetMetadata, target, query.sort);
+    const { page, perPage, offset, limit } = resolvePagination(query);
+    return this.#run(link.targetModel, async () => {
+      let rows = this.#db.select().from(target.table).where(where);
+      if (orderBy.length > 0) rows = rows.orderBy(...orderBy);
+      const [data, totals] = await Promise.all([
+        rows.limit(limit).offset(offset),
+        this.#db.select({
+          value: (0, import_drizzle_orm.count)()
+        }).from(target.table).where(where)
+      ]);
+      return {
+        data,
+        total: Number(totals[0]?.["value"] ?? 0),
+        page,
+        perPage
+      };
+    });
+  }
+  async attachRelated(model, id, relationField, targetId) {
+    const link = await this.#link(model, relationField);
+    const parentValue = await this.#referencedValue(model, id, link.to);
+    await this.#setForeignKey(link, targetId, parentValue);
+  }
+  async detachRelated(model, id, relationField, targetId) {
+    const link = await this.#link(model, relationField);
+    await this.#setForeignKey(link, targetId, null);
+  }
+  /* ---------------------------------------------------------------------- */
+  async #require(model) {
+    const models = await this.getModels();
+    const metadata = models.find((candidate) => candidate.name === model);
+    if (!metadata) throw new ModelNotFoundError(model);
+    const entry = this.#schema?.tables.find((candidate) => candidate.model === model);
+    if (!entry) throw new ModelNotFoundError(model);
+    return {
+      metadata,
+      entry
+    };
+  }
+  /**
+  * The two ends of a to-many, resolved to property names.
+  *
+  * `from` is the foreign key on the child, `to` the column on this model it
+  * points at. Only the `one` side carries them, so a `many` is resolved by
+  * finding its partner - which is why both sides are given the same relation
+  * name when the schema is read.
+  */
+  async #link(model, relationField) {
+    const { metadata } = await this.#require(model);
+    const field = metadata.fields.find((candidate) => candidate.name === relationField);
+    if (!field?.relation) throw new FieldNotFoundError(model, relationField);
+    if (field.relation.cardinality !== "many") {
+      throw new FieldNotFoundError(model, relationField, "Only to-many relations can be listed or modified through this route.");
+    }
+    const models = await this.getModels();
+    const target = models.find((candidate) => candidate.name === field.relation?.targetModel);
+    const inverse = target?.fields.find((candidate) => candidate.relation?.cardinality === "one" && candidate.relation.name === field.relation?.name);
+    const from = inverse?.relation?.from;
+    const to = inverse?.relation?.to;
+    if (from === void 0 || to === void 0) {
+      throw new FieldNotFoundError(model, relationField, "This relation has no foreign key on the far side. A many-to-many in Drizzle is a join table, and is administered as its own resource.");
+    }
+    return {
+      targetModel: field.relation.targetModel,
+      from,
+      to
+    };
+  }
+  async #referencedValue(model, id, column) {
+    const record = await this.findOne(model, id);
+    if (record === null) throw new RecordNotFoundError(model, id);
+    return record[column];
+  }
+  async #setForeignKey(link, targetId, value) {
+    const { metadata, entry } = await this.#require(link.targetModel);
+    await this.#run(link.targetModel, () => this.#db.update(entry.table).set({
+      [link.from]: value
+    }).where(this.#byId(metadata, entry, targetId)).returning());
+  }
+  #byId(metadata, entry, id) {
+    const key = metadata.primaryKey[0];
+    if (key === void 0 || metadata.primaryKey.length > 1) {
+      throw new AdapterError(`${metadata.name} has ${metadata.primaryKey.length === 0 ? "no" : "a composite"} primary key. Records are addressed by a single key in this version.`);
+    }
+    const column = entry.columns.get(key);
+    if (column === void 0) throw new FieldNotFoundError(metadata.name, key);
+    const field = metadata.fields.find((candidate) => candidate.name === key);
+    const value = field?.kind === "number" ? Number(id) : id;
+    return (0, import_drizzle_orm.eq)(column, value);
+  }
+  /**
+  * The submitted data, restricted to columns that exist and may be written.
+  *
+  * Generated columns are dropped rather than refused: a form that round-trips
+  * a record would otherwise fail on the id it was shown. Unknown keys *are*
+  * refused, because silently ignoring a field is how a value appears to save
+  * and does not.
+  */
+  #writable(metadata, entry, data) {
+    const writable = {};
+    for (const [key, value] of Object.entries(data)) {
+      const field = metadata.fields.find((candidate) => candidate.name === key);
+      if (!field || !entry.columns.has(key)) {
+        if (field?.kind === "relation") continue;
+        throw new FieldNotFoundError(metadata.name, key);
+      }
+      if (field.isGenerated && field.isId) continue;
+      writable[key] = field.kind === "datetime" && typeof value === "string" ? new Date(value) : value;
+    }
+    return writable;
+  }
+  /** Composite primary keys, which are only reachable through the dialect's config. */
+  async #compositeKeys(schema) {
+    const core = await (schema.dialect === "pg" ? import("drizzle-orm/pg-core") : import("drizzle-orm/sqlite-core"));
+    const keys = /* @__PURE__ */ new Map();
+    for (const entry of schema.tables) {
+      const declared = core.getTableConfig(entry.table).primaryKeys[0];
+      if (declared === void 0) continue;
+      const names = [];
+      for (const column of declared.columns) {
+        for (const [key, candidate] of entry.columns) {
+          if (candidate.name === column.name) names.push(key);
+        }
+      }
+      if (names.length > 0) keys.set(entry.model, names);
+    }
+    return keys;
+  }
+  /**
+  * Run a query, and translate whatever it throws.
+  *
+  * Core's own errors pass through: they were raised by this adapter and
+  * already say what is wrong. Everything else is the driver's, and becomes
+  * either a constraint the interface can put beside a field or an
+  * `AdapterError`, which the HTTP layer reports without its message.
+  */
+  async #run(model, operation) {
+    try {
+      return await operation();
+    } catch (cause) {
+      if (isNestAdminError(cause)) throw cause;
+      const entry = this.#schema?.tables.find((candidate) => candidate.model === model);
+      const toFieldNames = /* @__PURE__ */ __name((sqlNames) => {
+        if (entry === void 0) return sqlNames;
+        const named = [];
+        for (const sqlName of sqlNames) {
+          for (const [key, column] of entry.columns) {
+            if (column.name === sqlName) named.push(key);
+          }
+        }
+        return named;
+      }, "toFieldNames");
+      const constraint = toConstraintError(cause, model, toFieldNames);
+      if (constraint) throw constraint;
+      throw new AdapterError(`The database refused a ${model} operation: ${cause instanceof Error ? cause.message : String(cause)}`, {
+        cause
+      });
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PER_PAGE,
+  DrizzleAdapter,
+  MAX_PER_PAGE
+});
+//# sourceMappingURL=drizzle.cjs.map