@nullix/zod-mongoose-studio 3.3.0 → 3.3.2

package/server/utils/example-data.ts

@@ -0,0 +1,80 @@
+import type { ZodType } from "zod/v4";
+import { getMongooseMeta } from "@nullix/zod-mongoose";
+
+type Schema = ZodType & { _def: Record<string, any> };
+
+function checks(schema: Schema): Record<string, any>[] {
+  return (schema._def.checks || []).map((check: any) => check._zod?.def || check.def || {});
+}
+
+function sampleString(schema: Schema, key: string): string {
+  const rules = checks(schema);
+  const format = schema._def.format || rules.find((rule) => rule.format)?.format;
+  if (format === "email" || /email/i.test(key)) return "alex@example.com";
+  if (format === "uuid") return "123e4567-e89b-42d3-a456-426614174000";
+  if (format === "url") return "https://example.com";
+  if (format === "datetime") return "2026-01-01T12:00:00.000Z";
+  if (format === "date") return "2026-01-01";
+
+  const minimum = Math.max(1, ...rules.filter((rule) => rule.check === "min_length").map((rule) => rule.minimum));
+  const base = /name/i.test(key) ? "Alex Morgan" : /title/i.test(key) ? "Example title" : "example";
+  return base.padEnd(Math.min(minimum, 100), "x");
+}
+
+function sampleNumber(schema: Schema): number {
+  const rules = checks(schema);
+  const lower = rules.find((rule) => rule.check === "greater_than");
+  const upper = rules.find((rule) => rule.check === "less_than");
+  const integer = schema._def.type === "int" || rules.some((rule) => rule.check === "number_format" && rule.format === "safeint");
+  const minimum = lower ? Number(lower.value) + (lower.inclusive ? 0 : integer ? 1 : 0.1) : 1;
+  const maximum = upper ? Number(upper.value) - (upper.inclusive ? 0 : integer ? 1 : 0.1) : Infinity;
+  const candidate = Math.min(Math.max(21, minimum), maximum);
+  return integer ? Math.ceil(candidate) : candidate;
+}
+
+export function createExample(schema: Schema, key = "value", depth = 0, seen = new Set<Schema>()): unknown {
+  if (depth > 8 || seen.has(schema)) throw new Error("This recursive schema needs a handwritten example.");
+  const nextSeen = new Set(seen).add(schema);
+  const def = schema._def;
+  const mongooseType = getMongooseMeta(schema).type as any;
+  if (mongooseType === "ObjectId" || mongooseType?.schemaName === "ObjectId") return "507f1f77bcf86cd799439011";
+
+  switch (def.type) {
+    case "optional":
+    case "default":
+    case "prefault":
+      return depth === 0 ? createExample(def.innerType, key, depth + 1, nextSeen) : undefined;
+    case "nullable":
+    case "nonoptional":
+    case "readonly":
+    case "catch":
+      return createExample(def.innerType, key, depth + 1, nextSeen);
+    case "pipe":
+      return createExample(def.in, key, depth + 1, nextSeen);
+    case "lazy":
+      return createExample(def.getter(), key, depth + 1, nextSeen);
+    case "object": {
+      const result: Record<string, unknown> = {};
+      for (const [field, fieldSchema] of Object.entries((schema as any).shape || def.shape || {})) {
+        const value = createExample(fieldSchema as Schema, field, depth + 1, nextSeen);
+        if (value !== undefined) result[field] = value;
+      }
+      return result;
+    }
+    case "array": {
+      const minimum = Math.max(0, ...checks(schema).filter((rule) => rule.check === "min_length").map((rule) => rule.minimum));
+      return Array.from({ length: Math.min(Math.max(1, minimum), 10) }, () => createExample(def.element, key, depth + 1, nextSeen));
+    }
+    case "tuple": return def.items.map((item: Schema) => createExample(item, key, depth + 1, nextSeen));
+    case "string": return sampleString(schema, key);
+    case "number":
+    case "int": return sampleNumber(schema);
+    case "boolean": return true;
+    case "enum": return Object.values(def.entries)[0];
+    case "literal": return def.values?.[0];
+    case "union": return createExample(def.options[0], key, depth + 1, nextSeen);
+    case "record": return { example: createExample(def.valueType, key, depth + 1, nextSeen) };
+    case "date": return "2026-01-01T12:00:00.000Z";
+    default: throw new Error(`Automatic examples do not yet support ${def.type || "this schema"}.`);
+  }
+}

package/server/utils/parse-request.ts

