Get ts type that accepts type arguments

I have a type that looks like this:

interface PluginInstance<Input, TInput, Diff> {
  details: PluginDetails
  input: PluginInput<Input>
  transform: PluginTransform<Input, TInput> | undefined
  diff: PluginDiff<TInput, Diff>
  handle: PluginHandle<Diff, TInput>
  update: PluginUpdate | undefined
}

interface PluginInstance<Input, TInput, Diff> {
  details: PluginDetails
  input: PluginInput<Input>
  transform: PluginTransform<Input, TInput> | undefined
  diff: PluginDiff<TInput, Diff>
  handle: PluginHandle<Diff, TInput>
  update: PluginUpdate | undefined
}

I would prefer to instead define a Type and infer the ts type.

const pluginInstanceSchema = type({
  "+": "reject",
  details: pluginDetails,
  input: type("Function").as<PluginInput>(),
  transform: type("Function").as<PluginTransform | undefined>(),
  diff: type("Function").as<PluginDiff>(),
  handle: type("Function").as<PluginHandle>(),
  update: type("Function").as<PluginUpdate | undefined>(),
})

const pluginInstanceSchema = type({
  "+": "reject",
  details: pluginDetails,
  input: type("Function").as<PluginInput>(),
  transform: type("Function").as<PluginTransform | undefined>(),
  diff: type("Function").as<PluginDiff>(),
  handle: type("Function").as<PluginHandle>(),
  update: type("Function").as<PluginUpdate | undefined>(),
})

So ultimately I'd want to do this:

type PluginInstance = typeof pluginInstanceSchema.infer
type ReturnsPluginInstance<Input, TInput, Diff> = (input: Input) => PluginInstance<Input, TInput, Diff>

type PluginInstance = typeof pluginInstanceSchema.infer
type ReturnsPluginInstance<Input, TInput, Diff> = (input: Input) => PluginInstance<Input, TInput, Diff>

But of course PluginInstance doesn't take any type arguments. Is it possible to define generics on my schema and have the inferred type accept those type arguments? I tried playing around with scopes, tried doing const pluginInstanceSchema = type("<Input, TInput, Diff>", { ..., but didn't really get anywhere.

13 Replies

ssalbdivad•2mo ago

Can you show how ReturnsPluginInstance is being used?

GenshiiOP•2mo ago

It's a function that returns PluginInstance, so it's basically just:

const pluginInstance = somePlugin("input")
const input = pluginInstance.input()
pluginInstance.transform(...)
...

const pluginInstance = somePlugin("input")
const input = pluginInstance.input()
pluginInstance.transform(...)
...

ssalbdivad•2mo ago

My intuition is some of this either might not be necessary to validate at runtime or it's a very unique use-case, but if you did want to create a type you can pass generic parameters to, you were on the right track with the generic syntax, but you need to pass in the arguments as ArkType types as opposed to TS to get that to work. You could also try creating your own generic function that wrap the type call directly, but not 100% that would behave correctly

GenshiiOP•2mo ago

you need to pass in the arguments as ArkType types as opposed to TS to get that to work

Ah okay, meaning I would need to use a scope in my case because they're my own types?

ssalbdivad•2mo ago

