export function paramifyModel(original: IModel, options?: IParamifyOptions): IModel {
  const model = original.clone()
  const pkField = getPrimaryKeyField(original)
  const paramName = (options && options.idParamName) || pkField
  const children = model.spec.children as IModelChild[]
  const pkModel = children
    .find(child => child.path === pkField)!
    .model.strict(false)
    .required()
  model.spec = {}
  return model.type(ModelType.Object).children({[paramName]: pkModel})
}

export function addForeignKeys(
  modelInProgress: Sequelize.DefineAttributes,
  model: IModel,
  kiln: IKiln,
): void {
  const constraints = model.spec.db!.constrain
  for (const constraint of constraints) {
    if (constraint.type !== ConstraintType.Reference) {
      continue
    }

    assert.ok(constraint.properties.length === 1, 'foreign key must be single field')
    const fkName = getFlattenedPath(constraint.properties[0])
    const fkDefinition = modelInProgress[fkName] as Sequelize.DefineAttributeColumnOptions
    const sqlExecutor = kiln.build<ISQLExecutor>(constraint.meta.referencedModel!, SQL_EXECUTOR)
    fkDefinition.references = {
      key: getPrimaryKeyField(sqlExecutor.kilnModel.model),
      model: sqlExecutor.sequelizeModel,
    }
  }
}

    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)

    return async function(
      req: express.Request,
      res: express.Response,
      next: express.NextFunction,
    ): Promise<void> {
      const params = req.validated!.params
      const body = req.validated!.body

      if (options.byList) {
        const ids = (body as any[]).map(getPkFromItem)
        req.actionTarget = await Promise.all(ids.map(id => executor.findByIdOrThrow(id)))
      } else {
        req.actionTarget = await executor.findByIdOrThrow(

export function addPrimaryKey(modelInProgress: Sequelize.DefineAttributes, model: IModel): void {
  const pkName = getPrimaryKeyField(model)
  const pkDefinition = modelInProgress[pkName] as Sequelize.DefineAttributeColumnOptions
  pkDefinition.primaryKey = true
  pkDefinition.allowNull = false
}

   byId: true,
   byList: false,
   idParamName: undefined,
 },
 getAffectedCriteriaValues(model: IKilnModel, options: IActionOptions): GetCriteriaValues {
   return function(req: Request, property: string): AuthCriteriaValue[] {
     const items: any[] = [].concat(req.actionTarget)
     return items.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 | undefined {
   if (options.byId) return
   const pkField = getPrimaryKeyField(kilnModel.model)
   const pkModel = findModel(kilnModel.model, [pkField])
   const arrayPkModel = defaultModelContext
     .array()
     .children(pkModel)
     .required()
   return options.byList ? arrayPkModel : pkModel
 },
 responseModel(): undefined {
   return undefined
 },
 handler(
   kilnModel: IKilnModel,
   options: IActionOptions,
   executor: IDatabaseExecutor,
 ): IAnontatedHandler {