surreal-zod 0.0.0-alpha.1

package/README.md

@@ -0,0 +1,15 @@
+# surreal-zod
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.0. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/lib/index.js

@@ -0,0 +1,3 @@
+import * as sz from "./zod";
+export { sz };
+export default sz;

package/lib/print.js

@@ -0,0 +1,166 @@
+export function zodToSexpr(schema) {
+    if ("_zod" in schema) {
+        return zod4ToSexpr(schema);
+    }
+    throw new Error("Zod 3 not yet supported");
+}
+function zod4ToSexpr(_schema, depth = 0) {
+    const indent = "  ".repeat(depth);
+    const childIndent = "  ".repeat(depth + 1);
+    const schema = _schema;
+    const def = schema._zod.def;
+    const checks = def.checks ?? [];
+    if ("check" in def) {
+        checks.push(schema);
+    }
+    const type = def.type;
+    if (type === "object") {
+        return `(object)`;
+    }
+    // Primitives
+    switch (type) {
+        case "string": {
+            const constraints = formatChecks(checks);
+            return constraints.length > 0 ? `(string [${constraints}])` : `(string)`;
+        }
+        case "number": {
+            // const constraints = formatChecks(checks);
+            // return constraints.length > 0 ? `(number [${constraints}])` : `(number)`;
+            return `(number)`;
+        }
+        case "optional": {
+            const inner = zod4ToSexpr(def.innerType, depth + 1);
+            return `(optional ${inner})`;
+        }
+        case "nullable": {
+            const inner = zod4ToSexpr(def.innerType, depth + 1);
+            return `(nullable ${inner})`;
+        }
+        case "nonoptional": {
+            const inner = zod4ToSexpr(def.innerType, depth + 1);
+            return `(nonoptional ${inner})`;
+        }
+        case "array": {
+            const inner = zod4ToSexpr(def.element, depth + 1);
+            return `(array ${inner})`;
+        }
+        case "bigint": {
+            return `(bigint)`;
+        }
+        case "boolean": {
+            return `(boolean)`;
+        }
+        case "symbol": {
+            return `(symbol)`;
+        }
+        case "undefined": {
+            return `(undefined)`;
+        }
+        case "null": {
+            return `(null)`;
+        }
+        case "any": {
+            return `(any)`;
+        }
+        default: {
+            return `(unknown-type ${type || "?"})`;
+        }
+    }
+    // console.log("unknown type", def);
+    // if (type === "number") {
+    //   const constraints = formatChecks(checks);
+    //   return constraints.length > 0 ? `(number [${constraints}])` : `(number)`;
+    // }
+}
+function breakLine(sexpr, depth) {
+    // return sexpr.length > 80
+    //   ? `\n${"  ".repeat(depth)}${sexpr}\n${"  ".repeat(depth)}`
+    //   : sexpr;
+    return sexpr;
+}
+function formatChecks(checks) {
+    return checks.map((check) => formatCheck(check)).join(" ");
+}
+function formatCheck(_check) {
+    const check = _check;
+    const def = check._zod.def;
+    switch (def.check) {
+        case "min_length":
+            return `min:${def.minimum}`;
+        case "max_length":
+            return `max:${def.maximum}`;
+        case "length_equals":
+            return `length:${def.length}`;
+        case "string_format":
+            return parseStringFormat(check);
+        // case "bigint_format":
+        //   return `bigint_format=${def.format}`;
+        // case "number_format":
+        //   return `number_format=${def.format}`;
+        case "greater_than":
+            return `${def.inclusive ? ">=" : ">"}${def.value}`;
+        case "less_than":
+            return `${def.inclusive ? "<=" : "<"}${def.value}`;
+        // case "max_size":
+        //   return `max_size=${def.maximum}`;
+        // case "min_size":
+        //   return `min_size=${def.minimum}`;
+        // case "mime_type":
+        //   return `mime_type=${def.mime}`;
+        // case "multiple_of":
+        //   return `multiple_of=${def.value}`;
+        // case "size_equals":
+        //   return `size_equals=${def.size}`;
+        // case undefined: {
+        //   return `[unknown ${inspect(def, { colors: true })}]`;
+        // }
+        default:
+            return `[${def.check} ?]`;
+    }
+}
+function parseStringFormat(_check) {
+    const check = _check;
+    const def = check._zod.def;
+    const coerce = "coerce" in def ? `coerce:${def.coerce} ` : "";
+    if (def.format === "starts_with") {
+        return `starts_with:"${def.prefix}"`;
+    }
+    else if (def.format === "ends_with") {
+        return `ends_with:"${def.suffix}"`;
+    }
+    else if (def.format === "includes") {
+        return `includes:"${def.includes}"`;
+    }
+    else if (def.format === "regex") {
+        return `regex:${def.pattern}`;
+    }
+    else if (def.format === "uuid") {
+        return `format:uuid${def.version || ""}`;
+    }
+    else if (def.format === "xid") {
+        return `format:xid`;
+    }
+    else if (def.format === "url") {
+        const opts = [
+            def.normalize ? `normalize` : null,
+            def.hostname ? `hostname:${def.hostname}` : null,
+            def.protocol ? `protocol:${def.protocol}` : null,
+        ]
+            .filter(Boolean)
+            .join(", ");
+        return `format:url${opts.length > 0 ? `(${opts})` : ""}`;
+    }
+    return `${coerce}format:${def.format}`;
+}
+function zodObjectToSexpr(schema, level = 0) {
+    if (!("_zod" in schema)) {
+        throw new Error("Invalid schema provided, make sure you are using zod v4 as zod v3 is currently not supported.");
+    }
+    const def = schema._zod.def;
+    let sexpr = `(${def.type}${def.checks ? ` ${formatChecks(def.checks)}` : ""}`;
+    for (const [propName, propSchema] of Object.entries(def.shape)) {
+        sexpr += `${zod4ToSexpr(propSchema, level + 1)}\n`;
+    }
+    sexpr += ")";
+    return sexpr;
+}

