Ottoman: Object Data Modeler (ODM) for Couchbase Node.js SDK

Ottoman es un Modelador de Datos de Objetos (ODM) para el SDK Node.js de Couchbase que proporciona esquema JSON y validación para NoSQL.

Por qué utilizar un ODM para Couchbase

Con Ottoman, declaras el esquema en tu código. Aunque Couchbase no tiene aplicación de esquema para tus documentos, la mayoría de las aplicaciones necesitan algún nivel de esquema incluso en NoSQL. Exploraremos cómo lograr esquema y validación en NoSQL usando Ottoman y Couchbase.

Es importante validar que los documentos cumplen ciertos requisitos antes de persistir. Aunque Ottoman crea una abstracción sobre el SDK de Couchbase, los beneficios superan a los inconvenientes. Un desarrollador crea mucha lógica alrededor de la creación y actualización de documentos, escribiendo pre/post ciclo de vida, trabajando con estructuras de datos y validación.

Bases de datos NoSQL y diseño de esquemas

Un ODM tiene un papel similar en NoSQL al que tiene en una base de datos relacional, pero con beneficios adicionales. Couchbase no impone la validación ya que es flexible en cuanto al esquema. Ottoman puede realizar ciertas comprobaciones a medida que tus aplicaciones persisten los datos. Podemos advertir y error contra tipos de datos no deseados y formatos para campos individuales mediante la definición de esquemas y modelos para varios tipos de documentos.

El código de su aplicación de servidor es donde un gran lugar para aplicar la lógica de negocio y validación. El objetivo de Ottoman es proporcionar una mejor experiencia de desarrollo junto con darle el control sobre el esquema y la validación mientras se utiliza Couchbase con Node. Queremos dar a los desarrolladores una herramienta fiable para construir sistemas que sean fáciles de diseñar, mantener y escalar.

Couchbase es una base de datos NoSQL

Couchbase Server es una base de datos de documentos sin esquema, categorizada como un almacén de datos NoSQL, no es la mejor descripción ya que Couchbase utiliza una variante de SQL para realizar consultas llamada N1QL. El hecho de que un esquema no se aplique estrictamente en bases de datos NoSQL como Couchbase no significa que no debas aplicarlo.

Con Couchbase, obtienes los beneficios del escalado a nivel empresarial, nodos en clúster y la capacidad de almacenar y recuperar datos en formato JSON.

Si estás familiarizado con Mongoose, un ODM para MongoDB, te sentirás bastante cómodo con Ottoman, ya que tienen muchas características que se superponen porque ambos están hechos para NodeJS y se utilizan para modelar y persistir datos en una base de datos de valores clave orientada a documentos JSON.

Documento frente a relacional Base de datos

A medida que exploramos vamos a explorar Couchbase y NoSQL Base de datos y diseño de esquemas, primero vamos a ver cómo una estructura de datos de documentos difiere de un diseño de base de datos relacional, en el ejemplo siguiente, verá una comparación lado a lado de los datos que representa un Hotel.

A la izquierda, tenemos un documento que puede almacenar números de teléfono en una matriz que nos permite almacenar varios números de teléfono de un mismo hotel. Para hacer esto en una base de datos relacional se necesitaría sin duda una nueva tabla y mantener una relación entre las dos utilizando claves primarias.

Si desea más información sobre el modelado de documentos, consulte los recursos que he reunido en una entrada de blog: Guía de modelado de datos JSON

En Ottoman, tenemos muchas construcciones para ayudar a definir esquemas y modelos a nivel de aplicación. Repasemos algunos de los términos más importantes que debes conocer en Ottoman.

Tipos

Como se ve en rosa en la imagen de arriba, las propiedades de documento con el tipo de nombre en Couchbase son casi equivalentes a las tablas en una base de datos relacional. Pueden ayudar a agrupar diferentes tipos de documentos JSON para propósitos de indexación. Cuando usamos índices secundarios en Couchbase, podemos indexar sobre cualquier clave en los documentos. Si sólo 100 de 10.000 documentos en tu base de datos usan un tipo de 'hotel' y normalmente quieres buscar hoteles basados en ciudad o estado, entonces podrías querer construir un Índice Secundario Compuesto que sólo necesite buscar a través de esos cien documentos donde ciudad o estado sean iguales a un cierto valor. Esto es mucho más eficaz que utilizar, por ejemplo, un índice primario.

Más información sobre la indexación en Couchbase!

Colecciones

De forma similar a los tipos en Couchbase 6.x (última versión principal de Couchbase en el momento de escribir esto) y no mostrados en la ilustración anterior, las colecciones se verán favorecidas en Couchbase 7 (ya en beta). En el caso de que utilizara colecciones, simplemente no tendría un tipo en cada documento y, en su lugar, asignar el documento a una propiedad hotel colección.

Documentos

