constructor(options: Options, attribute: string, config: Partial<ObjectConfig> = {}) {
super(options, attribute, config, false);
this.config = optimal(
this.config,
{
keyType: string('string').notEmpty(),
nullable: bool(),
optional: bool(),
type: string('object').notEmpty(),
valueType: this.createUnionType(),
},
{
name: 'ObjectDefinition',
unknown: true,
},
);
this.keyType = DefinitionFactory.factory(this.options, `${this.attribute}_key`, {
nullable: false,
optional: false,
type: this.config.keyType,
} as StringConfig);
this.valueType = DefinitionFactory.factory(
this.options,
`${this.attribute}_value`,
this.config.valueType,
);
}
constructor(options: Options, attribute: string, config: Partial<PolymorphConfig> = {}) {
super(options, attribute, config, false);
this.config = optimal(
this.config,
{
export: bool(true),
keySuffix: string('_id').notEmpty(),
nullable: bool(),
optional: bool(),
type: string('polymorph').notEmpty(),
typeSuffix: string('_type').notEmpty(),
valueTypes: array(this.createUnionType())
.notEmpty()
.required(),
},
{
name: 'PolymorphDefinition',
unknown: true,
},
);
this.valueTypes = this.config.valueTypes.map((type, i) => {
const valueConfig = toConfig(type);
return DefinitionFactory.factory(this.options, `${this.attribute}_${i}`, {
...valueConfig,
nullable: false,
});
});
}
/**
* Validate the definition configuration.
*/
validateConfig() {
const { name } = this.constructor;
this.config = optimal(
this.config,
{
nullable: bool(),
optional: bool(),
type: string(
normalizeType(name.replace('Definition', '').toLowerCase() || 'unknown'),
).notEmpty(),
},
{
name: name || 'Definition',
unknown: true,
},
) as any;
}
constructor(options: Options, attribute: string, config: Partial<InstanceConfig> = {}) {
super(options, attribute, config, false);
this.config = optimal(
this.config,
{
contract: string()
.required()
.notEmpty(),
nullable: bool(),
optional: bool(),
type: string('instance').notEmpty(),
},
{
name: 'InstanceDefinition',
unknown: true,
},
);
}
constructor(options: Options, attribute: string, config: Partial<ArrayConfig> = {}) {
super(options, attribute, config, false);
this.config = optimal(
this.config,
{
nullable: bool(),
optional: bool(),
type: string('array').notEmpty(),
valueType: this.createUnionType(),
},
{
name: 'ArrayDefinition',
unknown: true,
},
);
this.valueType = DefinitionFactory.factory(this.options, this.attribute, this.config.valueType);
}
constructor(options: Options) {
this.options = optimal(options, {
defaultNullable: bool(),
defaultOptional: bool(),
disableEslint: bool(),
enums: bool(true),
importPath: string('shapeshifter').notEmpty(),
includeAttributes: bool(),
includeDefinitions: bool(),
includeSchemas: bool(),
indentCharacter: string(' ').notEmpty(),
inferPropTypesShape: bool(),
renderers: array(string<RendererType>()).notEmpty(),
schemaGenerics: bool(),
stripPropTypes: bool(),
suffix: bool(true),
useDefine: bool(),
});
}
constructor(options: Options, attribute: string, config: Partial<ReferenceConfig> = {}) {
super(options, attribute, config, false);
this.config = optimal(
this.config,
{
export: bool(true),
nullable: bool(),
optional: bool(),
reference: string().xor('self'),
relation: string(),
self: bool().xor('reference'),
subset: string(),
type: string('reference'),
},
{
name: 'ReferenceDefinition',
unknown: true,
},
);
}
constructor(options: Options, attribute: string, config: Partial<EnumConfig> = {}) {
super(options, attribute, config, false);
this.config = optimal(
this.config,
{
constant: bool(),
nullable: bool(),
optional: bool(),
type: string('enum').notEmpty(),
valueType: this.createUnionType(),
// `valueType` must be validated before values
values: array(custom(this.validateValue, ''))
.notEmpty()
.required(),
},
{
name: 'EnumDefinition',
unknown: true,
},
);
}