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

package/src/zod/original.ts

@@ -0,0 +1,369 @@
+/** biome-ignore-all assist/source/organizeImports: re-exporting */
+
+export {
+  // string
+  // string,
+  // _ZodString,
+  // ZodString,
+  type ZodCoercedString,
+  // iso
+  iso,
+  ZodISODate,
+  ZodISODateTime,
+  ZodISODuration,
+  ZodISOTime,
+  // email
+  email,
+  ZodEmail,
+  // // guid (patched)
+  guid as originalGuid,
+  ZodGUID as OriginalZodGUID,
+  // // uuid (patched)
+  uuid as originalUuid,
+  ZodUUID as OriginalZodUUID,
+  // uuidv4 (patched)
+  uuidv4 as originalUuidv4,
+  // // uuidv6 (patched)
+  uuidv6 as originalUuidv6,
+  // // uuidv7 (patched)
+  uuidv7 as originalUuidv7,
+  // url
+  url,
+  ZodURL,
+  // httpUrl
+  httpUrl,
+  // emoji
+  emoji,
+  ZodEmoji,
+  // nanoid
+  nanoid,
+  ZodNanoID,
+  // cuid
+  cuid,
+  ZodCUID,
+  // cuid2
+  cuid2,
+  ZodCUID2,
+  // ulid
+  ulid,
+  ZodULID,
+  // xid
+  xid,
+  ZodXID,
+  // ksuid
+  ksuid,
+  ZodKSUID,
+  // ipv4
+  ipv4,
+  ZodIPv4,
+  // mac
+  mac,
+  ZodMAC,
+  // ipv6
+  ipv6,
+  ZodIPv6,
+  // cidrv4
+  cidrv4,
+  ZodCIDRv4,
+  // cidrv6
+  cidrv6,
+  ZodCIDRv6,
+  // base64
+  base64,
+  ZodBase64,
+  // base64url
+  base64url,
+  ZodBase64URL,
+  // e164
+  e164,
+  ZodE164,
+  // jwt
+  jwt,
+  ZodJWT,
+  // stringFormat
+  stringFormat,
+  ZodStringFormat,
+  ZodCustomStringFormat,
+  // hostname
+  hostname,
+  // hex
+  hex,
+  // hash
+  hash,
+  // number
+  number,
+  ZodNumber,
+  ZodNumberFormat,
+  type _ZodNumber,
+  type ZodCoercedNumber,
+  // int
+  int,
+  type ZodInt,
+  // float32
+  float32,
+  type ZodFloat32,
+  // float64
+  float64,
+  type ZodFloat64,
+  // int32
+  int32,
+  type ZodInt32,
+  // uint32
+  uint32,
+  type ZodUInt32,
+  // boolean
+  boolean,
+  type _ZodBoolean,
+  ZodBoolean,
+  type ZodCoercedBoolean,
+  // bigint
+  bigint,
+  type _ZodBigInt,
+  ZodBigInt,
+  ZodBigIntFormat,
+  type ZodCoercedBigInt,
+  // int64
+  int64,
+  // uint64
+  uint64,
+  // symbol
+  symbol,
+  ZodSymbol,
+  // undefined
+  undefined,
+  ZodUndefined,
+  // any
+  any,
+  ZodAny,
+  type ZodTypeAny,
+  // unknown
+  unknown,
+  ZodUnknown,
+  // never
+  never,
+  ZodNever,
+  // void
+  void,
+  ZodVoid,
+  // null
+  null,
+  ZodNull,
+  // date (patched)
+  date as originalDate,
+  type _ZodDate as _OriginalZodDate,
+  ZodDate as OriginalZodDate,
+  type ZodCoercedDate,
+  // array
+  array,
+  ZodArray,
+  // keyof
+  keyof,
+  // object
+  object,
+  ZodObject,
+  type ZodRawShape,
+  // strictObject
+  strictObject,
+  // looseObject
+  looseObject,
+  // union
+  union,
+  ZodUnion,
+  // discriminatedUnion
+  discriminatedUnion,
+  ZodDiscriminatedUnion,
+  // intersection
+  intersection,
+  ZodIntersection,
+  // tuple
+  // tuple,
+  // ZodTuple,
+  // record
+  record,
+  ZodRecord,
+  // partialRecord
+  partialRecord,
+  // map
+  map,
+  ZodMap,
+  // set
+  set,
+  ZodSet,
+  // enum
+  enum,
+  ZodEnum,
+  // nativeEnum
+  nativeEnum,
+  // literal
+  literal,
+  ZodLiteral,
+  // file
+  file,
+  ZodFile,
+  // transform
+  transform,
+  ZodTransform,
+  // optional
+  optional,
+  ZodOptional,
+  // nullable
+  nullable,
+  ZodNullable,
+  // nullish
+  nullish,
+  // default
+  _default,
+  ZodDefault,
+  // prefault
+  prefault,
+  ZodPrefault,
+  // nonoptional
+  nonoptional,
+  ZodNonOptional,
+  // success
+  success,
+  ZodSuccess,
+  // catch
+  catch,
+  ZodCatch,
+  // nan
+  nan,
+  ZodNaN,
+  // pipe
+  pipe,
+  ZodPipe,
+  // codec
+  codec,
+  ZodCodec,
+  // readonly
+  readonly,
+  ZodReadonly,
+  // templateLiteral
+  templateLiteral,
+  ZodTemplateLiteral,
+  // lazy
+  lazy,
+  ZodLazy,
+  // promise
+  promise,
+  ZodPromise,
+  // function
+  function,
+  _function,
+  ZodFunction,
+  // custom
+  custom,
+  ZodCustom,
+  //
+  //      Others
+  //
+  clone,
+  coerce,
+  check,
+  // Error
+  ZodError,
+  ZodRealError,
+  type ZodErrorMap,
+  type ZodFlattenedError,
+  type ZodFormattedError,
+  formatError,
+  getErrorMap,
+  setErrorMap,
+  // Safe
+  decode,
+  decodeAsync,
+  safeDecode,
+  safeDecodeAsync,
+  encode,
+  encodeAsync,
+  safeEncode,
+  safeEncodeAsync,
+  parse,
+  parseAsync,
+  safeParse,
+  safeParseAsync,
+  type ZodSafeParseError,
+  type ZodSafeParseResult,
+  type ZodSafeParseSuccess,
+  type SafeExtendShape,
+  // output
+  type output,
+  $output,
+  // input
+  type input,
+  $input,
+  // brand
+  type BRAND,
+  $brand,
+  // meta
+  type GlobalMeta,
+  meta,
+  //
+  ZodFirstPartyTypeKind,
+  type ZodFirstPartySchemaTypes,
+  type inferFlattenedErrors,
+  type inferFormattedError,
+  type Infer,
+  type infer,
+  NEVER,
+  type RefinementCtx,
+  ZodType,
+  type _ZodType,
+  type Schema,
+  type ZodSchema,
+  TimePrecision,
+  type TypeOf,
+  type ZodJSONSchema,
+  type ZodJSONSchemaInternals,
+  config,
+  core,
+  endsWith,
+  startsWith,
+  describe,
+  flattenError,
+  globalRegistry,
+  gt,
+  gte,
+  lt,
+  lte,
+  includes,
+  instanceof,
+  json,
+  length,
+  locales,
+  lowercase,
+  toLowerCase,
+  uppercase,
+  toUpperCase,
+  minLength,
+  maxLength,
+  minSize,
+  maxSize,
+  size,
+  multipleOf,
+  negative,
+  nonnegative,
+  positive,
+  nonpositive,
+  property,
+  normalize,
+  overwrite,
+  preprocess,
+  prettifyError,
+  refine,
+  superRefine,
+  regexes,
+  mime,
+  regex,
+  slugify,
+  stringbool,
+  trim,
+  registry,
+  toJSONSchema,
+  treeifyError,
+  util,
+  z,
+  type IssueData,
+  ZodIssueCode,
+  type ZodIssue,
+} from "zod/v4";