Comparable a las filas de datos de una base de datos relacional. Los sistemas RDBMS tradicionales harán referencia a documentos relacionados de otras tablas, como se ve en la ilustración anterior. También puede hacer esto con un documento JSON, sin embargo; se sugiere incluir esa información como un documento incrustado cuando sea posible, como vemos con la propiedad número de teléfono del documento del hotel que es una matriz de números de teléfono. Aunque es un ejemplo muy simple de esto, piensa si tuvieras una propiedad de dirección que en sí misma fuera otro objeto JSON con muchas propiedades, podrías pensar que esto necesita tener su propio documento, pero anidar esa información en el documento padre en la mayoría de los casos está bien.

Campos

También conocidos como atributos, son similares a las columnas de una base de datos relacional y, con Ottoman, puede crear requisitos a nivel de campo como parte de su esquema.

Esquema

Aunque Couchbase no tiene esquema o es flexible en cuanto al esquema, podemos imponer una estructura a nivel de aplicación para nuestros documentos.

Modelo

Un método constructor que toma un esquema y crea una instancia de un documento equivalente a un único registro en una base de datos relacional. Esta instancia de documento puede ser construida y luego persistida a Couchbase por Ottoman utilizando el guardar() método.

Primeros pasos

Empecemos creando una aplicación de demostración que podamos utilizar para familiarizarnos con Ottoman como mapeador de documentos objeto.

Instalación de Couchbase

Antes de empezar, vamos a configurar Couchbase.

Puede elegir entre una de las siguientes opciones (para este artículo utilizamos la opción #1):

Instalar Couchbase Server usando Docker
Descargue Couchbase específico para su sistema operativo desde la página Sitio web de Couchbase

Vamos a navegar a través de algunos de los fundamentos de Ottoman mediante la implementación de un modelo que representa los datos para un ejemplo simplificado de aerolínea manteniendo la tradición con el conjunto de datos Travel-Sample de Couchbase.

Estoy usando Visual Studio Code, NodeJS v12.14, y NPM 6.14.8, así que necesitarás tener Node.js instalado en tu máquina. a continuación, crearemos un proyecto en blanco y empezaremos a escribir algo de código.

Inicializando nuestro proyecto con NPM

Creamos un directorio, inicializamos nuestro proyecto, instalamos Ottoman.js y abrimos en VS Code

mkdir intro-ottoman && cd $_ && npm init -y && npm i ottoman && touch createAirline.js && code .

1	mkdir introducción-otomana && cd $_ && npm init -y && npm i otomana && toque crearLínea Aérea.js && código .

Abra el terminal en el editor de su elección, he añadido un comando al final que se abrirá en VS Code.

Conexión a Couchbase con Ottoman

Empezaremos a trabajar a partir del archivo ./createAirline.js bajo la raíz del proyecto y añade lo siguiente (basado en la configuración por defecto):

const { Ottoman, model, Schema } = require('ottoman')

const ottoman = new Ottoman({collectionName: '_default'});
ottoman.connect({
    connectionString: 'couchbase://localhost',
    bucketName: 'travel',
    username: 'Administrator',
    password: 'password'
});

const { Otomano, modelo, Esquema } = requiere(otomana)

const otomana = nuevo Otomano({collectionName: por defecto});

otomana.conecte({

connectionString: couchbase://localhost,

bucketName: viajar,

nombre de usuario: Administrador,

contraseña: contraseña

});

Conjuntamente esto importa el paquete ottoman y especifica la colección por defecto (estilo Couchbase Server 6.x)

Esquemas y modelos otomanos

Los modelos son constructores extravagantes compilados a partir de definiciones de esquemas. Una instancia de un modelo se llama documento. Los modelos en Ottoman te ayudan a crear, leer, actualizar y borrar fácilmente documentos en tu base de datos Couchbase.

La creación de un modelo otomano comprende algunas cosas:

Definición de un esquema documental

Un esquema define las propiedades de un documento a través de un objeto cuyo nombre clave corresponde al nombre de la propiedad en la colección.

const airlineSchema = new Schema({
   callsign: String, 
   country: String, 
   name: String 
})

const airlineSchema = nuevo Esquema({

Indicativo: Cadena,

país: Cadena,

nombre: Cadena

})

Aquí definimos tres propiedades (indicativo, país, nombre) dentro de nuestro esquema, todos de tipo Cuerda. Especificando un tipo para cada una de las propiedades de nuestro modelo, corresponde a un validador interno que se activará cuando el modelo se guarde en la base de datos y fallará si el tipo de datos del valor no es del tipo Cadena.

Se permiten los siguientes tipos de esquema:

Definición de un modelo de documento

Necesitamos llamar al constructor del modelo en la instancia otomana y pasarle el nombre de la colección y una referencia a la definición del esquema.

const Airline = ottoman.model('Airline', airlineSchema)

1	const Línea aérea = otomana.modelo(Aerolínea, airlineSchema)

Cuando llame al modelo() crea una copia del esquema y compila el modelo para usted.

Demos también la airlineSchema una propiedad de número de teléfono. Podemos añadir una función de validación que asegure que el valor es un número de teléfono válido. Sustituya la propiedad airlineSchema con estos tres bloques de código:

const regx = /^(\([0-9]{3}\)|[0-9]{3}-)[0-9]{3}-[0-9]{4}$/
  if(value && !value.match(regx)) {
    throw new Error(`Phone Number ${value} is not valid`)
  }
}
addValidators({ 
  phone: phoneValidator
})
const airlineSchema = new Schema({ 
  callsign: String, 
  country: String, 
  name: String,
  phone: [{ type: String, validator: 'phone'}]
})

