surreal-zod 0.0.0-alpha.4 → 0.0.0-alpha.6

package/lib/index.d.ts

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

package/lib/index.js

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

package/lib/surql.d.ts

@@ -1,6 +1,6 @@
 import { BoundQuery, RecordId, Table } from "surrealdb";
 import * as z4 from "zod/v4/core";
-import type { SurrealZodType } from "./zod";
+import type { SurrealZodType } from "./zod/schema";
 export type ZodTypeName = z4.$ZodType["_zod"]["def"]["type"];
 export type SurrealZodTypeName = SurrealZodType["_zod"]["def"]["type"];
 export interface ZodToSurqlOptions<S extends z4.$ZodObject> {

package/lib/surql.js

@@ -119,7 +119,24 @@ export function zodTypeToSurrealType(type, parents = [], context) {
     const checks = getChecks(schema);
     parseChecks(context.name, checks, context, def.type);
     // console.log(zodToSexpr(type));
+    if ("surrealType" in def) {
+        switch (def.surrealType) {
+            case "record_id":
+                if (def.table) {
+                    return `record<${def.table.map(escapeIdent).join(" | ")}>`;
+                }
+                else {
+                    return "record";
+                }
+        }
+    }
     switch (def.type) {
+        case "any":
+        case "unknown":
+            return "any";
+        case "never":
+        case "undefined":
+            return "NONE";
         case "string":
             return "string";
         case "boolean":
@@ -144,25 +161,6 @@ export function zodTypeToSurrealType(type, parents = [], context) {
         //   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 };

package/lib/zod/schema.d.ts

@@ -0,0 +1,97 @@
+import { RecordId, type RecordIdValue } from "surrealdb";
+import * as core from "zod/v4/core";
+export interface SurrealZodTypeDef extends core.$ZodTypeDef {
+    surrealType?: "any" | "unknown" | "boolean" | "string" | "object" | "record_id" | "table";
+}
+export interface SurrealZodTypeInternals<out O = unknown, out I = unknown> extends core.$ZodTypeInternals<O, I> {
+    def: SurrealZodTypeDef;
+}
+export interface SurrealZodType<out O = unknown, out I = unknown, out Internals extends SurrealZodTypeInternals<O, I> = SurrealZodTypeInternals<O, I>> extends core.$ZodType<O, I, Internals> {
+    _surreal: {};
+}
+export interface _SurrealZodType<Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends SurrealZodType<any, any, Internals> {
+}
+export declare const SurrealZodType: core.$constructor<SurrealZodType>;
+export interface SurrealZodAny extends _SurrealZodType<core.$ZodAnyInternals> {
+}
+export declare const SurrealZodAny: core.$constructor<SurrealZodAny>;
+export declare function any(): SurrealZodAny;
+export interface SurrealZodUnknown extends _SurrealZodType<core.$ZodUnknownInternals> {
+}
+export declare const SurrealZodUnknown: core.$constructor<SurrealZodUnknown>;
+export declare function unknown(): SurrealZodUnknown;
+export interface SurrealZodNever extends _SurrealZodType<core.$ZodNeverInternals> {
+}
+export declare const SurrealZodNever: core.$constructor<SurrealZodNever>;
+export declare function never(params?: string | core.$ZodNeverParams): SurrealZodNever;
+export interface SurrealZodBoolean extends _SurrealZodType<core.$ZodBooleanInternals> {
+}
+export declare const SurrealZodBoolean: core.$constructor<SurrealZodBoolean>;
+export declare function boolean(params?: string | core.$ZodBooleanParams): SurrealZodBoolean;
+export interface SurrealZodString extends _SurrealZodType<core.$ZodStringInternals<string>> {
+}
+export declare const SurrealZodString: core.$constructor<SurrealZodString>;
+export declare function string(params?: string | core.$ZodStringParams): SurrealZodString;
+export interface SurrealZodObject<out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip> extends _SurrealZodType<core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
+}
+export declare const SurrealZodObject: core.$constructor<SurrealZodObject>;
+export declare function object<T extends core.$ZodLooseShape = Partial<Record<never, core.SomeType>>>(shape?: T, params?: string | core.$ZodObjectParams): SurrealZodObject<core.util.Writeable<T>, core.$strip>;
+export type SurrealZodRecordIdValue = core.$ZodAny | core.$ZodUnknown | core.$ZodString | core.$ZodNumber | core.$ZodObject | core.$ZodArray;
+export interface SurrealZodRecordIdDef<Table extends string = string, Id extends SurrealZodRecordIdValue = SurrealZodRecordIdValue> extends SurrealZodTypeDef {
+    surrealType: "record_id";
+    innerType: Id;
+    table?: Table[];
+}
+export type SurrealZodRecordIdValueOutput<T> = T extends {
+    _zod: {
+        output: any;
+    };
+} ? T["_zod"]["output"] : RecordIdValue;
+export interface SurrealZodRecordIdInternals<Table extends string = string, Id extends SurrealZodRecordIdValue = SurrealZodRecordIdValue> extends SurrealZodTypeInternals<RecordId<Table, SurrealZodRecordIdValueOutput<Id>>, RecordIdValue> {
+    def: SurrealZodRecordIdDef<Table, Id>;
+}
+export interface SurrealZodRecordId<Table extends string = string, Id extends SurrealZodRecordIdValue = SurrealZodRecordIdValue> extends _SurrealZodType<SurrealZodRecordIdInternals<Table, Id>> {
+    table<NewTable extends string | string[]>(table: NewTable): SurrealZodRecordId<NewTable extends string ? NewTable : NewTable[number], Id>;
+    type<NewType extends SurrealZodRecordIdValue>(innerType: NewType): SurrealZodRecordId<Table, NewType>;
+}
+export declare const SurrealZodRecordId: core.$constructor<SurrealZodRecordId>;
+export declare function recordId<const W extends string | string[]>(what?: W, innerType?: SurrealZodRecordIdValue): SurrealZodRecordId<W extends string ? W : W[number]>;
+export type SurrealZodTableFields = {
+    readonly [key: string]: SurrealZodType;
+};
+/**
+ * Normalizes the fields of a table schema to include the id field if it is not present.
+ * If the id field is present, it will be normalized using the table name and the inner type.
+ */
+export type NormalizedFields<Name extends string = string, Fields extends SurrealZodTableFields = SurrealZodTableFields> = Fields extends {
+    id: SurrealZodType;
+} ? Fields["id"] extends SurrealZodRecordId<infer _N, infer T> ? Omit<Fields, "id"> & {
+    id: SurrealZodRecordId<Name, T>;
+} : Fields["id"] extends SurrealZodRecordIdValue ? Omit<Fields, "id"> & {
+    id: SurrealZodRecordId<Name, Fields["id"]>;
+} : Omit<Fields, "id"> & {
+    id: SurrealZodRecordId<Name>;
+} : Fields & {
+    id: SurrealZodRecordId<Name>;
+};
+export interface SurrealZodTableDef<Name extends string = string, Fields extends SurrealZodTableFields = SurrealZodTableFields> extends SurrealZodTypeDef {
+    surrealType: "table";
+    name: Name;
+    fields: NormalizedFields<Name, Fields>;
+    comment?: string;
+    catchall?: SurrealZodType;
+}
+export interface SurrealZodTableInternals<Name extends string = string, Fields extends SurrealZodTableFields = SurrealZodTableFields> extends SurrealZodTypeInternals {
+    def: SurrealZodTableDef<Name, Fields>;
+}
+export interface SurrealZodTable<out Name extends string = string, out Fields extends SurrealZodTableFields = SurrealZodTableFields> extends _SurrealZodType<SurrealZodTableInternals<Name, Fields>> {
+    name<NewName extends string>(name: NewName): SurrealZodTable<NewName, Fields>;
+    fields<NewFields extends SurrealZodTableFields>(fields: NewFields): SurrealZodTable<Name, NewFields>;
+    comment(comment: string): this;
+    schemafull(): this;
+    schemaless(): this;
+    record(): this["_zod"]["def"]["fields"]["id"];
+}
+export declare const SurrealZodTable: core.$constructor<SurrealZodTable>;
+export declare function table<Name extends string = string>(name: Name): SurrealZodTable<Name>;
+export type SurrealZodTypes = SurrealZodAny | SurrealZodBoolean | SurrealZodString | SurrealZodObject | SurrealZodRecordId | SurrealZodTable;

package/lib/zod/schema.js

@@ -0,0 +1,298 @@
+import { escapeIdent, RecordId, Surreal, } from "surrealdb";
+import z4, { normalize } 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 = {};
+    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);
+});
+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);
+});
+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);
+});
+export function never(params) {
+    return core._never(SurrealZodNever, params);
+}
+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) => {
+    SurrealZodType.init(inst, def);
+    inst._surreal = true;
+    inst.table = (table) => {
+        return new SurrealZodRecordId({
+            ...def,
+            table: Array.isArray(table) ? table : [table],
+        });
+    };
+    inst.type = (innerType) => {
+        return new SurrealZodRecordId({
+            ...def,
+            innerType,
+        });
+    };
+    inst._zod.parse = (payload, ctx) => {
+        if (payload.value instanceof RecordId) {
+            if (def.table && !def.table.includes(payload.value.table.name)) {
+                payload.issues.push({
+                    code: "invalid_value",
+                    values: def.table,
+                    input: payload.value.table.name,
+                    message: def.table.length > 1
+                        ? `Expected RecordId's table to be one of ${def.table.map(escapeIdent).join(" | ")} but found ${payload.value.table.name}`
+                        : `Expected RecordId's table to be ${def.table[0]} but found ${payload.value.table.name}`,
+                });
+            }
+            if (def.innerType) {
+                const schema = def.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",
+        surrealType: "record_id",
+        table: what ? (Array.isArray(what) ? what : [what]) : undefined,
+        innerType: innerType ?? any(),
+    });
+}
+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;
+    // biome-ignore lint/style/noNonNullAssertion: already asserted
+    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 = Object.keys(def.fields);
+    for (const field of fields) {
+        if (!def.fields[field]?._zod.traits.has("SurrealZodType")) {
+            throw new Error(`Invalid field definition for "${field}": expected a Surreal Zod schema`);
+        }
+    }
+    if (def.fields.id) {
+        if (def.fields.id instanceof SurrealZodRecordId) {
+            def.fields.id = def.fields.id.table(def.name);
+        }
+        else {
+            def.fields.id = recordId(def.name).type(def.fields.id);
+        }
+    }
+    return {
+        ...def,
+        fields: def.fields,
+        fieldNames: fields,
+        fieldNamesSet: new Set(fields),
+    };
+}
+export const SurrealZodTable = core.$constructor("SurrealZodTable", (inst, def) => {
+    SurrealZodType.init(inst, def);
+    const normalized = core.util.cached(() => normalizeTableDef(def));
+    const catchall = def.catchall;
+    let value;
+    inst.name = (name) => {
+        return new SurrealZodTable({
+            ...def,
+            name,
+            // biome-ignore lint/suspicious/noExplicitAny: false-positive
+        });
+    };
+    inst.fields = (fields) => {
+        return new SurrealZodTable({
+            ...def,
+            fields: {
+                id: recordId(def.name),
+                ...fields,
+            },
+            // biome-ignore lint/suspicious/noExplicitAny: false-positive
+        });
+    };
+    inst.comment = (comment) => {
+        return new SurrealZodTable({
+            ...def,
+            comment,
+        });
+    };
+    inst.schemafull = () => {
+        return new SurrealZodTable({
+            ...def,
+            catchall: never(),
+        });
+    };
+    inst.schemaless = () => {
+        return new SurrealZodTable({
+            ...def,
+            catchall: unknown(),
+        });
+    };
+    inst.record = () => normalized.value.fields.id;
+    inst._zod.parse = (payload, ctx) => {
+        value ??= normalized.value;
+        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 = value.fields;
+        for (const field of value.fieldNames) {
+            // biome-ignore lint/style/noNonNullAssertion: bounds already checked
+            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.value, inst);
+    };
+    return inst;
+});
+export function table(name) {
+    return new SurrealZodTable({
+        type: "any",
+        surrealType: "table",
+        name,
+        fields: {
+            id: recordId(name),
+        },
+        catchall: unknown(),
+    });
+}

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,6 +1,6 @@
 {
   "name": "surreal-zod",
-  "version": "0.0.0-alpha.4",
+  "version": "0.0.0-alpha.6",
   "scripts": {
     "build": "tsc",
     "prepack": "bun run build"
@@ -32,6 +32,6 @@
   "dependencies": {
     "@surrealdb/node": "2.3.4",
     "dedent": "^1.7.0",
-    "surrealdb": "^2.0.0-alpha.13"
+    "surrealdb": "github:msanchezdev/surrealdb.js#typed-record-ids:packages/sdk"
   }
 }

package/src/index.ts

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

package/src/surql.ts

@@ -10,7 +10,7 @@ import * as z4 from "zod/v4/core";
 import z from "zod";
 import dedent from "dedent";
 import type sz from ".";
-import type { SurrealZodType, SurrealZodTypes } from "./zod";
+import type { SurrealZodType, SurrealZodTypes } from "./zod/schema";
 
 export type ZodTypeName = z4.$ZodType["_zod"]["def"]["type"];
 export type SurrealZodTypeName = SurrealZodType["_zod"]["def"]["type"];
@@ -209,7 +209,24 @@ export function zodTypeToSurrealType(
   parseChecks(context.name, checks, context, def.type);
   // console.log(zodToSexpr(type));
 
+  if ("surrealType" in def) {
+    switch (def.surrealType) {
+      case "record_id":
+        if (def.table) {
+          return `record<${def.table.map(escapeIdent).join(" | ")}>`;
+        } else {
+          return "record";
+        }
+    }
+  }
+
   switch (def.type) {
+    case "any":
+    case "unknown":
+      return "any";
+    case "never":
+    case "undefined":
+      return "NONE";
     case "string":
       return "string";
     case "boolean":
@@ -234,24 +251,7 @@ export function zodTypeToSurrealType(
     //   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 };