Alright, I believe I've cracked it, although the current solution may not be aesthetically pleasing and could use some enhancements. Essentially, I've utilized a mapped type named DataOrFuncValuesObject. This type maps the target type (Schema in this case) to an object type where the keys remain the same, but the value types are categorized as a union of two objects: one in its original form (col1: string) and another in a function form (
"$col1.$func": Record<string, any[]>
). Subsequently, I leverage a type inspired by an existing answer, which I've dubbed
PropertyValueIntersection to extract these property values as an intersection. So, given:
type Schema = {
col1: string;
col2: string;
};
The result is as follows:
type Result =
& ({ col1: string} | {$"col1.$func": Record<string, any[]>})
& ({ col2: string} | {$"col2.$func": Record<string, any[]>});
Here's how it looks:
export const FUNC_ENDING_HINT = "$func" as const;
// Symbol conversion to never (refer to next type)
type NonSymbol<K extends PropertyKey> = K extends Symbol ? never : K;
// Transforming the provided object into another object featuring properties with types
// that are unions of the key and its corresponding value or the mapped key along with
// the 'Record<string, any[]>' type.
// Note: The 'NonSymbol' piece is only necessary if your configuration doesn't exclusively support strings as keys.
type DataOrFuncValuesObject<ObjectType> = {
[Key in keyof ObjectType]:
| { [K in Key]: ObjectType[Key] }
| { [K in `${NonSymbol<Key>}.${typeof FUNC_ENDING_HINT}`]: Record<string, any[]> };
};
// Derive the property types of each property within the given object as an intersection
// (Referenced from https://stackoverflow.com/a/66445507/157247).
// It was titled 'ParamIntersection' there and wasn't generic; however, that's where I obtained it.
type PropertyValueIntersection<O> = {
[K in keyof O]: (x: O[K]) => void;
}[keyof O] extends (x: infer I) => void
? I
: never;
// Our customized type mapping
type DataOrFuncFromObject<TD> = PropertyValueIntersection<DataOrFuncValuesObject<TD>>;
I find the 'NonSymbol' element within the template literal of 'DataOrFuncValuesObject' somewhat hacky. My belief is that I should be able to exclude 'symbol' from the potential types of 'Key' earlier on, but my endeavors to achieve that have been unsuccessful.
Application/tests:
type Schema = {
col1: string;
col2: string;
};
// Passes
const basic: DataOrFuncFromObject<Schema> = {
col1: "",
col2: "",
};
// Succeeds
const funcs: DataOrFuncFromObject<Schema> = {
"col1.$func": { func: [] },
"col2.$func": { func: [] },
};
// Valid
const mixed: DataOrFuncFromObject<Schema> = {
col1: "",
"col2.$func": { func: [] },
};
// Throws an error due to missing `col1` / `"col1.$func"`
const wrong: DataOrFuncFromObject<Schema> = {
"col2.$func": { func: [] },
};
confirmed in a comment that was acceptable (though suboptimal). Should you wish to prohibit such occurrences, we can modify DataOrFuncValuesObject by incorporating the "other" property in each object type within the union as an optional attribute with the type never:
// Converts the given object into an object where each property's type is
// a union of the key and its value type or the mapped key and the
// `Record<string, any[]>` type.
// Note: You only need the `NonSymbol` thing below if your configuration
// has `keyofStringsOnly` turned off.
type DataOrFuncValuesObject<ObjectType> = {
[Key in keyof ObjectType]:
| ({ [K in Key]: ObjectType[Key] } & {
[K in `${NonSymbol<Key>}.${typeof FUNC_ENDING_HINT}`]?: never;
})
| ({ [K in `${NonSymbol<Key>}.${FUNC_ENDING_HINT}`]: Record<string, any[]> } & {
[K in Key]?: never;
});
};
Consequently, the subsequent time:
// ERROR, both 'col1' and '"col1.$func"' cannot coexist
const wrong2: DataOrFuncFromObject<Schema> = {
col1: "",
"col1.$func": { func: [] },
"col2.$func": { func: [] },
};
Okay, I think I've got it, but it's ugly and I bet it can be improved. I've used a mapped type called DataOrFuncValuesObject that maps the target type (Schema in the example) to an object type where the keys are the same but the value types are a union of objects, one in the original form (col1: string) and one in the function form (
"$col1.$func": Record<string, any[]>
). Then I use a type inspired by this answer which I've called
PropertyValueIntersection to extract those property values as an intersection. So given:
type Schema = {
col1: string;
col2: string;
};
...the result is:
type Result =
& ({ col1: string} | {$"col1.$func": Record<string, any[]>})
& ({ col2: string} | {$"col2.$func": Record<string, any[]>});
Here it is:
export const FUNC_ENDING_HINT = "$func" as const;
// Converts Symbol to never (see next type)
type NonSymbol<K extends PropertyKey> = K extends Symbol ? never : K;
// Converts the given object into an object where each property's type is
// a union of the key and its value type or the mapped key and the
// `Record<string, any[]>` type.
// Note: You only need the `NonSymbol` thing below if your configuration
// has `keyofStringsOnly` turned off.
type DataOrFuncValuesObject<ObjectType> = {
[Key in keyof ObjectType]:
| { [K in Key]: ObjectType[Key] }
| { [K in `${NonSymbol<Key>}.${typeof FUNC_ENDING_HINT}`]: Record<string, any[]> };
};
// Extract the property types of the properties in the given object
// as an intersection; see https://stackoverflow.com/a/66445507/157247
// (It's called `ParamIntersection` there and isn't generic, but that's
// where I got this from.)
type PropertyValueIntersection<O> = {
[K in keyof O]: (x: O[K]) => void;
}[keyof O] extends (x: infer I) => void
? I
: never;
// Our mapped type
type DataOrFuncFromObject<TD> = PropertyValueIntersection<DataOrFuncValuesObject<TD>>;
The NonSymbol thing in the template literal in DataOrFuncValuesObject feels like a hack, it seems to me I should be able exclude symbol from the possible types of Key earlier, but my attempts to do that failed.
Usage/tests:
type Schema = {
col1: string;
col2: string;
};
// OK
const basic: DataOrFuncFromObject<Schema> = {
col1: "",
col2: "",
};
// OK
const funcs: DataOrFuncFromObject<Schema> = {
"col1.$func": { func: [] },
"col2.$func": { func: [] },
};
// OK
const mixed: DataOrFuncFromObject<Schema> = {
col1: "",
"col2.$func": { func: [] },
};
// ERROR, missing `col1` / `"col1.$func"
const wrong: DataOrFuncFromObject<Schema> = {
"col2.$func": { func: [] },
};
Playground link
That version does allow both col1 and "col1.$func" in the same object, which you confirmed in a comment was okay (though not ideal). But if you want to disallow that, we can do that by modifying DataOrFuncValuesObject to include the "other" property in each object type in the union as an optional property with the type never:
// Converts the given object into an object where each property's type is
// a union of the key and its value type or the mapped key and the
// `Record<string, any[]>` type.
// Note: You only need the `NonSymbol` thing below if your configuration
// has `keyofStringsOnly` turned off.
type DataOrFuncValuesObject<ObjectType> = {
[Key in keyof ObjectType]:
| ({ [K in Key]: ObjectType[Key] } & {
[K in `${NonSymbol<Key>}.${typeof FUNC_ENDING_HINT}`]?: never;
})
| ({ [K in `${NonSymbol<Key>}.${typeof FUNC_ENDING_HINT}`]: Record<string, any[]> } & {
[K in Key]?: never;
});
};
Then this test happily fails:
// ERROR, can't have both `col1` and `"col1.$func"`
const wrong2: DataOrFuncFromObject<Schema> = {
col1: "",
"col1.$func": { func: [] },
"col2.$func": { func: [] },
};
Playground link