@njinlabs/njin 0.10.3 → 0.11.0

package/src/core/admin_schema.ts

@@ -0,0 +1,79 @@
+import type z from "zod";
+
+// 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.
+//
+// `forAgent` describes every link (relation/file/multi_*) as what it takes on the wire: the
+// related record's id as a plain string. The admin shape for a single relation is an object
+// `{ id }`, which is right for the panel's form but wrong for an agent: a relation written as an
+// object is stored as an embedded copy instead of a link to the record, so it never expands.
+export const toAdminSchema = (
+  schema: z.ZodObject,
+  options: { forAgent?: boolean } = {},
+) => {
+  const jsonSchema = schema.toJSONSchema({
+    unrepresentable: "any",
+    override: (ctx) => {
+      if (options.forAgent) {
+        const kind = ctx.jsonSchema.renderAs;
+        const target = String(ctx.jsonSchema.model ?? "");
+
+        if (kind === "relation" || kind === "file") {
+          ctx.jsonSchema.type = "string";
+          ctx.jsonSchema.description = `Id of a "${target}" record, as a plain string (not an object).`;
+          return;
+        }
+        if (kind === "multi_relation" || kind === "multi_file") {
+          ctx.jsonSchema.type = "array";
+          ctx.jsonSchema.items = { type: "string" };
+          ctx.jsonSchema.description = `Ids of "${target}" records, as plain strings (not objects).`;
+          return;
+        }
+      }
+
+      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;
+};

package/src/core/banner.ts

@@ -15,7 +15,11 @@ const PKG_VERSION: string = (() => {
   try {
     // Safe to use import.meta.dir here — this looks up njin's OWN version,
     // not anything project-specific (unlike view.ts's views lookup).
-    return (require(join(import.meta.dir, "../../package.json")) as { version: string }).version;
+    return (
+      require(join(import.meta.dir, "../../package.json")) as {
+        version: string;
+      }
+    ).version;
   } catch {
     return "0.0.0";
   }
@@ -35,9 +39,17 @@ export const printBanner = ({ mode }: BootSummary): void => {
 
   const rows: [string, string][] = [
     ["Local", `http://localhost:${port}`],
-    ["Database", `${config.db.path} ${c.dim}(${config.db.namespace}/${config.db.database})${c.reset}`],
+    [
+      "Database",
+      `${config.db.path} ${c.dim}(${config.db.namespace}/${config.db.database})${c.reset}`,
+    ],
     ["Models", `${config.models.length} registered`],
-    hasAdmin ? ["Admin", `http://localhost:${port}/_admin`] : ["Admin", `${c.dim}not found — drop a built admin panel into /_admin${c.reset}`],
+    hasAdmin
+      ? ["Admin", `http://localhost:${port}/_admin`]
+      : [
+          "Admin",
+          `${c.dim}not found — drop a built admin panel into /_admin${c.reset}`,
+        ],
   ];
 
   const label = (text: string) => `${c.dim}${text.padEnd(9)}${c.reset}`;
@@ -46,7 +58,9 @@ export const printBanner = ({ mode }: BootSummary): void => {
     "",
     `  ${c.bold}${c.cyan}njin${c.reset} ${c.dim}v${PKG_VERSION}${c.reset}  ${mode === "production" ? c.green : c.yellow}${mode}${c.reset}`,
     "",
-    ...rows.map(([key, value]) => `  ${c.green}➜${c.reset}  ${label(key)} ${value}`),
+    ...rows.map(
+      ([key, value]) => `  ${c.green}➜${c.reset}  ${label(key)} ${value}`,
+    ),
     "",
   ];
 

package/src/core/config.ts

@@ -1,13 +1,15 @@
+import { join } from "node:path";
 import type { AnyElysia } from "elysia";
 import type { FileAdapter } from "../modules/file";
-import { join } from "node:path";
 import bunFilesystemAdapter from "./adapters/bun_filesystem";
 import type { Helper } from "./helper";
 import type { makeModel } from "./model";
 import type { Plugin } from "./plugin";
 import type { makeVars } from "./vars";
 
-export type ModelFactory = () => Promise<{ default: ReturnType<typeof makeModel> }>;
+export type ModelFactory = () => Promise<{
+  default: ReturnType<typeof makeModel>;
+}>;
 
 // A hook file's only job is the side effect of calling afterCreate()/etc. at import
 // time — its module's exports (if any) are irrelevant, unlike ModelFactory.
@@ -27,7 +29,9 @@ export type RouteFactory = () => Promise<{ default: AnyElysia }>;
 
 // A vars file's default export is one makeVars() group (e.g. "general", "seo") —
 // a singleton settings object, not a list of records like a model.
-export type VarsFactory = () => Promise<{ default: ReturnType<typeof makeVars> }>;
+export type VarsFactory = () => Promise<{
+  default: ReturnType<typeof makeVars>;
+}>;
 
 // A helper file's default export is one defineHelper() — a stateless function
 // registered as an Edge global by its own name, unlike models/vars which are
@@ -36,6 +40,18 @@ export type HelperFactory = () => Promise<{ default: Helper }>;
 
 export type NjinConfig = {
   port?: number;
+  // Public base URL of the site as clients reach it (e.g. "https://example.com") — used for
+  // the OAuth/MCP discovery documents, which must name the exact host an agent connects to.
+  // Optional: falls back to the request's own origin (see core/public_url.ts), which is
+  // enough for a single-host setup without a proxy rewriting Host.
+  publicUrl?: string;
+  mcp?: {
+    // Extra OAuth callback URLs an MCP client may register, on top of the built-in ones (Claude,
+    // ChatGPT, Cursor, VS Code, and any loopback address). An entry is matched exactly, or as a
+    // path prefix when it ends in "*" ("https://app.example.com/oauth/*"). Only add callbacks of
+    // clients you trust: it is where the authorization code is sent after a user signs in.
+    redirectUris?: string[];
+  };
   // Base directory every project-relative path (src/views, _admin, public, upload dirs)
   // resolves against. Defaults to process.cwd() — only needs overriding by a build step
   // (see build-worker.ts) that bakes in an absolute path for a runtime whose cwd isn't
@@ -68,8 +84,15 @@ export type NjinConfig = {
 
 export type ResolvedConfig = {
   port: number;
+  publicUrl?: string;
+  mcp: { redirectUris: string[] };
   rootDir: string;
-  db: { path: string; namespace: string; database: string; auth?: { username: string; password: string } | string };
+  db: {
+    path: string;
+    namespace: string;
+    database: string;
+    auth?: { username: string; password: string } | string;
+  };
   img: { hosts: string[] };
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   adapters: { file: FileAdapter<any> };
@@ -133,6 +156,8 @@ export const loadConfig = async (preloaded?: NjinConfig): Promise<void> => {
   // prefix fails the same way it already does today — naturally, at runtime.
   resolved = {
     port: userConfig.port ?? 3000,
+    publicUrl: userConfig.publicUrl,
+    mcp: { redirectUris: userConfig.mcp?.redirectUris ?? [] },
     rootDir: userConfig.rootDir ?? process.cwd(),
     db: {
       path: userConfig.db?.path ?? "rocksdb://data",
@@ -142,17 +167,39 @@ export const loadConfig = async (preloaded?: NjinConfig): Promise<void> => {
     },
     img: { hosts: userConfig.img?.hosts ?? [] },
     adapters: { file: userConfig.adapters?.file ?? bunFilesystemAdapter() },
-    models: [...plugins.flatMap((p) => p.models ?? []), ...(userConfig.models ?? [])],
-    hooks: [...plugins.flatMap((p) => p.hooks ?? []), ...(userConfig.hooks ?? [])],
-    events: [...plugins.flatMap((p) => p.events ?? []), ...(userConfig.events ?? [])],
-    routes: [...plugins.flatMap((p) => p.routes ?? []), ...(userConfig.routes ?? [])],
+    models: [
+      ...plugins.flatMap((p) => p.models ?? []),
+      ...(userConfig.models ?? []),
+    ],
+    hooks: [
+      ...plugins.flatMap((p) => p.hooks ?? []),
+      ...(userConfig.hooks ?? []),
+    ],
+    events: [
+      ...plugins.flatMap((p) => p.events ?? []),
+      ...(userConfig.events ?? []),
+    ],
+    routes: [
+      ...plugins.flatMap((p) => p.routes ?? []),
+      ...(userConfig.routes ?? []),
+    ],
     vars: [...plugins.flatMap((p) => p.vars ?? []), ...(userConfig.vars ?? [])],
-    helpers: [...plugins.flatMap((p) => p.helpers ?? []), ...(userConfig.helpers ?? [])],
-    pluginInits: plugins.map((p) => p.init).filter((fn): fn is () => Promise<void> | void => typeof fn === "function"),
+    helpers: [
+      ...plugins.flatMap((p) => p.helpers ?? []),
+      ...(userConfig.helpers ?? []),
+    ],
+    pluginInits: plugins
+      .map((p) => p.init)
+      .filter(
+        (fn): fn is () => Promise<void> | void => typeof fn === "function",
+      ),
   };
 };
 
 export const getConfig = (): ResolvedConfig => {
-  if (!resolved) throw new Error("Config not loaded yet — loadConfig() must run before getConfig() is called.");
+  if (!resolved)
+    throw new Error(
+      "Config not loaded yet — loadConfig() must run before getConfig() is called.",
+    );
   return resolved;
 };

package/src/core/helper.ts

@@ -2,4 +2,7 @@
 export type Helper = { name: string; fn: (...args: any[]) => unknown };
 
 // Identity function — DX/typing only, same purpose as defineConfig/definePlugin.
-export const defineHelper = (name: string, fn: Helper["fn"]): Helper => ({ name, fn });
+export const defineHelper = (name: string, fn: Helper["fn"]): Helper => ({
+  name,
+  fn,
+});

package/src/core/html_page.ts

@@ -0,0 +1,63 @@
+// Shared by the small server-rendered pages (OAuth sign-in, MCP file drop) — they live outside
+// the site's own views on purpose, so they work regardless of what theme/templates a project uses.
+
+export const noStore = {
+  "Cache-Control": "no-store",
+  Pragma: "no-cache",
+};
+
+export const escapeHtml = (value: string) =>
+  value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+
+// A consent page must never be framable (clickjacking the Allow button) or cached.
+const pageHeaders = {
+  "Content-Type": "text/html; charset=utf-8",
+  "Content-Security-Policy":
+    "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'none'",
+  "X-Frame-Options": "DENY",
+  "Referrer-Policy": "no-referrer",
+  ...noStore,
+};
+
+export const page = (title: string, body: string, status = 200) =>
+  new Response(
+    `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${escapeHtml(title)}</title>
+<style>
+:root{color-scheme:light dark;--bg:#f6f6f7;--card:#fff;--fg:#18181b;--muted:#6b7280;--line:#d4d4d8;--accent:#18181b;--accent-fg:#fff;--danger:#b91c1c}
+@media (prefers-color-scheme:dark){:root{--bg:#09090b;--card:#18181b;--fg:#fafafa;--muted:#a1a1aa;--line:#3f3f46;--accent:#fafafa;--accent-fg:#18181b;--danger:#f87171}}
+*{box-sizing:border-box}
+body{margin:0;min-height:100vh;display:grid;place-items:center;padding:16px;background:var(--bg);color:var(--fg);font:16px/1.5 system-ui,sans-serif}
+main{width:100%;max-width:400px;background:var(--card);border:1px solid var(--line);border-radius:12px;padding:24px}
+h1{font-size:20px;margin:0 0 8px}
+p{margin:0 0 16px;color:var(--muted)}
+strong{color:var(--fg)}
+label{display:block;font-size:14px;margin:12px 0 4px}
+input[type=email],input[type=password]{width:100%;padding:10px 12px;border:1px solid var(--line);border-radius:8px;background:transparent;color:inherit;font:inherit}
+.row{display:flex;gap:8px;margin-top:20px}
+button{flex:1;padding:10px 12px;border-radius:8px;border:1px solid var(--line);background:transparent;color:inherit;font:inherit;cursor:pointer}
+button.primary{background:var(--accent);color:var(--accent-fg);border-color:var(--accent);order:1}
+.error{color:var(--danger);font-size:14px;margin:0 0 12px}
+input[type=file]{width:100%;padding:32px 12px;border:2px dashed var(--line);border-radius:8px;background:transparent;color:inherit;font:inherit;cursor:pointer}
+.ok{color:var(--fg)}
+ul{margin:0 0 16px;padding-left:20px;color:var(--muted)}
+.host{font-family:ui-monospace,monospace;font-size:14px;color:var(--fg)}
+</style>
+</head>
+<body>
+<main>
+${body}
+</main>
+</body>
+</html>`,
+    { status, headers: pageHeaders },
+  );

package/src/core/model/data_type/array.ts

@@ -1,14 +1,25 @@
 import z from "zod";
-import { type FormMeta } from "..";
+import type { FormMeta } from "..";
 
-export function array<T extends z.ZodTypeAny>(meta: FormMeta, input: T): z.ZodPreprocess<z.ZodArray<T>>;
+export function array<T extends z.ZodTypeAny>(
+  meta: FormMeta,
+  input: T,
+): z.ZodPreprocess<z.ZodArray<T>>;
 
-export function array<T extends z.ZodTypeAny, Z extends z.ZodTypeAny>(meta: FormMeta, input: T, rule: (z: z.ZodArray<T>) => Z): z.ZodPreprocess<Z>;
+export function array<T extends z.ZodTypeAny, Z extends z.ZodTypeAny>(
+  meta: FormMeta,
+  input: T,
+  rule: (z: z.ZodArray<T>) => Z,
+): z.ZodPreprocess<Z>;
 
-export function array(meta: FormMeta, input: z.ZodTypeAny, rule?: (z: any) => any) {
+export function array(
+  meta: FormMeta,
+  input: z.ZodTypeAny,
+  rule?: (z: any) => any,
+) {
   const baseRule = z.preprocess(
     (value) => {
-      if (!!value && !Array.isArray(value)) return [value];
+      if (value && !Array.isArray(value)) return [value];
 
       return value;
     },

package/src/core/model/data_type/boolean.ts

@@ -3,7 +3,10 @@ import type { FormMeta } from "..";
 
 export function boolean(meta: FormMeta): z.ZodBoolean;
 
-export function boolean<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodBoolean) => T): T;
+export function boolean<T extends z.ZodTypeAny>(
+  meta: FormMeta,
+  rule: (z: z.ZodBoolean) => T,
+): T;
 
 export function boolean(meta: FormMeta, rule?: (z: any) => any) {
   const baseRule = z.boolean();

package/src/core/model/data_type/date.ts

@@ -4,7 +4,10 @@ import type { FormMeta } from "..";
 
 export function date(meta: FormMeta): z.ZodPreprocess<z.ZodString>;
 
-export function date<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodString) => T): z.ZodPreprocess<T>;
+export function date<T extends z.ZodTypeAny>(
+  meta: FormMeta,
+  rule: (z: z.ZodString) => T,
+): z.ZodPreprocess<T>;
 
 export function date(meta: FormMeta, rule?: (z: any) => any) {
   const inner = rule ? rule(z.string()) : z.string();

package/src/core/model/data_type/email.ts

@@ -3,7 +3,10 @@ import type { FormMeta } from "..";
 
 export function email(meta: FormMeta): z.ZodPreprocess<z.ZodEmail>;
 
-export function email<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodEmail) => T): z.ZodPreprocess<T>;
+export function email<T extends z.ZodTypeAny>(
+  meta: FormMeta,
+  rule: (z: z.ZodEmail) => T,
+): z.ZodPreprocess<T>;
 
 export function email(meta: FormMeta, rule?: (z: any) => any) {
   const inner = rule ? rule(z.email()) : z.email();

package/src/core/model/data_type/file.ts

@@ -1,10 +1,23 @@
-import fileModule from "../../../modules/file";
 import type z from "zod";
-import { relation, type FormMeta, type RelationType } from "..";
+import fileModule from "../../../modules/file";
+import { type FormMeta, type RelationType, relation } from "..";
 
-export function file(meta: FormMeta): RelationType<ReturnType<ReturnType<typeof fileModule>["model"]["validation"]["partial"]>>;
+export function file(
+  meta: FormMeta,
+): RelationType<
+  ReturnType<ReturnType<typeof fileModule>["model"]["validation"]["partial"]>
+>;
 
-export function file<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: RelationType<ReturnType<ReturnType<typeof fileModule>["model"]["validation"]["partial"]>>) => T): T;
+export function file<T extends z.ZodTypeAny>(
+  meta: FormMeta,
+  rule: (
+    z: RelationType<
+      ReturnType<
+        ReturnType<typeof fileModule>["model"]["validation"]["partial"]
+      >
+    >,
+  ) => T,
+): T;
 
 export function file(meta: FormMeta, rule?: (z: any) => any) {
   return relation(meta, fileModule().model, rule ? rule : (z) => z).meta({

package/src/core/model/data_type/multi_file.ts

@@ -1,13 +1,18 @@
-import fileModule from "../../../modules/file";
 import type z from "zod";
-import { type FormMeta, type RelationType } from "..";
+import fileModule from "../../../modules/file";
+import type { FormMeta, RelationType } from "..";
 import { relationMany } from "./relation_many";
 
-type Return = RelationType<ReturnType<ReturnType<typeof fileModule>["model"]["validation"]["partial"]>>;
+type Return = RelationType<
+  ReturnType<ReturnType<typeof fileModule>["model"]["validation"]["partial"]>
+>;
 
 export function multiFile(meta: FormMeta): z.ZodPreprocess<z.ZodArray<Return>>;
 
-export function multiFile<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodArray<Return>) => T): T;
+export function multiFile<T extends z.ZodTypeAny>(
+  meta: FormMeta,
+  rule: (z: z.ZodArray<Return>) => T,
+): T;
 
 export function multiFile(meta: FormMeta, rule?: (z: any) => any) {
   return relationMany(meta, fileModule().model, rule ? rule : (z) => z).meta({

package/src/core/model/data_type/numeric.ts

@@ -3,7 +3,10 @@ import type { FormMeta } from "..";
 
 export function numeric(meta: FormMeta): z.ZodNumber;
 
-export function numeric<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodNumber) => T): T;
+export function numeric<T extends z.ZodTypeAny>(
+  meta: FormMeta,
+  rule: (z: z.ZodNumber) => T,
+): T;
 
 export function numeric(meta: FormMeta, rule?: (z: any) => any) {
   const baseRule = z.number();

package/src/core/model/data_type/object.ts

@@ -1,9 +1,15 @@
 import z from "zod";
 import type { FormMeta } from "..";
 
-export function object<T extends { [x: string]: z.ZodTypeAny }>(meta: FormMeta, shape: T): z.ZodObject<T>;
+export function object<T extends { [x: string]: z.ZodTypeAny }>(
+  meta: FormMeta,
+  shape: T,
+): z.ZodObject<T>;
 
-export function object<T extends { [x: string]: z.ZodTypeAny }, Z extends z.ZodTypeAny>(meta: FormMeta, shape: T, rule: (z: z.ZodObject<T>) => Z): Z;
+export function object<
+  T extends { [x: string]: z.ZodTypeAny },
+  Z extends z.ZodTypeAny,
+>(meta: FormMeta, shape: T, rule: (z: z.ZodObject<T>) => Z): Z;
 
 export function object(meta: FormMeta, shape: any, rule?: (z: any) => any) {
   const baseRule = z.object(shape);

package/src/core/model/data_type/relation.ts

@@ -1,6 +1,6 @@
 import { RecordId } from "surrealdb";
 import z from "zod";
-import { type FormMeta, type makeModel } from "..";
+import type { FormMeta, makeModel } from "..";
 
 export type RelationType<Relation> = z.ZodPreprocess<
   z.ZodPipe<
@@ -31,13 +31,29 @@ export type RelationType<Relation> = z.ZodPreprocess<
   >
 >;
 
-type Relation<Model extends ReturnType<typeof makeModel>> = RelationType<ReturnType<Model["validation"]["partial"]>>;
+type Relation<Model extends ReturnType<typeof makeModel>> = RelationType<
+  ReturnType<Model["validation"]["partial"]>
+>;
 
-export function relation<Model extends ReturnType<typeof makeModel>>(meta: FormMeta & { labelKey?: keyof Model["validation"]["shape"] }, model: Model): Relation<Model>;
+export function relation<Model extends ReturnType<typeof makeModel>>(
+  meta: FormMeta & { labelKey?: keyof Model["validation"]["shape"] },
+  model: Model,
+): Relation<Model>;
 
-export function relation<T extends z.ZodTypeAny, Model extends ReturnType<typeof makeModel>>(meta: FormMeta & { labelKey?: keyof Model["validation"]["shape"] }, model: Model, rule: (z: Relation<Model>) => T): T;
+export function relation<
+  T extends z.ZodTypeAny,
+  Model extends ReturnType<typeof makeModel>,
+>(
+  meta: FormMeta & { labelKey?: keyof Model["validation"]["shape"] },
+  model: Model,
+  rule: (z: Relation<Model>) => T,
+): T;
 
-export function relation(meta: any, model: ReturnType<typeof makeModel>, rule?: (z: any) => any) {
+export function relation(
+  meta: any,
+  model: ReturnType<typeof makeModel>,
+  rule?: (z: any) => any,
+) {
   const baseRule = z.preprocess(
     (value) => {
       if (typeof value === "string") {

package/src/core/model/data_type/relation_many.ts

@@ -1,14 +1,32 @@
 import { RecordId } from "surrealdb";
 import z from "zod";
-import { type FormMeta, type makeModel, type RelationType } from "..";
+import type { FormMeta, makeModel, RelationType } from "..";
 
-type Return<Model extends ReturnType<typeof makeModel>> = z.ZodPreprocess<z.ZodArray<RelationType<ReturnType<Model["validation"]["partial"]>>>>;
+type Return<Model extends ReturnType<typeof makeModel>> = z.ZodPreprocess<
+  z.ZodArray<RelationType<ReturnType<Model["validation"]["partial"]>>>
+>;
 
-export function relationMany<Model extends ReturnType<typeof makeModel>>(meta: FormMeta, model: Model): Return<Model>;
+export function relationMany<Model extends ReturnType<typeof makeModel>>(
+  meta: FormMeta,
+  model: Model,
+): Return<Model>;
 
-export function relationMany<T extends z.ZodTypeAny, Model extends ReturnType<typeof makeModel>>(meta: FormMeta, model: Model, rule: (z: z.ZodArray<RelationType<ReturnType<Model["validation"]["partial"]>>>) => T): T;
+export function relationMany<
+  T extends z.ZodTypeAny,
+  Model extends ReturnType<typeof makeModel>,
+>(
+  meta: FormMeta,
+  model: Model,
+  rule: (
+    z: z.ZodArray<RelationType<ReturnType<Model["validation"]["partial"]>>>,
+  ) => T,
+): T;
 
-export function relationMany(meta: FormMeta, model: ReturnType<typeof makeModel>, rule?: (z: any) => any) {
+export function relationMany(
+  meta: FormMeta,
+  model: ReturnType<typeof makeModel>,
+  rule?: (z: any) => any,
+) {
   const baseRule = z.array(
     z.preprocess(
       (value) => {
@@ -41,7 +59,7 @@ export function relationMany(meta: FormMeta, model: ReturnType<typeof makeModel>
   return z
     .preprocess(
       (value) => {
-        if (!!value && !Array.isArray(value)) return [value];
+        if (value && !Array.isArray(value)) return [value];
 
         return value;
       },

package/src/core/model/data_type/richtext.ts

@@ -3,7 +3,10 @@ import type { FormMeta } from "..";
 
 export function richtext(meta: FormMeta): z.ZodPreprocess<z.ZodString>;
 
-export function richtext<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodString) => T): z.ZodPreprocess<T>;
+export function richtext<T extends z.ZodTypeAny>(
+  meta: FormMeta,
+  rule: (z: z.ZodString) => T,
+): z.ZodPreprocess<T>;
 
 export function richtext(meta: FormMeta, rule?: (z: any) => any) {
   const inner = rule ? rule(z.string()) : z.string();

package/src/core/model/data_type/select.ts

@@ -1,11 +1,25 @@
 import z from "zod";
 import type { FormMeta } from "..";
 
-export function select<const T extends readonly string[]>(meta: FormMeta, options: T): z.ZodEnum<{ [x in T[number]]: x }>;
+export function select<const T extends readonly string[]>(
+  meta: FormMeta,
+  options: T,
+): z.ZodEnum<{ [x in T[number]]: x }>;
 
-export function select<const T extends readonly string[], Z extends z.ZodTypeAny>(meta: FormMeta, options: T, rule: (z: z.ZodEnum<{ [x in T[number]]: x }>) => Z): Z;
+export function select<
+  const T extends readonly string[],
+  Z extends z.ZodTypeAny,
+>(
+  meta: FormMeta,
+  options: T,
+  rule: (z: z.ZodEnum<{ [x in T[number]]: x }>) => Z,
+): Z;
 
-export function select(meta: FormMeta, options: string[], rule?: (z: any) => any) {
+export function select(
+  meta: FormMeta,
+  options: string[],
+  rule?: (z: any) => any,
+) {
   const baseRule = z.enum(options);
 
   return (rule ? rule(baseRule) : baseRule).meta({

package/src/core/model/data_type/text.ts

@@ -3,7 +3,10 @@ import type { FormMeta } from "..";
 
 export function text(meta: FormMeta): z.ZodPreprocess<z.ZodString>;
 
-export function text<T extends z.ZodTypeAny>(meta: FormMeta, rule: (z: z.ZodString) => T): z.ZodPreprocess<T>;
+export function text<T extends z.ZodTypeAny>(
+  meta: FormMeta,
+  rule: (z: z.ZodString) => T,
+): z.ZodPreprocess<T>;
 
 export function text(meta: FormMeta, rule?: (z: any) => any) {
   const inner = rule ? rule(z.string()) : z.string();