surreal-zod 0.0.0-alpha.11 → 0.0.0-alpha.12

package/lib/surql.js

@@ -1,7 +1,9 @@
-import { BoundQuery, escapeIdent, escapeIdPart, RecordId, surql, Table, } from "surrealdb";
-import * as z4 from "zod/v4/core";
-import z from "zod";
+import { BoundQuery, escapeIdent, escapeIdPart, surql, Table, toSurqlString as baseToSurqlString, } from "surrealdb";
+import * as core from "zod/v4/core";
+import * as _schema_ from "./zod/schema";
+import * as _core_ from "./zod/core";
 import dedent from "dedent";
+const OPEN_ISSUE_FOR_SUPPORT = " If you need this, please open an issue on the repository so we can look into your use case and possible implementation. https://github.com/msanchezdev/surreal-zod/issues";
 export function tableToSurql(table, statement, options) {
     if (statement === "define") {
         return defineTable(table, options);
@@ -81,31 +83,45 @@ export function defineTable(schema, options) {
     query.append(";\n");
     if (options?.fields) {
         for (const [fieldName, fieldSchema] of Object.entries(def.fields)) {
+            let defaultValue;
+            let comment;
+            let readonly;
+            let assert;
+            let value;
+            if (fieldSchema instanceof _schema_.ZodSurrealField) {
+                defaultValue = fieldSchema._zod.def.surreal.field?.default;
+                comment = fieldSchema._zod.def.surreal.field?.comment;
+                readonly = fieldSchema._zod.def.surreal.field?.readonly;
+                assert = fieldSchema._zod.def.surreal.field?.assert;
+                value = fieldSchema._zod.def.surreal.field?.value;
+            }
             query.append(defineField(fieldName, table.name, fieldName === "id"
                 ? fieldSchema._zod.def.innerType
                 : fieldSchema, {
                 exists: options.exists,
                 schemafull: surreal.schemafull,
+                default: defaultValue,
+                comment,
+                readonly,
+                assert,
+                value,
+                // @ts-expect-error - @internal
+                // We need to add the table schema to the fullParents set to avoid
+                // infinite recursion. Child fields keep a separate context from
+                // the table or other fields.
+                // The resting point for fullParents is in the inferSurrealType function,
+                // on the switch case for the "lazy" type.
+                fullParents: new Set([schema]),
             }));
         }
     }
     return query;
 }
-export function isNormalTable(table) {
-    return table._zod.def.surreal.tableType === "normal";
-}
 export function isRelationTable(table) {
-    return table._zod.def.surreal.tableType === "relation";
+    return (table instanceof _schema_.ZodSurrealTable &&
+        table._zod.def.surreal.tableType === "relation");
 }
-function defineField(name, table, schema, options) {
-    // const context: ZodSurrealTypeContext = {
-    //   name,
-    //   table,
-    //   rootSchema: schema,
-    //   children: [],
-    //   asserts: [],
-    //   transforms: [],
-    // };
+export function defineField(name, table, schema, options) {
     const query = surql `DEFINE FIELD`;
     if (options?.exists === "ignore") {
         query.append(" IF NOT EXISTS");
@@ -117,23 +133,37 @@ function defineField(name, table, schema, options) {
     const context = {
         type: new Set(),
         depth: 0,
+        parents: new Set(),
+        // @ts-expect-error - @internal
+        fullParents: options?.fullParents ?? new Set(),
         children: [],
         flexible: false,
     };
-    query.append(` TYPE ${inferSurrealType(schema, context)}`);
+    query.append(` TYPE ${inferSurrealType(schema, context).type}`);
     if (options?.schemafull && context.flexible) {
         query.append(" FLEXIBLE");
     }
-    // if (options.exists === "ignore") {
-    //   query.append(" IF NOT EXISTS");
-    // } else if (options.exists === "overwrite") {
-    //   query.append(" OVERWRITE");
-    // }
-    // query.append(` ${name} ON TABLE ${table.name}`);
+    if (options?.readonly) {
+        query.append(" READONLY");
+    }
+    if (options?.default) {
+        query.append(options.default.always
+            ? ` DEFAULT ALWAYS ${formatQuery(inlineQueryParameters(options.default.value))}`
+            : ` DEFAULT ${formatQuery(inlineQueryParameters(options.default.value))}`);
+    }
+    if (options?.value) {
+        query.append(` VALUE ${inlineQueryParameters(options.value)}`);
+    }
+    if (options?.assert) {
+        query.append(` ASSERT ${inlineQueryParameters(options.assert)}`);
+    }
+    if (options?.comment) {
+        query.append(` COMMENT ${JSON.stringify(options.comment)}`);
+    }
     // const type =
     //   name === "id"
     //     ? inferSurrealType(
-    //         (schema as unknown as SurrealZodRecordId)._zod.def.innerType,
+    //         (schema as unknown as ZodSurrealRecordId)._zod.def.innerType,
     //         [],
     //         context,
     //       )
@@ -170,273 +200,639 @@ function defineField(name, table, schema, options) {
     // }
     query.append(`;\n`);
     if (context.children.length > 0) {
+        context.fullParents.add(schema);
         for (const { name: childName, type: childType } of context.children) {
-            query.append(defineField(`${escapeIdent(name)}.${escapeIdent(childName)}`, table, childType, {
+            query.append(defineField(`${escapeIdent(name)}.${childName === "*" ? childName : escapeIdent(childName)}`, table, childType, {
                 exists: options?.exists,
+                // @ts-expect-error - @internal
+                fullParents: context.fullParents,
             }));
         }
     }
     return query;
 }
+function createContext(override) {
+    return {
+        type: new Set(),
+        depth: 0,
+        parents: new Set(),
+        fullParents: new Set(),
+        children: [],
+        flexible: false,
+        ...override,
+    };
+}
 export function inferSurrealType(type, context) {
+    context ??= createContext();
+    function enter(type, ctx) {
+        context ??= createContext();
+        if (context.parents.has(type)) {
+            console.warn("Recursive type detected", type._zod.def.type);
+            context.type.add("any");
+            // throw new Error("Recursive type detected");
+            return { type: "any", context };
+        }
+        const newContext = ctx
+            ? {
+                children: [],
+                flexible: false,
+                type: new Set(),
+                depth: context.depth + 1,
+                ...(typeof ctx === "object" ? ctx : {}),
+                parents: context.parents,
+                fullParents: context.fullParents,
+            }
+            : context;
+        context.parents.add(type);
+        context.fullParents.add(type);
+        const result = inferSurrealType(type, newContext);
+        context.fullParents.delete(type);
+        context.parents.delete(type);
+        return result;
+    }
     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.");
+        throw new Error("Invalid schema provided, make sure you are using zod v4+");
     }
-    // if ("surreal" in schema._zod.def) {
-    //   return schema._zod.def.surreal.type;
-    // } else {
-    //   throw new Error(
-    //     // @ts-expect-error - zod core not supported
-    //     `Invalid surreal schema provided. Received ${schema._zod.def.type}`,
-    //   );
-    // }
+    // console.log(schema);
     const def = schema._zod.def;
-    const childIndent = "  ".repeat(context.depth + 1);
     // const checks = getChecks(schema);
     // parseChecks(context.name, checks, context, def.type);
     // console.log(zodToSexpr(type));
-    switch (def.surreal?.type ?? def.type) {
-        case "any":
-        case "unknown": {
-            context.type.add("any");
-            break;
-        }
-        case "never":
-        case "undefined": {
-            context.type.add("none");
-            break;
-        }
-        case "optional": {
-            inferSurrealType(type._zod.def.innerType, context);
-            context.type.add("none");
-            break;
-        }
-        case "nonoptional": {
-            inferSurrealType(type._zod.def.innerType, context);
-            if (context.type.size > 1 && context.type.has("none")) {
-                context.type.delete("none");
+    // console.log(def);
+    if (def.surreal.type) {
+        context.type.add(def.surreal.type);
+    }
+    else
+        switch ( /* isSurrealZodSchemaDef(def) ? */def.type /*: def.type*/) {
+            // case "record_id": {
+            //   const table = (def as ZodSurrealdRecordId["_zod"]["def"]).table;
+            //   if (table) {
+            //     context.type.add(`record<${table.map(escapeIdent).join(" | ")}>`);
+            //   } else {
+            //     context.type.add("record");
+            //   }
+            //   break;
+            // }
+            // case "uuid": {
+            //   context.type.add("uuid");
+            //   break;
+            // }
+            // case "table": {
+            //   throw new Error(
+            //     `Table type cannot be used as a field type.${OPEN_ISSUE_FOR_SUPPORT}`,
+            //   );
+            // }
+            // case "void":
+            // case "never":
+            // case "undefined": {
+            //   context.type.add("none");
+            //   break;
+            // }
+            case "optional": {
+                enter(def.innerType);
+                context.type.add("none");
+                break;
             }
-            break;
-        }
-        case "null": {
-            context.type.add("null");
-            break;
-        }
-        case "nullable": {
-            inferSurrealType(type._zod.def.innerType, context);
-            context.type.add("null");
-            break;
-        }
-        case "boolean": {
-            context.type.add("bool");
-            break;
-        }
-        case "string": {
-            context.type.add("string");
-            break;
-        }
-        case "bigint":
-        case "number": {
-            context.type.add("number");
-            break;
-        }
-        case "object": {
-            const _schema = schema;
-            const shape = _schema._zod.def.shape;
-            const catchall = _schema._zod.def.catchall;
-            const isStrict = catchall?._zod.traits.has("$ZodNever");
-            const isLoose = catchall?._zod.traits.has("$ZodUnknown");
-            // buggy syntax
-            // if (isStrict) {
-            //   let type = "{";
-            //   if (Object.keys(shape).length > 0) {
-            //     type += "\n";
+            case "nonoptional": {
+                enter(def.innerType);
+                if (context.type.size > 1 && context.type.has("none")) {
+                    context.type.delete("none");
+                }
+                break;
+            }
+            case "nullable": {
+                enter(def.innerType);
+                context.type.add("null");
+                break;
+            }
+            // case "boolean": {
+            //   context.type.add("bool");
+            //   break;
+            // }
+            // case "string": {
+            //   // Needs override, this will not work with original zod types
+            //   // if (isStringFormat(def)) {
+            //   //   switch (def.format) {
+            //   //     case "uuid":
+            //   //     case "guid":
+            //   //       context.type.add("uuid");
+            //   //       break TYPE_CHECK;
+            //   //   }
+            //   // }
+            //   context.type.add("string");
+            //   break;
+            // }
+            // case "bigint": {
+            //   if (!isBigIntFormat(def as core.$ZodBigIntFormatDef)) {
+            //     context.type.add("int");
+            //     break;
             //   }
-            //   for (const [key, value] of Object.entries(shape)) {
-            //     const childContext: ZodSurrealTypeContext = {
-            //       type: new Set(),
-            //       depth: context.depth + 1,
-            //       children: [],
-            //     };
-            //     type += `${childIndent}${escapeIdent(key)}: ${inferSurrealType(value, childContext)},\n`;
+            //   switch ((def as core.$ZodBigIntFormatDef).format) {
+            //     case "int64":
+            //     case "uint64":
+            //       context.type.add("int");
+            //       break;
+            //     default:
+            //       throw new Error(
+            //         `Unsupported bigint format: ${(def as core.$ZodBigIntFormatDef).format}`,
+            //       );
             //   }
-            //   type += "}";
-            //   context.type.add(type);
             //   break;
             // }
-            context.type.add("object");
-            if (isLoose)
-                context.flexible = true;
-            for (const [key, value] of Object.entries(shape)) {
-                context.children.push({ name: key, type: value });
+            // case "number": {
+            //   if (!isNumberFormat(def as core.$ZodNumberDef)) {
+            //     context.type.add("number");
+            //     break;
+            //   }
+            //   switch ((def as core.$ZodNumberFormatDef).format) {
+            //     case "uint32":
+            //     case "safeint":
+            //     case "int32":
+            //       context.type.add("int");
+            //       break;
+            //     case "float64":
+            //     case "float32":
+            //       context.type.add("float");
+            //       break;
+            //     default:
+            //       throw new Error(
+            //         `Unsupported number format: ${(def as core.$ZodNumberFormatDef).format}. ${OPEN_ISSUE_FOR_SUPPORT}`,
+            //       );
+            //   }
+            //   break;
+            // }
+            // case "date": {
+            //   context.type.add("datetime");
+            //   break;
+            // }
+            case "object": {
+                const shape = def.shape;
+                const catchall = def.catchall;
+                const isStrict = catchall?._zod.traits.has("$ZodNever");
+                const isLoose = catchall?._zod.traits.has("$ZodUnknown");
+                // buggy syntax
+                // if (isStrict) {
+                //   let type = "{";
+                //   if (Object.keys(shape).length > 0) {
+                //     type += "\n";
+                //   }
+                //   for (const [key, value] of Object.entries(shape)) {
+                //     const childContext: ZodSurrealTypeContext = {
+                //       type: new Set(),
+                //       depth: context.depth + 1,
+                //       children: [],
+                //     };
+                //     type += `${childIndent}${escapeIdent(key)}: ${inferSurrealType(value, childContext).inner},\n`;
+                //   }
+                //   type += "}";
+                //   context.type.add(type);
+                //   break;
+                // }
+                context.type.add("object");
+                if (isLoose)
+                    context.flexible = true;
+                for (const [key, value] of Object.entries(shape)) {
+                    context.children.push({ name: key, type: value });
+                }
+                break;
             }
-            break;
-        }
-        case "record_id": {
-            const table = def.table;
-            if (table) {
-                context.type.add(`record<${table.map(escapeIdent).join(" | ")}>`);
+            case "array": {
+                const { type: element } = enter(def.element, true);
+                if (element === "any") {
+                    context.type.add("array");
+                    break;
+                }
+                context.type.add(`array<${element}>`);
+                break;
             }
-            else {
-                context.type.add("record");
+            case "set": {
+                const { type: element } = enter(def.valueType, true);
+                if (element === "any") {
+                    context.type.add("array");
+                    break;
+                }
+                context.type.add(`array<${element}>`);
+                break;
+            }
+            case "enum": {
+                const values = def.entries;
+                for (const key in values) {
+                    const value = values[key];
+                    context.type.add(toSurqlString(value));
+                }
+                break;
+            }
+            case "union": {
+                for (const option of def.options) {
+                    // context.type.add(inferSurrealType(option, context).inner);
+                    enter(option);
+                }
+                break;
+            }
+            // case "intersection": {
+            //   // TODO: Find a way to handle intersections
+            //   // Maybe a new function where we build a new object schema (or primitive one)
+            //   // And keep track of all the types that are used in the intersection
+            //   //
+            //   // const left = def.left;
+            //   // const right = def.right;
+            //   // inferSurrealType(left, context);
+            //   // inferSurrealType(right, context);
+            //   // inferSurrealType(z.never(), context);
+            //   // context.type.add("any");
+            //   context.type.add("any");
+            //   break;
+            // }
+            case "tuple": {
+                if (def.rest) {
+                    context.type.add("array");
+                    break;
+                }
+                const types = new Set();
+                for (const item of def.items) {
+                    types.add(enter(item, true).type);
+                }
+                context.type.add(`[${Array.from(types).join(", ")}]`);
+                break;
+            }
+            // case "record": {
+            //   context.type.add("object");
+            //   // Currently there is no way to restrict the key type of an object, so we just use *
+            //   // context.children.push({ name: "*", type: def.keyType });
+            //   // All commented out code is because of this. Check is only done in JS side.
+            //   enter((def as core.$ZodRecordDef).keyType, true);
+            //   /* const isPartial =
+            //     def.keyType._zod.values === undefined &&
+            //     !keyContext.type.has("string") &&
+            //     !keyContext.type.has("number") &&
+            //     !keyContext.type.has("int") &&
+            //     !keyContext.type.has("float") &&
+            //     !keyContext.type.has("decimal"); */
+            //   context.children.push({
+            //     name: "*",
+            //     type: /* isPartial ? z.optional(def.valueType) : */ (
+            //       def as core.$ZodRecordDef
+            //     ).valueType,
+            //   });
+            //   break;
+            // }
+            // case "map": {
+            //   context.type.add("object");
+            //   // Currently there is no way to restrict the key type of an object, so we just use *
+            //   // Surreal doesnt have a map type, so we use object instead. We cant really support non PropertyKey values
+            //   // unless we serialize the keys to strings.
+            //   const { context: keyContext } = enter(
+            //     (def as core.$ZodMapDef).keyType,
+            //     true,
+            //   );
+            //   for (const key of keyContext.type) {
+            //     if (!["string", "number", "float", "int", "decimal"].includes(key)) {
+            //       throw new Error(`Unsupported key type: ${key}`);
+            //     }
+            //   }
+            //   context.children.push({
+            //     name: "*",
+            //     type: (def as core.$ZodMapDef).valueType,
+            //   });
+            //   break;
+            // }
+            case "literal": {
+                for (const value of def.values) {
+                    context.type.add(toSurqlString(value));
+                }
+                break;
+            }
+            case "file": {
+                throw new Error(`File type cannot be used as a field type.${OPEN_ISSUE_FOR_SUPPORT}`);
+            }
+            case "transform": {
+                break;
+            }
+            case "readonly":
+            case "catch":
+            case "prefault":
+            case "default": {
+                enter(def.innerType);
+                break;
+            }
+            case "success": {
+                context.type.add("string");
+                break;
+            }
+            case "nan": {
+                context.type.add("number");
+                break;
+            }
+            case "pipe": {
+                enter(def.in);
+                enter(def.out);
+                break;
+            }
+            case "template_literal": {
+                context.type.add("string");
+                break;
+            }
+            case "lazy": {
+                const innerType = def.getter();
+                // All that cascading to get here, we dont want to keep complex types if
+                // recursive.
+                if (context.fullParents.has(type) || context.parents.has(type)) {
+                    context.type.add("any");
+                }
+                else {
+                    enter(innerType);
+                }
+                break;
+            }
+            case "promise": {
+                // We will not support promises for now, this can be uncommented after
+                // support is added
+                // const { inner: innerType } =
+                // enter(def.innerType);
+                // context.type.add(innerType);
+                throw new Error(`Promise type cannot be used as a field type.${OPEN_ISSUE_FOR_SUPPORT}`);
+            }
+            case "function": {
+                throw new Error(`Function type cannot be used as a field type.${OPEN_ISSUE_FOR_SUPPORT}`);
+            }
+            case "custom": {
+                throw new Error(`Custom type cannot be used as a field type.${OPEN_ISSUE_FOR_SUPPORT}`);
+            }
+            case "symbol": {
+                throw new Error(`Symbol type cannot be used as a field type.${OPEN_ISSUE_FOR_SUPPORT}`);
             }
-            break;
-        }
-        case "table": {
-            throw new Error("Table type cannot be used as a field type");
         }
-    }
-    if (context.type.has("any")) {
-        return "any";
-    }
-    return Array.from(context.type).join(" | ");
+    const inner = context.type.has("any") || context.type.size === 0
+        ? "any"
+        : Array.from(context.type).join(" | ");
+    return { type: inner, context };
 }
-// function getChecks(_schema: z4.$ZodType | SurrealZodType) {
-//   const schema = _schema as z4.$ZodTypes | SurrealZodTypes;
-//   const checks = schema._zod.def.checks ?? [];
-//   if ("check" in schema._zod.def) {
-//     checks.unshift(schema as z4.$ZodCheck);
-//   }
-//   return checks;
+// function isSurrealZodSchemaDef(
+//   def: core.$ZodTypeDef | ZodSurrealTypeDef,
+// ): def is ZodSurrealTypeDef {
+//   return "surreal" in def && def.surreal.type !== undefined;
 // }
-// function parseChecks(
-//   name: string,
-//   checks: z4.$ZodCheck[],
-//   context: ZodSurrealTypeContext,
-//   type: ZodTypeName | SurrealZodTypeName,
-// ) {
-//   for (const check of checks) {
-//     const { transform, assert } = parseCheck(name, check, type);
-//     if (transform) {
-//       context.transforms.push(transform);
-//     }
-//     if (assert) {
-//       context.asserts.push(assert);
-//     }
-//   }
+// function isStringFormat(
+//   def: core.$ZodStringDef,
+// ): def is core.$ZodStringFormatTypes["_zod"]["def"] {
+//   return def.type === "string" && "format" in def;
 // }
-// export const checkMap = {
-//   never(name: string) {
-//     return `THROW 'Field "${name}" must never be present'`;
-//   },
-//   min_length(name: string, value: number, type: ZodTypeName) {
-//     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: string, value: number, type: ZodTypeName) {
-//     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: string, value: z4.util.Numeric, inclusive: boolean) {
-//     return `$value ${inclusive ? ">=" : ">"} ${value} || { THROW 'Field "${name}" must be greater than ${inclusive ? "or equal to" : ""} ${value}' };`;
-//   },
-//   less_than(name: string, value: z4.util.Numeric, inclusive: boolean) {
-//     return `$value ${inclusive ? "<=" : "<"} ${value} || { THROW 'Field "${name}" must be less than ${inclusive ? "or equal to" : ""} ${value}' };`;
-//   },
-//   length_equals(name: string, value: number, type: ZodTypeName = "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: string) => {
-//       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: string,
-//       def?: Pick<z4.$ZodCheckURLParams, "hostname" | "protocol" | "normalize">,
-//     ) => {
-//       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: string,
-//   _check: z4.$ZodCheck,
-//   type: ZodTypeName,
-// ): { transform?: string; assert?: string } {
-//   const check = _check as z4.$ZodChecks;
-//   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}';` };
-//   }
+// function isBigIntFormat(
+//   def: core.$ZodBigIntDef,
+// ): def is core.$ZodBigIntFormatDef {
+//   return def.type === "bigint" && "format" in def;
 // }
-// // Remove look-around, look-behind, and look-ahead as they are not supported by SurrealDB
-// function assertionForStringFormat(
-//   name: string,
-//   _check: z4.$ZodCheck,
-// ): { transform?: string; assert?: string } {
-//   const check = _check as z4.$ZodStringFormatChecks;
-//   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}';` };
-//   }
+// function isNumberFormat(
+//   def: core.$ZodNumberDef,
+// ): def is core.$ZodNumberFormatDef {
+//   return def.type === "number" && "format" in def;
 // }
+// // function getChecks(_schema: z4.$ZodType | SurrealZodType) {
+// //   const schema = _schema as z4.$ZodTypes | SurrealZodTypes;
+// //   const checks = schema._zod.def.checks ?? [];
+// //   if ("check" in schema._zod.def) {
+// //     checks.unshift(schema as z4.$ZodCheck);
+// //   }
+// //   return checks;
+// // }
+// // function parseChecks(
+// //   name: string,
+// //   checks: z4.$ZodCheck[],
+// //   context: ZodSurrealTypeContext,
+// //   type: ZodTypeName | SurrealZodTypeName,
+// // ) {
+// //   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 = {
+// //   never(name: string) {
+// //     return `THROW 'Field "${name}" must never be present'`;
+// //   },
+// //   min_length(name: string, value: number, type: ZodTypeName) {
+// //     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: string, value: number, type: ZodTypeName) {
+// //     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: string, value: z4.util.Numeric, inclusive: boolean) {
+// //     return `$value ${inclusive ? ">=" : ">"} ${value} || { THROW 'Field "${name}" must be greater than ${inclusive ? "or equal to" : ""} ${value}' };`;
+// //   },
+// //   less_than(name: string, value: z4.util.Numeric, inclusive: boolean) {
+// //     return `$value ${inclusive ? "<=" : "<"} ${value} || { THROW 'Field "${name}" must be less than ${inclusive ? "or equal to" : ""} ${value}' };`;
+// //   },
+// //   length_equals(name: string, value: number, type: ZodTypeName = "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: string) => {
+// //       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: string,
+// //       def?: Pick<z4.$ZodCheckURLParams, "hostname" | "protocol" | "normalize">,
+// //     ) => {
+// //       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: string,
+// //   _check: z4.$ZodCheck,
+// //   type: ZodTypeName,
+// // ): { transform?: string; assert?: string } {
+// //   const check = _check as z4.$ZodChecks;
+// //   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: string,
+// //   _check: z4.$ZodCheck,
+// // ): { transform?: string; assert?: string } {
+// //   const check = _check as z4.$ZodStringFormatChecks;
+// //   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}';` };
+// //   }
+// // }
+const SurrealQLStatements = [
+    "ACCESS",
+    "ALTER",
+    "BEGIN",
+    "BREAK",
+    "CANCEL",
+    "COMMIT",
+    "CONTINUE",
+    "CREATE",
+    "DEFINE",
+    "DELETE",
+    "FOR",
+    "IF",
+    "INFO",
+    "INSERT",
+    "KILL",
+    "LET",
+    "LIVE",
+    "REBUILD",
+    "RELATE",
+    "REMOVE",
+    "RETURN",
+    "SELECT",
+    "SHOW",
+    "SLEEP",
+    "THROW",
+    "UPDATE",
+    "UPSERT",
+    "USE",
+    "EXPLAIN",
+    "FETCH",
+];
+function hasMultipleStatements(query) {
+    let inString = false;
+    let escaping = false;
+    let statements = 0;
+    let buffer = "";
+    for (let i = 0; i < query.length; i++) {
+        const ch = query[i];
+        const nextBuffer = `${buffer}${ch}`;
+        if (ch === "\n")
+            return true;
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escaping = true;
+                continue;
+            }
+            if (ch === inString) {
+                inString = false;
+                continue;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = ch;
+            continue;
+        }
+        if (ch === " ") {
+            if (SurrealQLStatements.includes(buffer.toUpperCase())) {
+                return true;
+            }
+            continue;
+        }
+        if (ch === ";" ||
+            // Single line Comments
+            nextBuffer === "--" ||
+            nextBuffer === "//" ||
+            ch === "#") {
+            statements++;
+            buffer = "";
+            continue;
+        }
+        buffer = nextBuffer;
+        if (statements > 1)
+            return true;
+    }
+    if (statements > 0 && (buffer || inString || escaping))
+        return true;
+    return statements > 1;
+}
+export function formatQuery(query) {
+    if (hasMultipleStatements(query)) {
+        return `{\n  ${dedent.withOptions({ alignValues: true }) `  ${query.trimStart()}`}\n}`;
+    }
+    return query.trim();
+}
+export function inlineQueryParameters(query) {
+    let value = query.query;
+    for (const [paramName, paramValue] of Object.entries(query.bindings ?? {})) {
+        value = value.replace(new RegExp(`\\$${paramName}\\b`, "g"), toSurqlString(paramValue));
+    }
+    return value;
+}
+function toSurqlString(value) {
+    return baseToSurqlString(value).replace(/^s"/g, '"');
+}