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

package/lib/zod/schema.js

@@ -0,0 +1,603 @@
+/** biome-ignore-all lint/suspicious/noExplicitAny: needed for conversion */
+/** biome-ignore-all lint/style/noNonNullAssertion: needed for conversion */
+import { BoundQuery, escapeIdent, RecordId, surql, Table, } from "surrealdb";
+import * as core from "zod/v4/core";
+import * as classic from "zod/v4";
+import { defineTable, inferSurrealType, tableToSurql, } from "../surql";
+export const SurrealZodType = core.$constructor("SurrealZodType", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodType.init(inst, def);
+    // Casting as _surreal.type is built while the schema is initialized
+    inst._zod.def.surreal ??= {};
+    // base methods
+    inst.clone = (def, params) => core.clone(inst, def, params);
+    // parsing
+    inst.parse = (data, params) => {
+        return core.parse(inst, data, params);
+    };
+    // inst.safeParse = (data, params) => {
+    //   return core.safeParse(inst, data, params);
+    // };
+    // wrappers
+    inst.optional = () => optional(inst);
+    inst.nonoptional = () => nonoptional(inst);
+    inst.nullable = () => nullable(inst);
+    inst.nullish = () => nullish(inst);
+    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);
+    // surreal internals
+    inst._zod.def.surreal.type = "any";
+});
+export function any() {
+    return core._any(SurrealZodAny);
+}
+export const SurrealZodUnknown = core.$constructor("SurrealZodUnknown", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodUnknown.init(inst, def);
+    SurrealZodType.init(inst, def);
+    // surreal internals
+    inst._zod.def.surreal.type = "unknown";
+});
+export function unknown() {
+    return core._unknown(SurrealZodUnknown);
+}
+export const SurrealZodNever = core.$constructor("SurrealZodNever", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodNever.init(inst, def);
+    SurrealZodType.init(inst, def);
+    // surreal internals
+    inst._zod.def.surreal.type = "never";
+});
+export function never(params) {
+    return core._never(SurrealZodNever, params);
+}
+export const SurrealZodUndefined = core.$constructor("SurrealZodUndefined", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodUndefined.init(inst, def);
+    SurrealZodType.init(inst, def);
+    // surreal internals
+    inst._zod.def.surreal.type = "undefined";
+});
+function _undefined(params) {
+    return core._undefined(SurrealZodUndefined, params);
+}
+export { _undefined as undefined };
+export const SurrealZodNull = core.$constructor("SurrealZodNull", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodNull.init(inst, def);
+    SurrealZodType.init(inst, def);
+    // surreal internals
+    inst._zod.def.surreal.type = "null";
+});
+function _null(params) {
+    return core._null(SurrealZodNull, params);
+}
+export { _null as null };
+export const SurrealZodBoolean = core.$constructor("SurrealZodBoolean", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodBoolean.init(inst, def);
+    SurrealZodType.init(inst, def);
+    // surreal internals
+    inst._zod.def.surreal.type = "boolean";
+});
+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);
+    // surreal internals
+    inst._zod.def.surreal.type = "string";
+});
+export function string(params) {
+    return core._string(SurrealZodString, params);
+}
+export const SurrealZodNumber = core.$constructor("SurrealZodNumber", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodNumber.init(inst, def);
+    SurrealZodType.init(inst, def);
+    // surreal internals
+    inst._zod.def.surreal.type = "number";
+});
+export function number(params) {
+    return core._number(SurrealZodNumber, params);
+}
+export const SurrealZodBigInt = core.$constructor("SurrealZodBigInt", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodBigInt.init(inst, def);
+    SurrealZodType.init(inst, def);
+    // surreal internals
+    inst._zod.def.surreal.type = "bigint";
+});
+export function bigint(params) {
+    return core._bigint(SurrealZodBigInt, params);
+}
+export const SurrealZodObject = core.$constructor("SurrealZodObject", (inst, def) => {
+    // TODO: Inline implementation and use core instead
+    // @ts-expect-error - unknown assertion error
+    core.$ZodObject.init(inst, def);
+    SurrealZodType.init(inst, def);
+    // surreal internals
+    inst._zod.def.surreal.type = "object";
+    // inst._zod.def.surreal.flexible = false;
+    inst.loose = () => inst.clone({
+        ...def,
+        catchall: unknown(),
+    });
+    inst.flexible = inst.loose;
+    inst.strict = () => inst.clone({
+        ...def,
+        catchall: never(),
+    });
+    inst.extend = (incoming) => core.util.extend(inst, incoming);
+    inst.safeExtend = (incoming) => core.util.safeExtend(inst, incoming);
+});
+export function object(shape, params) {
+    const def = {
+        type: "object",
+        shape: shape ?? {},
+        ...core.util.normalizeParams(params),
+    };
+    return new SurrealZodObject({
+        ...def,
+        surreal: {
+            type: "object",
+            flexible: false,
+        },
+    });
+}
+function normalizeRecordIdDef(def) {
+    const invalidType = getInvalidRecordIdValueSchema(def.innerType);
+    if (invalidType) {
+        throw new Error(`${invalidType} is not valid as a RecordId's value`);
+    }
+    return {
+        ...def,
+    };
+}
+function getInvalidRecordIdValueSchema(schema) {
+    const def = schema._zod.def;
+    switch (def.type) {
+        case "any":
+        case "string":
+        case "number":
+            return "";
+        default:
+            return def.type;
+    }
+}
+export const SurrealZodRecordId = core.$constructor("SurrealZodRecordId", (inst, def) => {
+    SurrealZodType.init(inst, def);
+    // surreal internals
+    inst._zod.def.surreal.type = "record_id";
+    const normalized = normalizeRecordIdDef(def);
+    inst.anytable = () => {
+        return inst.clone({
+            ...def,
+            table: undefined,
+        });
+    };
+    inst.table = (table) => {
+        return inst.clone({
+            ...inst._zod.def,
+            table: Array.isArray(table) ? table : [table],
+        });
+    };
+    inst.type = (innerType) => {
+        return inst.clone({
+            ...inst._zod.def,
+            innerType,
+        });
+    };
+    inst._zod.parse = (payload, ctx) => {
+        if (payload.value instanceof RecordId) {
+            if (normalized.table &&
+                !normalized.table.includes(payload.value.table.name)) {
+                payload.issues.push({
+                    code: "invalid_value",
+                    values: normalized.table,
+                    input: payload.value.table.name,
+                    message: normalized.table.length > 1
+                        ? `Expected RecordId's table to be one of ${normalized.table.map(escapeIdent).join(" | ")} but found ${payload.value.table.name}`
+                        : `Expected RecordId's table to be ${normalized.table[0]} but found ${payload.value.table.name}`,
+                });
+            }
+            const schema = normalized.innerType._zod;
+            const result = schema.run({ value: payload.value.id, issues: [] }, ctx);
+            if (result instanceof Promise) {
+                return result.then((result) => {
+                    if (result.issues.length) {
+                        payload.issues.push(...core.util.prefixIssues("id", result.issues));
+                    }
+                    payload.value = new RecordId(payload.value.table.name, result.value);
+                    return payload;
+                });
+            }
+            else if (result.issues.length) {
+                payload.issues.push(...core.util.prefixIssues("id", result.issues));
+            }
+            payload.value = new RecordId(payload.value.table.name, result.value);
+        }
+        else {
+            payload.issues.push({
+                code: "invalid_type",
+                // TODO: Surreal specific issues
+                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",
+        table: what ? (Array.isArray(what) ? what : [what]) : undefined,
+        innerType: innerType ?? any(),
+        surreal: {
+            type: "record_id",
+        },
+    });
+}
+function handleFieldResult(result, final, field, input) {
+    if (result.issues.length) {
+        final.issues.push(...core.util.prefixIssues(field, result.issues));
+    }
+    if (result.value === undefined) {
+        if (field in input) {
+            // @ts-expect-error: field not index-checked on final.value
+            final.value[field] = undefined;
+        }
+    }
+    else {
+        // @ts-expect-error: field not index-checked on final.value
+        final.value[field] = result.value;
+    }
+}
+function handleCatchall(promises, input, payload, ctx, def, inst) {
+    const unrecognized = [];
+    const known = def.fieldNamesSet;
+    const _catchall = def.catchall._zod;
+    const type = _catchall.def.type;
+    for (const field in input) {
+        if (known.has(field))
+            continue;
+        if (type === "never") {
+            unrecognized.push(field);
+            continue;
+        }
+        const result = _catchall.run({ value: input[field], issues: [] }, ctx);
+        if (result instanceof Promise) {
+            promises.push(result.then((result) => handleFieldResult(result, payload, field, input)));
+        }
+        else {
+            handleFieldResult(result, payload, field, input);
+        }
+    }
+    if (unrecognized.length) {
+        payload.issues.push({
+            code: "unrecognized_keys",
+            keys: unrecognized,
+            input,
+            inst,
+        });
+    }
+    if (!promises.length)
+        return payload;
+    return Promise.all(promises).then(() => payload);
+}
+function normalizeTableDef(def) {
+    const fields = {};
+    const fieldNames = Object.keys(def.fields);
+    if (def.fields.id) {
+        if (def.fields.id instanceof SurrealZodRecordId) {
+            fields.id = def.fields.id.table(def.name);
+        }
+        else {
+            fields.id = recordId(def.name).type(def.fields.id);
+        }
+    }
+    else {
+        fields.id = recordId(def.name).type(any());
+        fieldNames.push("id");
+    }
+    if (def.dto && !(fields.id instanceof SurrealZodOptional)) {
+        fields.id = optional(fields.id);
+    }
+    for (const field of fieldNames) {
+        if (field === "id")
+            continue;
+        // if (!def.fields[field]?._zod.traits.has("SurrealZodType")) {
+        //   throw new Error(
+        //     `Invalid field definition for "${field}": expected a Surreal Zod schema`,
+        //   );
+        // }
+        fields[field] = def.fields[field];
+    }
+    return {
+        ...def,
+        fields,
+        fieldNames,
+        fieldNamesSet: new Set(fieldNames),
+    };
+}
+export const SurrealZodTable = core.$constructor("SurrealZodTable", (inst, def) => {
+    SurrealZodType.init(inst, def);
+    const normalized = normalizeTableDef(def);
+    // @ts-expect-error - through normalization id is always present
+    inst._zod.def.fields = normalized.fields;
+    const catchall = normalized.catchall;
+    inst.name = (name) => {
+        return inst.clone({
+            ...inst._zod.def,
+            name,
+        });
+    };
+    inst.fields = (fields) => {
+        return inst.clone({
+            ...inst._zod.def,
+            // @ts-expect-error - id may or may not be provided
+            fields,
+        });
+    };
+    inst.any = () => {
+        return inst.clone({
+            ...inst._zod.def,
+            surreal: {
+                ...inst._zod.def.surreal,
+                tableType: "any",
+            },
+        });
+    };
+    inst.normal = () => {
+        return new SurrealZodTableNormal({
+            ...inst._zod.def,
+            surreal: {
+                ...inst._zod.def.surreal,
+                tableType: "normal",
+            },
+        });
+    };
+    inst.relation = () => {
+        // @ts-expect-error - id set in constructor
+        return new SurrealZodTableRelation({
+            ...inst._zod.def,
+            // fields: {
+            //   in: recordId().type(any()),
+            //   out: recordId().type(any()),
+            //   ...def.fields,
+            // },
+            surreal: {
+                ...inst._zod.def.surreal,
+                tableType: "relation",
+            },
+        });
+    };
+    inst.comment = (comment) => {
+        return inst.clone({
+            ...inst._zod.def,
+            surreal: {
+                ...inst._zod.def.surreal,
+                comment,
+            },
+        });
+    };
+    inst.schemafull = () => {
+        return inst.clone({
+            ...inst._zod.def,
+            catchall: never(),
+            surreal: {
+                ...inst._zod.def.surreal,
+                schemafull: true,
+            },
+        });
+    };
+    inst.schemaless = () => {
+        return inst.clone({
+            ...inst._zod.def,
+            catchall: unknown(),
+            surreal: {
+                ...inst._zod.def.surreal,
+                schemafull: false,
+            },
+        });
+    };
+    inst.drop = () => {
+        return inst.clone({
+            ...inst._zod.def,
+            surreal: {
+                ...inst._zod.def.surreal,
+                drop: true,
+            },
+        });
+    };
+    inst.nodrop = () => {
+        return inst.clone({
+            ...inst._zod.def,
+            surreal: {
+                ...inst._zod.def.surreal,
+                drop: false,
+            },
+        });
+    };
+    // @ts-expect-error - through normalization id is always present
+    inst.record = () => normalized.fields.id;
+    inst.dto = () => {
+        return inst.clone({
+            ...inst._zod.def,
+            dto: true,
+        });
+    };
+    inst.entity = () => {
+        let id = normalized.fields.id;
+        while (id && id instanceof SurrealZodOptional) {
+            id = id.unwrap();
+        }
+        return inst.clone({
+            ...inst._zod.def,
+            dto: false,
+            fields: {
+                ...normalized.fields,
+                id,
+            },
+        });
+    };
+    // @ts-expect-error - overloaded
+    inst.toSurql = (statement = "define", options) => 
+    // @ts-expect-error - overloaded
+    tableToSurql(inst, statement, options);
+    inst._zod.parse = (payload, ctx) => {
+        const input = payload.value;
+        if (!core.util.isObject(input)) {
+            payload.issues.push({
+                expected: "object",
+                code: "invalid_type",
+                input,
+                inst,
+            });
+            return payload;
+        }
+        payload.value = {};
+        const promises = [];
+        const fields = normalized.fields;
+        for (const field of normalized.fieldNames) {
+            const schema = fields[field];
+            const result = schema._zod.run({ value: input[field], issues: [] }, ctx);
+            if (result instanceof Promise) {
+                promises.push(result.then((result) => {
+                    handleFieldResult(result, payload, field, input);
+                }));
+            }
+            else {
+                handleFieldResult(result, payload, field, input);
+            }
+        }
+        if (!catchall) {
+            return promises.length
+                ? Promise.all(promises).then(() => payload)
+                : payload;
+        }
+        return handleCatchall(promises, input, payload, ctx, normalized, inst);
+    };
+    return inst;
+});
+export function table(name) {
+    return new SurrealZodTable({
+        type: "any",
+        name,
+        // @ts-expect-error - id set in constructor
+        fields: {},
+        catchall: unknown(),
+        surreal: {
+            type: "table",
+            tableType: "any",
+            schemafull: false,
+            drop: false,
+            comment: undefined,
+        },
+    });
+}
+export const SurrealZodTableNormal = core.$constructor("SurrealZodTableNormal", (inst, def) => {
+    SurrealZodTable.init(inst, def);
+});
+export function normalTable(name) {
+    return table(name).normal();
+}
+export const SurrealZodTableRelation = core.$constructor("SurrealZodTableRelation", (inst, def) => {
+    SurrealZodTable.init(inst, def);
+    inst.from = (from) => {
+        return new SurrealZodTableRelation({
+            ...def,
+            fields: {
+                ...def.fields,
+                in: from instanceof SurrealZodRecordId ? from : recordId(from),
+            },
+        });
+    };
+    inst.to = (to) => {
+        return new SurrealZodTableRelation({
+            ...def,
+            fields: {
+                ...def.fields,
+                out: to instanceof SurrealZodRecordId ? to : recordId(to),
+            },
+        });
+    };
+    inst.in = inst.from;
+    inst.out = inst.to;
+    inst.fields = (fields) => {
+        return new SurrealZodTableRelation({
+            ...def,
+            fields: {
+                ...def.fields,
+                ...fields,
+            },
+        });
+    };
+    return inst;
+});
+export function relationTable(name) {
+    return table(name).relation();
+}
+export const SurrealZodOptional = core.$constructor("SurrealZodOptional", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodOptional.init(inst, def);
+    SurrealZodType.init(inst, def);
+    inst.unwrap = () => {
+        return inst._zod.def.innerType;
+    };
+});
+export function optional(innerType) {
+    return new SurrealZodOptional({
+        type: "optional",
+        innerType,
+        surreal: {
+            type: "optional",
+        },
+    });
+}
+export const SurrealZodNonOptional = core.$constructor("SurrealZodNonOptional", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodNonOptional.init(inst, def);
+    SurrealZodType.init(inst, def);
+});
+export function nonoptional(innerType) {
+    return new SurrealZodNonOptional({
+        type: "nonoptional",
+        innerType,
+        surreal: {
+            type: "nonoptional",
+        },
+    });
+}
+export const SurrealZodNullable = core.$constructor("SurrealZodNullable", (inst, def) => {
+    // @ts-expect-error - unknown assertion error
+    core.$ZodNullable.init(inst, def);
+    SurrealZodType.init(inst, def);
+});
+export function nullable(innerType) {
+    return new SurrealZodNullable({
+        type: "nullable",
+        innerType,
+        surreal: {
+            type: "nullable",
+        },
+    });
+}
+/////////////////////////////////////////////////
+/////////////////////////////////////////////////
+//////////                             //////////
+//////////      SurrealZodNullish      //////////
+//////////                             //////////
+/////////////////////////////////////////////////
+/////////////////////////////////////////////////
+export function nullish(innerType) {
+    return optional(nullable(innerType));
+}

package/lib/zod/utils.d.ts

@@ -0,0 +1,2 @@
+import type { SurrealZodTableFields } from "./schema";
+export declare const optionalFields: (fields: SurrealZodTableFields) => string[];

package/lib/zod/utils.js

@@ -0,0 +1,2 @@
+import * as core from "zod/v4/core";
+export const optionalFields = core.util.optionalKeys;

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "surreal-zod",
-  "version": "0.0.0-alpha.1",
-  "module": "index.ts",
+  "version": "0.0.0-alpha.11",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "prepack": "bun run build"
   },
   "files": [
     "lib",
     "src"
   ],
+  "module": "lib/index.js",
+  "types": "lib/index.d.ts",
   "exports": {
     ".": {
       "bun": "./src/index.ts",
@@ -30,6 +32,6 @@
   "dependencies": {
     "@surrealdb/node": "2.3.4",
     "dedent": "^1.7.0",
-    "surrealdb": "^2.0.0-alpha.13"
+    "surrealdb": "^2.0.0-alpha.14"
   }
 }

package/src/index.ts

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