mega-framework 0.1.6 → 0.1.7

package/src/models/model-crud.js

@@ -0,0 +1,483 @@
+// @ts-check
+/**
+ * MegaModel 공통 CRUD 본문 (ADR-212) — schema 기반 bounded CRUD + driver 자동 dialect 디스패치.
+ *
+ * MegaModel 의 static CRUD 메서드가 여기로 위임한다(`this`=Model 클래스). 각 함수는:
+ *   1) `getModelMeta(Model)` 로 컬럼 화이트리스트·PK(메모이즈, schema-builder 재사용)
+ *   2) `getCrudDialect(Model)` 로 driver→dialect(DML facet) 해석
+ *   3) `crud-sql-builder` 순수 함수로 SQL+params 빌드
+ *   4) **`Model.query(sql, params)`** 실행 — 어댑터의 계측(ADR-138)·트랜잭션(ALS) 경로를 그대로 탐
+ *   5) `dialect.parseRead/WriteResult` 로 native 형태(pg/maria/sqlite)를 **정규화 계약**으로 흡수
+ *
+ * raw 트랙(`this.query`/`this.db`)·어댑터 native 형태는 무변경(ADR-009 보존). `static schema` 없는 모델은
+ * CRUD 호출 시 `model.crud_requires_schema` throw(호출 안 하면 영향 0).
+ *
+ * @module models/model-crud
+ */
+import { MegaInternalError } from '../errors/http-errors.js'
+import { buildModelRecord } from '../core/migration/schema-builder.js'
+import { getDialect, dmlFacetMissing } from '../core/migration/dialect-registry.js'
+import {
+  buildWhere,
+  buildOrderBy,
+  buildSelectList,
+  assertColumn,
+  assertNonNegInt,
+} from './crud-sql-builder.js'
+// mongo(document) 경로 — driver=mongodb 이면 각 메서드가 여기로 디스패치(ADR-212 P3). 순환 import 는
+// getModelMeta 가 hoisted 함수 export 라 런타임 호출 시점엔 양쪽 모듈이 완전 로드돼 안전하다.
+import * as mongoCrud from './mongo-crud.js'
+
+/** driver 가 mongo(document)인지 — 그렇다면 SQL 경로 대신 mongo-crud 로 디스패치. @param {any} Model @returns {boolean} */
+function isMongo(Model) {
+  return Model._resolveAdapter().driver === 'mongodb'
+}
+
+/** @typedef {{ record: any, cols: Set<string>, pk: string | null, pkCols: string[], uniques: Set<string>, table: string }} ModelMeta */
+
+/** Model 클래스 → 메타(메모이즈). WeakMap 이라 클래스 GC 시 함께 정리. @type {WeakMap<Function, ModelMeta>} */
+const META = new WeakMap()
+
+/**
+ * 모델의 schema record(컬럼·PK·unique)를 1회 평가·메모이즈한다(ADR-204 `buildModelRecord` 재사용).
+ * `static schema` 없으면 `model.crud_requires_schema`.
+ * @param {any} Model @returns {ModelMeta}
+ */
+export function getModelMeta(Model) {
+  const cached = META.get(Model)
+  if (cached) return cached
+  if (typeof Model.schema !== 'function') {
+    throw new MegaInternalError(
+      'model.crud_requires_schema',
+      `${Model.name}: 공통 CRUD 는 'static schema' 선언이 필요합니다(ADR-212). raw SQL 은 this.query 로 그대로 쓸 수 있습니다.`,
+      { details: { model: Model.name } },
+    )
+  }
+  const record = buildModelRecord(Model) // throw 시 schema 검증 에러 그대로 전파(ADR-204)
+  const cols = new Set(Object.keys(record.columns ?? {}))
+  /** @type {string[]} */
+  const pkCols =
+    Array.isArray(record.primaryKey) && record.primaryKey.length > 0
+      ? record.primaryKey
+      : Object.entries(record.columns ?? {})
+          .filter(([, d]) => /** @type {any} */ (d)?.primary)
+          .map(([n]) => n)
+  const uniques = new Set(
+    Object.entries(record.columns ?? {})
+      .filter(([, d]) => /** @type {any} */ (d)?.unique)
+      .map(([n]) => n),
+  )
+  /** @type {ModelMeta} */
+  const meta = {
+    record,
+    cols,
+    pk: pkCols.length === 1 ? pkCols[0] : null,
+    pkCols,
+    uniques,
+    table: record.table,
+  }
+  META.set(Model, meta)
+  return meta
+}
+
+/**
+ * Model 의 어댑터 driver 로 SQL dialect(DML facet)를 해석한다. mongo·DML facet 미구현 driver 는 throw.
+ * @param {any} Model @returns {{ dialect: any, driver: string }}
+ */
+export function getCrudDialect(Model) {
+  const driver = Model._resolveAdapter().driver
+  if (driver === 'mongodb') {
+    throw new MegaInternalError(
+      'model.crud_unsupported_driver',
+      `${Model.name}: SQL 공통 CRUD 는 mongo(document) 미지원입니다(P3). raw document API(this.db) 를 쓰세요.`,
+      { details: { model: Model.name, driver } },
+    )
+  }
+  const dialect = getDialect(driver)
+  const missing = dmlFacetMissing(dialect)
+  if (missing.length > 0) {
+    throw new MegaInternalError(
+      'model.dml_dialect_unsupported',
+      `driver '${driver}' 는 CRUD DML facet 미구현 — 누락: [${missing.join(', ')}].`,
+      {
+        details: { model: Model.name, driver, missing },
+      },
+    )
+  }
+  return { dialect, driver }
+}
+
+/** 테이블 인용 단축. @param {any} dialect @param {ModelMeta} meta @returns {string} */
+function tbl(dialect, meta) {
+  return dialect.quoteIdent(meta.table)
+}
+
+// ── 읽기 ───────────────────────────────────────────────────────────────────
+
+/** @param {any} Model @param {Record<string, any>} filter @param {{ select?: string[] }} [opts] @returns {Promise<any|null>} */
+export async function findOne(Model, filter, opts = {}) {
+  if (isMongo(Model)) return mongoCrud.findOne(Model, filter, opts)
+  const { dialect } = getCrudDialect(Model)
+  const meta = getModelMeta(Model)
+  const sel = buildSelectList(opts.select, meta.cols, dialect, Model.name)
+  const { clause, params } = buildWhere(filter ?? {}, meta.cols, dialect, Model.name, 1)
+  const where = clause ? ` WHERE ${clause}` : ''
+  const rows = dialect.parseReadResult(
+    await Model.query(`SELECT ${sel} FROM ${tbl(dialect, meta)}${where} LIMIT 1`, params),
+  )
+  return rows[0] ?? null
+}
+
+/** @param {any} Model @param {Record<string, any>} filter @param {{ select?: string[], orderBy?: any, limit?: number, offset?: number }} [opts] @returns {Promise<any[]>} */
+export async function findMany(Model, filter, opts = {}) {
+  if (isMongo(Model)) return mongoCrud.findMany(Model, filter, opts)
+  const { dialect } = getCrudDialect(Model)
+  const meta = getModelMeta(Model)
+  const sel = buildSelectList(opts.select, meta.cols, dialect, Model.name)
+  const { clause, params } = buildWhere(filter ?? {}, meta.cols, dialect, Model.name, 1)
+  const where = clause ? ` WHERE ${clause}` : ''
+  const order = buildOrderBy(opts.orderBy, meta.cols, dialect, Model.name)
+  // 기본 limit 없음(ADR-212 #2) — 명시할 때만 부착(검증된 정수 리터럴).
+  const limit =
+    opts.limit !== undefined ? ` LIMIT ${assertNonNegInt(opts.limit, 'limit', Model.name)}` : ''
+  const offset =
+    opts.offset !== undefined ? ` OFFSET ${assertNonNegInt(opts.offset, 'offset', Model.name)}` : ''
+  return dialect.parseReadResult(
+    await Model.query(
+      `SELECT ${sel} FROM ${tbl(dialect, meta)}${where}${order}${limit}${offset}`,
+      params,
+    ),
+  )
+}
+
+/** @param {any} Model @param {any} id @param {{ select?: string[] }} [opts] @returns {Promise<any|null>} */
+export async function findById(Model, id, opts = {}) {
+  if (isMongo(Model)) return mongoCrud.findById(Model, id, opts)
+  const meta = getModelMeta(Model)
+  if (!meta.pk) {
+    throw new MegaInternalError(
+      'model.no_primary_key',
+      `${Model.name}: findById 는 단일 PK 가 필요합니다(현재 PK: [${meta.pkCols.join(', ') || '없음'}]).`,
+      {
+        details: { model: Model.name, pk: meta.pkCols },
+      },
+    )
+  }
+  return findOne(Model, { [meta.pk]: id }, opts)
+}
+
+/** @param {any} Model @param {Record<string, any>} [filter] @returns {Promise<number>} */
+export async function count(Model, filter = {}) {
+  if (isMongo(Model)) return mongoCrud.count(Model, filter)
+  const { dialect } = getCrudDialect(Model)
+  const meta = getModelMeta(Model)
+  const { clause, params } = buildWhere(filter, meta.cols, dialect, Model.name, 1)
+  const where = clause ? ` WHERE ${clause}` : ''
+  const rows = dialect.parseReadResult(
+    await Model.query(`SELECT count(*) AS n FROM ${tbl(dialect, meta)}${where}`, params),
+  )
+  return Number(rows[0]?.n ?? 0)
+}
+
+/** @param {any} Model @param {Record<string, any>} filter @returns {Promise<boolean>} */
+export async function exists(Model, filter) {
+  if (isMongo(Model)) return mongoCrud.exists(Model, filter)
+  const { dialect } = getCrudDialect(Model)
+  const meta = getModelMeta(Model)
+  const { clause, params } = buildWhere(filter ?? {}, meta.cols, dialect, Model.name, 1)
+  const where = clause ? ` WHERE ${clause}` : ''
+  const rows = dialect.parseReadResult(
+    await Model.query(`SELECT 1 AS x FROM ${tbl(dialect, meta)}${where} LIMIT 1`, params),
+  )
+  return rows.length > 0
+}
+
+/** @param {any} Model @param {Record<string, any>} filter @param {{ select?: string[], orderBy?: any, limit: number, offset?: number, withTotal?: boolean }} opts @returns {Promise<{ rows: any[], limit: number, offset: number, total?: number }>} */
+export async function paginate(Model, filter, opts) {
+  if (isMongo(Model)) return mongoCrud.paginate(Model, filter, opts)
+  const limit = assertNonNegInt(opts?.limit, 'limit', Model.name)
+  const offset = opts?.offset !== undefined ? assertNonNegInt(opts.offset, 'offset', Model.name) : 0
+  const rows = await findMany(Model, filter, {
+    select: opts?.select,
+    orderBy: opts?.orderBy,
+    limit,
+    offset,
+  })
+  /** @type {{ rows: any[], limit: number, offset: number, total?: number }} */
+  const out = { rows, limit, offset }
+  if (opts?.withTotal === true) out.total = await count(Model, filter ?? {}) // 추가 count 쿼리(opt-in #4)
+  return out
+}
+
+// ── 쓰기 ───────────────────────────────────────────────────────────────────
+
+/** insert 컬럼 검증 + placeholder/params 빌드. @param {any} Model @param {Record<string, any>} data @param {any} dialect @param {ModelMeta} meta @returns {{ colSql: string, phs: string[], params: any[], cols: string[] }} */
+function prepInsert(Model, data, dialect, meta) {
+  const cols = Object.keys(data ?? {})
+  if (cols.length === 0) {
+    throw new MegaInternalError('model.empty_insert', `${Model.name}: 삽입할 컬럼이 없습니다.`, {
+      details: { model: Model.name },
+    })
+  }
+  cols.forEach((c) => assertColumn(c, meta.cols, Model.name, 'data'))
+  let i = 1
+  const phs = cols.map(() => dialect.placeholder(i++))
+  return {
+    colSql: cols.map((c) => dialect.quoteIdent(c)).join(', '),
+    phs,
+    params: cols.map((c) => data[c]),
+    cols,
+  }
+}
+
+/** @param {any} Model @param {Record<string, any>} data @param {{ returning?: boolean }} [opts] @returns {Promise<any>} */
+export async function insertOne(Model, data, opts = {}) {
+  if (isMongo(Model)) return mongoCrud.insertOne(Model, data, opts)
+  const { dialect } = getCrudDialect(Model)
+  const meta = getModelMeta(Model)
+  const { colSql, phs, params } = prepInsert(Model, data, dialect, meta)
+  const head = `INSERT INTO ${tbl(dialect, meta)} (${colSql}) VALUES (${phs.join(', ')})`
+
+  if (opts.returning === true) {
+    if (dialect.supportsReturning) {
+      const rows = dialect.parseReadResult(await Model.query(`${head} RETURNING *`, params))
+      return rows[0]
+    }
+    // maria: insert 후 PK 로 재조회
+    if (!meta.pk) {
+      throw new MegaInternalError(
+        'model.no_primary_key',
+        `${Model.name}: RETURNING 미지원 driver 에서 returning:true 레코드 반환에는 단일 PK 가 필요합니다(insert 후 PK 재조회).`,
+        {
+          details: { model: Model.name },
+        },
+      )
+    }
+    const w = dialect.parseWriteResult(await Model.query(head, params))
+    return findById(Model, data[meta.pk] ?? w.insertId)
+  }
+
+  // 기본(returning:false) — 새 id 반환(성능 우선, ADR-212 #1).
+  if (!meta.pk) return dialect.parseWriteResult(await Model.query(head, params)).count // PK 없으면 affected count
+  if (dialect.supportsReturning) {
+    const rows = dialect.parseReadResult(
+      await Model.query(`${head} RETURNING ${dialect.quoteIdent(meta.pk)}`, params),
+    )
+    return rows[0]?.[meta.pk]
+  }
+  const w = dialect.parseWriteResult(await Model.query(head, params))
+  return data[meta.pk] ?? w.insertId
+}
+
+/** @param {any} Model @param {Record<string, any>[]} rows @param {{ returning?: boolean }} [opts] @returns {Promise<{ count: number } | any[]>} */
+export async function insertMany(Model, rows, opts = {}) {
+  if (isMongo(Model)) return mongoCrud.insertMany(Model, rows, opts)
+  if (!Array.isArray(rows) || rows.length === 0) return opts.returning === true ? [] : { count: 0 }
+  const { dialect } = getCrudDialect(Model)
+  const meta = getModelMeta(Model)
+  // 모든 행이 같은 컬럼 집합이어야 한다(멀티-VALUES 정합).
+  const cols = Object.keys(rows[0] ?? {})
+  if (cols.length === 0)
+    throw new MegaInternalError('model.empty_insert', `${Model.name}: 삽입할 컬럼이 없습니다.`, {
+      details: { model: Model.name },
+    })
+  cols.forEach((c) => assertColumn(c, meta.cols, Model.name, 'data'))
+  const colKey = cols.slice().sort().join(',')
+  for (const r of rows) {
+    if (Object.keys(r).slice().sort().join(',') !== colKey) {
+      throw new MegaInternalError(
+        'model.insert_shape_mismatch',
+        `${Model.name}: insertMany 의 모든 행은 동일 컬럼 집합이어야 합니다.`,
+        { details: { model: Model.name } },
+      )
+    }
+  }
+  // VALUES 튜플: 행마다 컬럼 수만큼 placeholder, params 는 행→컬럼 순서로 평탄화.
+  let i = 1
+  const tuples = rows.map(() => `(${cols.map(() => dialect.placeholder(i++)).join(', ')})`)
+  /** @type {any[]} */
+  const params = []
+  for (const r of rows) for (const c of cols) params.push(r[c])
+  const colSql = cols.map((c) => dialect.quoteIdent(c)).join(', ')
+  const head = `INSERT INTO ${tbl(dialect, meta)} (${colSql}) VALUES ${tuples.join(', ')}`
+
+  if (opts.returning === true) {
+    if (!dialect.supportsBulkReturning) {
+      throw new MegaInternalError(
+        'model.bulk_returning_unsupported',
+        `${Model.name}: 이 driver 는 insertMany returning 을 지원하지 않습니다(maria). returning:false(count) 또는 per-row insertOne 을 쓰세요.`,
+        { details: { model: Model.name } },
+      )
+    }
+    return dialect.parseReadResult(await Model.query(`${head} RETURNING *`, params))
+  }
+  return { count: dialect.parseWriteResult(await Model.query(head, params)).count }
+}
+
+/** UPDATE SQL+params 빌드. allowEmpty=false 면 빈 filter throw(unbounded). @param {any} Model @param {Record<string, any>} filter @param {Record<string, any>} patch @param {any} dialect @param {ModelMeta} meta @param {boolean} allowEmpty @returns {{ sql: string, params: any[] }} */
+function buildUpdate(Model, filter, patch, dialect, meta, allowEmpty) {
+  const setCols = Object.keys(patch ?? {})
+  if (setCols.length === 0)
+    throw new MegaInternalError(
+      'model.empty_patch',
+      `${Model.name}: 갱신할 컬럼(patch)이 없습니다.`,
+      { details: { model: Model.name } },
+    )
+  setCols.forEach((c) => assertColumn(c, meta.cols, Model.name, 'patch'))
+  let i = 1
+  const setSql = setCols
+    .map((c) => `${dialect.quoteIdent(c)} = ${dialect.placeholder(i++)}`)
+    .join(', ')
+  const setParams = setCols.map((c) => patch[c])
+  const filterKeys = Object.keys(filter ?? {})
+  if (filterKeys.length === 0 && !allowEmpty) {
+    throw new MegaInternalError(
+      'model.unbounded_write',
+      `${Model.name}: 빈 filter 의 전체 UPDATE 는 막혀 있습니다. 의도면 { all: true } 또는 raw SQL 을 쓰세요.`,
+      { details: { model: Model.name } },
+    )
+  }
+  const { clause, params: whereParams } = buildWhere(
+    filter ?? {},
+    meta.cols,
+    dialect,
+    Model.name,
+    i,
+  )
+  const where = clause ? ` WHERE ${clause}` : ''
+  return {
+    sql: `UPDATE ${tbl(dialect, meta)} SET ${setSql}${where}`,
+    params: [...setParams, ...whereParams],
+  }
+}
+
+/** @param {any} Model @param {Record<string, any>} filter @param {Record<string, any>} patch @returns {Promise<number>} */
+export async function updateOne(Model, filter, patch) {
+  if (isMongo(Model)) return mongoCrud.updateOne(Model, filter, patch)
+  const { dialect } = getCrudDialect(Model)
+  const meta = getModelMeta(Model)
+  if (Object.keys(filter ?? {}).length === 0) {
+    throw new MegaInternalError(
+      'model.invalid_filter',
+      `${Model.name}: updateOne 은 대상을 특정하는 filter 가 필요합니다(빈 filter 금지).`,
+      { details: { model: Model.name } },
+    )
+  }
+  const { sql, params } = buildUpdate(Model, filter, patch, dialect, meta, false)
+  // 원자적 "정확히 하나"(ADR-212 #3) — implicit tx 로 감싸 >1 매칭 시 롤백.
+  return Model.withTransaction(async () => {
+    const n = dialect.parseWriteResult(await Model.query(sql, params)).count
+    if (n > 1) throw multipleMatches(Model, 'updateOne', n)
+    return n
+  })
+}
+
+/** @param {any} Model @param {Record<string, any>} filter @param {Record<string, any>} patch @param {{ all?: boolean }} [opts] @returns {Promise<number>} */
+export async function updateMany(Model, filter, patch, opts = {}) {
+  if (isMongo(Model)) return mongoCrud.updateMany(Model, filter, patch, opts)
+  const { dialect } = getCrudDialect(Model)
+  const meta = getModelMeta(Model)
+  const { sql, params } = buildUpdate(Model, filter, patch, dialect, meta, opts.all === true)
+  return dialect.parseWriteResult(await Model.query(sql, params)).count
+}
+
+/** DELETE SQL+params 빌드. @param {any} Model @param {Record<string, any>} filter @param {any} dialect @param {ModelMeta} meta @param {boolean} allowEmpty @returns {{ sql: string, params: any[] }} */
+function buildDelete(Model, filter, dialect, meta, allowEmpty) {
+  const filterKeys = Object.keys(filter ?? {})
+  if (filterKeys.length === 0 && !allowEmpty) {
+    throw new MegaInternalError(
+      'model.unbounded_write',
+      `${Model.name}: 빈 filter 의 전체 DELETE 는 막혀 있습니다. 의도면 { all: true } 또는 raw SQL 을 쓰세요.`,
+      { details: { model: Model.name } },
+    )
+  }
+  const { clause, params } = buildWhere(filter ?? {}, meta.cols, dialect, Model.name, 1)
+  const where = clause ? ` WHERE ${clause}` : ''
+  return { sql: `DELETE FROM ${tbl(dialect, meta)}${where}`, params }
+}
+
+/** @param {any} Model @param {Record<string, any>} filter @returns {Promise<number>} */
+export async function deleteOne(Model, filter) {
+  if (isMongo(Model)) return mongoCrud.deleteOne(Model, filter)
+  const { dialect } = getCrudDialect(Model)
+  const meta = getModelMeta(Model)
+  if (Object.keys(filter ?? {}).length === 0) {
+    throw new MegaInternalError(
+      'model.invalid_filter',
+      `${Model.name}: deleteOne 은 대상을 특정하는 filter 가 필요합니다(빈 filter 금지).`,
+      { details: { model: Model.name } },
+    )
+  }
+  const { sql, params } = buildDelete(Model, filter, dialect, meta, false)
+  return Model.withTransaction(async () => {
+    const n = dialect.parseWriteResult(await Model.query(sql, params)).count
+    if (n > 1) throw multipleMatches(Model, 'deleteOne', n)
+    return n
+  })
+}
+
+/** @param {any} Model @param {Record<string, any>} filter @param {{ all?: boolean }} [opts] @returns {Promise<number>} */
+export async function deleteMany(Model, filter, opts = {}) {
+  if (isMongo(Model)) return mongoCrud.deleteMany(Model, filter, opts)
+  const { dialect } = getCrudDialect(Model)
+  const meta = getModelMeta(Model)
+  const { sql, params } = buildDelete(Model, filter, dialect, meta, opts.all === true)
+  return dialect.parseWriteResult(await Model.query(sql, params)).count
+}
+
+/** @param {any} Model @param {Record<string, any>} data @param {{ conflict: string[], update?: string[], returning?: boolean }} opts @returns {Promise<any>} */
+export async function upsert(Model, data, opts) {
+  if (isMongo(Model)) return mongoCrud.upsert(Model, data, opts)
+  const { dialect } = getCrudDialect(Model)
+  const meta = getModelMeta(Model)
+  const { colSql, phs, params, cols } = prepInsert(Model, data, dialect, meta)
+  const conflict = opts?.conflict
+  if (!Array.isArray(conflict) || conflict.length === 0) {
+    throw new MegaInternalError(
+      'model.invalid_conflict_target',
+      `${Model.name}: upsert 는 opts.conflict(충돌 컬럼 배열)가 필요합니다.`,
+      { details: { model: Model.name } },
+    )
+  }
+  conflict.forEach((c) => {
+    assertColumn(c, meta.cols, Model.name, 'conflict')
+    const isPk = meta.pkCols.includes(c)
+    if (!isPk && !meta.uniques.has(c)) {
+      throw new MegaInternalError(
+        'model.invalid_conflict_target',
+        `${Model.name}: conflict '${c}' 은 PK/unique 컬럼이 아닙니다(schema 기준).`,
+        { details: { model: Model.name, conflict: c } },
+      )
+    }
+  })
+  const updateCols = opts.update ?? cols.filter((c) => !conflict.includes(c))
+  updateCols.forEach((c) => assertColumn(c, meta.cols, Model.name, 'update'))
+  const clause = dialect.upsertClause({ conflictCols: conflict, updateCols })
+  const head = `INSERT INTO ${tbl(dialect, meta)} (${colSql}) VALUES (${phs.join(', ')}) ${clause}`
+
+  if (opts.returning === true) {
+    if (dialect.supportsReturning) {
+      const rows = dialect.parseReadResult(await Model.query(`${head} RETURNING *`, params))
+      return rows[0]
+    }
+    // maria: upsert 후 conflict 키로 재조회
+    await Model.query(head, params)
+    /** @type {Record<string, any>} */
+    const sel = {}
+    conflict.forEach((c) => (sel[c] = data[c]))
+    return findOne(Model, sel)
+  }
+  await Model.query(head, params)
+  return undefined // returning:false → void
+}
+
+/** @param {any} Model @param {string} method @param {number} n */
+function multipleMatches(Model, method, n) {
+  return new MegaInternalError(
+    'model.multiple_matches',
+    `${Model.name}.${method}: filter 가 ${n} 행에 매칭됐습니다("정확히 하나" 위반) — 변경은 롤백됐습니다. PK/unique filter 를 쓰거나 ${method.replace('One', 'Many')} 를 쓰세요.`,
+    {
+      details: { model: Model.name, method, matched: n },
+    },
+  )
+}