package/src/zod/parse.ts

@@ -0,0 +1,138 @@
+import type { Surreal, SurrealTransaction } from "surrealdb";
+import * as classic from "zod/v4";
+import * as core from "zod/v4/core";
+import type * as _core_ from "./core";
+import type { ZodSurrealType } from "./schema";
+
+export interface ParseDbContext<T extends core.$ZodIssueBase = core.$ZodIssue>
+  extends core.ParseContext<T> {
+  db?: Surreal | SurrealTransaction;
+}
+
+export interface ParseDbContextInternal<
+  T extends core.$ZodIssueBase = core.$ZodIssue,
+> extends core.ParseContextInternal<T> {
+  db?: Surreal | SurrealTransaction;
+}
+
+export type ZodSafeParseResult<T> =
+  | classic.ZodSafeParseSuccess<T>
+  | classic.ZodSafeParseError<T>;
+
+export type ParsingEncodingDecodingMethodNames =
+  | "parse"
+  | "encode"
+  | "decode"
+  | "parseAsync"
+  | "encodeAsync"
+  | "decodeAsync"
+  | "safeParse"
+  | "safeEncode"
+  | "safeDecode"
+  | "safeParseAsync"
+  | "safeEncodeAsync"
+  | "safeDecodeAsync";
+
+export interface ParsingEncodingDecodingMethods<
+  T extends _core_.$SomeSurrealType,
+> {
+  parse<Ctx extends ParseDbContext>(
+    data: unknown,
+    params?: Ctx,
+  ): Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>;
+  encode<Ctx extends ParseDbContext>(
+    data: Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>,
+    params?: Ctx,
+  ): Ctx extends { db: any } ? _core_.dbinput<T> : core.input<T>;
+  decode<Ctx extends ParseDbContext>(
+    data: Ctx extends { db: any } ? _core_.dbinput<T> : core.input<T>,
+    params?: Ctx,
+  ): Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>;
+  parseAsync<Ctx extends ParseDbContext>(
+    data: unknown,
+    params?: Ctx,
+  ): Promise<Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>>;
+  encodeAsync<Ctx extends ParseDbContext>(
+    data: Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>,
+    params?: Ctx,
+  ): Promise<Ctx extends { db: any } ? _core_.dbinput<T> : core.input<T>>;
+  decodeAsync<Ctx extends ParseDbContext>(
+    data: Ctx extends { db: any } ? _core_.dbinput<T> : core.input<T>,
+    params?: Ctx,
+  ): Promise<Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>>;
+  safeParse<Ctx extends ParseDbContext>(
+    data: unknown,
+    params?: Ctx,
+  ): classic.ZodSafeParseResult<
+    Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>
+  >;
+  safeEncode<Ctx extends ParseDbContext>(
+    data: Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>,
+    params?: Ctx,
+  ): classic.ZodSafeParseResult<
+    Ctx extends { db: any } ? _core_.dbinput<T> : core.input<T>
+  >;
+  safeDecode<Ctx extends ParseDbContext>(
+    data: Ctx extends { db: any } ? _core_.dbinput<T> : core.input<T>,
+    params?: Ctx,
+  ): classic.ZodSafeParseResult<
+    Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>
+  >;
+  safeParseAsync<Ctx extends ParseDbContext>(
+    data: unknown,
+    params?: Ctx,
+  ): Promise<
+    classic.ZodSafeParseResult<
+      Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>
+    >
+  >;
+  spa<Ctx extends ParseDbContext>(
+    data: unknown,
+    params?: Ctx,
+  ): Promise<
+    classic.ZodSafeParseResult<
+      Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>
+    >
+  >;
+  safeEncodeAsync<Ctx extends ParseDbContext>(
+    data: Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>,
+    params?: Ctx,
+  ): Promise<
+    classic.ZodSafeParseResult<
+      Ctx extends { db: any } ? _core_.dbinput<T> : core.input<T>
+    >
+  >;
+  safeDecodeAsync<Ctx extends ParseDbContext>(
+    data: Ctx extends { db: any } ? _core_.dbinput<T> : core.input<T>,
+    params?: Ctx,
+  ): Promise<
+    classic.ZodSafeParseResult<
+      Ctx extends { db: any } ? _core_.dboutput<T> : core.output<T>
+    >
+  >;
+}
+
+export function assignParsingMethods(inst: ZodSurrealType) {
+  inst.parse = (data, params) => classic.parse(inst as any, data, params);
+  inst.decode = (data, params) => classic.decode(inst as any, data, params);
+  inst.encode = (data, params) => classic.encode(inst as any, data, params);
+  inst.parseAsync = (data, params) =>
+    classic.parseAsync(inst as any, data, params);
+  inst.decodeAsync = (data, params) =>
+    classic.decodeAsync(inst as any, data, params);
+  inst.encodeAsync = (data, params) =>
+    classic.encodeAsync(inst as any, data, params);
+  inst.safeParse = (data, params) =>
+    classic.safeParse(inst as any, data, params);
+  inst.safeDecode = (data, params) =>
+    classic.safeDecode(inst as any, data, params);
+  inst.safeEncode = (data, params) =>
+    classic.safeEncode(inst as any, data, params);
+  inst.safeParseAsync = (data, params) =>
+    classic.safeParseAsync(inst as any, data, params);
+  inst.spa = inst.safeParseAsync;
+  inst.safeDecodeAsync = (data, params) =>
+    classic.safeDecodeAsync(inst as any, data, params);
+  inst.safeEncodeAsync = (data, params) =>
+    classic.safeEncodeAsync(inst as any, data, params);
+}