@@ -0,0 +1,28 @@
+import { createError } from "h3";
+import type { H3Event } from "h3";
+import type { ParseBody } from "./studio-execution";
+
+const MAX_BODY_BYTES = 160_000;
+
+export async function readStudioRequest(event: H3Event): Promise<ParseBody> {
+  const chunks: Buffer[] = [];
+  let size = 0;
+  for await (const chunk of event.node.req) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += bytes.length;
+    if (size > MAX_BODY_BYTES) throw createError({ statusCode: 413, message: "Studio input is too large." });
+    chunks.push(bytes);
+  }
+  let body: ParseBody;
+  try { body = JSON.parse(Buffer.concat(chunks).toString("utf8")); }
+  catch { throw createError({ statusCode: 400, message: "Invalid JSON request." }); }
+  if (typeof body?.sourceCode !== "string" || !body.sourceCode.trim()) {
+    throw createError({ statusCode: 400, message: "Add a Zod schema to the editor first." });
+  }
+  if (body.sourceCode.length > 50_000 || typeof body.inputData !== "string" || body.inputData.length > 100_000 ||
+      (body.selectedSchema !== undefined && typeof body.selectedSchema !== "string") ||
+      (body.action !== undefined && body.action !== "run" && body.action !== "example")) {
+    throw createError({ statusCode: 400, message: "Invalid or oversized Studio input." });
+  }
+  return body;
+}

package/server/utils/runner-client.ts