const regx = /^($[0-9]{3}$|[0-9]{3}-)[0-9]{3}-[0-9]{4}$/

si(valor && !valor.match(regx)) {

tirar nuevo Error(`Número de teléfono ${valor} no es válido`)

}

addValidators({

teléfono: phoneValidator

})

const airlineSchema = nuevo Esquema({

Indicativo: Cadena,

país: Cadena,

nombre: Cadena,

teléfono: [{ tipo: Cadena, validador: teléfono}]

})

En el ejemplo anterior, te muestro cómo crear un validador personalizado, que acaba de pasar a ser el uso de una expresión regular como el check-in de nuestro validador, acaba de entender que usted podría tener cualquier lógica dentro de uno de estos validadores y en un momento voy a mostrar un buen truco para reducir nuestro código hacia abajo teniendo en cuenta que estamos utilizando una expresión regular para nuestra coincidencia de los números de teléfono.

Definición de validadores

Validadores registrado con Ottoman (como hemos hecho aquí con el otomana.addValidators() ) será llamado una vez por cada valor que la propiedad de nuestro documento tenga en el array. Si la propiedad no tuviera un array y en su lugar tuviera un único valor String, el validador sólo se ejecutaría una vez. Por esta razón, imprimo el número de teléfono problemático si la validación falla.

Sin embargo, existe una forma más sencilla de validar cualquier valor de las propiedades del documento siempre que la comprobación que se realice utilice una expresión regular. La dirección ValidatorOption puede tomar un regexp y mensaje como argumento, por lo que podemos reducir nuestro código a:

const regx = /^(\([0-9]{3}\)|[0-9]{3}-)[0-9]{3}-[0-9]{4}$/
const airlineSchema = new Schema({
callsign: String,
country: String,
name: String,
phone: [{type: String, validator: {regexp: regx, message: 'phone invalid'}}]
})

const regx = /^($[0-9]{3}$|[0-9]{3}-)[0-9]{3}-[0-9]{4}$/

