lecodes-sdk 2.0.6 → 2.0.8

package/src/server/runtime.ts

@@ -14,6 +14,7 @@ import { AsyncLocalStorage } from "node:async_hooks"
 import type { ServerManifest } from "../compile/serverSplit"
 import type { AuthHost } from "./auth/host"
 import type { AuthState } from "./auth/types"
+import type { FilesHost } from "./files/host"
 import { isChannel, isChannelGroup, setChannelPublisher, type ChannelRecord } from "./channel"
 import { setRequestProvider, type RequestContext } from "./context"
 import type { Db } from "./db/types"
@@ -69,6 +70,9 @@ export type InvokerOptions = {
   onError?: (id: string, error: unknown) => void
   /** The auth host (./auth/host.ts): resolves the bearer token into `ctx.auth` before each call. Absent = no sessions. */
   auth?: AuthHost | null
+  /** The files host (./files/host.ts): the uploads of a call become `File` arguments, and what the call
+   *  left unused — or deleted — is cleaned up after it. Absent = a call with files is refused. */
+  files?: FilesHost | null
 }
 
 // The bundle's ApiError is a different class object than ours (its own SDK copy) — duck-type it.
@@ -96,6 +100,7 @@ export const createInvoker = (server: LoadedServer, opts: InvokerOptions = {}) =
   const onError = opts.onError ?? ((id, e) => console.error(`[server] ${id}:`, e))
   const params = server.manifest.params as Record<string, ParamSchema[]> | undefined
   const auth = opts.auth ?? null
+  const files = opts.files ?? null
 
   return async (id: string, args: unknown[], ctx: Omit<RequestContext, "id"> = { headers: {} }): Promise<InvokeResult> => {
     const fn = server.endpoints.get(id)
@@ -103,6 +108,9 @@ export const createInvoker = (server: LoadedServer, opts: InvokerOptions = {}) =
     if (!Array.isArray(args)) return { ok: false, status: 400, message: "args must be an array" }
     const rc: RequestContext = { ...ctx, id }
     try {
+      // an upload is an argument like any other once it is adopted: validated, then passed
+      if (files) args = await files.adopt(args, rc)
+      else if (rc.uploads?.length) return { ok: false, status: 400, message: "this server takes no files" }
       if (validate && params?.[id]) validateArgs(params[id], args)
       if (auth) await auth.resolve(rc)
       const result = await als.run(rc, () => fn(...args))
@@ -113,6 +121,39 @@ export const createInvoker = (server: LoadedServer, opts: InvokerOptions = {}) =
       if (e instanceof ValidationError) return { ok: false, status: 400, message: e.message }
       onError(id, e)
       return withSession({ ok: false, status: 500, message: "Internal error" }, rc)
+    } finally {
+      // in the request's scope: the urls of what the call returned are already made, this is the cleanup
+      if (files) await als.run(rc, () => files.finish(rc))
+    }
+  }
+}
+
+/**
+ * A file field of one row written from OUTSIDE the project's code — a data browser's form. It goes
+ * the way an endpoint's write does, through the bundle's own db: `args` are `[model, id, key, value]`,
+ * the value what an endpoint would write to the field — an upload of this call (`{ "$file": i }`), a
+ * file the row already has (`{ url }`, kept), a list of them, or null. So the field's rule (`t.image()`),
+ * the quota and the removal of what is no longer listed are the same.
+ */
+export const createFileWriter = (server: LoadedServer, opts: { files?: FilesHost | null } = {}) => {
+  installProvider()
+  const files = opts.files ?? null
+  return async (args: unknown[], ctx: Omit<RequestContext, "id"> = { headers: {} }): Promise<InvokeResult> => {
+    const refuse = (message: string): InvokeResult => ({ ok: false, status: 400, message })
+    if (!files?.enabled) return refuse("this project stores no files — a model needs a t.file() field")
+    const rc: RequestContext = { ...ctx, id: "$file" }
+    try {
+      const [model, id, key, value] = await files.adopt(args, rc)
+      const db = server.dbs.find(d => d.$files.some(f => f.model === model && f.key === key))
+      if (!db) return refuse(`${model}.${key} is not a file field`)
+      const name = model as string
+      await als.run(rc, () => (db as any)[name.charAt(0).toLowerCase() + name.slice(1)].update(id, { [key as string]: value }))
+      return { ok: true, result: null }
+    } catch (e) {
+      // whoever asks is the project's developer: the reason as it is
+      return { ok: false, status: apiStatus(e) ?? 500, message: (e as Error)?.message ?? String(e) }
+    } finally {
+      await als.run(rc, () => files.finish(rc))
     }
   }
 }

package/src/server/validate.ts

@@ -12,6 +12,8 @@ export type Schema =
   | { t: "tuple", items: Schema[], rest?: Schema }
   | { t: "object", props: Record<string, Schema>, optional?: string[], index?: Schema }
   | { t: "union", of: Schema[] }
+  /** A `File` parameter: an upload of this very call (./files/host.ts) — nothing the app can spell in JSON. */
+  | { t: "file" }
 
 /** One endpoint parameter: its schema and whether it may be omitted (`?`, default value, rest). */
 export type ParamSchema = { name: string, schema: Schema, optional?: boolean, rest?: boolean }
@@ -61,6 +63,9 @@ export const check = (schema: Schema, value: unknown, path: string): string | nu
       }
       return null
     }
+    case "file":
+      return (globalThis as { __lecodesFiles?: { uploaded(v: unknown): string | undefined } }).__lecodesFiles?.uploaded(value)
+        ? null : `${path}: expected a file, got ${typeName(value)}`
     case "union": {
       const errors: string[] = []
       for (const s of schema.of) { const e = check(s, value, path); if (!e) return null; errors.push(e) }

package/src/version.ts

@@ -4,7 +4,7 @@
 // same manifest). Its MAJOR is the bundle ↔ runtime contract: a bundle's `// sdk:` header line
 // and a host's embedded version must agree on the major for the host to run the bundle; minor
 // and patch never gate anything (features are detected, never versioned).
-export const SDK_VERSION = "2.0.6"
+export const SDK_VERSION = "2.0.8"
 
 /** The major of a semver string, or null when it is not one. */
 export const sdkMajor = (version: string | null | undefined): number | null => {