export function creatifyModel(original: IModel): IModel {
  const model = original.clone()
  const automanage = model.spec.db!.automanage
  const automanagedPaths = automanage
    .filter(item => eventMatches(item.event, DatabaseEvent.Create))
    .map(item => item.property)
  return omitAll(model, automanagedPaths)
}

export function getModelForEvent(original: IModel, event: DatabaseEvent): IModel {
  const model = original.clone()
  if (!model.spec.db) {
    return model
  }

  setDatabaseProperties(model, event)
  setAutomanagePhaseProperties(model, event)
  return model
}

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 updateifyModel(original: IModel): IModel {
  const model = original.clone()
  const constraints = model.spec.db!.constrain
  const automanage = model.spec.db!.automanage
  const automanagedPaths = automanage
    .filter(item => eventMatches(item.event, DatabaseEvent.Update))
    .map(item => item.property)
  const immutableProperties = constraints
    .filter(item => item.type === ConstraintType.Immutable)
    .map(item => item.properties)

  const mergedPaths = [...automanagedPaths, ...flatten(immutableProperties)]
  for (const path of mergedPaths) {
    const childModel = findModel(model, path)
    childModel.optional()
  }

  return model
}

  public async create(object: object, extras?: IQueryExtras): Promise<object> {
    const record = this._createModel.validate(object, {failLoudly: true}).value as object
    await evaluateUniqueConstraints(this, this._model, record, extras)
    await evaluateCustomConstraints(
      this,
      this._model,
      record,
      undefined,
      DatabaseEvent.Create,
      extras,
    )

    return this._executor.save(record, extras)
  }

  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())
    }
  }

  public async update(object: object, extras?: IQueryExtras): Promise<object> {
    const primaryKey = getPrimaryKey(this._model, object)
    const record = this._updateModel.validate(object, {failLoudly: true}).value as object
    const existing = await this.findByIdOrThrow(primaryKey!)
    await evaluateImmutableConstraints(this, this._model, record, existing, extras)
    await evaluateUniqueConstraints(this, this._model, record, extras)
    await evaluateCustomConstraints(
      this,
      this._model,
      record,
      existing,
      DatabaseEvent.Update,
      extras,
    )

    return this._executor.save(record, extras)
  }