TypeScript modelAssertions.ok方法代码示例

  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
  }

 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!
 }

  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 _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
  }

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
  }

  const routes: IRouterRoute[] = map(routerOptions.routes, (typeOrOption, key) => {
    const [method, path] = key.split(' ')
    const routeOptions = typeof typeOrOption === 'string' ? {type: typeOrOption} : typeOrOption
    const route = createRouteOrActionRoute(routeOptions, routerOptions, kilnModel, executor)

    for (const [name, handler] of entries(route.paramHandlers)) {
      const existing = paramHandlers[name] || handler
      modelAssertions.ok(
        isEqual(existing.model.spec, handler.model.spec),
        `incompatible params model for ${name}`,
      )

      paramHandlers[name] = handler
    }

    return {
      path,
      method: method.toLowerCase() as HTTPMethod,
      options: routeOptions,
      kilnModel,
      ...route,
    }
  })

 private _getModelOrThrow(modelName: string): IKilnModel {
   const kilnModel = this._models.get(modelName)
   modelAssertions.ok(kilnModel, `unable to find model "${modelName}"`)
   return kilnModel!
 }