Alternatives for GenericSchema

[babakfp]

Hi 👋

import { error } from "@sveltejs/kit"
import * as v from "valibot"

const collectionNameSchema = v.pipe(
    v.string(),
    v.minLength(1),
    v.regex(
        /^[a-z]+$/,
        "The collection name can only contain lowercase letters.",
    ),
)

export const validateCollectionName = (name: string) => {
    validateAnEntryName(collectionNameSchema, name)
}

// ---

const validateAnEntryName = (schema: v.GenericSchema, name: string) => {
    const result = v.safeParse(schema, name)
    if (!result.success) {
        return error(400, result.issues[0].message)
    }
}

I want to say that the schema parameter in validateAnEntryName can receive any generic Valibot String Schema. It can be wrapped with pipe or not, doesn't matter. So, something like v.GenericSchema but for String Schemas.

In the previous version, I was just using v.StringSchema.

Same for other schemas.

v.GenericObjectSchema

This is how I typed an Object Schema with Generic Entries in the previous version.

export const getCollectionEntry = async <T extends v.ObjectEntries>( // 👈
    name: string,
    slug: string,
    schema: v.ObjectSchema<T>, // 👈
) => {
    const entries = await markdownFilesToEntries()
    const collectionEntries = entries.filter(
        (entry) => entry.collection.name === name,
    )
    const entry = collectionEntries.filter(
        (entry) => entry.collection.name === name && entry.slug === slug,
    )[0]

    if (entry) {
        return await getGlobEntryValue<T>(entry, schema) // 👈
    }
}

[fabian-hiller]

Just use v.StringSchema<any> or v.StringSchema<ErrorMessage<StringIssue> | undefined> to avoid using any. I decided not to use defaults for generics in our internal implementation, as this often leads to bugs. I just created v.GenericSchema to reduce the boilerplate for end users. We could also add v.GenericStringSchema, but I am not sure if we should go that way. This could make usage very complicated, as most developers will never know what to use.

[babakfp]

const validateAnEntryName = (
    schema: v.StringSchema<v.ErrorMessage<v.StringIssue> | undefined>
)

When using it this way 👆 I get into trouble with the pipe function:

Argument of type 'SchemaWithPipe<[StringSchema<undefined>, MinLengthAction<string, 1, undefined>, RegexAction<string, "The collection entry name can only contain letters, numbers, and a single hyphen in between them.">]>' is not assignable to parameter of type 'StringSchema<ErrorMessage<StringIssue> | undefined>'.
  The types returned by '_run(...)' are incompatible between these types.
    Type 'Dataset<string, StringIssue | MinLengthIssue<string, 1> | RegexIssue<string>>' is not assignable to type 'Dataset<string, StringIssue>'.ts(2345)

I think this means I need to type it in a way that both v.string() and v.pipe(v.string(), v.minLength(1) /* ... */) are acceptable. This looks like it's just going to get more and more complicated.

I don't want to deal with this sort of complications. I just want to have type safety and don't do any work for it or even think about it.

How much less I need to see this page, that much better:

They way that I'm using this function that receive Valibot schema is similar to how Astro receives collection frontmatter types. https://docs.astro.build/en/guides/content-collections/#defining-a-collection-schema (scroll a bit down to see the code block).

[fabian-hiller]

I understand the problem and appreciate you bringing it up. What about using v.GenericSchema<string> or v.GenericSchema<string, unknown>? Does that work for you?