lecodes-sdk 2.0.6 → 2.0.8

package/src/server/files/db.ts

@@ -0,0 +1,182 @@
+/**
+ * The db layer's half of stored files (./models.ts): what turns a file FIELD — a value in a row — into
+ * operations on the platform's `File` model, and back.
+ *
+ *   read    the field is selected as the reverse relation it is (the `File` rows that point at the
+ *           row, in order) and comes back as a `StoredFile`, or a list of them
+ *   insert  the row is inserted without the field; each upload's `File` row is then pointed at it
+ *           (`ref` to the insert's id) — one transaction
+ *   update  the row's files that are no longer listed are deleted, the uploads are pointed at it —
+ *           one transaction with the update itself
+ *
+ * An upload written to a `t.image()` field is first made a picture fit to show (the host's work,
+ * ./host.ts): that is why a plan is awaited. What it became — its type, its size — goes to its row
+ * in the operation that attaches it.
+ *
+ * A file is written from the FILE's side (its reference to the owner): that is the side the database
+ * cascades over. Only an upload of the current request is ever attached: a `StoredFile` the app hands
+ * back means "keep this one", and one of another row is not moved — a client that knows the url of
+ * someone else's file cannot take it.
+ */
+
+import type { MarciOp } from "../db/marci/query"
+import { FILE_MODEL, fileUrl, filesSeam, storedFileId, type FileField, type StoredFile } from "./models"
+
+type Plan = { op: MarciOp, after: MarciOp[] }
+
+export type FileLayer = {
+  /** The operation as the database runs it, and the ones that follow it in the same transaction.
+   *  `index` is the operation's place in that transaction (what `ref` counts from). */
+  plan(op: MarciOp, index: number): Promise<Plan>
+  /** The database's answer to a planned operation, as the project reads it. */
+  result(op: MarciOp, value: any): any
+}
+
+const FILE_SELECT = { id: true, name: true, type: true, size: true, width: true, height: true, $order: { position: "asc" } }
+
+const stored = (row: any): StoredFile => {
+  const out: StoredFile = { url: fileUrl(row.id, row.name), name: row.name, type: row.type, size: row.size }
+  if (row.width != null) out.width = row.width
+  if (row.height != null) out.height = row.height
+  return out
+}
+
+/**
+ * `fields`: the schema's `t.file()` fields. `relations`: model → relation field → its target model.
+ * `scalars`: model → what a query without a selection returns (file fields included).
+ */
+export const createFileLayer = (
+  fields: FileField[],
+  relations: Record<string, Record<string, string>>,
+  scalars: Record<string, string[]>,
+): FileLayer => {
+  const byModel: Record<string, Record<string, FileField>> = {}
+  for (const f of fields) (byModel[f.model] ??= {})[f.key] = f
+  const hasFiles = (model: string) => model in byModel
+
+  // ── read ──
+
+  /** The query with every selected file field as the relation select it is. */
+  const select = (model: string, query: Record<string, any>): Record<string, any> => {
+    const out: Record<string, any> = {}
+    for (const key in query) {
+      const value = query[key]
+      if (key.charCodeAt(0) === 36 /* $ */) { out[key] = value; continue }
+      if (byModel[model]?.[key]) { if (value) out[key] = FILE_SELECT; continue }
+      const target = relations[model]?.[key]
+      if (!target || !value) { out[key] = value; continue }
+      // `relation: true` is "its scalars" to the engine, which knows no file among them
+      if (value === true) out[key] = hasFiles(target) ? select(target, Object.fromEntries(scalars[target].map(k => [k, true]))) : true
+      else out[key] = typeof value === "object" ? select(target, value) : value
+    }
+    return out
+  }
+
+  const rows = (model: string, query: Record<string, any>, value: any): any => {
+    if (Array.isArray(value)) { for (const row of value) rows(model, query, row); return value }
+    if (value === null || typeof value !== "object") return value
+    for (const key in query) {
+      if (key.charCodeAt(0) === 36) continue
+      const field = byModel[model]?.[key]
+      if (field) {
+        const list = Array.isArray(value[key]) ? value[key].map(stored) : []
+        value[key] = field.array ? list : list[0] ?? null
+        continue
+      }
+      const target = relations[model]?.[key]
+      if (target && query[key] && typeof query[key] === "object") rows(target, query[key], value[key])
+    }
+    return value
+  }
+
+  // ── write ──
+
+  /** The row's data without its file fields, and those fields' values as lists. */
+  const split = (model: string, data: any): { data: any, files: [FileField, unknown[]][] } => {
+    const own = byModel[model]
+    if (!own || data === null || typeof data !== "object") return { data, files: [] }
+    const rest: Record<string, unknown> = {}
+    const files: [FileField, unknown[]][] = []
+    for (const key in data) {
+      const field = own[key]
+      if (!field) { rest[key] = data[key]; continue }
+      const value = data[key]
+      if (value === undefined) continue
+      if (field.array && !Array.isArray(value)) throw new Error(`${model}.${key}: a list of files is expected`)
+      files.push([field, field.array ? value : value === null ? [] : [value]])
+    }
+    return { data: rest, files }
+  }
+
+  const attach = async (field: FileField, id: string, owner: unknown, position: number): Promise<MarciOp> => {
+    const facts = field.image ? await filesSeam()!.image(id, field.image) : {}
+    return { model: FILE_MODEL, action: "update", id: { id }, data: { ...facts, [field.owner]: { $connect: owner }, position } }
+  }
+
+  const insert = async (op: MarciOp, index: number): Promise<Plan> => {
+    const { data, files } = split(op.model, op.data)
+    const after: MarciOp[] = []
+    for (const [field, values] of files) {
+      for (let position = 0; position < values.length; position++) {
+        const id = filesSeam()?.uploaded(values[position])
+        if (!id) throw new Error(`${op.model}.${field.key}: a new row takes uploaded files only — a file that is already stored belongs to its row`)
+        after.push(await attach(field, id, { $ref: String(index) }, position))
+      }
+    }
+    return { op: { ...op, data }, after }
+  }
+
+  const update = async (op: MarciOp): Promise<Plan> => {
+    const { data, files } = split(op.model, op.data)
+    const after: MarciOp[] = []
+    for (const [field, values] of files) {
+      const keep: string[] = []
+      const then: MarciOp[] = []
+      for (let position = 0; position < values.length; position++) {
+        const value = values[position]
+        const upload = filesSeam()?.uploaded(value)
+        const id = upload ?? storedFileId(value)
+        if (!id) throw new Error(`${op.model}.${field.key}: a file is expected — an upload, or the stored file the field already holds`)
+        keep.push(id)
+        if (upload) then.push(await attach(field, upload, op.id, position))
+        // one that stays: its place in the list — and only where it IS this row's file
+        else if (field.array) then.push({ model: FILE_MODEL, action: "updateMany", query: { $where: { id, [field.owner]: op.id } }, data: { position } })
+      }
+      // what the field held and no longer lists is deleted, with its bytes
+      after.push({ model: FILE_MODEL, action: "deleteMany", query: { $where: { [field.owner]: op.id, ...(keep.length ? { id: { $notIn: keep } } : {}) } } }, ...then)
+    }
+    return { op: { ...op, data }, after }
+  }
+
+  return {
+    async plan(op, index) {
+      switch (op.action) {
+        case "findMany": case "findFirst":
+          return { op: { ...op, query: select(op.model, op.query ?? {}) }, after: [] }
+        case "count": case "aggregate":
+          return { op, after: [] }
+      }
+      // rows of File go when a row is deleted (itself, or by a cascade) and when a field is rewritten
+      const dirty = () => { const seam = filesSeam(); if (seam) seam.dirty = true }
+      switch (op.action) {
+        case "insert": return insert(op, index)
+        case "update": {
+          const plan = await update(op)
+          if (plan.after.length) dirty()
+          return plan
+        }
+        case "delete": case "deleteMany":
+          dirty()
+          break
+        case "updateMany":
+          for (const key in byModel[op.model] ?? {}) {
+            if (op.data && key in op.data) throw new Error(`${op.model}.${key}: a file is written to one row — update(id, …), not updateMany`)
+          }
+      }
+      return { op, after: [] }
+    },
+    result(op, value) {
+      return op.action === "findMany" || op.action === "findFirst" ? rows(op.model, op.query ?? {}, value) : value
+    },
+  }
+}