Plantilla de Backend del Editor de Notas y Markdown
Organiza Notas y Colabora en Tiempo Real

Conclusiones clave

Resumen

Una aplicación para tomar notas necesita características robustas para colaboración en tiempo real y edición de markdown.

Esta plantilla define Usuario, Nota y Colaboración con capacidades en tiempo real y controles de acceso, permitiendo que los equipos trabajen juntos de manera efectiva.

¿Por qué construir tu backend de toma de notas con Back4app?

Back4app proporciona las primitivas esenciales para notas, usuarios y colaboración, para que tu equipo pueda centrarse en mejorar la productividad y la colaboración en lugar de la infraestructura del backend.

• •Gestión de documentos y notas: Modela notas con soporte para markdown y gestiona la colaboración de usuarios de manera efectiva.
• •Funciones de seguridad y compartición robustas: Controla el acceso a las notas con permisos detallados y permite una colaboración fluida.
• •Capacidades en tiempo real: Habilita la edición en vivo con Live Queries mientras mantienes el soporte para REST y GraphQL para todos los clientes.

Construye y mejora rápidamente tus características de toma de notas con un backend centralizado que admite todas las plataformas.

Beneficios clave

Un backend para tomar notas que acelera el desarrollo sin sacrificar funcionalidad.

Pila técnica

Todo incluido en esta plantilla de backend de toma de notas.

Diagrama ER

Modelo de relación de entidades para el esquema backend de toma de notas.

erDiagram
    User ||--o{ Note : "owner"
    User ||--o{ AccessLog : "user"
    Note ||--o{ AccessLog : "note"
    Note ||--o{ Tag : "tags"

    User {
        String objectId PK
        String username
        String email
        String password
        String role
        Date createdAt
        Date updatedAt
    }

    Note {
        String objectId PK
        String title
        String content
        Array tags
        Pointer owner FK
        Date createdAt
        Date updatedAt
    }

    Tag {
        String objectId PK
        String name
        Date createdAt
    }

    AccessLog {
        String objectId PK
        Pointer user FK
        Pointer note FK
        Date accessTime
    }

Flujo de integración

Flujo típico de ejecución para autenticación, gestión de notas y colaboración.

sequenceDiagram
  participant User
  participant App as Note-Taking & Markdown Editor App
  participant Back4app as Back4app Cloud

  User->>App: Login
  App->>Back4app: POST /login
  Back4app-->>App: Session token

  User->>App: Create new note
  App->>Back4app: POST /classes/Note
  Back4app-->>App: Note created confirmation

  User->>App: List all notes
  App->>Back4app: GET /classes/Note?order=-createdAt
  Back4app-->>App: List of notes
  
  User->>App: Access a note
  App->>Back4app: GET /classes/Note/noteId
  Back4app-->>App: Note details

  App->>Back4app: Log access
  Back4app-->>App: AccessLog objectId

Diccionario de datos

Referencia completa a nivel de campo para cada clase en el esquema de toma de notas.

Seguridad y Permisos

Cómo la estrategia de ACL y CLP asegura a los usuarios, notas y colaboración.

Esquema (JSON)

Definición de esquema JSON en bruto lista para copiar en Back4app o usar como referencia de implementación.

{
  "classes": [
    {
      "className": "User",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "username": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "password": {
          "type": "String",
          "required": true
        },
        "role": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Note",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "title": {
          "type": "String",
          "required": true
        },
        "content": {
          "type": "String",
          "required": true
        },
        "tags": {
          "type": "Array",
          "required": false
        },
        "owner": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "Tag",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "name": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "AccessLog",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "user": {
          "type": "Pointer",
          "required": true,
          "targetClass": "User"
        },
        "note": {
          "type": "Pointer",
          "required": true,
          "targetClass": "Note"
        },
        "accessTime": {
          "type": "Date",
          "required": true
        }
      }
    }
  ]
}

API Playground

Prueba los endpoints REST y GraphQL contra el esquema de toma de notas. Las respuestas utilizan datos simulados y no requieren una cuenta de Back4app.

Utiliza el mismo esquema que esta plantilla.

Lo que obtienes con cada tecnología

Cada pila utiliza el mismo esquema de backend para la toma de notas y contratos de API.

Preguntas Frecuentes

Preguntas comunes sobre la construcción de un backend de toma de notas con esta plantilla.