Best practice for encrypting model properties

## 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.
}
```

Start with DefaultCrudRepository and trace the create path plus the corresponding conversion paths described in the proposal. Define the entityToData and dataToEntity hook behavior, then update the Key Concepts > Repositories documentation with a property encryption/decryption guide; done means the acceptance criteria are covered.

Written by the indexing model from the issue text.