Best practice for encrypting model properties

Nadie ha tomado este issue todavía.

## Description / Steps to reproduce / Feature proposal
In my application, I have models with properties that need to be encrypted before saved in the database.
I'm trying to decide what's the best practice to implement that use-case.

## Current implementation
What I'm currently doing is set an attribute in the property itself:
`encrypted: true`

In my repository, I override the relevant methods. e.g. create:

```
async create(entity: DataObject, options?: AnyObject): Promise {
for (let propertyName in this.entityClass.definition.properties) {
if (this.entityClass.definition.properties[propertyName]['encrypted']) {
entity[propertyName] = encrypted(entity, propertyName)
}
}
return (await super.create(entity, options));
}
```

There are a couple of problems with this implementation.
- This method is not generic, as if tomorrow I would like to implement another logic?
- It requires to override a lot of methods in the repository.
- It requires editing per repository meaning that the CLI only covers a small part of the creation process.

Is there any better implementation for this issue?

## Acceptance criteria

- [ ] A mechanism allowing Repository classes to execute custom code whenever the repository is trying to convert model instance into raw data to be stored and also from the raw data to model instance. This is basically an Operation Hook, and it should be implemented by DefaultCrudRepository. See #2095 (comment) for more details, the code snippet is cross-posted below.

- [ ] A section in our documentation (e.g. in [Key Concepts >> Repositories](https://loopback.io/doc/en/lb4/Repositories.html)) explaining how to use these new mechanism.

- [ ] A guide in our documentation showing how can applications implement property encryption/decryption.

Proposed implementation:

```ts
class DefaultCrudRepository /*...*/{
protected async entityToData(entity: DataObject, options?: Options): DataObject {
// "persist hook" - no-op by default
return entity;
}

protected async dataToEntity(data: DataObject, options?: Options): DataObject {
// "load hook" - no-op by default
return this.toEntity(data);
}

async create(entity: DataObject, options?: Options): Promise {
const data = await this.entityToData(entity, options);
const model = await ensurePromise(this.modelClass.create(data, options));
const result = await this.dataToEntity(model);
return result;
}

// etc.
}
```

Comienza con DefaultCrudRepository y rastrea el create path junto con los conversion paths correspondientes descritos en la propuesta. Define el comportamiento de los hooks entityToData y dataToEntity, y después actualiza la documentación de Key Concepts > Repositories con una guía sobre el cifrado/descifrado de propiedades; se considera terminado cuando los criterios de aceptación están cubiertos.

Escrito por el modelo de indexación a partir del texto del issue.