Quickstarters
¿Cómo construir un backend para SwiftUI?

41min
Introducción
En este tutorial, aprenderás a construir un backend completo para una SwiftUI aplicación iOS utilizando Back4App. 
Te mostraremos cómo integrar el SDK de Parse Swift en tu proyecto de SwiftUI y aprovechar las características clave de Back4App, como la gestión de bases de datos, funciones de Cloud Code, APIs REST y GraphQL, autenticación de usuarios y consultas en tiempo real, para crear un backend seguro y escalable. 
Este enfoque te ayuda a almacenar datos de forma segura, realizar operaciones del lado del servidor sin configurar tu propia infraestructura y escalar fácilmente tu aplicación iOS o aplicación web según sea necesario.
También verás cómo la configuración rápida de Back4app y su entorno intuitivo pueden reducir drásticamente el tiempo y el esfuerzo en comparación con la configuración manual de tu propio servidor y base de datos. 
Al final, entenderás cómo construir un backend para SwiftUI que puede ser ampliado a un entorno de producción o integrado con lógica y APIs personalizadas. 
¡Comencemos a crear un robusto, backend escalable con un mínimo de sobrecarga!
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 básico de desarrollo de SwiftUI
Necesitarás Xcode instalado en tu máquina y un proyecto básico de SwiftUI o iOS configurado.
Swift Package Manager o CocoaPods
Para agregar el SDK de Parse Swift. Documentación del SDK de Parse Swift.﻿
Familiaridad con Swift y SwiftUI
Si eres nuevo en SwiftUI, revisa Documentación de SwiftUI de Apple. antes de comenzar.
Asegúrate de que todo esté en su lugar antes de comenzar. Tener tu proyecto de Back4app configurado y tu entorno local de SwiftUI listo te ayudará a seguir más fácilmente.
Paso 1 – Configuración del Proyecto de Back4app
Crear un Nuevo Proyecto
El primer paso para construir tu backend de SwiftUI en Back4App es crear un nuevo proyecto. Si aún no has creado uno, sigue estos pasos:
Inicia sesión en tu cuenta de Back4app.
Haz clic en el botón “Nueva App” en tu panel de control de Back4app.
Dale un nombre a tu app (por ejemplo, “SwiftUI-Backend-Tutorial”).
﻿
Una vez que se crea el proyecto, lo verás listado en tu panel de control de Back4app. Este proyecto será la base para todas las configuraciones de backend discutidas en este tutorial.
Conectar el SDK de Parse Swift
Back4app se basa en la Plataforma Parse para gestionar tus datos, proporcionar características en tiempo real, manejar la autenticación de usuarios y más. Conectar tu aplicación de SwiftUI a Back4app implica instalar el SDK de Parse Swift e inicializarlo con las credenciales de tu panel de control de Back4app.
Recupera tus claves de Parse:
En tu panel de Back4app, navega a la sección “Configuración de la aplicación” o “Seguridad y claves” de tu aplicación para encontrar tu ID de aplicación y Clave de cliente (o Clave de JavaScript). También encontrarás la URL del servidor de Parse (a menudo en el formato https://parseapi.back4app.com).
﻿
Instala el SDK de Parse para Swift:
Si usas Swift Package Manager, abre tu proyecto en Xcode y luego:
Archivo → Agregar paquetes → ingresa la URL https://github.com/netreconlab/Parse-Swift.git.
Elige “Hasta la próxima versión importante” de las reglas de versión y confirma.
Si usas CocoaPods:
Bash
pod 'ParseSwiftOG'
pod 'ParseSwiftOG'
﻿
Inicializa Parse en tu aplicación. Por ejemplo, en tu App struct:
Swift
@main
struct MyApp: App {
    init() {
        do {
            try await ParseSwift.initialize(
                applicationId: "YOUR_APP_ID",
                clientKey: "YOUR_CLIENT_KEY",
                serverURL: URL(string: "https://parseapi.back4app.com")!
            )
        } catch {
            print("Error initializing Parse: \(error)")
        }
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
@main
struct MyApp: App {
    init() {
        do {
            try await ParseSwift.initialize(
                applicationId: "YOUR_APP_ID",
                clientKey: "YOUR_CLIENT_KEY",
                serverURL: URL(string: "https://parseapi.back4app.com")!
            )
        } catch {
            print("Error initializing Parse: \(error)")
        }
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
﻿
Al completar este paso, has establecido una conexión segura entre tu front-end de SwiftUI y el backend de Back4app. Todas las solicitudes y transacciones de datos son manejadas por el SDK de Parse Swift, reduciendo la complejidad de las llamadas manuales REST o GraphQL (aunque aún puedes usarlas cuando sea necesario).
Paso 2 – Configuración de la Base de Datos
Guardando y Consultando Datos
Con tu proyecto de Back4app configurado y el SDK de Parse Swift integrado, ahora puedes comenzar a guardar y recuperar datos. A continuación se muestra un simple ParseObject ejemplo. Supongamos que tenemos una Todo estructura:
Swift
import ParseSwift

struct Todo: ParseObject {
    // ParseObject conformance
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}
import ParseSwift

struct Todo: ParseObject {
    // ParseObject conformance
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}
﻿
Guardando un nuevo Todo:
Swift
func createTodoItem(title: String, isCompleted: Bool) async {
    var todo = Todo()
    todo.title = title
    todo.isCompleted = isCompleted
    do {
        let savedTodo = try await todo.save()
        print("Todo saved successfully: \(savedTodo)")
    } catch {
        print("Error saving Todo: \(error)")
    }
}
func createTodoItem(title: String, isCompleted: Bool) async {
    var todo = Todo()
    todo.title = title
    todo.isCompleted = isCompleted
    do {
        let savedTodo = try await todo.save()
        print("Todo saved successfully: \(savedTodo)")
    } catch {
        print("Error saving Todo: \(error)")
    }
}
﻿
Consultando todos los Todos:
Swift
func fetchTodos() async {
    do {
        let todos = try await Todo.query().find()
        print("Fetched Todos: \(todos)")
    } catch {
        print("Error fetching Todos: \(error)")
    }
}
func fetchTodos() async {
    do {
        let todos = try await Todo.query().find()
        print("Fetched Todos: \(todos)")
    } catch {
        print("Error fetching Todos: \(error)")
    }
}
﻿
Alternativamente, puedes usar Back4app’s REST API endpoints, o GraphQL:
Curl
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 groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
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 groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
GraphQL:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Tener múltiples opciones (Parse Swift SDK, REST, GraphQL) te permite elegir el enfoque que mejor funcione para tu flujo de trabajo.
Diseño de Esquema y Tipos de Datos
Por defecto, Parse permite la creación de esquemas sobre la marcha, pero también puedes definir tus clases en el panel de control de Back4app para tener más control.
Navega a la sección “Base de Datos” en tu panel de control de Back4app.
Crea una nueva clase (por ejemplo, “Todo”) y agrega columnas relevantes, como title (String) y isCompleted (Boolean).
Crear nueva clase
﻿
Back4app admite varios tipos de datos: String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, y Polygon. Puedes elegir el tipo apropiado para cada campo.
Crear columna
﻿
Back4app también proporciona un AI Agent que puede ayudarte a diseñar tu modelo de datos:
Abre el AI Agent desde el panel de control de tu aplicación.
Describe tu modelo de datos en un lenguaje simple (por ejemplo, “Por favor, crea un nuevo esquema de clase ToDo.”).
Deja que el AI Agent genere el esquema por ti.
﻿
Datos Relacionales
Si tienes datos relacionales—digamos, un Categoría objeto que apunta a múltiples Todo elementos—puedes usar Punteros o Relaciones en Parse. Por ejemplo:
Swift
struct Category: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var name: String?
}

struct Todo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var title: String?
    var category: Pointer<Category>?
}

func createTodoWithCategory(categoryId: String, title: String) async {
    var todo = Todo()
    todo.title = title
    // Construct pointer
    let categoryPointer = Pointer<Category>(objectId: categoryId)
    todo.category = categoryPointer

    do {
        try await todo.save()
    } catch {
        print("Error creating Todo with category relationship: \(error)")
    }
}
struct Category: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var name: String?
}

struct Todo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var title: String?
    var category: Pointer<Category>?
}

func createTodoWithCategory(categoryId: String, title: String) async {
    var todo = Todo()
    todo.title = title
    // Construct pointer
    let categoryPointer = Pointer<Category>(objectId: categoryId)
    todo.category = categoryPointer

    do {
        try await todo.save()
    } catch {
        print("Error creating Todo with category relationship: \(error)")
    }
}
﻿
Este es un ejemplo de cómo puedes manejar datos relacionales en tu aplicación.
Al consultar, también puedes incluir datos de puntero:
Swift
let query = Todo.query()
    .include("category")
do {
    let todosWithCategory = try await query.find()
    print("Todos with category: \(todosWithCategory)")
} catch {
    print("Error fetching Todos: \(error)")
}
let query = Todo.query()
    .include("category")
do {
    let todosWithCategory = try await query.find()
    print("Todos with category: \(todosWithCategory)")
} catch {
    print("Error fetching Todos: \(error)")
}
﻿
Consultas en Vivo
Para actualizaciones en tiempo real, Back4app proporciona Consultas en Vivo. En tu aplicación SwiftUI, puedes suscribirte a cambios en una clase específica:
Habilitar Consultas en Vivo en tu panel de Back4app bajo Configuración del Servidor.
Suscribirse en código.
Swift
// Example snippet using the Parse Swift subscription system:
Task {
    let subscription = try Todo.query().subscribeCallback()

    // React to events
    for await event in subscription {
        switch event {
        case .entered(let todo):
            print("New Todo entered: \(todo)")
        case .updated(let todo):
            print("Todo updated: \(todo)")
        case .left(let todo):
            print("Todo deleted or left subscription: \(todo)")
        default:
            break
        }
    }
}
// Example snippet using the Parse Swift subscription system:
Task {
    let subscription = try Todo.query().subscribeCallback()

    // React to events
    for await event in subscription {
        switch event {
        case .entered(let todo):
            print("New Todo entered: \(todo)")
        case .updated(let todo):
            print("Todo updated: \(todo)")
        case .left(let todo):
            print("Todo deleted or left subscription: \(todo)")
        default:
            break
        }
    }
}
﻿
Cada vez que un Todo es creado, actualizado o eliminado en el servidor, tu aplicación recibe una notificación en tiempo real. Esta función es muy útil para aplicaciones colaborativas o dinámicas que requieren sincronización de datos inmediata.
Paso 3 – Aplicando Seguridad con ACLs y CLPs
Mecanismo de Seguridad de Back4app
Back4app proporciona Listas de Control de Acceso (ACLs) y Permisos a Nivel de Clase (CLPs) para una robusta seguridad de datos. Estos te permiten restringir quién puede leer o escribir datos a nivel de objeto o de clase, asegurando que solo los usuarios autorizados puedan modificar tus datos.
﻿
Listas de Control de Acceso (ACLs)
Una ACL se aplica a objetos individuales. Por ejemplo, para asegurar que solo un usuario particular pueda leer/escribir un Todo:
Swift
func createPrivateTodo(title: String, user: User) async {
    var todo = Todo()
    todo.title = title

    var acl = ParseACL()
    // Grant read/write to the owner only
    acl.setReadAccess(true, for: user)
    acl.setWriteAccess(true, for: user)
    todo.ACL = acl

    do {
        let saved = try await todo.save()
        print("Private Todo saved: \(saved)")
    } catch {
        print("Error saving private todo: \(error)")
    }
}
func createPrivateTodo(title: String, user: User) async {
    var todo = Todo()
    todo.title = title

    var acl = ParseACL()
    // Grant read/write to the owner only
    acl.setReadAccess(true, for: user)
    acl.setWriteAccess(true, for: user)
    todo.ACL = acl

    do {
        let saved = try await todo.save()
        print("Private Todo saved: \(saved)")
    } catch {
        print("Error saving private todo: \(error)")
    }
}
﻿
Permisos a Nivel de Clase (CLPs)
Los CLPs rigen los valores predeterminados de toda una clase, como si la clase es públicamente legible o escribible, o si solo ciertos roles pueden acceder a ella.
Ve al Panel de Control de Back4app y selecciona tu aplicación.
Abre la Base de Datos sección, selecciona una clase (por ejemplo, Todo).
Abre la pestaña de Permisos a Nivel de Clase. 
Configura valores predeterminados como “Requiere Autenticación” o “Sin Acceso.”
﻿
Estos permisos establecen una base amplia, mientras que las ACL te permiten ajustar la seguridad a nivel de objeto. Combinar ambos asegura un modelo de seguridad sólido. Para más detalles, 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 personalizado del lado del servidor en Swift (o JavaScript) sin gestionar servidores. Es ideal para agregar lógica de negocio, validaciones de datos, disparadores o integraciones de backend que no deberían ejecutarse desde el cliente.
Cómo Funciona
Escribe tu Código en la Nube en un archivo como main.js (JavaScript) o aprovecha el entorno de Código en la Nube basado en Swift.
Despliega en tu proyecto de Back4app. El código se ejecuta en el entorno de Parse Server, por lo que no necesitas mantener tu propio servidor.
Llama a tu Código en la Nube desde el cliente a través del SDK de Swift, REST o GraphQL.
Casos de Uso Típicos
Lógica de Negocio: Validaciones de datos complejas, cálculos de campos o integraciones externas.
Disparadores de Datos: Ejecutar lógica cuando un objeto es guardado, actualizado o eliminado.
Seguridad: Proteger operaciones sensibles del cliente ejecutándolas en el lado del servidor.
Función de Ejemplo
A continuación se muestra un ejemplo de JavaScript Cloud Code (ya que Cloud Code utiliza principalmente JS en Back4App) 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 };
});
﻿
Despliegue a través de la CLI
Instalar el Back4app CLI.
Configurar tu clave de cuenta:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
Desplegar Cloud Code:
Bash
b4a deploy
b4a deploy
﻿
Llamando a tu función
Desde Swift:
Swift
struct CloudFunction {
    static func calculateTextLength(text: String) async throws -> Int {
        do {
            if let result = try await ParseCloud.callFunction("calculateTextLength", with: ["text": text]) as? [String: Any],
               let length = result["length"] as? Int {
                return length
            }
        } catch {
            throw error
        }
        return 0
    }
}

