replace vine with valibot

Signed-off-by: Kirill Mokevnin <[email protected]>

Author: mokevnin

AGENTS.md

@@ -15,7 +15,7 @@
 - `npm run dev`: Start Fastify with watch on http://localhost:3000.
 - `npm start`: Start in production mode.
 - `npm test` or `make test`: Run Node tests (`node --test`).
-- `make lint` / `make lint-fix`: Lint and autofix via ESLint.
+- `make lint` / `make lint-fix`: Lint and autofix.
 - `make check-types`: Type-check with `tsc` (JS + d.ts).
 - `make generate-types`: Compile TypeSpec and generate Fastify handler types.
 - `make migration-generate`: Generate Drizzle migrations.

Makefile

@@ -5,7 +5,7 @@ dev:
 	npm run dev
 
 check-types:
-	npx tsc --noEmit
+	npx tsc
 
 routes:
 	npx fastify print-routes routes/api/users.js
@@ -14,10 +14,10 @@ migration-generate:
 	npx drizzle-kit generate
 
 lint:
-	npx eslint .
+	npx @biomejs/biome check
 
 lint-fix:
-	npx eslint --fix .
+	npx @biomejs/biome check --fix
 
 generate-openapi:
 	npx tsp compile .

app.ts

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import type { AutoloadPluginOptions } from '@fastify/autoload';
 import AutoLoad from '@fastify/autoload';
-import { errors } from '@vinejs/vine';
+import { ValiError } from 'valibot'
 import type { FastifyPluginAsync, FastifyServerOptions } from 'fastify';
 import glue from 'fastify-openapi-glue';
 import serviceHandlers from './routes/index.ts';
@@ -18,18 +18,27 @@ const app: FastifyPluginAsync<AppOptions> = async (
   opts,
 ): Promise<void> => {
   fastify.setErrorHandler((error, _request, reply) => {
-    if (error instanceof errors.E_VALIDATION_ERROR) {
+    if (error instanceof ValiError) {
+      const errors = error.issues.map((issue) => {
+        const lastPathItem = issue.path && issue.path.length > 0 ? issue.path[issue.path.length - 1] : undefined
+        const field = lastPathItem && 'key' in lastPathItem && lastPathItem.key != null ? String(lastPathItem.key) : ''
+        return {
+          message: issue.message ?? 'Validation error',
+          rule: String(issue.type ?? 'validation'),
+          field,
+        }
+      })
       const errorDetail = {
         status: 422,
         title: 'Validation Error',
         detail: 'Errors related to business logic such as uniqueness',
-        errors: error.messages,
-      };
-      reply.type('application/problem+json').code(422).send(errorDetail);
+        errors,
+      }
+      reply.type('application/problem+json').code(422).send(errorDetail)
     } else {
-      reply.send(error);
+      reply.send(error)
     }
-  });
+  })
 
   fastify.addContentTypeParser(
     'application/problem+json',

package-lock.json

@@ -13,7 +13,8 @@
     "@fastify/response-validation": "^3.0.3",
     "@fastify/sensible": "^6.0.3",
     "@typespec/openapi": "^1.3.0",
-    "@vinejs/vine": "^3.0.1",
+    "drizzle-valibot": "^0.3.0",
+    "valibot": "^1.0.0",
     "ajv-formats": "^3.0.1",
     "better-sqlite3": "^12.2.0",
     "drizzle-orm": "^0.44.4",

package.json

@@ -1,40 +1,19 @@
-import vine from '@vinejs/vine';
 import { eq } from 'drizzle-orm';
-import { drizzle } from 'drizzle-orm/better-sqlite3';
-import * as schemas from '../db/schema.ts';
+import { checkAsync } from 'valibot';
+import type { DrizzleDB, DrizzleSchema } from '../types/index.ts';
 
-/**
- * @param {any} value
- * @param {{ schema: import('../types/index.ts').DrizzleSchema }} options
- * @param {import('@vinejs/vine/types').FieldContext} field
- */
-async function unique(value, options, field) {
-  /**
-   * We do not want to deal with non-string
-   * values. The "string" rule will handle the
-   * the validation.
-   */
-  if (typeof value !== 'string') {
-    return;
-  }
+type Options = {
+  schema: DrizzleSchema;
+  field: string;
+};
 
-  /** @type {ReturnType<typeof drizzle<typeof schemas>>} */
-  const db = field.meta.db;
-  const [row] = await db
-    .select()
-    .from(options.schema)
-    .where(eq(options.schema[field.name], value));
-
-  if (row) {
-    field.report(
-      `The {{ field }} field (= ${value}) is not unique.`,
-      'unique',
-      field,
-    );
-  }
+export default function unique(db: DrizzleDB, options: Options) {
+  return checkAsync(async (value: string) => {
+    const [row] = await db
+      .select()
+      .from(options.schema)
+      // @ts-expect-error index signature for dynamic column access
+      .where(eq(options.schema[options.field], value));
+    return !row;
+  });
 }
-
-export default vine.createRule(unique, {
-  // implicit: true,
-  isAsync: true,
-});

rules/unique.ts

@@ -1,15 +1,17 @@
 /** biome-ignore-all lint/complexity/noStaticOnlyClass: - */
 
-import vine from '@vinejs/vine';
-import type { CourseLessonInsert, DrizzleDB } from '../../types/index.ts';
+import type { CourseLessonInsert, DrizzleDB } from '../../types/index.ts'
+import { object, parseAsync, string } from 'valibot'
 
-const schema = vine.object({}).allowUnknownProperties();
-const validator = vine.compile(schema);
+const schema = object({
+  name: string(),
+  body: string(),
+})
 
 class LessonValidator {
-  static validate(db: DrizzleDB, data: CourseLessonInsert) {
-    return validator.validate(data, { meta: { db } });
+  static validate(_db: DrizzleDB, data: CourseLessonInsert) {
+    return parseAsync(schema, data)
   }
 }
 
-export default LessonValidator;
+export default LessonValidator

validators/Course/LessonValidator.ts

@@ -1,20 +1,19 @@
 /** biome-ignore-all lint/complexity/noStaticOnlyClass: - */
 
-import vine from '@vinejs/vine';
-import type { CourseInsert, DrizzleDB } from '../types/index.ts';
+import type { CourseInsert, DrizzleDB } from '../types/index.ts'
+import { object, parseAsync, string } from 'valibot'
 
-const schema = vine
-  .object({
-    // name: vine.string(),
-    // description: vine.string(),
-  })
-  .allowUnknownProperties();
-const validator = vine.compile(schema);
+// Keep validation permissive: accept fields used by routes
+// and let handlers add/override creatorId.
+const schema = object({
+  name: string(),
+  description: string(),
+})
 
 class CourseValidator {
-  static validate(db: DrizzleDB, data: CourseInsert) {
-    return validator.validate(data, { meta: { db } });
+  static validate(_db: DrizzleDB, data: CourseInsert) {
+    return parseAsync(schema, data)
   }
 }
 
-export default CourseValidator;
+export default CourseValidator