> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Describe cómo probar tus conexiones de base de datos personalizadas en Auth0 Dashboard.
# Probar conexiones de base de datos personalizadas
Si usas la estructura de base de datos alojada por Auth0 para almacenar tus usuarios, puedes probar la conexión autenticando usuarios en el mismo inquilino o en uno distinto.
## Pruebe con la importación de usuarios a Auth0 habilitada
Cuando la importación de usuarios está habilitada, los usuarios se migran gradualmente de su almacén de usuarios externo al almacén de usuarios de Auth0. Durante este proceso, los usuarios se autenticarán en el almacén externo la primera vez que inicien sesión correctamente. Todos los intentos de inicio de sesión posteriores se realizarán en el almacén de usuarios de Auth0. Para obtener más información, consulte la sección sobre migraciones automáticas en [Import and Export Users](/es/docs/manage-users/user-migration).
### Cree un inquilino y una aplicación de prueba
1. Use el Auth0 Dashboard para [crear un nuevo inquilino](/es/docs/get-started/auth0-overview/create-tenants).
2. Vaya a [Applications > Applications](https://manage.auth0.com/#/applications/applications) y cree una aplicación de [Machine-to-Machine](https://manage.auth0.com/#/applications/applications/create).
Debe anotar el **ID de cliente** y el **Secreto del cliente** al crear los scripts de base de datos personalizada. Debe anotar el **ID de cliente** para habilitar los alcances en la Management API.
3. Habilite los grants **Password** y **Client Credential** para esta aplicación (ambos grants deben estar habilitados para esta prueba).
4. Para autorizar la aplicación, vaya a [Applications > APIs](https://manage.auth0.com/#/apis).
5. Seleccione **Management API**.
6. En la pestaña **Machine-to-Machine Applications**, use el interruptor para autorizar la aplicación de prueba.
7. Seleccione el menú desplegable para habilitar los siguientes alcances de la Auth0 Management API:
* `read:users`
* `update:users`
* `delete:users`
* `create:users`
* `read:users_app_metadata`
* `update:users_app_metadata`
* `create:users_app_metadata`
### Crear conexiones de base de datos de prueba
Después de crear un inquilino y una aplicación en Dashboard, crea una conexión de base de datos de origen y una conexión de base de datos de destino.
1. Ve a [Authentication > Database](https://manage.auth0.com/#/connections/database) para crear una nueva conexión de base de datos que será el origen.
2. Asigna un nombre a la conexión de origen de prueba, habilita **Requires Username** y selecciona **Create**.
Puedes crear usuarios para usarlos en tu prueba desde [User Management > Users](https://manage.auth0.com/#/users). Después de seleccionar **Create** **Users** y completar los campos necesarios, selecciona la conexión de base de datos de origen en el campo **Connection**.
3. Crea una segunda base de datos como destino con la misma configuración del paso 2.
Puedes establecer **Password Policy** en **Non-empty password required** tanto en la base de datos de destino como en la de origen para usar contraseñas simples en tus pruebas.
4. En tu base de datos de destino, cambia a la vista **Custom Database** y activa **Use my own database**.
Si quieres hacer pruebas con Organizations en tus bases de datos personalizadas, habilita **Context object in database scripts**.
5. Cambia a la vista **Settings** y habilita **Import Users to Auth0**.
6. Cambia a la vista **Custom Database** y luego busca la sección **Database settings**. Agrega la siguiente información de tu base de datos de origen creada en el paso 1:
| Clave | Valor |
| ----------------- | ---------------------------------------------------------------------------- |
| `client_id` | ID de cliente de la aplicación que creaste. |
| `client_secret` | Secreto del cliente de la aplicación que creaste. |
| `auth0_domain` | El nombre de tu inquilino en el dominio de Auth0: `yourTenant.us.auth0.com`. |
| `source_database` | Nombre de la conexión de origen. |
7. Actualiza los scripts de Action de base de datos [Login](/es/docs/authenticate/database-connections/custom-db/test-custom-database-connections#login) y [Get User](/es/docs/authenticate/database-connections/custom-db/test-custom-database-connections#get-user) en tu base de datos de destino. Para obtener más información sobre las prácticas recomendadas al usar scripts de Action de base de datos, consulta [Prácticas recomendadas para conexiones de bases de datos personalizadas y scripts de Action](/es/docs/authenticate/database-connections/custom-db/custom-database-connections-scripts).
8. Selecciona **Save and Try** en cada script. Debes supervisar la salida de `console.log` en los Registros en tiempo real de Actions. Para obtener más información, consulta [Actions Real-time Logs](/es/docs/customize/actions/actions-real-time-logs).
9. Selecciona **Try Connection** para probar la conexión directamente.
## Probar sin habilitar Import Users
1. Repite los pasos de [Crear un inquilino y una aplicación de prueba](/es/docs/authenticate/database-connections/custom-db/test-custom-database-connections#create-a-test-tenant-and-application).
2. Crea una conexión de base de datos de prueba.
3. Asegúrate de que **Import Users to Auth0** esté deshabilitado en la configuración de tu base de datos de origen. Los usuarios se autenticarán en el almacén de usuarios externo en cada intento de inicio de sesión.
4. Actualiza todos los scripts de acciones de base de datos con los ejemplos a continuación.
### Get User script
El script [Get User](/es/docs/authenticate/database-connections/custom-db/templates/get-user) implementa una función ejecutable que determina el estado actual de un usuario.
Cuando **Import Users to Auth0** está habilitado, el script Get User se ejecuta cuando un usuario intenta registrarse para comprobar si ya existe en el almacén de usuarios externo.
El script Get User también se ejecuta cuando un usuario intenta:
* Cambiar la dirección de correo electrónico de un usuario (script [Change Email](/es/docs/authenticate/database-connections/custom-db/templates/change-email))
* Iniciar sesión (script [Login](/es/docs/authenticate/database-connections/custom-db/templates/login))
* Cambiar la contraseña de un usuario (script [Change Password](/es/docs/authenticate/database-connections/custom-db/templates/change-password))
Cuando **Import Users to Auth0** está deshabilitado, el script Get User se ejecuta cuando un usuario intenta registrarse para comprobar si ya existe en el almacén de usuarios externo. Si el usuario ya existe en el almacén de usuarios externo, no se ejecutará el script Create.
El script Get User también se ejecuta cuando un usuario intenta:
* Crear un usuario (script [Create](/es/docs/authenticate/database-connections/custom-db/templates/create))
* Cambiar la dirección de correo electrónico de un usuario (script [Change Email](/es/docs/authenticate/database-connections/custom-db/templates/change-email))
* Cambiar la contraseña de un usuario (script [Change Password](/es/docs/authenticate/database-connections/custom-db/templates/change-password))
#### Ejemplo
```js lines expandable theme={null}
async function getUser(user, context, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
accessToken = accessToken.access_token;
if (!accessToken) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
log(`The Access Token is available. Searching for user "${user}" in "${configuration.source_database}"`);
user = user.toLowerCase();
const searchQuery = encodeURI(`identities.connection:"${configuration.source_database}"+AND+(email:${user} OR username:${user})`);
var options = {
method: `GET`,
url: `https://${configuration.auth0_domain}/api/v2/users?q=${searchQuery}`,
headers: {
Authorization: `Bearer ${accessToken}`,
}
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
let search_results = JSON.parse(response.body);
let profile = null;
if (search_results.length > 0) {
log(`A user "${user}" is FOUND in "${configuration.source_database}" database.`);
profile = {
user_id: search_results[0].user_id.toString(),
nickname: search_results[0].nickname,
username: search_results[0].username,
email: search_results[0].email
};
} else {
log(`A user "${user}" is NOT FOUND in "${configuration.source_database}" database.`);
}
log(`Script completed!`);
return callback(null, profile);
});
/* -- OBTENER TOKEN DE ACCESO VÍA CREDENCIALES DE CLIENTE -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- REGISTRO -- */
function log(message, error = false) {
const script_name = `GET USER`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Login script
El script [Login](/es/docs/authenticate/database-connections/custom-db/templates/login) implementa una función ejecutable que autentica a un usuario cuando inicia sesión. Si el usuario existe en la base de datos de destino (Auth0), se autentica con ese registro. De lo contrario, se autentica al usuario con su registro en la base de datos de origen (externa).
#### Ejemplo
```javascript lines expandable theme={null}
function login(usernameOrEmail, password, context, callback) {
log(`Script started.`);
const jwt = require('jsonwebtoken');
const options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: { "Content-Type": `application/x-www-form-urlencoded` },
json: true,
form: {
grant_type: `http://auth0.com/oauth/grant-type/password-realm`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
username: usernameOrEmail,
password: password,
realm: `${configuration.source_database}`
}
};
request(options, function (error, response, body) {
log(`Attempting to authenticate a user "${usernameOrEmail}" against "${configuration.source_database}" database in "${configuration.auth0_domain}" tenant.`);
if (error) return log(`Cannot connect to "${configuration.auth0_domain}" database.`, true);
if (response.statusCode !== 200) {
console.log(`LOGIN: (ERROR) ${response.body.error_description}`);
return callback(new WrongUsernameOrPasswordError(usernameOrEmail, `LOGIN: (ERROR) ${response.body.error_description}`));
}
log(`Successfuly authenticated user "${usernameOrEmail}" against "${configuration.source_database}" database in "${configuration.auth0_domain}" tenant.`);
const decoded_id_token = jwt.decode(body.id_token);
const profile = {
user_id: decoded_id_token.sub,
nickname: decoded_id_token.nickname,
username: decoded_id_token.username,
email: decoded_id_token.email
};
log(`Script completed.`);
return callback(null, profile);
});
/* -- REGISTRO -- */
function log(message, error = false) {
const script_name = `LOGIN`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Script de Create
El [script de Create](/es/docs/authenticate/database-connections/custom-db/templates/create) implementa una función ejecutable que crea el registro de usuario correspondiente en la base de datos externa cuando un usuario se registra a través de Universal Login, o se crea en el Auth0 Dashboard o con la Management API de Auth0.
#### Ejemplo
```js lines expandable theme={null}
async function create(user, context, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
if (!accessToken.access_token) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
accessToken = accessToken.access_token;
log(`The Access Token is available. Attempting to create a user "${user.email}" in "${configuration.source_database}"`);
const options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/api/v2/users`,
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": `application/x-www-form-urlencoded`
},
form: {
connection: configuration.source_database,
email: user.email,
password: user.password,
username: user.username
},
json: true
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
switch (response.statusCode) {
case 201:
log(`The user "${user.email}" is successfuly created in "${configuration.source_database}" database.`);
return callback(null);
case 409:
return callback(new ValidationError(`user_exists`, `The user already exists in "${configuration.source_database}" database.`));
default:
return log(`Failed to create a user "${user.email}" in "${configuration.source_database}" database. Error: "${response.statusCode}, ${response.body.message}"`, true);
}
});
/* -- OBTENER TOKEN DE ACCESO VÍA CREDENCIALES DE CLIENTE -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- REGISTRO -- */
function log(message, error = false) {
const script_name = `CREATE`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Script de eliminación
El [script de eliminación](/es/docs/authenticate/database-connections/custom-db/templates/delete) implementa una función ejecutable que elimina un usuario de Auth0 y de la base de datos externa en una sola operación cuando se elimina un usuario en el Auth0 Dashboard o mediante la Auth0 Management API.
#### Ejemplo
```js lines expandable theme={null}
async function deleteUser(user, context, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
if (!accessToken.access_token) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
accessToken = accessToken.access_token;
log(`The Access Token is available. Attempting to delete a user "${user}" from "${configuration.source_database}"`);
const options = {
method: `DELETE`,
url: `https://${configuration.auth0_domain}/api/v2/users/${user}`,
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": `application/x-www-form-urlencoded`
},
json: true
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
switch (response.statusCode) {
case 204:
log(`The user "${user}" is successfuly deleted from "${configuration.source_database}" database.`);
return callback(null);
default:
return log(`Failed to delete a user "${user}" from "${configuration.source_database}" database. Error: "${response.statusCode}, ${response.body.message}"`, true);
}
});
/* -- OBTENER TOKEN DE ACCESO VÍA CREDENCIALES DE CLIENTE -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- REGISTRO -- */
function log(message, error = false) {
const script_name = `DELETE`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Script de verificación
El [script de verificación](/es/docs/authenticate/database-connections/custom-db/templates/verify) implementa una función ejecutable que marca el estado de verificación del correo electrónico de un usuario en la base de datos externa cuando el usuario hace clic en el enlace del correo de verificación enviado por Auth0.
#### Ejemplo
```js lines expandable theme={null}
async function verify(user, context, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
if (!accessToken.access_token) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
accessToken = accessToken.access_token;
log(`The Access Token is available. Searching for user "${user}" in "${configuration.source_database}"`);
user = user.toLowerCase();
const searchQuery = encodeURI(`identities.connection:"${configuration.source_database}"+AND+(email:${user} OR username:${user})`);
var options = {
method: `GET`,
url: `https://${configuration.auth0_domain}/api/v2/users?q=${searchQuery}`,
headers: {
Authorization: `Bearer ${accessToken}`,
}
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
let search_results = JSON.parse(response.body);
if (search_results.length > 0) {
log(`A user "${user}" is found in "${configuration.source_database}" database.`);
const user_id = search_results[0].user_id.toString();
log(`Attempting to mark user "${user_id}" as verified in "${configuration.source_database}" database`);
const options = {
method: `PATCH`,
url: `https://${configuration.auth0_domain}/api/v2/users/${user_id}`,
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": `application/x-www-form-urlencoded`
},
form: {
email_verified: true,
},
json: true
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
switch (response.statusCode) {
case 200:
log(`The user "${user}" is marked as verified in "${configuration.source_database}" database.`);
return callback(null, true);
default:
return log(`Failed to mark a user "${user}" as verified in "${configuration.source_database}" database. Error: "${response.statusCode}, ${response.body.message}"`, true);
}
});
} else {
log(`A user "${user}" is not found in "${configuration.source_database}" database. Unable to verify.`, true);
}
});
/* -- OBTENER TOKEN DE ACCESO VÍA CREDENCIALES DE CLIENTE -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- REGISTRO -- */
function log(message, error = false) {
const script_name = `VERIFY`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Script de Change Password
El [script de Change Password](/es/docs/authenticate/database-connections/custom-db/templates/change-password) implementa una función ejecutable que actualiza la contraseña de un usuario en la base de datos externa cuando se inicia un flujo de cambio de contraseña desde el Auth0 Dashboard o la Auth0 Management API.
#### Ejemplo
```js lines expandable theme={null}
async function changePassword(user, newPassword, context, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
if (!accessToken.access_token) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
accessToken = accessToken.access_token;
log(`The Access Token is available. Searching for user "${user}" in "${configuration.source_database}" database.`);
user = user.toLowerCase();
const searchQuery = encodeURI(`identities.connection:"${configuration.source_database}"+AND+(email:${user} OR username:${user})`);
var options = {
method: `GET`,
url: `https://${configuration.auth0_domain}/api/v2/users?q=${searchQuery}`,
headers: {
Authorization: `Bearer ${accessToken}`,
}
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
let search_results = JSON.parse(response.body);
if (search_results.length > 0) {
log(`A user "${user}" is found in "${configuration.source_database}" database.`);
const user_id = search_results[0].user_id.toString();
log(`Attempting to change password for user "${user_id}" in "${configuration.source_database}" database.`);
const options = {
method: `PATCH`,
url: `https://${configuration.auth0_domain}/api/v2/users/${user_id}`,
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": `application/x-www-form-urlencoded`
},
form: {
password: newPassword,
},
json: true
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
switch (response.statusCode) {
case 200:
log(`The user "${user}" password successfully changed in "${configuration.source_database}" database.`);
return callback(null, true);
default:
return log(`Failed to change password for "${user}" in "${configuration.source_database}" database. Error: "${response.statusCode}, ${response.body.message}"`, true);
}
});
} else {
log(`A user "${user}" is not found in "${configuration.source_database}" database. Unable to change password.`, true);
}
});
/* -- OBTENER TOKEN DE ACCESO VÍA CREDENCIALES DE CLIENTE -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- REGISTRO -- */
function log(message, error = false) {
const script_name = `CHANGE PASSWORD`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
### Script de Change Email
El script [Change Email](/es/docs/authenticate/database-connections/custom-db/templates/change-email) implementa una función ejecutable que actualiza la dirección de correo electrónico de un usuario cuando este cambia su dirección de correo electrónico o el estado de verificación de su correo electrónico.
Este script no está disponible en el Auth0 Dashboard. Debe llamar al endpoint de la Management API [Actualizar una conexión](https://auth0.com/docs/api/management/v2/connections/patch-connections-by-id) y proporcionar la propiedad `options.customScripts.change_email`.
#### Ejemplo
```js lines expandable theme={null}
async function changeEmail(user, newEmail, verified, callback) {
log(`Script started.`);
log(`Requesting an Access Token from "${configuration.auth0_domain}".`);
let accessToken = await getAccessToken();
if (!accessToken.access_token) return log(`Failed to get an Access Token from "${configuration.auth0_domain}".`, true);
accessToken = accessToken.access_token;
log(`The Access Token is available. Searching for user "${user}" in "${configuration.source_database}" database.`);
user = user.toLowerCase();
const searchQuery = encodeURI(`identities.connection:"${configuration.source_database}"+AND+(email:${user} OR username:${user})`);
var options = {
method: `GET`,
url: `https://${configuration.auth0_domain}/api/v2/users?q=${searchQuery}`,
headers: {
Authorization: `Bearer ${accessToken}`,
}
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
let search_results = JSON.parse(response.body);
if (search_results.length > 0) {
log(`A user "${user}" is found in "${configuration.source_database}" database.`);
const user_id = search_results[0].user_id.toString();
log(`Attempting to change email / verified status for user "${user_id}" in "${configuration.source_database}" database.`);
const options = {
method: `PATCH`,
url: `https://${configuration.auth0_domain}/api/v2/users/${user_id}`,
headers: {
Authorization: `Bearer ${accessToken}`,
"Content-Type": `application/x-www-form-urlencoded`
},
form: {
email: newEmail,
email_verified: verified || false
},
json: true
};
request(options, function (error, response) {
if (error) return log(`Cannot connect to "${configuration.source_database}" database.`, true);
switch (response.statusCode) {
case 200:
log(`The user "${user}" email / verified status successfully changed in "${configuration.source_database}" database.`);
return callback(null, true);
default:
return log(`Failed to change email / verified status for "${user}" in "${configuration.source_database}" database. Error: "${response.statusCode}, ${response.body.message}"`, true);
}
});
} else {
log(`A user "${user}" is not found in "${configuration.source_database}" database. Unable to change email / verified status.`, true);
}
});
/* -- OBTENER TOKEN DE ACCESO VÍA CREDENCIALES DE CLIENTE -- */
async function getAccessToken() {
var options = {
method: `POST`,
url: `https://${configuration.auth0_domain}/oauth/token`,
headers: {
"Content-Type": `application/x-www-form-urlencoded`,
},
form: {
grant_type: `client_credentials`,
client_id: configuration.client_id,
client_secret: configuration.client_secret,
audience: `https://${configuration.auth0_domain}/api/v2/`
},
json: true
};
return new Promise(function (resolve) {
request(options, function (error, response) {
resolve(error || response.body);
});
});
}
/* -- REGISTRO -- */
function log(message, error = false) {
const script_name = `CHANGE EMAIL`;
const error_label = error ? `(ERROR)` : ``;
const return_message = `${script_name}: ${error_label} ${message}`;
console.log(return_message);
if (error) return callback(new Error(return_message));
}
}
```
## Más información
* [Seguridad de la contraseña en las conexiones de base de datos de Auth0](/es/docs/authenticate/database-connections/password-strength)
* [Prácticas recomendadas para el entorno del script de Action de base de datos personalizada](/es/docs/authenticate/database-connections/custom-db/custom-database-connections-scripts/environment)
* [Opciones de contraseña en las conexiones de base de datos de Auth0](/es/docs/authenticate/database-connections/password-options)
* [Configurar la conexión del Proveedor de identidad para actualizar el perfil de usuario](/es/docs/manage-users/user-accounts/user-profiles/configure-connection-sync-with-auth0)
* [Prácticas recomendadas para la configuración de conexiones](/es/docs/authenticate/connection-settings-best-practices)
* [Crear conexiones de base de datos personalizadas](/es/docs/authenticate/database-connections/custom-db/create-db-connection)