Iniciadores Rápidos
¿Cómo construir un backend para NativeScript?

47min
Introducción
En este tutorial, aprenderás cómo construir un backend para NativeScript utilizando Back4app, una plataforma de código abierto que simplifica el desarrollo de backend para aplicaciones móviles. 
Recorreremos la integración de características esenciales de Back4app—como la gestión de bases de datos, funciones de Cloud Code, puntos finales de API REST y GraphQL, autenticación de usuarios y consultas en tiempo real (Consultas en Vivo)—para crear un backend seguro y escalable para tus aplicaciones de NativeScript.
También descubrirás cómo Back4app reduce drásticamente el tiempo de configuración en comparación con las configuraciones manuales de servidores y bases de datos. 
Exploraremos mecanismos de seguridad avanzados, programación de tareas con Cloud Jobs y el uso de webhooks para conectarnos con servicios de terceros. 
Al final de esta guía, tendrás un backend flexible que aprovecha NativeScript Core, que impulsa las soluciones móviles multiplataforma de NativeScript.
Con esta base, estarás listo para integrar tu propia lógica personalizada o APIs externas según sea necesario. Este será un gran paso hacia el desarrollo de aplicaciones NativeScript listas para producción.
Requisitos previos
Una cuenta de Back4app y un nuevo proyecto de Back4app
Comenzando con Back4app.
Si no tienes una cuenta, puedes crear una gratis. Sigue la guía anterior para preparar tu proyecto.
Entorno de desarrollo básico de NativeScript
Puedes configurarlo utilizando el CLI de NativeScript o otro flujo de trabajo preferido.
Guía de inicio de NativeScript.﻿
Node.js (versión 14 o superior) instalado
Necesitarás Node.js para instalar paquetes npm y ejecutar el CLI de NativeScript. Instalando Node.js﻿
Familiaridad con JavaScript y NativeScript Core
Documentación oficial de NativeScript.
Si eres nuevo en NativeScript, revisa la documentación oficial o un tutorial para principiantes antes de comenzar.
Asegúrate de tener todos estos requisitos previos en su lugar antes de comenzar. Tener tu proyecto de Back4app configurado y tu entorno local de NativeScript listo te ayudará a seguir más fácilmente.
Paso 1 – Configuración del Proyecto Back4app
Crear un Nuevo Proyecto
El primer paso para construir tu backend de NativeScript en Back4app es crear un nuevo proyecto. Si aún no lo has hecho, sigue estos pasos:
Inicia sesión en tu cuenta de Back4app.
Haz clic en el botón “Nueva Aplicación” en tu panel de control de Back4app.
Dale un nombre a tu aplicación (por ejemplo, “NativeScript-Backend-Tutorial”).
﻿
Después de crear el proyecto, lo verás listado en tu panel de control de Back4app. Este proyecto servirá como la base para todas las configuraciones de backend cubiertas en este tutorial.
Conectar el SDK de Parse
Back4app utiliza la Plataforma Parse para manejar tus datos, funcionalidad en tiempo real, autenticación de usuarios y más. Para conectar tu aplicación de NativeScript a Back4app, instala el parse paquete npm e inicialízalo con las credenciales que obtienes de tu panel de control de Back4app.
Recupera tus Claves de Parse:
En tu panel de control de Back4app, ve a la sección “Configuración de la Aplicación” o “Seguridad y Claves” de tu aplicación. Busca tu ID de Aplicación, Clave de JavaScript, y URL del Servidor Parse (en el formato https://parseapi.back4app.com).
﻿
Instalar el SDK de Parse:
Bash
npm install parse
npm install parse
﻿
Luego, inicializa Parse en un archivo de configuración o tu archivo de entrada principal (por ejemplo, app.js). Por ejemplo, podrías crear un archivo llamado parseConfig.js en un proyecto basado en NativeScript:
src/parseConfig.js
import Parse from 'parse';

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

export default Parse;
import Parse from 'parse';

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';

export default Parse;
﻿
Siempre que necesites acceder a Parse en tu aplicación NativeScript, simplemente importa este archivo. Al completar este paso, has establecido una conexión segura entre tu frontend de NativeScript y el backend de Back4app, simplificando las operaciones de datos.
Paso 2 – Configuración de la Base de Datos
Guardar y Consultar Datos
Con tu proyecto de Back4app listo y el SDK de Parse integrado, puedes guardar y consultar datos desde tu aplicación NativeScript. A continuación se muestra un ejemplo utilizando la Parse.Object clase para guardar y obtener una lista de elementos:
JS
// Example: Create a Task item
import Parse from './parseConfig';

async function createTaskItem(title, isCompleted) {
  const Task = Parse.Object.extend('Task');
  const task = new Task();
  task.set('title', title);
  task.set('isCompleted', isCompleted);

  try {
    const savedTask = await task.save();
    console.log('Task saved successfully:', savedTask);
    return savedTask;
  } catch (error) {
    console.error('Error saving Task:', error);
  }
}

// Example: Query all Task items
async function fetchTasks() {
  const Task = Parse.Object.extend('Task');
  const query = new Parse.Query(Task);

  try {
    const results = await query.find();
    console.log('Fetched Task items:', results);
    return results;
  } catch (error) {
    console.error('Error fetching Tasks:', error);
  }
}
// Example: Create a Task item
import Parse from './parseConfig';

async function createTaskItem(title, isCompleted) {
  const Task = Parse.Object.extend('Task');
  const task = new Task();
  task.set('title', title);
  task.set('isCompleted', isCompleted);

  try {
    const savedTask = await task.save();
    console.log('Task saved successfully:', savedTask);
    return savedTask;
  } catch (error) {
    console.error('Error saving Task:', error);
  }
}

// Example: Query all Task items
async function fetchTasks() {
  const Task = Parse.Object.extend('Task');
  const query = new Parse.Query(Task);

  try {
    const results = await query.find();
    console.log('Fetched Task items:', results);
    return results;
  } catch (error) {
    console.error('Error fetching Tasks:', error);
  }
}
﻿
También puedes usar la API REST de Back4app si prefieres llamadas HTTP directas:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy supplies", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Task
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy supplies", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Task
﻿
O usa GraphQL:
GraphQL
mutation {
  createTask(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    task {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTask(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    task {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Esta flexibilidad hace que sea conveniente construir características de backend para tus aplicaciones de NativeScript a través del SDK de Parse, REST o los puntos finales de la API de GraphQL.
Diseño de Esquema y Tipos de Datos
Por defecto, Parse puede crear esquemas automáticamente sobre la marcha, o puedes definir tus clases y tipos de datos en el panel de control de Back4app:
Ve a la sección “Base de datos” en tu panel de control de Back4app.
Crea una nueva clase (por ejemplo, “Tarea”) y agrega columnas como título (String) y isCompleted (Boolean).
Crear Nueva Clase
﻿
Back4app soporta tipos de datos como String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, y Polygon. Puedes dejar que Parse cree estas columnas cuando guardes un objeto por primera vez o definirlas para tener más control.
Crear columna
﻿
Usar el Agente AI de Back4app también puede ayudarte a generar esquemas automáticamente:
Abre el Agente AI en el panel de control de tu aplicación.
Describe tu modelo de datos deseado (por ejemplo, “Por favor, crea una nueva clase de Tarea para aplicaciones móviles con campos isCompleted y dueDate.”).
Deja que el agente cree el esquema automáticamente.
﻿
Datos Relacionales
Si deseas datos relacionales—como un objeto Categoría que apunta a múltiples Tareas—usa Punteros o Relaciones en Parse:
JS
// Linking a Task to a Category with a pointer
async function createTaskForCategory(categoryObjectId, title) {
  const task = new Parse.Object('Task');
  const categoryPointer = new Parse.Object('Category');
  categoryPointer.id = categoryObjectId;

  task.set('title', title);
  task.set('category', categoryPointer);

  try {
    return await task.save();
  } catch (err) {
    console.error('Error creating Task with category relationship:', err);
  }
}

// Including the pointer data in a query
const query = new Parse.Query('Task');
query.include('category');
const tasksWithCategory = await query.find();
// Linking a Task to a Category with a pointer
async function createTaskForCategory(categoryObjectId, title) {
  const task = new Parse.Object('Task');
  const categoryPointer = new Parse.Object('Category');
  categoryPointer.id = categoryObjectId;

  task.set('title', title);
  task.set('category', categoryPointer);

  try {
    return await task.save();
  } catch (err) {
    console.error('Error creating Task with category relationship:', err);
  }
}

// Including the pointer data in a query
const query = new Parse.Query('Task');
query.include('category');
const tasksWithCategory = await query.find();
﻿
Este enfoque te ayuda a obtener datos completos para una Tarea y su Categoría relacionada en una sola consulta.
Consultas en Vivo
Para actualizaciones en tiempo real, habilita Consultas en Vivo en Configuraciones del Servidor en el panel de control de Back4app. Los desarrolladores de NativeScript pueden suscribirse a cambios en una clase específica. Actualiza tu configuración de Parse para incluir una URL de servidor de Consultas en Vivo:
src/parseConfig.js
import Parse from 'parse';

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';
Parse.liveQueryServerURL = 'wss://YOUR_SUBDOMAIN_HERE.b4a.io'; 

export default Parse;
import Parse from 'parse';

// Replace the placeholders with your Back4app credentials
Parse.initialize('YOUR_APPLICATION_ID', 'YOUR_JAVASCRIPT_KEY');
Parse.serverURL = 'https://parseapi.back4app.com';
Parse.liveQueryServerURL = 'wss://YOUR_SUBDOMAIN_HERE.b4a.io'; 

export default Parse;
﻿
Y luego suscríbete a eventos en tiempo real:
JS
import Parse from './parseConfig';

async function subscribeToTasks(callback) {
  const query = new Parse.Query('Task');
  const subscription = await query.subscribe();

  subscription.on('create', (newTask) => {
    console.log('New Task created:', newTask);
    callback('create', newTask);
  });

  subscription.on('update', (updatedTask) => {
    console.log('Task updated:', updatedTask);
    callback('update', updatedTask);
  });

  subscription.on('delete', (deletedTask) => {
    console.log('Task deleted:', deletedTask);
    callback('delete', deletedTask);
  });

  return subscription;
}
import Parse from './parseConfig';

async function subscribeToTasks(callback) {
  const query = new Parse.Query('Task');
  const subscription = await query.subscribe();

  subscription.on('create', (newTask) => {
    console.log('New Task created:', newTask);
    callback('create', newTask);
  });

  subscription.on('update', (updatedTask) => {
    console.log('Task updated:', updatedTask);
    callback('update', updatedTask);
  });

  subscription.on('delete', (deletedTask) => {
    console.log('Task deleted:', deletedTask);
    callback('delete', deletedTask);
  });

  return subscription;
}
﻿
Esta suscripción actualiza automáticamente su interfaz de usuario cada vez que se agrega, modifica o elimina una Tarea, perfecto para aplicaciones colaborativas en tiempo real de NativeScript.
Paso 3 – Aplicando Seguridad con ACLs y CLPs
Mecanismo de Seguridad de Back4app
Back4app incorpora Listas de Control de Acceso (ACLs) y Permisos a Nivel de Clase (CLPs) para proteger sus datos. Estos modelos de seguridad le permiten controlar el acceso de lectura/escritura tanto a nivel de clase como de objeto.
﻿
Listas de Control de Acceso (ACLs)
Una ACL establece permisos para cada objeto. Por ejemplo, para dar solo al propietario acceso de lectura y escritura:
JS
async function createPrivateTask(title, ownerUser) {
  const Task = Parse.Object.extend('Task');
  const task = new Task();
  task.set('title', title);

  const acl = new Parse.ACL(ownerUser);
  acl.setPublicReadAccess(false);
  acl.setPublicWriteAccess(false);
  task.setACL(acl);

  try {
    return await task.save();
  } catch (err) {
    console.error('Error saving private task:', err);
  }
}
async function createPrivateTask(title, ownerUser) {
  const Task = Parse.Object.extend('Task');
  const task = new Task();
  task.set('title', title);

  const acl = new Parse.ACL(ownerUser);
  acl.setPublicReadAccess(false);
  acl.setPublicWriteAccess(false);
  task.setACL(acl);

  try {
    return await task.save();
  } catch (err) {
    console.error('Error saving private task:', err);
  }
}
﻿
Esto asegura que solo el usuario especificado pueda modificar o leer el objeto.
Editar ACL
﻿
Permisos a Nivel de Clase (CLPs)
Los CLPs establecen los permisos predeterminados para toda una clase:
Abre la Base de Datos en Back4app y selecciona la clase relevante.
Accede a los Permisos a Nivel de Clase.
Ajusta los permisos para el público, usuarios autenticados o roles específicos según sea necesario.
﻿
Combinar ACLs y CLPs ofrece un modelo de seguridad sólido para aplicaciones de NativeScript. Para más información, consulta Directrices de Seguridad de la Aplicación.
Paso 4 – Escribir y Desplegar Funciones en la Nube
El Código en la Nube te permite ejecutar código JavaScript personalizado en el lado del servidor, por lo que no necesitas mantener la infraestructura tú mismo. Esto es ideal para agregar lógica avanzada o integraciones solo en el servidor en tu backend de NativeScript.
Cómo Funciona
Normalmente colocas tu Código en la Nube (funciones de JavaScript, triggers y cualquier módulo NPM requerido) en un main.js archivo. Luego lo despliegas en Back4app, y se ejecuta en el entorno del Servidor Parse sin configuración adicional del servidor.
Ejemplo de Estructura de main.js:
JS
const axios = require('axios');

Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

Parse.Cloud.beforeSave('Task', (request) => {
  const task = request.object;
  if (!task.get('title')) {
    throw new Error('Task must have a title');
  }
});
const axios = require('axios');

Parse.Cloud.define('fetchExternalData', async (request) => {
  const url = request.params.url;
  if (!url) {
    throw new Error('URL parameter is required');
  }
  const response = await axios.get(url);
  return response.data;
});

Parse.Cloud.beforeSave('Task', (request) => {
  const task = request.object;
  if (!task.get('title')) {
    throw new Error('Task must have a title');
  }
});
﻿
Puedes instalar y usar paquetes NPM como axios para solicitudes HTTP. Este enfoque permite una amplia gama de integraciones, desde pasarelas de pago hasta APIs externas, todo detrás de la seguridad de tu aplicación Back4app.
Casos de Uso Típicos
Lógica de Negocios: Cálculos automáticos, transformaciones de datos o actualizaciones de estado.
Validaciones de Datos: Asegúrate de que los campos requeridos estén presentes antes de guardar.
Triggers: Ejecuta código cuando se crea, actualiza o elimina datos.
Integraciones: Conéctate con servicios externos para pagos, análisis o mensajería.
Aplicación de Seguridad: Valida los datos entrantes o los roles de usuario antes de continuar.
Despliega Tu Función
Aquí hay una función simple que calcula la longitud del texto:
main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Desplegando a través de Back4app CLI:
Instalar el CLI:
Bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
﻿
Para Windows, descarga el b4a.exe archivo de la página de lanzamientos.
Configura tu clave de cuenta:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
Despliega tu código en la nube:
Bash
b4a deploy
b4a deploy
﻿
Desplegando a través del Panel de Control:
Ve a Cloud Code > Functions en tu panel.
Pega tu código de función en main.js.
Haz clic en Desplegar.
﻿
Llamando a tu función
Desde tu aplicación NativeScript usando el SDK de Parse:
JS
import Parse from './parseConfig';

async function getTextLength(text) {
  try {
    const result = await Parse.Cloud.run('calculateTextLength', { text });
    console.log('Text length:', result.length);
  } catch (err) {
    console.error('Error calling cloud function:', err);
  }
}
import Parse from './parseConfig';

async function getTextLength(text) {
  try {
    const result = await Parse.Cloud.run('calculateTextLength', { text });
    console.log('Text length:', result.length);
  } catch (err) {
    console.error('Error calling cloud function:', err);
  }
}
﻿
También puedes llamarlo usando REST o GraphQL:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello Back4app"}' \
  https://parseapi.back4app.com/functions/calculateTextLength
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello Back4app"}' \
  https://parseapi.back4app.com/functions/calculateTextLength
﻿
GraphQL
mutation {
  calculateTextLength(input: {
    text: "Hello GraphQL"
  }) {
    result
  }
}
mutation {
  calculateTextLength(input: {
    text: "Hello GraphQL"
  }) {
    result
  }
}
﻿
Esto te brinda una forma flexible de integrar lógica del lado del servidor en tus aplicaciones móviles basadas en NativeScript.
Paso 5 – Configurando la Autenticación de Usuarios
Autenticación de Usuarios en Back4app
Back4app utiliza la clase Parse User para manejar la autenticación, que incluye el hash de contraseñas, tokens de sesión y más. Esto elimina gran parte de la complejidad asociada con la gestión de cuentas de usuario.
Configuración de la Autenticación de Usuarios
En tu aplicación NativeScript, puedes crear un nuevo usuario:
JS
import Parse from './parseConfig';

async function signUpUser(username, password, email) {
  const user = new Parse.User();
  user.set('username', username);
  user.set('password', password);
  user.set('email', email);

  try {
    await user.signUp();
    console.log('User signed up successfully!');
  } catch (error) {
    console.error('Error signing up user:', error);
  }
}

async function logInUser(username, password) {
  try {
    const user = await Parse.User.logIn(username, password);
    console.log('User logged in:', user);
  } catch (error) {
    console.error('Error logging in user:', error);
  }
}
import Parse from './parseConfig';

async function signUpUser(username, password, email) {
  const user = new Parse.User();
  user.set('username', username);
  user.set('password', password);
  user.set('email', email);

  try {
    await user.signUp();
    console.log('User signed up successfully!');
  } catch (error) {
    console.error('Error signing up user:', error);
  }
}

async function logInUser(username, password) {
  try {
    const user = await Parse.User.logIn(username, password);
    console.log('User logged in:', user);
  } catch (error) {
    console.error('Error logging in user:', error);
  }
}
﻿
Un ejemplo de REST podría verse así:
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secret123' \
  https://parseapi.back4app.com/login
﻿
Gestión de Sesiones
Después de iniciar sesión, Parse asigna un token de sesión al usuario. Para verificar el usuario actualmente conectado:
JS
const currentUser = Parse.User.current();
if (currentUser) {
  console.log('Logged-in user:', currentUser.getUsername());
} else {
  console.log('No user is logged in');
}
const currentUser = Parse.User.current();
if (currentUser) {
  console.log('Logged-in user:', currentUser.getUsername());
} else {
  console.log('No user is logged in');
}
﻿
Cerrar sesión es simple:
JS
await Parse.User.logOut();
await Parse.User.logOut();
﻿
Integración de Inicio de Sesión Social
Parse también se integra con proveedores de OAuth como Google o Facebook. La configuración varía según el proveedor, así que consulta Iniciar Sesión con Apple y Otros para más detalles. Por ejemplo, con Facebook:
JS
const facebookLogin = async () => {
  try {
    const user = await Parse.FacebookUtils.logIn('email');
    console.log(user.existed() ? 'User logged in' : 'User signed up and logged in');
  } catch (error) {
    console.error('Error logging in with Facebook:', error);
  }
};
const facebookLogin = async () => {
  try {
    const user = await Parse.FacebookUtils.logIn('email');
    console.log(user.existed() ? 'User logged in' : 'User signed up and logged in');
  } catch (error) {
    console.error('Error logging in with Facebook:', error);
  }
};
﻿
Verificación de Correo Electrónico y Restablecimiento de Contraseña
Habilita estas funciones en tu panel de Back4app:
Navega a Configuración de Correo Electrónico en tu aplicación de Back4app.
Habilita la verificación de correo electrónico y restablecimiento de contraseña.
Configura tus plantillas de correo electrónico y la dirección “De”.
Paso 6 – Manejo del Almacenamiento de Archivos
Subiendo y Recuperando Archivos
Back4app soporta la gestión de archivos a través de la Parse.File clase. En NativeScript, puedes subir imágenes o documentos de manera similar:
JS
import Parse from './parseConfig';

async function uploadImage(file) {
  const name = file.name;
  const parseFile = new Parse.File(name, file);

  try {
    const savedFile = await parseFile.save();
    console.log('File saved:', savedFile.url());
    return savedFile.url();
  } catch (err) {
    console.error('Error uploading file:', err);
  }
}

async function createPhotoObject(file) {
  const Photo = Parse.Object.extend('Photo');
  const photo = new Photo();
  const parseFile = new Parse.File(file.name, file);
  photo.set('imageFile', parseFile);

  return await photo.save();
}
import Parse from './parseConfig';

async function uploadImage(file) {
  const name = file.name;
  const parseFile = new Parse.File(name, file);

  try {
    const savedFile = await parseFile.save();
    console.log('File saved:', savedFile.url());
    return savedFile.url();
  } catch (err) {
    console.error('Error uploading file:', err);
  }
}

async function createPhotoObject(file) {
  const Photo = Parse.Object.extend('Photo');
  const photo = new Photo();
  const parseFile = new Parse.File(file.name, file);
  photo.set('imageFile', parseFile);

  return await photo.save();
}
﻿
Puedes recuperar la URL del archivo desde el objeto guardado:
JS
const imageFile = photo.get('imageFile');
const imageUrl = imageFile.url();
// Use imageUrl in your NativeScript UI components
const imageFile = photo.get('imageFile');
const imageUrl = imageFile.url();
// Use imageUrl in your NativeScript UI components
﻿
Seguridad de Archivos
Parse Server te permite configurar la seguridad de la subida de archivos:
JSON
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
{
  "fileUpload": {
    "enableForPublic": true,
    "enableForAnonymousUser": true,
    "enableForAuthenticatedUser": true
  }
}
﻿
Esto asegura que puedes limitar o permitir las subidas de archivos según tus preferencias de seguridad.
Paso 7 – Programando Tareas con Cloud Jobs
Trabajos en la Nube
Trabajos en la Nube te ayudan a automatizar tareas rutinarias, como eliminar registros obsoletos o enviar notificaciones. Por ejemplo:
JS
// main.js
Parse.Cloud.job('cleanupOldTasks', async (request) => {
  const Task = Parse.Object.extend('Task');
  const query = new Parse.Query(Task);

  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTasks = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTasks, { useMasterKey: true });
    return `Deleted ${oldTasks.length} old Tasks.`;
  } catch (err) {
    throw new Error('Cleanup error:' + err.message);
  }
});
// main.js
Parse.Cloud.job('cleanupOldTasks', async (request) => {
  const Task = Parse.Object.extend('Task');
  const query = new Parse.Query(Task);

  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTasks = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTasks, { useMasterKey: true });
    return `Deleted ${oldTasks.length} old Tasks.`;
  } catch (err) {
    throw new Error('Cleanup error:' + err.message);
  }
});
﻿
Desplegar este trabajo a través de CLI o el panel de control.
En el Panel de Control de Back4app > Configuraciones del Servidor > Trabajos en Segundo Plano, prográmalo para que se ejecute diariamente o en un intervalo de tu elección.
Programando un Trabajo en la Nube
﻿
Paso 8 – Integrando Webhooks
Webhooks te permiten enviar solicitudes HTTP a servicios externos cuando ocurren ciertos eventos en tu aplicación, como nuevos registros o registros de usuarios. Esto se puede usar para integrarse con Slack, pasarelas de pago o plataformas de análisis.
Ve a la configuración de Webhooks en tu panel de control de Back4app y selecciona Agregar Webhook.
Agrega tu endpoint URL (por ejemplo, https://your-service.com/webhook).
Configura disparadores para clases o eventos específicos.
Agregando un Webhook
﻿
También puedes definir webhooks en Cloud Code o llamar a APIs externas directamente en disparadores como beforeSave o afterSave.
BeforeSave WebHook
﻿
Paso 9 – Explorando el Panel de Administración de Back4app
El Back4app Admin App es una interfaz centrada en el modelo y fácil de usar para la gestión de datos. Ayuda a equipos o usuarios no técnicos a realizar operaciones CRUD, crear paneles personalizados y gestionar tareas a nivel empresarial sin necesidad de escribir código.
Habilitando la Aplicación de Administración
En tu App Dashboard, haz clic en Más > Aplicación de Administración.
Habilitar Aplicación de Administración.
Habilitar Aplicación de Administración
﻿
Crea un primer usuario administrador (nombre de usuario/contraseña). Esta configuración añade el B4aAdminUser rol y las clases asociadas (B4aSetting, B4aMenuItem, etc.) a tu esquema.
﻿
Elige un subdominio, luego inicia sesión con tus nuevas credenciales de administrador:
﻿
﻿
Este portal permite una rápida manipulación de datos sin salir de una interfaz gráfica, una gran solución para colaborar con miembros del equipo que pueden no estar familiarizados con la codificación.
Conclusión
Siguiendo esta guía, has aprendido cómo construir un backend para NativeScript utilizando Back4app y:
Creado un backend seguro para tus aplicaciones NativeScript.
Configurado una base de datos con clases, esquemas y relaciones.
Implementado consultas en tiempo real para actualizaciones en vivo.
Asegurado tus datos con ACLs y CLPs.
Ampliado la funcionalidad con Cloud Code.
Configurado la autenticación para el registro de usuarios, inicio de sesión y tokens de sesión.
Gestionado cargas de archivos y recuperación a través de Parse File.
Programado Cloud Jobs para tareas automatizadas y periódicas.
Creado Webhooks para integraciones de terceros.
Usado el Panel de Administración de Back4app para la gestión de datos sin código.
Estos pasos forman una base sólida para construir aplicaciones móviles de código abierto y multiplataforma con NativeScript Core. Continúa explorando características avanzadas, incorpora más puntos finales de API o integra tu propia lógica personalizada para adaptar el backend a las necesidades exactas de tu aplicación.
Próximos Pasos
Escala tus aplicaciones NativeScript optimizando el rendimiento, la caché y las reglas de seguridad.
Explora la gestión avanzada de usuarios como permisos basados en roles.
Consulta la documentación oficial de Back4app para guías detalladas sobre seguridad, registros y rendimiento.
Experimenta con integraciones del mundo real como herramientas de pagos o análisis.
¡Feliz codificación y disfruta del flujo de trabajo de desarrollo optimizado que Back4app proporciona!
Actualizado 23 Jan 2025
¿Esta página le fue útil?
¿Cómo construir un backend para htmx?
¿Cómo construir un backend para ASP.NET Core?