@@ -0,0 +1,40 @@
+import { createError } from "h3";
+import { request } from "node:http";
+import type { ParseBody } from "./studio-execution";
+
+const MAX_RESPONSE_BYTES = 1_000_000;
+
+export function runInContainer(body: ParseBody, socketPath: string): Promise<unknown> {
+  const payload = JSON.stringify(body);
+  return new Promise((resolve, reject) => {
+    const req = request({
+      socketPath,
+      path: "/run",
+      method: "POST",
+      headers: { "content-type": "application/json", "content-length": Buffer.byteLength(payload) },
+    }, (res) => {
+      const chunks: Buffer[] = [];
+      let size = 0;
+      res.on("data", (chunk: Buffer) => {
+        size += chunk.length;
+        if (size > MAX_RESPONSE_BYTES) {
+          req.destroy(new Error("Studio result is too large."));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      res.on("end", () => {
+        try {
+          const result = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+          if (res.statusCode !== 200) {
+            reject(createError({ statusCode: res.statusCode === 400 ? 400 : res.statusCode === 504 ? 504 : 503, message: result.error || "Studio runner failed." }));
+          } else resolve(result);
+        } catch { reject(createError({ statusCode: 502, message: "Invalid response from Studio runner." })); }
+      });
+      res.on("error", reject);
+    });
+    req.setTimeout(5000, () => req.destroy(new Error("Studio runner timed out.")));
+    req.on("error", reject);
+    req.end(payload);
+  });
+}

package/server/utils/studio-execution.ts

@@ -0,0 +1,176 @@
+import vm from "node:vm";
+import { transformSync } from "esbuild";
+import util from "node:util";
+import { parse } from "acorn";
+import * as zod from "zod/v4";
+import mongoose from "mongoose";
+import * as mongooseZod from "@nullix/zod-mongoose";
+import { createExample } from "./example-data";
+
+mongooseZod.setMongoose(mongoose);
+
+export class StudioExecutionError extends Error {
+  statusCode = 400;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message || error.name : String(error);
+}
+
+function declaredNames(jsCode: string): string[] {
+  const file = parse(jsCode, { ecmaVersion: "latest", sourceType: "script" });
+  const names: string[] = [];
+  for (const statement of file.body) {
+    if (statement.type !== "VariableDeclaration") continue;
+    for (const declaration of statement.declarations) {
+      if (declaration.id.type === "Identifier") names.push(declaration.id.name);
+    }
+  }
+  return names;
+}
+
+function displayValue(value: unknown): string {
+  const seen = new WeakSet<object>();
+  return JSON.stringify(value, (_key, item) => {
+    if (typeof item === "bigint") return `${item.toString()}n`;
+    if (typeof item === "undefined") return "[undefined]";
+    if (typeof item === "number" && !Number.isFinite(item)) return String(item);
+    if (typeof item === "object" && item !== null) {
+      if (item instanceof Date) return item.toISOString();
+      if (typeof item.toHexString === "function") return item.toHexString();
+      if (seen.has(item)) return "[Circular]";
+      seen.add(item);
+    }
+    return item;
+  }, 2) || "undefined";
+}
+
+function formatMongoose(value: any): any {
+  if (typeof value === "function") return value.name || value.toString();
+  if (Array.isArray(value)) return value.map(formatMongoose);
+  if (value !== null && typeof value === "object" && value.constructor === Object) {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, formatMongoose(entry)]));
+  }
+  return value;
+}
+
+export type ParseBody = {
+  sourceCode?: string;
+  inputData?: string;
+  selectedSchema?: string;
+  action?: "run" | "example";
+};
+
+export function executeStudio(body: ParseBody, timeoutMs: number) {
+  const sourceCode = body.sourceCode!;
+  mongooseZod.hooks.removeAllHooks();
+  try {
+    let jsCode: string;
+    try {
+      jsCode = transformSync(sourceCode, { loader: "ts", format: "cjs", target: "esnext" }).code;
+    } catch (error) {
+      throw new StudioExecutionError(`Compilation error: ${errorMessage(error)}`);
+    }
+    const names = declaredNames(jsCode);
+
+    const sandboxRequire = (moduleName: string) => {
+      if (moduleName === "zod" || moduleName === "zod/v4") return zod;
+      if (moduleName === "@nullix/zod-mongoose") return mongooseZod;
+      if (moduleName === "mongoose") return mongoose;
+      throw new Error(`Module "${moduleName}" is unavailable in Studio.`);
+    };
+    const context = vm.createContext({
+      ...mongooseZod,
+      z: zod.z,
+      mongoose,
+      require: sandboxRequire,
+      console: { log: () => {}, warn: () => {}, error: () => {} },
+      __filename: "/sandbox/main.ts",
+      __dirname: "/sandbox",
+    });
+    const captured = names.map((name) => `${JSON.stringify(name)}: typeof ${name} === "undefined" ? undefined : ${name}`).join(",");
+    const script = new vm.Script(`
+      (() => {
+        let exports = {};
+        let module = { exports };
+        ${jsCode}
+        return { exported: module.exports, declared: { ${captured} } };
+      })()
+    `);
+    const result = script.runInContext(context, { timeout: timeoutMs });
+    const choices = new Map<string, zod.ZodType>();
+    for (const [name, value] of Object.entries(result.declared)) {
+      if (value instanceof zod.ZodType && ![...choices.values()].includes(value)) choices.set(name, value);
+    }
+    for (const [name, value] of Object.entries(result.exported || {})) {
+      if (value instanceof zod.ZodType && ![...choices.values()].includes(value)) choices.set(name, value);
+    }
+    const defaultExport = result.exported instanceof zod.ZodType ? result.exported : result.exported?.default;
+    if (defaultExport instanceof zod.ZodType && ![...choices.values()].includes(defaultExport)) choices.set("default", defaultExport);
+    if (!choices.size) throw new Error("Define a Zod schema, such as const UserSchema = z.object({ name: z.string() }).");
+
+    const selectedSchema = body.selectedSchema && choices.has(body.selectedSchema)
+      ? body.selectedSchema : choices.keys().next().value as string;
+    const schema = choices.get(selectedSchema)!;
+    const schemaNames = [...choices.keys()];
+
+    let example: string | undefined;
+    let exampleError: string | undefined;
+    let inputData = body.inputData;
+    if (body.action === "example") {
+      try {
+        const fixture = result.declared.exampleInput;
+        const generated = fixture !== undefined ? fixture : createExample(schema as any);
+        const exampleResult = schema.safeParse(generated);
+        if (!exampleResult.success) throw new Error("The example does not satisfy this schema. Add or update a valid const exampleInput for custom rules.");
+        example = displayValue(generated);
+        inputData = example;
+      } catch (error) {
+        exampleError = errorMessage(error);
+      }
+    }
+
+    let validation: { status: "valid" | "invalid" | "json-error" | "parse-error" | "empty"; parsed?: string; issues?: { path: string; message: string; code: string }[]; message?: string } = { status: "empty" };
+    if (typeof inputData !== "string" || !inputData.trim()) {
+      validation = { status: "empty", message: "Add JSON data to try this schema." };
+    } else {
+      let input: unknown;
+      let inputValid = false;
+      try {
+        input = JSON.parse(inputData);
+        inputValid = true;
+      } catch (error) {
+        validation = { status: "json-error", message: errorMessage(error) };
+      }
+      if (inputValid) {
+        try {
+          const parsed = schema.safeParse(input);
+          validation = parsed.success
+            ? { status: "valid", parsed: displayValue(parsed.data) }
+            : { status: "invalid", issues: parsed.error.issues.map((issue) => ({ path: issue.path.length ? issue.path.join(".") : "(root)", message: issue.message, code: issue.code })) };
+        } catch (error) {
+          validation = { status: "parse-error", message: `Validation could not run: ${errorMessage(error)}` };
+        }
+      }
+    }
+
+    let conversion: { definition?: string; schemaObj?: string; schemaTree?: string; schemaPaths?: string; error?: string };
+    try {
+      const extracted = mongooseZod.extractMongooseDef(schema);
+      const converted = mongooseZod.toMongooseSchema(schema, { modelName: "ParsedSchema" });
+      const inspect = (value: unknown) => util.inspect(formatMongoose(value), { depth: null, colors: false, showHidden: false });
+      conversion = {
+        definition: inspect(extracted),
+        schemaObj: inspect(converted.obj),
+        schemaTree: inspect((converted as any).tree),
+        schemaPaths: inspect((converted as any).paths),
+      };
+    } catch (error) {
+      conversion = { error: errorMessage(error) };
+    }
+
+    return { schemaNames, selectedSchema, validation, conversion, example, exampleError };
+  } finally {
+    mongooseZod.hooks.removeAllHooks();
+  }
+}