TypeScript defaultModelContext.array方法代码示例

 it('should reference schema from cache', () => {
   const arrayModel = defaultModelContext.array().children(model)
   const cache = new Cache()
   const arraySchema = components.getSchema(arrayModel, cache, 'Users')
   expect(arraySchema).toHaveProperty('$ref', '#/definitions/Users')
   const schema = components.getSchema(model, cache)
   expect(schema).toHaveProperty('$ref', '#/definitions/UsersItem')
 })

export function buildSpecification(kiln: IKiln, router: IRouter, overrides?: Partial<Spec>): Spec {
  const schemaCache = new SwaggerSchemaCache()
  for (const kilnModel of kiln.getModels()) {
    const arrayModel = defaultModelContext.array().children(kilnModel.model)
    getSchema(kilnModel.model, schemaCache, startCase(kilnModel.name))
    getSchema(arrayModel, schemaCache, `${startCase(kilnModel.meta.plural)}List`)
  }

  return {
    swagger: '2.0',
    basePath: '/',
    produces: ['application/json'],
    host: 'localhost',
    schemes: ['http'],
    info: {
      title: 'Title',
      version: 'Version',
    },
    paths: buildPaths(router, schemaCache),
    definitions: schemaCache.getUniqueSchemas(),
    ...overrides,
  }
}

export function createValidationMiddleware(
  model: IModel,
  pathInReq: ValidateIn = ValidateIn.Body,
  options: IValidationMiddlewareOptions = {},
): IAnontatedHandler {
  const arrayModel = options.allowedAsList && defaultModelContext.array().children(model)

  return function(req: Request, res: Response, next: NextFunction): void {
    const sourceData = req[pathInReq]
    const validated = req.validated || {}
    const result =
      arrayModel && Array.isArray(sourceData)
        ? arrayModel.validate(sourceData)
        : model.validate(sourceData)
    validated[pathInReq] = result.value
    req.validated = validated

    if (result.conforms) {
      next()
    } else {
      next(result.toError())
    }
  }
}

    byList: false,
    idParamName: undefined,
  },
  getAffectedCriteriaValues(model: IKilnModel, options: IActionOptions): GetCriteriaValues {
    return function(req: Request, property: string): AuthCriteriaValue[] {
      const incomingItems: any[] = [].concat(req.validated!.body)
      const existingItems: any[] = [].concat(req.actionTarget)
      return incomingItems.concat(existingItems).map(item => item[property])
    }
  },
  paramsModel(kilnModel: IKilnModel, options: IActionOptions): IModel | undefined {
    return options.byId ? paramifyModel(kilnModel.model, options) : undefined
  },
  bodyModel(kilnModel: IKilnModel, options: IActionOptions): IModel {
    const updateModel = updateifyModel(kilnModel.model)
    const arrayUpdateModel = defaultModelContext
      .array()
      .children(updateModel)
      .required()
      .strict()
    return options.byList ? arrayUpdateModel : updateModel
  },
  handler(
    model: IKilnModel,
    options: IActionOptions,
    executor: IDatabaseExecutor,
  ): IAnontatedHandler {
    if (options.byId && options.byList) {
      throw new Error('Cannot update both byId and byList')
    }

    return function(req: Request, res: Response, next: NextFunction): void {

      }
    }

    return {permission, getAffectedCriteriaValues}
  },
  queryModel(model: IKilnModel, options: IActionOptions): undefined {
    return undefined
  },
  paramsModel(model: IKilnModel, options: IActionOptions): undefined {
    return undefined
  },
  bodyModel(model: IKilnModel, options: IActionOptions): undefined {
    return undefined
  },
  responseModel(model: IKilnModel, options: IActionOptions): IModel {
    const arrayModel = defaultModelContext
      .array()
      .children(model.model)
      .required()
      .strict()
    return options.byList ? arrayModel : model.model
  },
  lookupActionTarget(
    kilnModel: IKilnModel,
    options: IActionOptions,
    executor: IDatabaseExecutor,
  ): IAnontatedHandler | undefined {
    const actionType = (this as any).type
    if (!actionTypesWithTarget.has(actionType)) return undefined

    const pkField = options.idParamName || getPrimaryKeyField(kilnModel.model)
    const getPkFromItem = (item: any) => (typeof item === 'object' ? item[pkField] : item)

import {IKilnModel} from 'klay-kiln'

import {creatifyModel} from '../helpers/transform-model'
import {ActionType, IAction, IActionOptions, IAnontatedHandler} from '../typedefs'

import {defaultAction} from './action'

export const upsertAction: IAction = {
  ...defaultAction,
  type: ActionType.Upsert,
  defaultOptions: {
    byList: false,
  },
  bodyModel(kilnModel: IKilnModel, options: IActionOptions): IModel {
    const createModel = creatifyModel(kilnModel.model)
    const arrayCreateModel = defaultModelContext
      .array()
      .children(createModel)
      .required()
      .strict()
    return options.byList ? arrayCreateModel : createModel
  },
  handler(
    model: IKilnModel,
    options: IActionOptions,
    executor: IDatabaseExecutor,
  ): IAnontatedHandler {
    // TODO: properly handle actionTarget and permissions
    return function(req: Request, res: Response, next: NextFunction): void {
      const payload = req.validated!.body
      res.promise = options.byList ? executor.upsertAll(payload) : executor.upsert(payload)
      next()