package/lib/surql.js

@@ -0,0 +1,351 @@
+import { BoundQuery, escapeIdent, escapeIdPart, RecordId, surql, Table, } from "surrealdb";
+import * as z4 from "zod/v4/core";
+import z from "zod";
+import dedent from "dedent";
+export function zodToSurql(options) {
+    const table = typeof options.table === "string"
+        ? new Table(options.table)
+        : options.table;
+    const schema = options.schema;
+    if (!("_zod" in schema)) {
+        throw new Error("Invalid schema provided, make sure you are using zod v4 as zod v3 is currently not supported.");
+    }
+    const def = schema._zod.def;
+    const shape = def.shape;
+    const query = defineTable(options);
+    for (const [key, value] of Object.entries(shape)) {
+        query.append(defineField({ name: key, table, type: value, exists: options.exists }));
+    }
+    // @ts-expect-error - extend is not a method of z4.$ZodObject
+    return [schema.extend({ id: z.any() }), query];
+}
+function defineTable(options) {
+    const table = typeof options.table === "string"
+        ? new Table(options.table)
+        : options.table;
+    const query = surql `DEFINE TABLE`;
+    if (options.exists === "ignore") {
+        query.append(" IF NOT EXISTS");
+    }
+    else if (options.exists === "overwrite") {
+        query.append(" OVERWRITE");
+    }
+    // Looks like passing Table instance is not supported yet
+    query.append(` ${escapeIdPart(table.name)}`);
+    if (options.drop) {
+        query.append(" DROP");
+    }
+    if (options.schemafull) {
+        query.append(" SCHEMAFULL");
+    }
+    else {
+        query.append(" SCHEMALESS");
+    }
+    if (options.comment) {
+        query.append(surql ` COMMENT ${options.comment}`);
+    }
+    query.append(";\n");
+    return query;
+}
+function defineField(options) {
+    const name = options.name;
+    const table = typeof options.table === "string"
+        ? new Table(options.table)
+        : options.table;
+    const schema = options.type;
+    if (!("_zod" in schema)) {
+        throw new Error("Invalid field schema provided, make sure you are using zod v4 as zod v3 is currently not supported.");
+    }
+    const context = {
+        name,
+        table,
+        rootSchema: schema,
+        children: [],
+        asserts: [],
+        transforms: [],
+    };
+    const query = surql `DEFINE FIELD`;
+    if (options.exists === "ignore") {
+        query.append(" IF NOT EXISTS");
+    }
+    else if (options.exists === "overwrite") {
+        query.append(" OVERWRITE");
+    }
+    query.append(` ${name} ON TABLE ${table.name}`);
+    const type = zodTypeToSurrealType(schema, [], context);
+    query.append(` TYPE ${type}`);
+    if (context.default) {
+        query.append(context.default.always
+            ? ` DEFAULT ALWAYS ${JSON.stringify(context.default.value)}`
+            : ` DEFAULT ${JSON.stringify(context.default.value)}`);
+    }
+    if (context.transforms.length > 0) {
+        query.append(` VALUE {\n`);
+        for (const transform of context.transforms) {
+            query.append(dedent.withOptions({ alignValues: true }) `
+          //
+              ${transform}\n`.slice(3));
+        }
+        query.append(`}`);
+    }
+    if (context.asserts.length > 0) {
+        query.append(` ASSERT {\n`);
+        for (const assert of context.asserts) {
+            query.append(dedent.withOptions({ alignValues: true }) `
+          //
+              ${assert}\n`.slice(3));
+        }
+        query.append(`}`);
+    }
+    query.append(`;\n`);
+    if (context.children.length > 0) {
+        for (const { name: childName, type: childType } of context.children) {
+            query.append(defineField({
+                name: `${name}.${childName}`,
+                table,
+                type: childType,
+                exists: options.exists,
+            }));
+        }
+    }
+    return query;
+}
+export function zodTypeToSurrealType(type, parents = [], context) {
+    const schema = type;
+    if (!("_zod" in schema)) {
+        throw new Error("Invalid schema provided, make sure you are using zod v4 as zod v3 is currently not supported.");
+    }
+    const def = schema._zod.def;
+    const checks = getChecks(schema);
+    parseChecks(context.name, checks, context, def.type);
+    // console.log(zodToSexpr(type));
+    switch (def.type) {
+        case "string":
+            return "string";
+        case "boolean":
+            return "bool";
+        case "object": {
+            const isInArray = context.rootSchema._zod.def.type === "array";
+            // TODO: remove any
+            for (const [key, value] of Object.entries(def.shape)) {
+                context.children.push({
+                    name: isInArray ? `*.${key}` : key,
+                    // TODO: remove as
+                    type: value,
+                });
+            }
+            return "object";
+        }
+        case "number":
+            return "number";
+        case "null":
+            return "NULL";
+        // case "bigint":
+        //   return "bigint";
+        // case "symbol":
+        //   return "symbol";
+        case "any": {
+            //===============================
+            // Surreal Specific Types
+            //===============================
+            if ("surrealType" in def) {
+                if (def.surrealType === "record_id") {
+                    if (def.what) {
+                        return `record<${Object.keys(def.what).join(" | ")}>`;
+                    }
+                    else {
+                        return "record";
+                    }
+                }
+            }
+            return "any";
+        }
+        case "undefined": {
+            return "NONE";
+        }
+        case "default": {
+            // if (typeof def.defaultValue === "function") {
+            //   context.default = { value: def.defaultValue(), always: false };
+            // } else {
+            // console.log(
+            //   "default",
+            //   Object.getOwnPropertyDescriptor(def, "defaultValue").get?.toString(),
+            // );
+            // TODO: remove any
+            context.default = { value: def.defaultValue, always: false };
+            // }
+            return zodTypeToSurrealType(
+            // TODO: remove any
+            def.innerType, [...parents, def.type], context);
+        }
+        case "nullable": {
+            const inner = zodTypeToSurrealType(
+            // TODO: remove any
+            def.innerType, [...parents, def.type], context);
+            if (parents.includes("nullable")) {
+                return inner;
+            }
+            return `${inner} | NULL`;
+        }
+        case "optional": {
+            const inner = zodTypeToSurrealType(
+            // TODO: remove any
+            def.innerType, [...parents, def.type], context);
+            if (parents.includes("optional") || parents.includes("nonoptional")) {
+                return inner;
+            }
+            return `option<${inner}>`;
+        }
+        case "nonoptional": {
+            // just a marker for children optional to skip the option<...> wrapper
+            return zodTypeToSurrealType(
+            // TODO: remove any
+            def.innerType, [...parents, def.type], context);
+        }
+        case "union": {
+            // TODO: remove any
+            return (def.options
+                // TODO: remove any
+                .map((option) => zodTypeToSurrealType(option, [...parents, def.type], context))
+                .join(" | "));
+        }
+        case "array": {
+            const inner = zodTypeToSurrealType(
+            // TODO: remove any
+            def.element, [...parents, def.type], context);
+            return `array<${inner}>`;
+        }
+        case "custom": {
+            return "any";
+        }
+        default: {
+            console.log("unknown type", def.type);
+            return "any";
+        }
+    }
+}
+function getChecks(_schema) {
+    const schema = _schema;
+    const checks = schema._zod.def.checks ?? [];
+    if ("check" in schema._zod.def) {
+        checks.unshift(schema);
+    }
+    return checks;
+}
+function parseChecks(name, checks, context, type) {
+    for (const check of checks) {
+        const { transform, assert } = parseCheck(name, check, type);
+        if (transform) {
+            context.transforms.push(transform);
+        }
+        if (assert) {
+            context.asserts.push(assert);
+        }
+    }
+}
+export const checkMap = {
+    min_length(name, value, type) {
+        if (type === "array") {
+            return `$value.len() >= ${value} || { THROW 'Field "${name}" must have at least ${value} ${value === 1 ? "item" : "items"}' };`;
+        }
+        if (type === "string") {
+            return `$value.len() >= ${value} || { THROW 'Field "${name}" must be at least ${value} ${value === 1 ? "character" : "characters"} long' };`;
+        }
+        throw new Error(`Invalid type: ${type}`);
+    },
+    max_length(name, value, type) {
+        if (type === "array") {
+            return `$value.len() <= ${value} || { THROW 'Field "${name}" must have at most ${value} ${value === 1 ? "item" : "items"}' };`;
+        }
+        if (type === "string") {
+            return `$value.len() <= ${value} || { THROW 'Field "${name}" must be at most ${value} ${value === 1 ? "character" : "characters"} long' };`;
+        }
+        throw new Error(`Invalid type: ${type}`);
+    },
+    greater_than(name, value, inclusive) {
+        return `$value ${inclusive ? ">=" : ">"} ${value} || { THROW 'Field "${name}" must be greater than ${inclusive ? "or equal to" : ""} ${value}' };`;
+    },
+    less_than(name, value, inclusive) {
+        return `$value ${inclusive ? "<=" : "<"} ${value} || { THROW 'Field "${name}" must be less than ${inclusive ? "or equal to" : ""} ${value}' };`;
+    },
+    length_equals(name, value, type = "string") {
+        if (type === "array") {
+            return `$value.len() == ${value} || { THROW 'Field "${name}" must have exactly ${value} ${value === 1 ? "item" : "items"}' };`;
+        }
+        if (type === "string") {
+            return `$value.len() == ${value} || { THROW 'Field "${name}" must be exactly ${value} ${value === 1 ? "character" : "characters"} long' };`;
+        }
+        throw new Error(`Invalid type: ${type}`);
+    },
+    string_format: {
+        email: (name) => {
+            const regex = /^[A-Za-z0-9'_+-]+(?:\.[A-Za-z0-9'_+-]+)*@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
+            return `string::matches($value, ${regex}) || { THROW "Field '${name}' must be a valid email address" };`;
+        },
+        url: (name, def) => {
+            return dedent `
+        LET $url = {
+            scheme: parse::url::scheme($value),
+            host: parse::url::host($value),
+            domain: parse::url::domain($value),
+            path: parse::url::path($value),
+            port: parse::url::port($value),
+            query: parse::url::query($value),
+            hash: parse::url::fragment($value),
+        };
+        $url.scheme || { THROW "Field '${name}' must be a valid URL" };
+        ${def?.hostname
+                ? `($url.host ?? "").matches(${def.hostname}) || { THROW "Field '${name}' must match hostname ${def.hostname.toString().replace(/\\/g, "\\\\")}" };`
+                : ""}
+        ${def?.protocol
+                ? `($url.scheme ?? "").matches(${def.protocol}) || { THROW "Field '${name}' must match protocol ${def.protocol.toString().replace(/\\/g, "\\\\")}" };`
+                : ""}
+        $url.scheme + "://" + ($url.host ?? "") + (
+            IF $url.port && (
+                ($url.scheme == "http" && $url.port != 80) ||
+                ($url.scheme == "https" && $url.port != 443)
+            ) { ":" + <string>$url.port } ?? ""
+        )
+        + ($url.path ?? "")
+        + (IF $url.query { "?" + $url.query } ?? "")
+        + (IF $url.fragment { "#" + $url.fragment } ?? "");
+      `;
+        },
+    },
+};
+function parseCheck(name, _check, type) {
+    const check = _check;
+    const def = check._zod.def;
+    switch (def.check) {
+        case "min_length":
+            return { assert: checkMap.min_length(name, def.minimum, type) };
+        case "max_length":
+            return { assert: checkMap.max_length(name, def.maximum, type) };
+        case "greater_than":
+            return { assert: checkMap.greater_than(name, def.value, def.inclusive) };
+        case "less_than":
+            return { assert: checkMap.less_than(name, def.value, def.inclusive) };
+        case "length_equals":
+            return { assert: checkMap.length_equals(name, def.length, type) };
+        case "string_format":
+            return assertionForStringFormat(name, check);
+        default:
+            return { assert: `THROW 'Unknown check: ${def.check}';` };
+    }
+}
+// Remove look-around, look-behind, and look-ahead as they are not supported by SurrealDB
+function assertionForStringFormat(name, _check) {
+    const check = _check;
+    const def = check._zod.def;
+    switch (def.format) {
+        case "email": {
+            return { assert: checkMap.string_format.email(name) };
+        }
+        case "url": {
+            const code = checkMap.string_format.url(name, def);
+            return def.normalize ? { transform: code } : { assert: code };
+        }
+        default:
+            return { assert: `THROW 'Unsupported string format: ${def.format}';` };
+    }
+}