Task {
    do {
        let len = try await CloudFunction.calculateTextLength(text: "Hello Back4App")
        print("Text length: \(len)")
    } catch {
        print("Error calling cloud function: \(error)")
    }
}
struct CloudFunction {
    static func calculateTextLength(text: String) async throws -> Int {
        do {
            if let result = try await ParseCloud.callFunction("calculateTextLength", with: ["text": text]) as? [String: Any],
               let length = result["length"] as? Int {
                return length
            }
        } catch {
            throw error
        }
        return 0
    }
}

Task {
    do {
        let len = try await CloudFunction.calculateTextLength(text: "Hello Back4App")
        print("Text length: \(len)")
    } catch {
        print("Error calling cloud function: \(error)")
    }
}
﻿
A través de REST:
Curl
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
﻿
Paso 5 – Configuración de la Autenticación de Usuario
Autenticación de Usuario en Back4app
Back4app utiliza la ParseUser clase para manejar la autenticación segura. El hash de contraseñas, los tokens de sesión y los datos se manejan automáticamente, permitiéndote concentrarte en la lógica de la aplicación.
Configurando la Autenticación de Usuario
Registrar un nuevo usuario:
Swift
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Required fields
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpUser(username: String, password: String, email: String) async {
    var newUser = User()
    newUser.username = username
    newUser.password = password
    newUser.email = email

    do {
        try await newUser.signUp()
        print("User signed up successfully!")
    } catch {
        print("Error signing up user: \(error)")
    }
}
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Required fields
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpUser(username: String, password: String, email: String) async {
    var newUser = User()
    newUser.username = username
    newUser.password = password
    newUser.email = email

    do {
        try await newUser.signUp()
        print("User signed up successfully!")
    } catch {
        print("Error signing up user: \(error)")
    }
}
﻿
Iniciar sesión como usuario existente:
Swift
func logInUser(username: String, password: String) async {
    do {
        let user = try await User.login(username: username, password: password)
        print("User logged in: \(user)")
    } catch {
        print("Error logging in user: \(error)")
    }
}
func logInUser(username: String, password: String) async {
    do {
        let user = try await User.login(username: username, password: password)
        print("User logged in: \(user)")
    } catch {
        print("Error logging in user: \(error)")
    }
}
﻿
Tokens de sesión se manejan automáticamente por Parse. Puedes cerrar sesión:
Swift
func logOut() async {
    do {
        try await User.logout()
        print("User logged out.")
    } catch {
        print("Error logging out: \(error)")
    }
}
func logOut() async {
    do {
        try await User.logout()
        print("User logged out.")
    } catch {
        print("Error logging out: \(error)")
    }
}
﻿
Integración de inicio de sesión social
Las integraciones con Google, Apple, Facebook, etc., son posibles con configuración adicional. Consulta la Documentación de inicio de sesión social para más detalles.
Verificación de correo electrónico y restablecimiento de contraseña
Habilita la verificación de correo electrónico en tu panel de Back4app y configura los correos electrónicos de restablecimiento de contraseña para que los usuarios puedan recuperar sus cuentas de forma segura. Para restablecimientos de contraseña:
Swift
try await User.passwordReset(email: "[email protected]")
try await User.passwordReset(email: "user@example.com")
﻿
Paso 6 – Manejo del Almacenamiento de Archivos
Subiendo y Recuperando Archivos
Parse incluye ParseFile para manejar las subidas de archivos:
Swift
func uploadImage(fileData: Data) async {
    let parseFile = ParseFile(name: "photo.jpg", data: fileData)
    do {
        let savedFile = try await parseFile.save()
        print("File saved at: \(savedFile.url ?? "No URL")")
    } catch {
        print("Error uploading file: \(error)")
    }
}
func uploadImage(fileData: Data) async {
    let parseFile = ParseFile(name: "photo.jpg", data: fileData)
    do {
        let savedFile = try await parseFile.save()
        print("File saved at: \(savedFile.url ?? "No URL")")
    } catch {
        print("Error uploading file: \(error)")
    }
}
﻿
Adjúntalo a un ParseObject:
Swift
struct Photo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var imageFile: ParseFile?
}