You can use a scope but you don't have to. You can use the invoked generic syntax like type.Record("string", otherType) if you don't want to string embed things Scopes determine what names are available if you're resolving a type reference from a string, so if you want to do something like "MyGeneric<Custom1, Custom2>", yes you would need a scope. But, you can usually create something equivalent using simple composition and invoking your generic if you don't need something as flexible as a scope (definitely a useful feature though, so your call- just seems like you're delving quickly into the deep end of complex functionality 😅) This is probably the easiest way to do what you described without creating additional validators you don't need just for the generics:

interface PluginInput<Input> {}

interface PluginTransform<Input, TInput> {}

interface PluginDiff<TInput, Diff> {}

interface PluginHandle<Diff, TInput> {}

interface PluginUpdate {}

const getPluginInstance = <Input, TInput, Diff>() =>
    type({
        "+": "reject",
        details: {},
        input: type("Function").as<PluginInput<Input>>(),
        transform: type("Function")
            .as<PluginTransform<Input, TInput>>()
            .or("undefined"),
        diff: type("Function").as<PluginDiff<TInput, Diff>>(),
        handle: type("Function").as<PluginHandle<Diff, TInput>>(),
        update: type("Function").as<PluginUpdate>().or("undefined")
    })

const instance = getPluginInstance<
    { someInput: string },
    { someTInput: string },
    { someDiff: string }
>()

const validated = instance({})

interface PluginInput<Input> {}

interface PluginTransform<Input, TInput> {}

interface PluginDiff<TInput, Diff> {}

interface PluginHandle<Diff, TInput> {}

interface PluginUpdate {}

const getPluginInstance = <Input, TInput, Diff>() =>
    type({
        "+": "reject",
        details: {},
        input: type("Function").as<PluginInput<Input>>(),
        transform: type("Function")
            .as<PluginTransform<Input, TInput>>()
            .or("undefined"),
        diff: type("Function").as<PluginDiff<TInput, Diff>>(),
        handle: type("Function").as<PluginHandle<Diff, TInput>>(),
        update: type("Function").as<PluginUpdate>().or("undefined")
    })

const instance = getPluginInstance<
    { someInput: string },
    { someTInput: string },
    { someDiff: string }
>()

const validated = instance({})

GenshiiOP•2mo ago

Sorry, trying to wrap my head around all of this. I'm not sure if that would work in my case because I specifically need the PluginInstance type. It's used elsewhere as a type for a function argument for example. This is my exact implementation right now:

interface PluginInstance<Input, TInput, Diff> {
  details: PluginDetails
  input: PluginInput<Input>
  transform: PluginTransform<Input, TInput> | undefined
  diff: PluginDiff<TInput, Diff>
  handle: PluginHandle<Diff, TInput>
  update: PluginUpdate | undefined
}

const pluginInstanceSchema = type({
  "+": "reject",
  details: pluginDetails,
  input: type("Function").as<PluginInput>(),
  transform: type("Function").as<PluginTransform>().or("undefined"),
  diff: type("Function").as<PluginDiff>(),
  handle: type("Function").as<PluginHandle>(),
  update: type("Function").as<PluginUpdate>().or("undefined"),
})

/**
 * A plugin is a function that takes its input and returns a PluginInstance
 */
type Plugin<Input = unknown, TInput = Input, Diff = unknown> = (input: Input) => PluginInstance<Input, TInput, Diff>

interface PluginInstance<Input, TInput, Diff> {
  details: PluginDetails
  input: PluginInput<Input>
  transform: PluginTransform<Input, TInput> | undefined
  diff: PluginDiff<TInput, Diff>
  handle: PluginHandle<Diff, TInput>
  update: PluginUpdate | undefined
}

const pluginInstanceSchema = type({
  "+": "reject",
  details: pluginDetails,
  input: type("Function").as<PluginInput>(),
  transform: type("Function").as<PluginTransform>().or("undefined"),
  diff: type("Function").as<PluginDiff>(),
  handle: type("Function").as<PluginHandle>(),
  update: type("Function").as<PluginUpdate>().or("undefined"),
})

/**
 * A plugin is a function that takes its input and returns a PluginInstance
 */
type Plugin<Input = unknown, TInput = Input, Diff = unknown> = (input: Input) => PluginInstance<Input, TInput, Diff>

I'm basically defining the same thing twice, so it would make this more concise if I could infer the exact same PluginInstance type (with type arguments) from the arktype type. Err sorry I didn't include what PluginInput, PluginTransform, etc are but those are just function types.

ssalbdivad•2mo ago

The best thing to do if you need the type explicitly would be to just remove all the casts from your type and just annotate pluginInstanceSchema to have the generic signature you need, directly instantiating PluginInstance Like I said though, this is pretty questionable territory as it doesn't really make sense to have a runtime validator that accepts arbitrary TS types as input that affect its inference but do nothing at runtime I'd say it likely indicates that a lot of this shouldn't be validated at runtime at all (usually functions don't need to be)

GenshiiOP•2mo ago

It's moreso that properties like input, diff, etc could be undefined so I at least want to make sure they're functions during runtime.

ssalbdivad•2mo ago

Where are they coming from though? Normally, only external data needs to be checked e.g. a JSON payload or form submission. Functions usually can't even be defined externally

GenshiiOP•2mo ago

A PluginBuilder class that doesn't necessarily guarantee that all the functions will be defined. It's "external" in the sense that people (i.e. users of my library) could incorrectly create a plugin by forgetting to call a method. Which may sound silly or like it's bad design (it might be 😅) but it's the best I have for now

ssalbdivad•2mo ago

Haha yeah you might be overcomplicating things a bit for yourself 😅 If you just want to make sure property was defined and is a function amidst all your internal generic logic, you don't need to wrap everything in a validator to achieve that It is possible to continue down this path and get what you're describing but in addition to probably not being what you'll eventually want, it's also not easy and will require a somewhat deep understanding of generics to be able to compose everything together the way you need. So just proceed at your own risk with the generic solution, I suppose ⚠️

GenshiiOP•2mo ago

Makes sense, thanks. it's probably not really necessary like you said Really appreciate you taking the time to help me out

ssalbdivad•2mo ago

But you learned about some of the advanced features of the library anyways which hopefully will be useful in the future! So maybe not a total loss 😊 Hope it works out! Happy to help

Gaming

Programming

Get ts type that accepts type arguments

Did you find this page helpful?