Confirming the validity of a certain attribute by referencing other attribute keys

Question

Confirming the validity of a certain attribute by referencing other attribute keys

I am looking to enhance the type-checking for the following object:

interface Config {
    fields: Record<string, unknown>;
    table: { id: string }[];
}

const config: Config = {
    fields: {
        id: {}
    },
    table: [
        { id: 'id' },
        { id: 'name' },
    ]
};

The challenge I am facing is ensuring that the type-checking validates that the id in the table object matches a key in the fields. If the id in the table is not present in the keys of fields, then it should result in an error. For example:

{ id: 'id' } should be accepted, as the id key exists in fields
{ id: 'name' } should trigger an error, as the key name does not exist in fields

Is there a way to achieve this? If not, I may consider implementing this check at runtime as a Plan B.

typescript

Answer 1

Answer №1

Currently, it is not feasible to develop a standalone type that can perform validation in that manner. However, utilizing generic types can offer the necessary power to accomplish this task. When it comes to validation, generic types work best when paired with a function.

function useConfig<F>(config: { fields: F, table: { id: keyof F }[]}) {}

Within this function, the generic type F contains details regarding the object supplied with the fields property. The use of keyof F within table is crucial in this context.

Below are some test cases to verify the outcome:

useConfig({
    fields: {
        id: {}
    },
    table: [
        { id: 'id' }
    ]
})
// successful

useConfig({
    fields: {
        id: {}
    },
    table: [
        { id: 'id' },
        { id: 'name' }
    ]
})
// error

useConfig({
    fields: {
        id: {},
        name: {}
    },
    table: [
        { id: 'id' },
        { id: 'name' }
    ]
})
// successful

Interactive Playground

Answer 2

Currently, it is not feasible to develop a standalone type that can perform validation in that manner. However, utilizing generic types can offer the necessary power to accomplish this task. When it comes to validation, generic types work best when paired with a function.

function useConfig<F>(config: { fields: F, table: { id: keyof F }[]}) {}

Within this function, the generic type F contains details regarding the object supplied with the fields property. The use of keyof F within table is crucial in this context.

Below are some test cases to verify the outcome:

useConfig({
    fields: {
        id: {}
    },
    table: [
        { id: 'id' }
    ]
})
// successful

useConfig({
    fields: {
        id: {}
    },
    table: [
        { id: 'id' },
        { id: 'name' }
    ]
})
// error

useConfig({
    fields: {
        id: {},
        name: {}
    },
    table: [
        { id: 'id' },
        { id: 'name' }
    ]
})
// successful

Interactive Playground

Answer 3

Answer №2

interface FieldsType = {id:any}
const configuration:{fields:FieldsType, table:{[key:string]:keyof FieldsType}[]} = {
    fields: {
        id: {},
    },
    table: [
        { id: 'id' },
        { id: 'name' },
    ]
};

Answer 4

interface FieldsType = {id:any}
const configuration:{fields:FieldsType, table:{[key:string]:keyof FieldsType}[]} = {
    fields: {
        id: {},
    },
    table: [
        { id: 'id' },
        { id: 'name' },
    ]
};

Answer 5

Answer №3

This particular approach might be effective, but personally, I find the explicit listing of fields in the generic to be a bit cumbersome. It would be more convenient to have some kind of type inference at play here. ^_^U

type Schema<T extends string> = {
    fields: {
        [K in T]: unknown
    };
    table: { id: T }[];
}

const schema: Schema<'id' | 'name'> = {
    fields: {
        id: {},
        name: {},
    },
    table: [
        { id: 'id' },
        { id: 'title' }, // <== this causes an error
    ]
};

View in Playground.

Answer 6

This particular approach might be effective, but personally, I find the explicit listing of fields in the generic to be a bit cumbersome. It would be more convenient to have some kind of type inference at play here. ^_^U

type Schema<T extends string> = {
    fields: {
        [K in T]: unknown
    };
    table: { id: T }[];
}

const schema: Schema<'id' | 'name'> = {
    fields: {
        id: {},
        name: {},
    },
    table: [
        { id: 'id' },
        { id: 'title' }, // <== this causes an error
    ]
};

View in Playground.

Confirming the validity of a certain attribute by referencing other attribute keys

Answer №1

Answer №2

Answer №3

Similar questions

Can someone explain how this "const s: string = ['a'][1];" is considered a valid Typescript expression?

Using the index in Vue.js to locate a method within an HTML file

What is the most effective method for comparing two arrays of objects and extracting the differing values within a React application?

What is the best way to ensure that two promises are both resolved before triggering a function from within a promise?

Issue with Typescript typing for the onChange event

Whenever I try to import a function, I encounter the error message "no exported member."

Search functionality in Angular using column-based filtering algorithm

Discovering the type in Typescript without explicitly defining a type variable for the callback

Is there a way to access the name of a generic type T class in TypeScript?

Revamp your search experience with Algolia's Angular Instant Search: Design a personalized search box template

Is there a way to prevent the splash screen from appearing every time I navigate using a navbar link in a single page application (SPA)?

Implementing the "$store" property within Vue components

retrieve a nested object's property using a dynamic string

Initialization of an empty array in Typescript

The element 'flat' is not found within the specified type

What is the process for obtaining a flattened tuple type from a tuple comprised of nested tuples?

Guide on loading a PDF asset dynamically within an Angular application with the help of webpack

Angular 8 Issue: Absence of _body and Headers in Response

What is the method for utilizing Tuple elements as keys in a Mapped Type or template literal within typescript?

What could be causing the issue with FindOne not functioning correctly when using TypeORM and MongoDB to find by ID?