Merge pull request #58 from matt45400/main

Update to Valibot 0.31

.changeset/red-wolves-shout.md

@@ -0,0 +1,7 @@
+---
+"@typeschema/all": patch
+"@typeschema/main": patch
+"@typeschema/valibot": patch
+---
+
+Update to Valibot 0.31

packages/all/package.json

@@ -117,8 +117,8 @@
     "superstruct": "^1.0.4",
     "suretype": "^3.3.1",
     "@sinclair/typebox": "^0.32.20",
-    "@gcornut/valibot-json-schema": "^0.0.27",
-    "valibot": "^0.30.0",
+    "@gcornut/valibot-json-schema": "^0.31.0",
+    "valibot": "^0.31.0",
     "@badrap/valita": "^0.3.8",
     "@vinejs/vine": "^2.0.0",
     "@sodaru/yup-to-json-schema": "^2.0.1",

packages/main/package.json

@@ -112,8 +112,8 @@
     "@typeschema/typebox": "workspace:*",
     "@sinclair/typebox": "^0.32.20",
     "@typeschema/valibot": "workspace:*",
-    "@gcornut/valibot-json-schema": "^0.0.27",
-    "valibot": "^0.30.0",
+    "@gcornut/valibot-json-schema": "^0.31.0",
+    "valibot": "^0.31.0",
     "@typeschema/valita": "workspace:*",
     "@badrap/valita": "^0.3.8",
     "@typeschema/vine": "workspace:*",

packages/valibot/package.json

@@ -59,17 +59,17 @@
   },
   "//devDependencies": "This field is manually maintained.",
   "devDependencies": {
-    "@gcornut/valibot-json-schema": "^0.0.27",
-    "valibot": "^0.30.0"
+    "@gcornut/valibot-json-schema": "^0.31.0",
+    "valibot": "^0.31.0"
   },
   "//peerDependencies": {
     "//": "This field is manually maintained.",
     "@gcornut/valibot-json-schema": "Required for serialization",
     "valibot": "Required for inference and validation"
   },
   "peerDependencies": {
-    "@gcornut/valibot-json-schema": "^0.0.27",
-    "valibot": "^0.30.0"
+    "@gcornut/valibot-json-schema": "^0.31.0",
+    "valibot": "^0.31.0"
   },
   "//peerDependenciesMeta": "This field is manually maintained.",
   "peerDependenciesMeta": {

packages/valibot/src/__tests__/valibot.test.ts

@@ -2,19 +2,19 @@ import type {Infer, InferIn} from '..';
 
 import {initTRPC} from '@trpc/server';
 import {expectTypeOf} from 'expect-type';
-import {email, number, object, string, transform} from 'valibot';
+import {email, isoTimestamp, number, object, pipe, string, transform} from 'valibot';
 import {describe, expect, test} from 'vitest';
 
 import {assert, toJSONSchema, validate, wrap} from '..';
 
 describe('valibot', () => {
   const schema = object({
     age: number(),
-    createdAt: transform(string(), value => new Date(value)),
-    email: string([email()]),
+    createdAt: pipe(string(), isoTimestamp(), transform((input) => new Date(input))),
+    email: pipe(string(), email()),
     id: string(),
     name: string(),
-    updatedAt: transform(string(), value => new Date(value)),
+    updatedAt: pipe(string(), isoTimestamp(), transform((input) => new Date(input))),
   });
 
   const data = {

packages/valibot/src/resolver.ts

@@ -1,8 +1,8 @@
 import type {IfDefined, Resolver} from '@typeschema/core';
-import type {BaseSchema, BaseSchemaAsync, Input, Output} from 'valibot';
+import type {GenericSchema, GenericSchemaAsync, InferInput, InferOutput} from 'valibot';
 
 export interface AdapterResolver extends Resolver {
-  base: IfDefined<BaseSchema | BaseSchemaAsync, 'valibot'>;
-  input: this['schema'] extends this['base'] ? Input<this['schema']> : never;
-  output: this['schema'] extends this['base'] ? Output<this['schema']> : never;
+  base: IfDefined<GenericSchema | GenericSchemaAsync, 'valibot'>;
+  input: this['schema'] extends this['base'] ? InferInput<this['schema']> : never;
+  output: this['schema'] extends this['base'] ? InferOutput<this['schema']> : never;
 }

packages/valibot/src/serialization.ts

@@ -12,5 +12,5 @@ export const serializationAdapter: SerializationAdapter<
   AdapterResolver
 > = async schema => {
   const {toJSONSchema} = await importSerializationModule();
-  return toJSONSchema({schema});
+  return toJSONSchema({ignoreUnknownValidation: true, schema});
 };

packages/valibot/src/validation.ts

@@ -4,28 +4,27 @@ import type {ValidationAdapter} from '@typeschema/core';
 import {memoize} from '@typeschema/core';
 
 const importValidationModule = memoize(async () => {
-  const {safeParseAsync} = await import('valibot');
-  return {safeParseAsync};
+  const {getDotPath, safeParseAsync} = await import('valibot');
+  return {getDotPath, safeParseAsync};
 });
 
 export const validationAdapter: ValidationAdapter<
   AdapterResolver
 > = async schema => {
-  const {safeParseAsync} = await importValidationModule();
+  const {getDotPath, safeParseAsync} = await importValidationModule();
   return async data => {
     const result = await safeParseAsync(schema, data);
     if (result.success) {
       return {
-        data: result.output,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        data: result.output as any,
         success: true,
       };
     }
     return {
-      issues: result.issues.map(({message, path}) => ({
-        message,
-        path: path?.map(({type, key}) =>
-          type === 'map' || type === 'unknown' ? String(key) : key,
-        ),
+      issues: result.issues.map(issue => ({
+        message: issue.message,
+        path: getDotPath(issue)?.split('.'),
       })),
       success: false,
     };