const airlineSchema = nuevo Esquema({

Indicativo: Cadena,

país: Cadena,

nombre: Cadena,

teléfono: [{tipo: Cadena, validador: {regexp: regx, mensaje: "teléfono no válido}}]

})

Como puedes ver, podemos hacer todo lo que estábamos haciendo antes en línea al crear un nuevo Schema. Pero no dejes que esto te impida entender cómo crear un validador personalizado, a veces necesitamos lógica adicional y es por eso que el primer ejemplo sigue siendo algo que vale la pena conocer.

Básico Operaciones documentales en NoSQL

La mayoría de las operaciones básicas están cubiertas en nuestra documentación Ottoman V2, cubriremos algo de eso aquí, pero siéntase libre de sumergirse en nuestro Documentación de Ottoman V2 (alfa) e infórmenos si hay algo que no encuentra o no entiende.

Crear documentos

Teniendo en cuenta el código que ya repasamos anteriormente que crea un esquema, modelo y validadores. Guardar un modelo y persistirlo en la base de datos es bastante fácil. Vamos a crear un nuevo Línea aérea utilizando nuestro Esquema y luego guardarlo/persistirlo en la base de datos.

// Constructing our document
const cbAirlines = new Airline({
  callsign: 'CBA',
  country: 'United States',
  name: 'Couchbase Airlines',
  phone: ['321-321-3210', '321-123-1234']
})

// Persist the Couchbase Airlines document to Couchbase Server
const saveDocument = async() => {
  try {
    const result = await cbAirlines.save()
    console.log(result)
  } catch (error) {
    throw error
  }
}

// Ensure that all indexes exist on the server
ottoman.start()
  // Next, let's save our document and print a success message 
  .then(async() => {
    saveDocument()
      .then(() => process.exit(0))
      .catch((error) => console.log(error))
  })

// Construir nuestro documento

const cbAirlines = nuevo Línea aérea({

Indicativo: CBA,

país: Estados Unidos,

nombre: Couchbase Airlines,

teléfono: ['321-321-3210', '321-123-1234']

})

// Persistir el documento Couchbase Airlines a Couchbase Server

const guardarDocumento = async() => {

pruebe {

const resultado = await cbAirlines.guardar()

consola.registro(resultado)

} captura (error) {

tirar error

}

// Asegúrese de que todos los índices existen en el servidor

otomana.iniciar()

// A continuación, vamos a guardar nuestro documento e imprimir un mensaje de éxito

.entonces(async() => {

guardarDocumento()

.entonces(() => proceso.salida(0))

.captura((error) => consola.registro(error))

})

Tal vez se pregunte por qué no llamamos al guardarDocumento() por sí sola. En su lugar, la llamamos después de la función otomana.start() ha terminado. En iniciar es un atajo para ejecutar ensureCollections y ensureIndexes. Todo lo que tienes que saber por ahora es que este método se asegura de que los índices apropiados relacionados con Ottoman han sido creados en Couchbase y esto es importante para asegurar que podemos ejecutar cosas como el método encontrar() y utilizar herramientas como el Constructor de consultas a la que llegaremos al final del artículo.

En este punto, si ejecutáramos todo el código que hemos escrito usando Node, nuestro documento se guardaría en la base de datos:

node createAirline.js

1	nodo crearLínea Aérea.js

El resultado de esta operación:

_Model {
  callsign: 'CBA',
  country: 'United States',
  name: 'Couchbase Airlines',
  phone: [ '321-321-3210', '321-123-1234' ],
  id: '2384568f-f1e9-446e-97d1-cad697c40e76',
  _type: 'Airline'
}

Modelo {

Indicativo: CBA,

país: Estados Unidos,

nombre: Couchbase Airlines,

teléfono: [ '321-321-3210', '321-123-1234' ],

id: '2384568f-f1e9-446e-97d1-cad697c40e76',

Tipo: Aerolínea

}

Se devuelven los siguientes campos:

Los campos indicativo, país y nombre son todos String, el valor más básico que podemos tener en un documento.
El campo id es autogenerado por Couchbase y es una clave única. El valor ID es lo que usarás en cualquier caso para encontrar un documento con Ottoman en métodos como findByID o removeByID
El campo teléfono está representado por una matriz y contiene números de teléfono válidos.
En El campo _type puede ayudarnos a organizar nuestros documentos como lo hace una tabla en una base de datos relacional, en Couchbase 7, podemos utilizar colecciones y ámbitos.

Errores de validación

Si introducimos un número de teléfono no válido y ejecutamos nodo createAirline.js este archivo de nuevo, obtendríamos un mensaje de error:

ValidationError: Phone Number 321-321-32xx is not valid

1	ValidationError: Teléfono Número 321-321-32xx es no válido

CONSEJO: Puede definir su conexión, esquema y modelos en archivos separados, exportarlos y utilizarlos en otros archivos. Cree un nuevo archivo llamado airline-schema-model.js y mover nuestro esquema y la definición del modelo a la misma:

const { model, Schema } = require('ottoman')

const regx = /^(\([0-9]{3}\)|[0-9]{3}-)[0-9]{3}-[0-9]{4}$/
const airlineSchema = new Schema({ 
  callsign: String, 
  country: String, 
  name: String,
  phone: [{type: String, validator: {regexp: regx, message: 'phone invalid'}}]
})

// Compile our model using our schema
const Airline = model('Airline', airlineSchema)

exports.airlineSchema = airlineSchema;
exports.Airline = Airline;

const { modelo, Esquema } = requiere(otomana)

const regx = /^($[0-9]{3}$|[0-9]{3}-)[0-9]{3}-[0-9]{4}$/

const airlineSchema = nuevo Esquema({

Indicativo: Cadena,

país: Cadena,

nombre: Cadena,

teléfono: [{tipo: Cadena, validador: {regexp: regx, mensaje: "teléfono no válido}}]

})

// Compilar nuestro modelo usando nuestro esquema

const Línea aérea = modelo(Aerolínea, airlineSchema)

exportaciones.airlineSchema = airlineSchema;

exportaciones.Línea aérea = Línea aérea;

Ahora podemos crear algunos archivos nuevos, findAirline.js, updateAirline.jsy removeAirline.js y rellene cada archivo con lo siguiente:

const { Ottoman } = require('ottoman')
const ottoman = new Ottoman({collectionName: '_default'});
ottoman.connect({
    connectionString: 'couchbase://localhost',
    bucketName: 'travel',
    username: 'Administrator',
    password: 'password'
});

const { Airline } = require('./airline-schema-and-model')

const { Otomano } = requiere(otomana)

const otomana = nuevo Otomano({collectionName: por defecto});

otomana.conecte({

connectionString: couchbase://localhost,

bucketName: viajar,

nombre de usuario: Administrador,

contraseña: contraseña

});

const { Línea aérea } = requiere('./esquema-y-modelo-de-la-línea-aérea')

Esto nos ayudará a separar parte de nuestro código para que no lo estemos repitiendo en cada archivo y a medida que repasamos cada una de las operaciones CRUD podemos simplemente añadir algo de código a cada archivo y nuestro esquema y modelo ya estarán importados.

Buscar documentos

Intentemos recuperar el registro que hemos guardado antes en la base de datos. La clase model expone varios métodos estáticos y de instancia para realizar operaciones en la base de datos. Ahora intentaremos encontrar el registro que creamos anteriormente utilizando el método find y pasándole el indicativo como término de búsqueda. Vamos a crear un nuevo fichero llamado findAirline.js y podemos añadir el siguiente código:

// Find the Couchbase Airline document by Callsign from Couchbase Server
const findDocument = async() => {
  try {
    Airline.find({ callsign: { $like: 'CBA' } })
    .then((result) => console.log(result.rows));
  } catch (error) {
    throw error
  }
}

ottoman.start()
  .then(async() => {
    findDocument()
      .then(() => process.exit(0))
      .catch((error) => console.log(error))
  })

// Buscar el documento Couchbase Airline por indicativo desde Couchbase Server

const buscarDocumento = async() => {

pruebe {

Línea aérea.encontrar({ Indicativo: { $como: CBA } })

.entonces((resultado) => consola.registro(resultado.filas));

} captura (error) {

tirar error

}

otomana.iniciar()

.entonces(async() => {

buscarDocumento()

.entonces(() => proceso.salida(0))

.captura((error) => consola.registro(error))

})

Buscar resultado de documento:

Query Result:  [
  _Model {
    _type: 'Airline',
    callsign: 'CBA',
    country: 'United States',
    name: 'Couchbase Airlines',
    phone: ['321-321-3210','321-123-1234'],
    id: '971045ac-39d8-4e72-8c93-fdaac69aae31',
  }

Consulta Resultado: [

Modelo {

Tipo: Aerolínea,

Indicativo: CBA,

país: Estados Unidos,

nombre: Couchbase Airlines,

teléfono: ['321-321-3210','321-123-1234'],

id: '971045ac-39d8-4e72-8c93-fdaac69aae31',

}

Actualizar documentos

Modifiquemos el registro anterior buscándolo por el indicativo, que podemos suponer que el indicativo será un campo único en nuestros datos, entonces podremos actualizar el documento todo en una sola operación.

// Update the Couchbase Airline document by Callsign from Couchbase Server
const findDocumentAndUpdate = async() => {
  const newDocument = {
    callsign: 'CBSA',
    country: 'United States',
    name: 'Couchbase Airways',
    phone: ['321-321-3210','321-123-1234']
  }
  try {
    let result = await Airline.findOneAndUpdate(
      { callsign: { $like: 'CBA' } }, newDocument, { new: true }
    )
    console.log(result)
  } catch (error) {
    throw error
  }
}

ottoman.start()
  .then(async() => {
    findDocumentAndUpdate()
      .then(() => process.exit(0))
      .catch((error) => console.log(error))
  })

// Actualizar el documento Couchbase Airline por indicativo desde Couchbase Server

const findDocumentAndUpdate = async() => {

const nuevoDocumento = {

Indicativo: CBSA,

país: Estados Unidos,

nombre: Couchbase Airways,

teléfono: ['321-321-3210','321-123-1234']

}

pruebe {

deje resultado = await Línea aérea.findOneAndUpdate(

{ Indicativo: { $como: CBA } }, nuevoDocumento, { nuevo: verdadero }

)

consola.registro(resultado)

} captura (error) {

tirar error

}

otomana.iniciar()

.entonces(async() => {

findDocumentAndUpdate()

.entonces(() => proceso.salida(0))

.captura((error) => consola.registro(error))

})

Buscar documento y actualizar resultado:

_Model {
  _type: 'Airline',
  callsign: 'CBSA',
  country: 'United States',
  id: '971045ac-39d8-4e72-8c93-fdaac69aae31',
  name: 'Couchbase Airways',
  phone: [ '321-321-3210', '321-123-1234' ]
}

Modelo {

Tipo: Aerolínea,

Indicativo: CBSA,

país: Estados Unidos,

id: '971045ac-39d8-4e72-8c93-fdaac69aae31',

nombre: Couchbase Airways,

teléfono: [ '321-321-3210', '321-123-1234' ]

}

Eliminar documentos

Ottoman dispone de varios métodos para eliminar documentos: eliminar, removeById y removeMany. Teniendo en cuenta los numerosos ejemplos que hemos tenido hasta ahora, cada uno de ellos debería ser muy fácil de entender cómo se utiliza, por lo que aquí nos limitaremos a dar un ejemplo sencillo para mostrar cómo eliminar un documento que ya hemos encontrado utilizando la función encontrar() método.

// Remove the Couchbase Airline document by ID from Couchbase Server
const removeDocument = async() => {
  try {
    await Airline.removeById('60e3f517-6a2a-41fe-be45-97081181d675')
      .then((result) => console.log(result))
  } catch (error) {
    throw error
  }
}

// Eliminar el documento Couchbase Airline por ID de Couchbase Server

const eliminarDocumento = async() => {

pruebe {

await Línea aérea.removeById('60e3f517-6a2a-41fe-be45-97081181d675')

.entonces((resultado) => consola.registro(resultado))

} captura (error) {

tirar error

}

Eliminar documento resultado es un simple valor casutilizado para rastrear cambios en documentos Couchbase.

{ cas: CbCas { '0': <Buffer 00 00 2e 30 62 db 6c 16> } }

1	{ cas: CbCas { '0': <Tampón 00 00 2e 30 62 db 6c 16> } }

Middleware

Ya hemos visto nuestro middleware en acción, nuestro validador que creamos inicialmente puede aprovechar el middleware usando funciones que se ejecutan en etapas específicas de un pipeline pasando el control durante la ejecución de funciones asíncronas.

Ganchos disponibles

valide
guardar
actualización
eliminar

Ejemplo de Middleware (también conocido como ganchos pre y post)

Vamos a intentar un ejemplo simplemente generando un log en la consola antes y después de la creación (guardado) de un documento, voy a crear un nuevo archivo llamado createWithHooks.js y la mayor parte del código te resultará familiar excepto que he añadido pre y post hooks que simplemente nos reportarán el nombre del documento pre-save y el id del documento post-save:

const { Ottoman } = require('ottoman')
const ottoman = new Ottoman({collectionName: '_default'});
ottoman.connect({
    connectionString: 'couchbase://localhost',
    bucketName: 'travel',
    username: 'Administrator',
    password: 'password'
});

const { Airline, airlineSchema } = require('./airline-schema-and-model')

// Plugins and Hooks are middleware, think lifecycle hooks!
const pluginLog = (airlineSchema) => {
  airlineSchema.pre('save', (doc) => 
    console.log(`Doc: ${doc.name} about to be saved`)
  )
  airlineSchema.post('save', (doc) => 
    console.log(`Doc: ${doc.id} has been saved`)
  )
};

// Our plugin must be registered before the model creation
airlineSchema.plugin(pluginLog)

// Constructing our document
const cbAirlines = new Airline({
  callsign: 'UNITED',
  country: 'United States',
  name: 'United Airlines',
  phone: ['321-321-3210', '321-123-1234']
})

const saveDocument = async() => {
  try {
    // pre and post hooks will run
    const result = await cbAirlines.save()
    console.log(result)
  } catch (error) {
    throw error
  }
}

ottoman.start()
  .then(async() => {
    saveDocument()
      .then(() => process.exit(0))
      .catch((error) => console.log(error))
  })

const { Otomano } = requiere(otomana)

const otomana = nuevo Otomano({collectionName: por defecto});

otomana.conecte({

connectionString: couchbase://localhost,

bucketName: viajar,

nombre de usuario: Administrador,

contraseña: contraseña

});

const { Línea aérea, airlineSchema } = requiere('./esquema-y-modelo-de-la-línea-aérea')

// Plugins y Hooks son middleware, ¡piensa en ganchos de ciclo de vida!

const pluginLog = (airlineSchema) => {

airlineSchema.pre("guardar, (doc) =>

consola.registro(`Doc: ${doc.name} a punto de ser guardado`)

)

airlineSchema.Correo electrónico:("guardar, (doc) =>

consola.registro(`Doc: ${doc.id} ha sido guardado`)

)

};

// Nuestro plugin debe ser registrado antes de la creación del modelo

airlineSchema.plugin(pluginLog)

// Construir nuestro documento

const cbAirlines = nuevo Línea aérea({

Indicativo: "UNIDOS,

país: Estados Unidos,

nombre: United Airlines,

teléfono: ['321-321-3210', '321-123-1234']

})

const guardarDocumento = async() => {

pruebe {

// los ganchos pre y post se ejecutarán

const resultado = await cbAirlines.guardar()

consola.registro(resultado)

} captura (error) {

tirar error

}

otomana.iniciar()

.entonces(async() => {

guardarDocumento()

.entonces(() => proceso.salida(0))

.captura((error) => consola.registro(error))

})

Guardar el resultado del documento:

Doc: United Airlines about to be saved
Doc: 1316488a-98ba-4dbb-b0d7-ea6001a0bf57 has been saved
_Model {
  callsign: 'UNITED',
  country: 'United States',
  name: 'United Airlines',
  phone: [ '321-321-3210', '321-123-1234' ],
  id: '1316488a-98ba-4dbb-b0d7-ea6001a0bf57',
  _type: 'Airline'
}

Doc: Estados Unidos Líneas aéreas acerca de a sea guardado

Doc: 1316488a-98ba-4dbb-b0d7-ea6001a0bf57 tiene ha sido guardado

Modelo {

Indicativo: "UNIDOS,

país: Estados Unidos,

nombre: United Airlines,

teléfono: [ '321-321-3210', '321-123-1234' ],

id: '1316488a-98ba-4dbb-b0d7-ea6001a0bf57',

Tipo: Aerolínea

}

Tenemos nuestros mensajes antes y después de guardar. Con la validación, puedes asegurarte de que ciertos valores de las propiedades del documento cumplen tus criterios. Aprovechar el ciclo de vida cuando el documento se guarda, actualiza y elimina también nos ayudó a controlar el middleware otomano.

Construcción de consultas

Ottoman tiene una API muy rica que maneja muchas operaciones complejas soportadas por Couchbase y N1QL. Nuestro constructor de consultas crea tus sentencias N1QL por ti. Cuando usas Query Builder tienes tres opciones de que modo usar.

En los tres ejemplos siguientes, haré lo mismo utilizando cada uno de los tres modos diferentes de QueryBuilder (parámetros, funciones de acceso y modo mixto). Cada ejemplo lo hará:

Seleccione nombre y país de Aerolíneas
Dónde está el país el valor es "Estados Unidos"
Y LIMITAR nuestros resultados al 10

Primero vamos a crear un nuevo archivo llamado: findWithQueryBuilder.jsy añada el siguiente código:

const { Ottoman, Query } = require('ottoman')
const ottoman = new Ottoman({collectionName: '_default'});

ottoman.connect({
    connectionString: 'couchbase://localhost',
    bucketName: 'travel',
    username: 'Administrator',
    password: 'password'
});

/* Replace with QueryBuilder Example */

const executeQuery = async(query) => {
  try {
    const result = await ottoman.query(query)
    console.log('Query Result: ' , result)
  } catch (error) {
    throw error
  }
}

generateQuery()
  .then((query) => {
    executeQuery(query)
      .then(() => process.exit(0))
  })
  .catch((error) => console.log(error))

const { Otomano, Consulta } = requiere(otomana)

const otomana = nuevo Otomano({collectionName: por defecto});

otomana.conecte({

connectionString: couchbase://localhost,

bucketName: viajar,

nombre de usuario: Administrador,

contraseña: contraseña

});

/* Reemplazar con QueryBuilder Ejemplo */

const executeQuery = async(consulta) => {

pruebe {

const resultado = await otomana.consulta(consulta)

consola.registro(Resultado de la consulta: ' , resultado)

} captura (error) {

tirar error

}

generateQuery()

.entonces((consulta) => {

executeQuery(consulta)

.entonces(() => proceso.salida(0))

})

.captura((error) => consola.registro(error))

Este archivo tiene un comentario en el medio que dice: "Reemplazar con QueryBuilder Ejemplo". Podemos simplemente copiar cualquiera de los siguientes ejemplos de esta sección en esa zona del archivo.

Parámetros

const generateQuery = async() => {
  try {
    const params = {
      select : [
        { $field: 'name' }, 
        { $field: 'country'}
      ],
      where: { $and: [
        { country: {$eq: 'United States'}},
        { _type: {$eq: 'Airline'}}
      ] },
      limit: 10
    }
    const query = new Query(params, '`travel`').build()
    console.log('Query Generated: ', query)
    return query
  } catch (error) {
    throw error
  }
}

const generateQuery = async() => {

pruebe {

const parámetros = {

seleccione : [

{ $campo: nombre },

{ $campo: país}

donde: { $y: [

{ país: {$eq: Estados Unidos}},

{ Tipo: {$eq: Aerolínea}}

] },

límite: 10

}

const consulta = nuevo Consulta(parámetros, ``viajar``).construya()

consola.registro(Consulta generada: ', consulta)

devolver consulta

} captura (error) {

tirar error

}

Funciones de acceso

const generateQuery = async() => {
  try {
    const query = new Query({}, '`travel`')
      .select([
        { $field: 'name' }, 
        { $field: 'country'}
      ])
      .where({ $and: [
        { country: {$eq: 'United States'}},
        { _type: {$eq: 'Airline'}}
      ]})
      .limit(10)
      .build()
      console.log('Query Generated: ', query)
      return query
  } catch (error) {
    throw error
  }
}

const generateQuery = async() => {

pruebe {

const consulta = nuevo Consulta({}, ``viajar``)

.seleccione([

{ $campo: nombre },

{ $campo: país}

])

.donde({ $y: [

{ país: {$eq: Estados Unidos}},

{ Tipo: {$eq: Aerolínea}}

]})

.límite(10)

.construya()

consola.registro(Consulta generada: ', consulta)

devolver consulta

} captura (error) {

tirar error

}

Modo mixto

const generateQuery = async() => {
  try {
    const where =  { $and: [
      { country: {$eq: 'United States'}},
      { _type: {$eq: 'Airline'}}
    ] }
    // pass in our query as a condition expression
    const query = new Query({ where }, '`travel`')
      .select([
        { $field: 'name' }, 
        { $field: 'country' }
      ])
      .limit(10)
      .build()
      console.log('Query Generated: ', query)
      return query
  } catch (error) {
    throw error
  }
}

const generateQuery = async() => {

pruebe {

const donde = { $y: [

{ país: {$eq: Estados Unidos}},

{ Tipo: {$eq: Aerolínea}}

] }

// pasar nuestra consulta como una expresión de condición

const consulta = nuevo Consulta({ donde }, ``viajar``)

.seleccione([

{ $campo: nombre },

{ $campo: país }

])

.límite(10)

.construya()

consola.registro(Consulta generada: ', consulta)

devolver consulta

} captura (error) {

tirar error

}

Una vez creado un generarQuery() utilizando uno de los modos mixtos anteriores, deberá llamar de forma asíncrona a la función generateQuery y executeQuery y el código para que como he dicho funcionará con muchos sabores del código anterior:

Un resultado de cualquiera de los tres modos anteriores:

Query Generated:  SELECT name,country FROM default:`travel` WHERE (country="United States" AND _type="Airline") LIMIT 10
Query Result:  {
  meta: {
    requestId: '1514fa20-755e-49b3-bbfa-4ed75a1a40ee',
    clientContextId: '0334862c79e727f8',
    status: 'success',
    signature: { country: 'json', name: 'json' },
    profile: undefined,
    metrics: {
      elapsedTime: 6.219,
      executionTime: 5.9619,
      sortCount: undefined,
      resultCount: 2,
      resultSize: 106,
      mutationCount: undefined,
      errorCount: undefined,
      warningCount: undefined
    }
  },
  rows: [
    { country: 'United States', name: 'United Airlines' },
    { country: 'United States', name: 'Jet Blue Airlines' }
  ]
}

Consulta Generado: SELECCIONE nombre,país DESDE por defecto:`viaje` DONDE (país="Estados Unidos" Y Tipo="Aerolínea") LÍMITE 10

Consulta Resultado: {

meta: {

requestId: '1514fa20-755e-49b3-bbfa-4ed75a1a40ee',

clientContextId: '0334862c79e727f8',

estado: éxito,

firma: { país: json, nombre: json },

perfil: indefinido,

métricas: {

tiempo transcurrido: 6.219,

executionTime: 5.9619,

sortCount: indefinido,

resultCount: 2,

resultSize: 106,

recuento de mutaciones: indefinido,

errorCount: indefinido,

warningCount: indefinido

}

filas: [

{ país: Estados Unidos, nombre: United Airlines },

{ país: Estados Unidos, nombre: Jet Blue Airlines }

]

}

Recursos

Conclusión

Hemos realizado una visita guiada por Ottoman para comprender muchos conceptos. Esquema, modelos, middleware, plugins, hooks y construcción de consultas.

Exploramos cómo conectar con Couchbase en Ottoman. Definimos esquemas y modelos. Tocamos varios fundamentos en el esquema y diseño de bases de datos NoSQL. Finalmente, recorrimos algunas de las operaciones CRUD más útiles. Todo un esfuerzo para ponerte al día en la creación, lectura, actualización y eliminación de documentos en Couchbase a través de Ottoman.

Opine y contribuya

Espero que este artículo haya desmitificado por qué y cómo usar Ottoman y ODM para Couchbase. Como se ha mostrado, puedes usar Ottoman para el diseño de esquemas de bases de datos NoSQL, validación y reducción de boiler-plate. La escritura de operaciones CRUD se simplifica y ayuda a un rápido desarrollo.

Si tienes alguna pregunta sobre Ottoman, quieres ayudar a contribuir a este proyecto de código abierto, o simplemente te gustaría saludar, mi nombre es Eric Bishard y soy el Developer Advocate aquí en Couchbase centrándome en la experiencia de los desarrolladores de Node.js y JavaScript, mi DM está siempre abierto en Twitter/@httpJunkie.

Eric Bishard

Comparte este artículo

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Introducción a Ottoman With Couchbase

Por qué utilizar un ODM para Couchbase

Bases de datos NoSQL y diseño de esquemas

Couchbase es una base de datos NoSQL

Documento frente a relacional Base de datos

Tipos

Colecciones

Documentos

Campos

Esquema

Modelo

Primeros pasos

Instalación de Couchbase

Inicializando nuestro proyecto con NPM

Conexión a Couchbase con Ottoman

Esquemas y modelos otomanos

Definición de un esquema documental

Definición de un modelo de documento

Definición de validadores

Básico Operaciones documentales en NoSQL

Crear documentos

Errores de validación

Buscar documentos

Actualizar documentos

Eliminar documentos

Middleware

Ganchos disponibles

Construcción de consultas

Parámetros

Funciones de acceso

Modo mixto

Recursos

Conclusión

Opine y contribuya

Recibe actualizaciones del blog de Couchbase en tu bandeja de entrada

Author

Posted by Eric Bishard

Deja un comentario Cancelar respuesta

¿Listo para empezar con Couchbase Capella?

Empezar a construir

Utilizar Capella gratis

Póngase en contacto