func createPhotoObject(fileData: Data) async {
    var photo = Photo()
    photo.imageFile = ParseFile(name: "image.jpg", data: fileData)

    do {
        _ = try await photo.save()
    } catch {
        print("Error saving photo object: \(error)")
    }
}
struct Photo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    var imageFile: ParseFile?
}

func createPhotoObject(fileData: Data) async {
    var photo = Photo()
    photo.imageFile = ParseFile(name: "image.jpg", data: fileData)

    do {
        _ = try await photo.save()
    } catch {
        print("Error saving photo object: \(error)")
    }
}
﻿
Seguridad de Archivos
Por defecto, los archivos son accesibles a través de una URL pública. Puedes configurar la seguridad de los archivos usando la configuración del servidor Parse. Para controles de archivo más estrictos, asegúrate de que solo los usuarios autenticados o roles especificados puedan subir o recuperar archivos.
Paso 7 – Programación de Tareas con Cloud Jobs
Cloud Jobs te permiten programar y ejecutar tareas recurrentes como limpiar datos o enviar correos electrónicos.
JS
// main.js (JavaScript Cloud Code)
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  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 oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
// main.js (JavaScript Cloud Code)
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  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 oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
﻿
Después de la implementación, programalo a través del Panel de Control de Back4app en Configuración del Servidor > Tareas en Segundo Plano.
﻿
Paso 8 – Integración de Webhooks
Webhooks permiten que tu aplicación de Back4app envíe solicitudes HTTP a servicios externos (como Stripe) cada vez que ocurren ciertos eventos. Esto es útil para conectarse a herramientas de terceros u otras integraciones del lado del servidor.
Ve a Webhooks en tu panel de Back4app > Más > WebHooks.
Agrega un endpoint (por ejemplo, https://your-service.com/webhook).
Configura qué eventos (por ejemplo, nuevo registro en la clase Todo) activarán el webhook.
Añadiendo un Webhook
﻿
Por ejemplo, podrías enviar un mensaje de Slack cada vez que un usuario crea un nuevo Todo. Esto te ayuda a mantener los servicios externos sincronizados con tus datos de Back4app.
Paso 9 – Explorando el Panel de Administración de Back4app
La Aplicación de Administración de Back4app es una interfaz de gestión basada en la web para usuarios no técnicos para realizar operaciones CRUD en tus datos. Proporciona una interfaz de usuario amigable que es independiente del Panel de Control de Parse, lo que facilita la gestión de datos en producción.
Habilitando la Aplicación de Administración
Ve a tu Panel de la Aplicación > Más > Aplicación de Administración y haz clic en “Habilitar Aplicación de Administración.”
Habilitar Aplicación de Administración
﻿
Crea un Usuario Administrador, que genera automáticamente un rol de administrador y clases asociadas. Elige un subdominio para la interfaz de administración, luego inicia sesión para gestionar tus datos a través de una interfaz de usuario simple de apuntar y hacer clic.
﻿
Conclusión
Siguiendo esta guía completa, has aprendido:
Cómo construir un backend para SwiftUI utilizando Back4app y el SDK de Parse Swift.
Cómo almacenar datos de forma segura con esquemas de clase personalizados y relaciones.
Cómo integrar consultas en tiempo real (Consultas en Vivo) para actualizaciones inmediatas de datos.
Cómo aplicar medidas de seguridad utilizando ACLs y CLPs para proteger y gestionar el acceso a los datos.
Cómo ejecutar lógica de negocio a través de Cloud Code.
Cómo manejar el almacenamiento de archivos, autenticación y programación de tareas en segundo plano con Cloud Jobs.
Cómo integrar tu aplicación con servicios externos utilizando webhooks.
Con estas habilidades, puedes construir una aplicación iOS o aplicación web que sea fácil de gestionar, segura y lista para escalar. Explora características más avanzadas, como permisos basados en roles, notificaciones push o almacenamiento en caché avanzado. También puedes integrar otras API o adaptar tu Cloud Code para satisfacer casos de uso especializados.
Feliz codificación, y disfruta construyendo aplicaciones increíbles en Back4App!
Próximos Pasos
Aplicación SwiftUI Lista para Producción: Extiende este backend para manejar modelos de datos más complejos, almacenamiento en caché y mejoras de rendimiento.
Características Avanzadas: Profundiza en autenticación especializada, acceso basado en roles o integraciones de API de terceros (como Stripe).
Explora la Documentación Oficial de Back4app: Para profundizar en seguridad del lado del servidor, análisis de registros y ajuste avanzado de bases de datos.
Revisa Tutoriales Adicionales: Chat en tiempo real, servicios basados en ubicación o aplicaciones multi-tenant: combina los métodos aprendidos aquí con APIs externas para crear soluciones sofisticadas del mundo real.
﻿
Actualizado 23 Jan 2025
¿Esta página le fue útil?
¿Cómo construir un backend para iOS?
¿Cómo construir un backend para Swift?