public addModel(kilnModel: IKilnModelInput): IKiln {
modelAssertions.typeof(kilnModel.name, 'string', 'name')
modelAssertions.ok(kilnModel.model.isKlayModel, 'model must be a klay model')
modelAssertions.ok(!this._models.has(kilnModel.name), 'model with same name already exists')
const meta = {plural: `${kilnModel.name}s`, ...kilnModel.meta}
this._models.set(kilnModel.name, {...kilnModel, meta, extensions: new Map()})
return this
}
public index(properties: IIndexPropertyInput[]): IDatabaseOptions {
assertions.typeof(properties, 'array', 'index')
assertions.ok(properties.length, 'must specify at least 1 property for index')
properties.forEach((item, i) => {
properties[i] = DatabaseOptions._determineIndex(item, i)
})
this.spec.index.push(properties as IIndexProperty[])
return this
}
private static _determineIndex(property: IIndexPropertyInput, i: number): IIndexProperty {
if (Array.isArray(property)) {
return {property, direction: SortDirection.Ascending}
}
assertions.typeof(property, 'object')
assertions.typeof(property.property, 'array', `index.${i}.property`)
assertions.oneOf(property.direction, values(SortDirection), `index.${i}.property`)
return property
}
public automanage(property: IAutomanagePropertyInput): IDatabaseOptions {
assertions.typeof(property, 'object', 'automanage')
property.property = property.property || []
property.phase = property.phase || ValidationPhase.Parse
property.supplyWith = DatabaseOptions._determineSupplyWith(property.supplyWith)
assertions.typeof(property.property, 'array', 'automanage.propertyPath')
assertions.oneOf(property.event, values(DatabaseEvent), 'automanage.event')
assertions.oneOf(property.phase, values(ValidationPhase), 'automanage.phase')
this.spec.automanage.push(property as IAutomanageProperty)
return this
}
export function findModel(model: IModel, pathToModel: string[]): IModel {
let target = model
const parts = pathToModel.slice()
while (parts.length) {
modelAssertions.typeof(target.spec.children, 'array', 'children')
const nextPath = parts.shift()
const found = (target.spec.children as IModelChild[]).find(child => child.path === nextPath)
modelAssertions.ok(found, `could not find model child ${nextPath}`)
target = found!.model
}
return target
}
public constrain(input: IConstraintInput): IDatabaseOptions {
assertions.typeof(input, 'object', 'constrain')
input.properties = input.properties || [[]]
input.meta = input.meta || {}
assertions.typeof(input.properties, 'array', 'constrain.propertyPaths')
assertions.ok(input.properties.length, 'must specify at least 1 property for constrain')
assertions.oneOf(input.type, values(ConstraintType), 'constrain.type')
assertions.typeof(input.meta, 'object')
const constrain = input as IConstraint
constrain.name = DatabaseOptions.computeConstraintName(constrain)
constrain.meta = DatabaseOptions.computeMetaProperties(constrain)
this.spec.constrain.push(constrain)
return this
}
public addExtension(input: IKilnExtensionInput<any>): IKiln {
const {modelName, extension, defaultOptions} = input
modelAssertions.typeof(extension.name, 'string', 'name')
modelAssertions.typeof(extension.defaultOptions, 'object', 'options')
modelAssertions.typeof(extension.build, 'function', 'build')
if (modelName) {
this._getModelOrThrow(modelName).extensions.set(extension.name, {extension, defaultOptions})
} else {
for (const kilnModel of this._models.values()) {
kilnModel.extensions.set(extension.name, {extension, defaultOptions})
}
}
return this
}
forEach(rootModel.spec.db!.automanage, item => {
if (item.phase === ValidationPhase.Database) return
if (!eventMatches(item.event, event)) return
modelAssertions.typeof(item.supplyWith, 'function')
const model = findModel(rootModel, item.property)
model.coerce(item.supplyWith as ICoerceFunction, item.phase)
})
private _getExtensionInputOrThrow<TResult, TOptions>(
modelName: string,
extensionName: string,
): IKilnExtensionInput<TResult, TOptions> {
const extension = this._getExtensionInput<TResult, TOptions>(modelName, extensionName)
modelAssertions.ok(extension, `unable to find extension "${extensionName}"`)
return extension!
}
private static _determineSupplyWith(
supplyWith: ISupplyWithFunction | SupplyWithPreset,
): ISupplyWithFunction | SupplyWithPreset {
if (supplyWith === SupplyWithPreset.AutoIncrement || typeof supplyWith === 'function') {
return supplyWith
}
const supplyWithFunc = supplyWithPresets[supplyWith]
assertions.ok(supplyWithFunc, 'invalid automanage supplyWith')
return supplyWithFunc
}