package/lib/zod.js

@@ -0,0 +1,126 @@
+import { RecordId } from "surrealdb";
+import z4 from "zod/v4";
+import * as core from "zod/v4/core";
+export const SurrealZodType = core.$constructor("SurrealZodType", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodType.init(inst, def);
+    inst._surreal = true;
+    return inst;
+});
+export const SurrealZodAny = core.$constructor("SurrealZodAny", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodAny.init(inst, def);
+    SurrealZodType.init(inst, def);
+});
+export function any() {
+    return core._any(SurrealZodAny);
+}
+export const SurrealZodBoolean = core.$constructor("SurrealZodBoolean", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodBoolean.init(inst, def);
+    SurrealZodType.init(inst, def);
+    // const originalDefault = inst.default;
+    // inst.default = (defaultValue?: any) => {
+    //   if (typeof defaultValue === "function") {
+    //     throw new TypeError(
+    //       "Functions for default values are not supported in surreal-zod",
+    //     );
+    //   }
+    //   return originalDefault(defaultValue);
+    // };
+});
+export function boolean(params) {
+    return core._boolean(SurrealZodBoolean, params);
+}
+export const SurrealZodString = core.$constructor("SurrealZodString", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodString.init(inst, def);
+    SurrealZodType.init(inst, def);
+});
+export function string(params) {
+    return core._string(SurrealZodString, params);
+}
+export const SurrealZodObject = core.$constructor("SurrealZodObject", (inst, def) => {
+    // TODO: Inline implementation and use core instead
+    // @ts-expect-error - unknown assertion error
+    z4.ZodObject.init(inst, def);
+    SurrealZodType.init(inst, def);
+});
+export function object(shape, params) {
+    const def = {
+        type: "object",
+        shape: shape ?? {},
+        ...core.util.normalizeParams(params),
+    };
+    return new SurrealZodObject(def);
+}
+export const SurrealZodRecordId = core.$constructor("SurrealZodRecordId", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodAny.init(inst, def);
+    SurrealZodType.init(inst, def);
+    inst._surreal = true;
+    inst._zod.parse = (payload, _ctx) => {
+        if (payload.value instanceof RecordId) {
+            if (def.what) {
+                if (def.what[payload.value.table.name] === undefined) {
+                    payload.issues.push({
+                        code: "invalid_value",
+                        values: Object.keys(def.what),
+                        input: payload.value.table.name,
+                        message: `Expected record table to be one of ${Object.keys(def.what).join(" | ")} but found ${payload.value.table.name}`,
+                    });
+                }
+            }
+            // } else if (typeof payload.value === "string") {
+            //   let tablePart = '';
+            //   let idPart = '';
+            //   let quote = '';
+            //   for (let i = 0; i < payload.value.length; i++) {
+            //     const char = payload.value[i];
+            //     if (char === '`') {
+            //       if (quote === '`') {
+            //         tablePart = payload.value.slice(1, i);
+            //       } else quote = '`';
+            //     }
+            //     if (char === ':') {
+            //       tablePart = payload.value.slice(0, charIndex);
+            //       idPart = payload.value.slice(tablePart.length + 1);
+            //       break;
+            //     }
+            //     tablePart += char;
+            //   }
+            //   for (const char of payload.value.slice(tablePart.length + 1)) {
+            //     idPart += char;
+            //   }
+            //   if (/^(`|\u27e8)/.test(payload.value)) {
+            //     payload.value = new RecordId(payload.value.split(":")[0], payload.value.split(":")[1]);
+            //   } else {
+            //     payload.issues.push({
+            //       code: 'invalid_format',
+            //       format: 'record_id',
+            //       message: 'Invalid record id format',
+            //     });
+            //   }
+        }
+        else {
+            payload.issues.push({
+                code: "invalid_type",
+                expected: "custom",
+                input: payload.value,
+            });
+        }
+        return payload;
+    };
+    return inst;
+});
+export function recordId(what, innerType) {
+    return new SurrealZodRecordId({
+        // Zod would not be happy if we have a custom type here, so we use any
+        type: "any",
+        surrealType: "record_id",
+        what: what
+            ? Object.freeze(Object.fromEntries(what.map((v) => [v, v])))
+            : undefined,
+        innerType: innerType ?? any(),
+    });
+}