arktype•9mo ago

Wrapper around `type()`

In my configuration loader that I'm building, I have a "registry" pattern where I want to have developers declare the type schema of the config they expect, and then they need to register the config in order to get it loaded, looks something like this:

const GoodConfig = registerConfig(
      'GoodConfig',
      type({
        server: {
          base_url: 'url',
        },
        customer_support_email: 'email',
        widget_counter_increment: 'parse.integer',
        'some_optional_thing?': 'uuid',
      })
    );

const GoodConfig = registerConfig(
      'GoodConfig',
      type({
        server: {
          base_url: 'url',
        },
        customer_support_email: 'email',
        widget_counter_increment: 'parse.integer',
        'some_optional_thing?': 'uuid',
      })
    );

But I don't love having registerConfig() wrapped around type(), instead I would love to just have the second parameter to the register function be passed through from type() so that I could call type() internally, i.e.

function registerConfig(name:string, typeDef: Parameters<typeof type>[0]){
    const configType = type(typeDef)
    //...etc

function registerConfig(name:string, typeDef: Parameters<typeof type>[0]){
    const configType = type(typeDef)
    //...etc

This is ideal as it avoids the need to import both my config library and arktype, as well as just being simpler for the consumer of my library. The problem I'm having is that Parameters<typeof type>[0] is not resolving correctly. Is there a better way to get to that type?

51 Replies

ssalbdivad•9mo ago

This is the pattern you'll want to use:

const registerConfig = <const def>(
    name: string,
    def: validateTypeRoot<def>
): Type<inferTypeRoot<def>, {}> => {
    const t = type(def)
    // implementation
}

const registerConfig = <const def>(
    name: string,
    def: validateTypeRoot<def>
): Type<inferTypeRoot<def>, {}> => {
    const t = type(def)
    // implementation
}

SneakyTurtleOP•9mo ago

Oh huzzah! What's the name of the <const def> syntax? I see that all over the arktype codebase but I've not used it previously

ssalbdivad•9mo ago

I've just heard const type parameters, it was introduced in TS 5.0 I believe

SneakyTurtleOP•9mo ago

ahhh I'm getting some angry ban-types linting on the use of {} here, is that expected? And type(def) is not happy either the ts error for type(def) is

Argument of type 'validateTypeRoot<def>' is not assignable to parameter of type '[def] extends [Terminal] ? Terminal & def : ...

Argument of type 'validateTypeRoot<def>' is not assignable to parameter of type '[def] extends [Terminal] ? Terminal & def : ...

it goes on for many lines after that

ssalbdivad•9mo ago

A lot of built-in lint rules suck Well at least for working with complex types like this

SneakyTurtleOP•9mo ago

got it mostly making sure that use of {} isn't some weird footgun that I need to be worried about

ssalbdivad•9mo ago

You will want to cast def to never there, since it's trying to validate it.

SneakyTurtleOP•9mo ago

gotcha

ssalbdivad•9mo ago

No it should be used in a scenario like this as a "baseline" for a mapped type I think in a very recent version of eslint they actually changed the default complaint about that type to hopefully be more descriptive Personally I think the lint rule about {} is actually more of a foot-gun than {} itself I've seen a bunch of people struggling with types where they followed the advice of the lint rule and replaced it with Record<string, never> or similar then tried to map over that but it adds an index signature you definitely don't want when used in that way

SneakyTurtleOP•9mo ago

Yeah I've definitely hit that before I built a pretty cool ts rpc library called cheep that had some great complex typing stuff, this is bringing back memories for me

ssalbdivad•9mo ago

I think TS's greatest strength is the flexibility it provides library authors to create amazing DX at the cost of a lot of casting internally but the trade-off is worth it because if written correctly, end users get more precise types and have to cast less But a lot of people get caught in the mentality they should never have to cast which if you're writing anything to do with runtime validation you have to give up on very quickly 😛

SneakyTurtleOP•9mo ago

aint that the truth 🤣 Thanks for all the help, between your quick responses and the awesome work you've done on arktype this little project has been remarkably smooth

ssalbdivad•9mo ago

Great to hear! Hopefully things will be even easier soon once the new docs are done 🙏

Gaming

Programming

Wrapper around `type()`

Did you find this page helpful?