lecodes-sdk 2.0.4 → 2.0.6

package/tests/helpers/memoryMarci.ts

@@ -1,124 +0,0 @@
-/**
- * An in-memory `MarciTransport` for tests: enough of marcidb's query language for the auth runtime and
- * simple endpoint tests (equality `$where` on scalars and `one` relations, `$and`, `$order`/`$limit`/
- * `$skip`, select shapes with nested `one` selects, `$increment`, updateMany/deleteMany, count, batch).
- * Defaults come from the model definitions. Not a marcidb — the e2e test against the real engine is
- * the source of truth; this makes the flows runnable everywhere.
- */
-import type { MarciOp, MarciTransport } from "../../src/server/db/marci/query"
-import type { Field, FieldDef } from "../../src/server/db/fields"
-import type { Model } from "../../src/server/db/types"
-
-type Row = Record<string, any>
-
-export const memoryMarci = (models: Record<string, Model> | (() => Record<string, Model>)) => {
-  const modelsOf = typeof models === "function" ? models : () => models
-  const tables = new Map<string, Row[]>()
-  const nextId = new Map<string, number>()
-  const defs = (model: string): Record<string, FieldDef> =>
-    Object.fromEntries(Object.entries(modelsOf()[model]?.fields ?? {}).map(([k, f]) => [k, (f as Field<any, any>).def]))
-  const rows = (model: string) => { let t = tables.get(model); if (!t) { t = []; tables.set(model, t) } return t }
-  const ops: MarciOp[] = []
-
-  const matchesField = (row: Row, key: string, cond: any, d: FieldDef | undefined): boolean => {
-    const v = row[key]
-    if (d && (d.kind === "one")) {
-      if (cond === null) return v === null || v === undefined
-      if (typeof cond === "object" && "id" in cond) return v?.id === cond.id
-      if (typeof cond === "object" && "$not" in cond) return !matchesField(row, key, cond.$not, d)
-      throw new Error(`memoryMarci: unsupported relation condition ${JSON.stringify(cond)}`)
-    }
-    if (cond !== null && typeof cond === "object" && !Array.isArray(cond)) {
-      for (const [op, x] of Object.entries(cond)) {
-        switch (op) {
-          case "$eq": if (v !== x) return false; break
-          case "$ne": case "$not": if (v === x) return false; break
-          case "$in": if (!(x as any[]).includes(v)) return false; break
-          case "$gt": if (!(v > (x as any))) return false; break
-          case "$gte": if (!(v >= (x as any))) return false; break
-          case "$lt": if (!(v < (x as any))) return false; break
-          case "$lte": if (!(v <= (x as any))) return false; break
-          default: throw new Error(`memoryMarci: unsupported operator ${op}`)
-        }
-      }
-      return true
-    }
-    return v === cond
-  }
-  const matches = (model: string, row: Row, where: any): boolean => {
-    if (!where) return true
-    if (where.$and) return where.$and.every((w: any) => matches(model, row, w))
-    if (where.$or) return where.$or.some((w: any) => matches(model, row, w))
-    if (where.$not) return !matches(model, row, where.$not)
-    const d = defs(model)
-    return Object.entries(where).every(([k, c]) => matchesField(row, k, c, d[k]))
-  }
-  const project = (model: string, row: Row, shape: Record<string, any>): Row => {
-    const out: Row = {}
-    const d = defs(model)
-    for (const [k, v] of Object.entries(shape)) {
-      if (k.startsWith("$") || v === false || v === undefined) continue
-      const def = d[k]
-      if (def?.kind === "one") {
-        const ref = row[k]
-        if (!ref) { out[k] = null; continue }
-        const target = rows(def.model!).find(r => r.id === ref.id)
-        out[k] = target ? (v === true ? { id: target.id } : project(def.model!, target, v)) : null
-        continue
-      }
-      out[k] = row[k] === undefined ? null : row[k]
-    }
-    return out
-  }
-  const select = (model: string, q: Record<string, any>): Row[] => {
-    let list = rows(model).filter(r => matches(model, r, q.$where))
-    if (q.$order) {
-      const [[f, dir]] = Object.entries(q.$order) as [string, string][]
-      list = [...list].sort((a, b) => (a[f] < b[f] ? -1 : a[f] > b[f] ? 1 : 0) * (dir === "desc" ? -1 : 1))
-    }
-    if (q.$skip) list = list.slice(q.$skip)
-    if (q.$limit !== undefined) list = list.slice(0, q.$limit)
-    return list.map(r => project(model, r, q))
-  }
-  const applyUpdate = (model: string, row: Row, data: Row) => {
-    const d = defs(model)
-    for (const [k, v] of Object.entries(data)) {
-      if (v !== null && typeof v === "object" && "$increment" in v) { row[k] = (row[k] ?? 0) + v.$increment; continue }
-      if (d[k]?.kind === "one") { row[k] = v === null ? null : { id: (v as any).id ?? (v as any).$connect?.id }; continue }
-      row[k] = v
-    }
-  }
-  const insert = (model: string, data: Row): Row => {
-    const d = defs(model)
-    const id = (nextId.get(model) ?? 0) + 1
-    nextId.set(model, id)
-    const row: Row = { id }
-    for (const [k, def] of Object.entries(d)) {
-      if (def.kind === "many" || def.kind === "list") continue
-      if (k in data && data[k] !== undefined) { row[k] = def.kind === "one" ? { id: data[k].id } : data[k]; continue }
-      if (def.hasDefault) { row[k] = def.default === "now" ? Date.now() : def.default; continue }
-      row[k] = null
-    }
-    rows(model).push(row)
-    return row
-  }
-  const idOf = (id: any) => (typeof id === "object" ? id.id : id)
-
-  const exec = async (op: MarciOp): Promise<any> => {
-    ops.push(op)
-    const { model, action } = op
-    switch (action) {
-      case "insert": return { id: insert(model, op.data).id }
-      case "findMany": return select(model, op.query ?? {})
-      case "findFirst": return select(model, { ...(op.query ?? {}), $limit: 1 })[0] ?? null
-      case "update": { const r = rows(model).find(r => r.id === idOf(op.id)); if (!r) throw new Error("not found"); applyUpdate(model, r, op.data); return null }
-      case "updateMany": { let n = 0; for (const r of rows(model)) if (matches(model, r, op.query?.$where)) { applyUpdate(model, r, op.data); n++ } return n }
-      case "delete": { const t = rows(model); const i = t.findIndex(r => r.id === idOf(op.id)); if (i >= 0) t.splice(i, 1); return i >= 0 }
-      case "deleteMany": { const t = rows(model); const keep = t.filter(r => !matches(model, r, op.query?.$where)); const n = t.length - keep.length; tables.set(model, keep); return n }
-      case "count": return rows(model).filter(r => matches(model, r, op.query?.$where)).length
-      default: throw new Error(`memoryMarci: unsupported action ${action}`)
-    }
-  }
-  const transport: MarciTransport = { exec, batch: async (batch) => { const out = []; for (const op of batch) out.push(await exec(op)); return out } }
-  return { transport, ops, rows, tables }
-}