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

package/lib/index.d.ts

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

package/lib/print.d.ts

@@ -0,0 +1,2 @@
+import type * as z4 from "zod/v4/core";
+export declare function zodToSexpr(schema: z4.$ZodType): string;

package/lib/surql.d.ts

@@ -0,0 +1,48 @@
+import { BoundQuery, RecordId, Table } from "surrealdb";
+import * as z4 from "zod/v4/core";
+import type { SurrealZodType } from "./zod";
+export type ZodTypeName = z4.$ZodType["_zod"]["def"]["type"];
+export type SurrealZodTypeName = SurrealZodType["_zod"]["def"]["type"];
+export interface ZodToSurqlOptions<S extends z4.$ZodObject> {
+    table: string | Table;
+    schemafull?: boolean;
+    exists?: "ignore" | "error" | "overwrite";
+    drop?: boolean;
+    comment?: string;
+    schema: S;
+}
+export declare function zodToSurql<S extends z4.$ZodObject>(options: ZodToSurqlOptions<S>): [
+    S extends z4.$ZodObject<infer Shape> ? z4.$ZodObject<Shape & {
+        id: z4.$ZodCustom<RecordId>;
+    }> : never,
+    BoundQuery
+];
+type ZodSurrealTypeContext = {
+    name: string;
+    table: Table;
+    rootSchema: z4.$ZodType;
+    children: ZodSurrealChildType[];
+    asserts: string[];
+    transforms: string[];
+    default?: {
+        value: any;
+        always: boolean;
+    };
+};
+type ZodSurrealChildType = {
+    name: string;
+    type: z4.$ZodType;
+};
+export declare function zodTypeToSurrealType(type: z4.$ZodType | SurrealZodType, parents: string[] | undefined, context: ZodSurrealTypeContext): string;
+export declare const checkMap: {
+    min_length(name: string, value: number, type: ZodTypeName): string;
+    max_length(name: string, value: number, type: ZodTypeName): string;
+    greater_than(name: string, value: z4.util.Numeric, inclusive: boolean): string;
+    less_than(name: string, value: z4.util.Numeric, inclusive: boolean): string;
+    length_equals(name: string, value: number, type?: ZodTypeName): string;
+    string_format: {
+        email: (name: string) => string;
+        url: (name: string, def?: Pick<z4.$ZodCheckURLParams, "hostname" | "protocol" | "normalize">) => string;
+    };
+};
+export {};

package/lib/zod.d.ts

@@ -0,0 +1,55 @@
+import { RecordId, type RecordIdValue } from "surrealdb";
+import * as core from "zod/v4/core";
+export interface SurrealZodTypeDef extends core.$ZodTypeDef {
+    surrealType?: "any" | "boolean" | "string" | "object" | "record_id";
+}
+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: true;
+}
+export interface _SurrealZodType<out 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 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 interface SurrealZodRecordIdDef<out W extends {
+    [key: string]: string;
+} = {
+    [key: string]: string;
+}, T extends core.SomeType = core.SomeType> extends SurrealZodTypeDef {
+    surrealType: "record_id";
+    innerType: T;
+    what?: W;
+}
+export interface SurrealZodRecordIdInternals<W extends {
+    [key: string]: string;
+} = {
+    [key: string]: string;
+}, T extends core.SomeType = core.SomeType> extends SurrealZodTypeInternals<RecordId<W[keyof W]>, RecordIdValue> {
+    def: SurrealZodRecordIdDef<W, T>;
+}
+export interface SurrealZodRecordId<W extends {
+    [key: string]: string;
+} = {
+    [key: string]: string;
+}, T extends core.SomeType = core.SomeType> extends _SurrealZodType<SurrealZodRecordIdInternals<W, T>> {
+}
+export declare const SurrealZodRecordId: core.$constructor<SurrealZodRecordId>;
+export declare function recordId<const W extends readonly string[]>(what?: W, innerType?: core.$ZodType | SurrealZodType): SurrealZodRecordId<core.util.ToEnum<W[number]>>;
+export type SurrealZodTypes = SurrealZodAny | SurrealZodBoolean | SurrealZodString | SurrealZodObject | SurrealZodRecordId;

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "surreal-zod",
-  "version": "0.0.0-alpha.1",
-  "module": "index.ts",
+  "version": "0.0.0-alpha.3",
   "scripts": {
     "build": "tsc"
   },
@@ -9,6 +8,8 @@
     "lib",
     "src"
   ],
+  "module": "lib/index.js",
+  "types": "lib/index.d.ts",
   "exports": {
     ".": {
       "bun": "./src/index.ts",

package/src/index.ts

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