@njinlabs/njin 0.10.2 → 0.11.0-beta.1

package/src/modules/api.ts

@@ -1,61 +1,11 @@
-import { getConfig } from "../core/config";
-import { makeModule } from "../core/module";
 import Elysia from "elysia";
 import z from "zod";
+import { toAdminSchema } from "../core/admin_schema";
+import { getConfig } from "../core/config";
+import { makeModule } from "../core/module";
 import auth from "./auth";
 import elysia from "./elysia";
 
-// Removes fields marked hideForm: true from a JSON schema's properties/required,
-// recursing into nested object/array shapes so hidden fields never reach the admin panel.
-const stripHiddenFields = (node: any): void => {
-  if (!node || typeof node !== "object") return;
-
-  if (node.properties) {
-    for (const [key, prop] of Object.entries(node.properties as Record<string, any>)) {
-      if (prop?.hideForm) {
-        delete node.properties[key];
-        if (Array.isArray(node.required)) {
-          node.required = node.required.filter((r: string) => r !== key);
-        }
-      } else {
-        stripHiddenFields(prop);
-      }
-    }
-  }
-
-  if (node.items) stripHiddenFields(node.items);
-};
-
-// Shared by both models and vars groups on the /api/schema endpoint — strips
-// non-JSON-representable renderAs types (relation/multi_relation/file) into
-// plain JSON-schema shapes the admin panel can render a form from, and drops
-// any field marked hideForm: true so it never reaches the admin panel.
-const toAdminSchema = (schema: z.ZodObject) => {
-  const jsonSchema = schema.toJSONSchema({
-    unrepresentable: "any",
-    override: (ctx) => {
-      if (ctx.jsonSchema.renderAs === "relation") {
-        ctx.jsonSchema.type = "object";
-        ctx.jsonSchema.properties = {
-          id: {
-            type: "string",
-          },
-        };
-        ctx.jsonSchema.required = ["id"];
-        ctx.jsonSchema.additionalProperties = {};
-      } else if (ctx.jsonSchema.renderAs === "multi_relation") {
-        (ctx.jsonSchema.items! as any).type = "string";
-      } else if (ctx.jsonSchema.renderAs === "file") {
-        ctx.jsonSchema.type = "string";
-      }
-    },
-  });
-
-  stripHiddenFields(jsonSchema);
-
-  return jsonSchema;
-};
-
 const api = makeModule(() => {
   const fn = () => {};
 
@@ -75,43 +25,45 @@ const api = makeModule(() => {
     // every listener file's .listen() registration before any route goes live.
     for (const promise of events) await promise();
 
-    const controller = new Elysia({ prefix: "/api/schema" }).use(authPlugin.plugin).get(
-      "/",
-      async () => {
-        const allModels = await Promise.all(
-          models.map((model) =>
-            (async () => {
-              const { default: data } = await model();
-
-              return {
-                name: data.name,
-                prefix: data.prefix,
-                schema: toAdminSchema(data.validation),
-              };
-            })(),
-          ),
-        );
-
-        const allVars = await Promise.all(
-          varsGroups.map((varsGroup) =>
-            (async () => {
-              const { default: group } = await varsGroup();
-
-              return {
-                name: group.name,
-                prefix: group.prefix,
-                schema: toAdminSchema(group.validation),
-              };
-            })(),
-          ),
-        );
-
-        return { data: allModels, vars: allVars };
-      },
-      {
-        auth: true,
-      },
-    );
+    const controller = new Elysia({ prefix: "/api/schema" })
+      .use(authPlugin.plugin)
+      .get(
+        "/",
+        async () => {
+          const allModels = await Promise.all(
+            models.map((model) =>
+              (async () => {
+                const { default: data } = await model();
+
+                return {
+                  name: data.name,
+                  prefix: data.prefix,
+                  schema: toAdminSchema(data.validation),
+                };
+              })(),
+            ),
+          );
+
+          const allVars = await Promise.all(
+            varsGroups.map((varsGroup) =>
+              (async () => {
+                const { default: group } = await varsGroup();
+
+                return {
+                  name: group.name,
+                  prefix: group.prefix,
+                  schema: toAdminSchema(group.validation),
+                };
+              })(),
+            ),
+          );
+
+          return { data: allModels, vars: allVars };
+        },
+        {
+          auth: true,
+        },
+      );
 
     elysia().use(controller);
 
@@ -185,11 +137,25 @@ const api = makeModule(() => {
         )
         .get(
           "/",
-          async ({ query: { search, page, limit, sort, order, populate, filters } }) => {
+          async ({
+            query: { search, page, limit, sort, order, populate, filters },
+          }) => {
             const populateOpt =
-              populate === "none" ? ("none" as const) : populate ? populate.split(",").map((s) => s.trim()) : undefined;
-
-            return model.read({ search, page, limit, sort, order, populate: populateOpt, filters });
+              populate === "none"
+                ? ("none" as const)
+                : populate
+                  ? populate.split(",").map((s) => s.trim())
+                  : undefined;
+
+            return model.read({
+              search,
+              page,
+              limit,
+              sort,
+              order,
+              populate: populateOpt,
+              filters,
+            });
           },
           {
             auth: true,
@@ -201,7 +167,13 @@ const api = makeModule(() => {
               order: z.enum(["asc", "desc"]).default("asc"),
               populate: z.coerce.string().optional(),
               filters: z
-                .record(z.string(), z.union([z.coerce.string(), z.record(z.string(), z.coerce.string())]))
+                .record(
+                  z.string(),
+                  z.union([
+                    z.coerce.string(),
+                    z.record(z.string(), z.coerce.string()),
+                  ]),
+                )
                 .optional(),
             }),
           },

package/src/modules/auth.ts

@@ -1,9 +1,9 @@
 import bearer from "@elysia/bearer";
-import { makeModule } from "../core/module";
 import Elysia, { status } from "elysia";
 import moment from "moment";
 import { eq, RecordId, Table, Uuid } from "surrealdb";
 import z from "zod";
+import { makeModule } from "../core/module";
 import elysia from "./elysia";
 import surreal from "./surreal";
 
@@ -30,19 +30,26 @@ const auth = makeModule(() => {
 
             const [_table, tokenId, plainToken] = bearer.split(":");
 
-            const token = await surreal().select<Token>(new RecordId(table, tokenId!)).fetch("user");
+            const token = await surreal()
+              .select<Token>(new RecordId(table, tokenId!))
+              .fetch("user");
 
             if (!token) {
               throw new Error("Unauthorized");
             }
 
-            const hash = new Bun.CryptoHasher("sha256").update(plainToken!).digest("utf8");
+            const hash = new Bun.CryptoHasher("sha256")
+              .update(plainToken!)
+              .digest("utf8");
 
             if (hash !== token.hash) {
               throw new Error("Unauthorized");
             }
 
-            const { password: _, ...safeUser } = token.user as typeof token.user & { password: string };
+            const { password: _, ...safeUser } =
+              token.user as typeof token.user & {
+                password: string;
+              };
 
             return {
               user: { ...safeUser, tokenId: token.id },
@@ -79,7 +86,11 @@ const auth = makeModule(() => {
       prefix: "/api/auth",
     })
       .use((await fn()).plugin)
-      .get("/check-token", ({ user: { tokenId: _, ...user } }) => ({ data: user }), { auth: true })
+      .get(
+        "/check-token",
+        ({ user: { tokenId: _, ...user } }) => ({ data: user }),
+        { auth: true },
+      )
       .delete(
         "/logout",
         async ({ user: { tokenId, ...user } }) => {
@@ -93,7 +104,9 @@ const auth = makeModule(() => {
         "/login",
         async ({ body }) => {
           try {
-            const [data] = await surreal().select<Token["user"]>(user.table).where(eq("email", body.email));
+            const [data] = await surreal()
+              .select<Token["user"]>(user.table)
+              .where(eq("email", body.email));
 
             if (!data) {
               throw new Error("Unauthorized");
@@ -108,7 +121,9 @@ const auth = makeModule(() => {
             const [token] = await surreal()
               .create<Token>(table)
               .content({
-                hash: new Bun.CryptoHasher("sha256").update(plainToken).digest("utf8"),
+                hash: new Bun.CryptoHasher("sha256")
+                  .update(plainToken)
+                  .digest("utf8"),
                 user: data.id as unknown as Token["user"],
                 createdAt: moment().toISOString(),
                 updatedAt: moment().toISOString(),
@@ -116,7 +131,9 @@ const auth = makeModule(() => {
 
             await surreal().relate(token!.id, new Table("user_token"), data.id);
 
-            const { password: _, ...safeData } = data as typeof data & { password: string };
+            const { password: _, ...safeData } = data as typeof data & {
+              password: string;
+            };
 
             return {
               data: {

package/src/modules/elysia.ts

@@ -1,9 +1,9 @@
 import cors from "@elysia/cors";
+import Elysia, { type AnyElysia, status, ValidationError } from "elysia";
 import { getConfig } from "../core/config";
 import { UniqueConstraintError } from "../core/model";
 import { makeModule } from "../core/module";
 import { serveWorker } from "../core/worker";
-import Elysia, { status, ValidationError, type AnyElysia } from "elysia";
 import logger from "./logger";
 
 // Elysia's query parser only understands object/record-shaped query schemas as a single

package/src/modules/file.ts

@@ -1,11 +1,11 @@
+import { resolve } from "node:path";
+import Elysia from "elysia";
+import { RecordId } from "surrealdb";
+import z from "zod";
 import { getConfig } from "../core/config";
 import type { makeModel } from "../core/model";
 import { makeModule } from "../core/module";
 import { resolveSafePath } from "../core/path_guard";
-import Elysia from "elysia";
-import { resolve } from "node:path";
-import { RecordId } from "surrealdb";
-import z from "zod";
 import auth from "./auth";
 import elysia from "./elysia";
 import surreal from "./surreal";
@@ -22,7 +22,9 @@ export type FileUpload<Meta> = {
 };
 
 export interface FileAdapter<Meta> {
-  write: (file: File) => Promise<Omit<FileUpload<Meta>, "id" | "createdAt" | "updatedAt">>;
+  write: (
+    file: File,
+  ) => Promise<Omit<FileUpload<Meta>, "id" | "createdAt" | "updatedAt">>;
   unlink: (file: FileUpload<Meta>) => Promise<void>;
   meta: Meta;
   // Only set by filesystem-backed adapters — tells this module where to serve
@@ -33,14 +35,33 @@ export interface FileAdapter<Meta> {
 
 const file = makeModule(() => {
   let model: ReturnType<typeof makeModel>;
+  // Set in init() once the file model is loaded — shared by the REST routes below and any
+  // other caller (e.g. the MCP upload flow) so every path goes through the same adapter.
+  let upload: (file: File) => Promise<unknown>;
+  let remove: (id: string) => Promise<unknown>;
 
-  const fn = () => ({ model });
+  const fn = () => ({ model, upload, remove });
 
   fn.init = async () => {
     const { default: baseModel } = await import("../models/file");
 
     type FileUploadCurrent = Awaited<ReturnType<typeof baseModel.create>>;
 
+    upload = async (file) =>
+      surreal()
+        .create<Omit<FileUploadCurrent, "id">>(baseModel.table)
+        .content(await getConfig().adapters.file.write(file));
+
+    remove = async (id) => {
+      const data = await surreal().delete<FileUploadCurrent>(
+        new RecordId(baseModel.table, id),
+      );
+
+      await getConfig().adapters.file.unlink(data);
+
+      return data;
+    };
+
     const controller = new Elysia({ prefix: "/api/file" })
       .use((await auth()).plugin)
       .get(
@@ -62,11 +83,7 @@ const file = makeModule(() => {
       .delete(
         "/:id",
         async ({ params }) => {
-          const data = await surreal().delete<FileUploadCurrent>(new RecordId(baseModel.table, params.id));
-
-          await getConfig().adapters.file.unlink(data);
-
-          return { data };
+          return { data: await remove(params.id) };
         },
         {
           params: z.object({
@@ -78,11 +95,7 @@ const file = makeModule(() => {
       .post(
         "/",
         async ({ body }) => {
-          const data = await surreal()
-            .create<Omit<FileUploadCurrent, "id">>(baseModel.table)
-            .content(await getConfig().adapters.file.write(body.file));
-
-          return { data };
+          return { data: await upload(body.file) };
         },
         {
           auth: true,
@@ -99,23 +112,27 @@ const file = makeModule(() => {
       // already-absolute dir must win outright rather than get nested under rootDir.
       const uploadsDir = resolve(getConfig().rootDir, adapterDir);
 
-      const uploadsController = new Elysia().get("/uploads/*", async ({ params }) => {
-        // Elysia leaves wildcard params percent-encoded — decode before touching the filesystem.
-        let decoded: string;
-        try {
-          decoded = decodeURIComponent(params["*"]);
-        } catch {
-          return new Response("Not Found", { status: 404 });
-        }
-
-        const requested = resolveSafePath(uploadsDir, decoded);
-        if (!requested) return new Response("Not Found", { status: 404 });
-
-        const file = Bun.file(requested);
-        if (!(await file.exists())) return new Response("Not Found", { status: 404 });
-
-        return file;
-      });
+      const uploadsController = new Elysia().get(
+        "/uploads/*",
+        async ({ params }) => {
+          // Elysia leaves wildcard params percent-encoded — decode before touching the filesystem.
+          let decoded: string;
+          try {
+            decoded = decodeURIComponent(params["*"]);
+          } catch {
+            return new Response("Not Found", { status: 404 });
+          }
+
+          const requested = resolveSafePath(uploadsDir, decoded);
+          if (!requested) return new Response("Not Found", { status: 404 });
+
+          const file = Bun.file(requested);
+          if (!(await file.exists()))
+            return new Response("Not Found", { status: 404 });
+
+          return file;
+        },
+      );
 
       elysia().use(controller).use(uploadsController);
     } else {

package/src/modules/img.ts

@@ -1,10 +1,13 @@
+import Elysia from "elysia";
 import { getConfig } from "../core/config";
 import { makeModule } from "../core/module";
-import Elysia from "elysia";
 import elysia from "./elysia";
 import view from "./view";
 
-export function isAllowed(imageUrl: string, allowedHosts: string[] = getConfig().img.hosts): boolean {
+export function isAllowed(
+  imageUrl: string,
+  allowedHosts: string[] = getConfig().img.hosts,
+): boolean {
   if (imageUrl.startsWith("/")) return true;
 
   let parsed: URL;
@@ -21,7 +24,11 @@ export function isAllowed(imageUrl: string, allowedHosts: string[] = getConfig()
   // header, or allowing loopback unconditionally, would turn this into an SSRF
   // primitive (an attacker controls both the `url` query param and their own
   // request's `Host` header), so neither is honored here.
-  if (process.env.NODE_ENV !== "production" && (imageHostname === "localhost" || imageHostname === "127.0.0.1")) return true;
+  if (
+    process.env.NODE_ENV !== "production" &&
+    (imageHostname === "localhost" || imageHostname === "127.0.0.1")
+  )
+    return true;
 
   // Every other host: require explicit whitelist
   return allowedHosts.includes(imageHostname);
@@ -42,13 +49,16 @@ const img = makeModule(() => {
   const fn = () => {};
 
   fn.init = async () => {
-    view().global("imgOptimize", (url: string, options?: { w?: number; h?: number; q?: number }) => {
-      const params = new URLSearchParams({ url });
-      if (options?.w != null) params.set("w", String(options.w));
-      if (options?.h != null) params.set("h", String(options.h));
-      if (options?.q != null) params.set("q", String(options.q));
-      return `/img?${params.toString()}`;
-    });
+    view().global(
+      "imgOptimize",
+      (url: string, options?: { w?: number; h?: number; q?: number }) => {
+        const params = new URLSearchParams({ url });
+        if (options?.w != null) params.set("w", String(options.w));
+        if (options?.h != null) params.set("h", String(options.h));
+        if (options?.q != null) params.set("q", String(options.q));
+        return `/img?${params.toString()}`;
+      },
+    );
 
     const controller = new Elysia();
 
@@ -95,7 +105,9 @@ const img = makeModule(() => {
         // pathname+query, but a handler further down that inspects request.url (absolute-URL
         // generation, host-based logic, ...) should see the same scheme/host this request
         // actually arrived on, not a fake one that may not match across environments.
-        const resp = await elysia().handle(new Request(`${new URL(request.url).origin}${url}`));
+        const resp = await elysia().handle(
+          new Request(`${new URL(request.url).origin}${url}`),
+        );
         if (!resp.ok) return new Response("Image not found", { status: 404 });
         imageData = await resp.arrayBuffer();
       } else {
@@ -107,7 +119,8 @@ const img = makeModule(() => {
         } catch {
           return new Response("Failed to fetch image", { status: 502 });
         }
-        if (!resp.ok) return new Response("Failed to fetch image", { status: 502 });
+        if (!resp.ok)
+          return new Response("Failed to fetch image", { status: 502 });
         imageData = await resp.arrayBuffer();
       }
 
@@ -117,13 +130,19 @@ const img = makeModule(() => {
         // Bun.Image.resize() takes width first and derives height from aspect ratio
         // when height is omitted — there's no height-only equivalent, so width-only
         // and width+height both go through this branch unchanged.
-        pipeline.resize(width, height, { fit: "inside", withoutEnlargement: true });
+        pipeline.resize(width, height, {
+          fit: "inside",
+          withoutEnlargement: true,
+        });
       } else if (height) {
         // Height-only request — derive a proportional width from the source dimensions
         // since resize() requires a width argument.
         const meta = await pipeline.metadata();
         const derivedWidth = Math.round((meta.width / meta.height) * height);
-        pipeline.resize(derivedWidth, height, { fit: "inside", withoutEnlargement: true });
+        pipeline.resize(derivedWidth, height, {
+          fit: "inside",
+          withoutEnlargement: true,
+        });
       }
 
       const output = await pipeline.webp({ quality }).buffer();

package/src/modules/logger.ts

@@ -1,6 +1,6 @@
-import { makeModule } from "../core/module";
 import pino from "pino";
 import pretty from "pino-pretty";
+import { makeModule } from "../core/module";
 
 const logger = makeModule(() => {
   let p: pino.Logger;