Rust Web App – 1/3 – Data Access

construyendo un TODOMVC desde cero con rust como
back-end postgres como base de datos y componentes web nativos para el front-end. De acuerdo, el próximo código ahora
en este proyecto vamos a tener dos partes primero el front-end con nuestro paquete.json y
por ahora lo mantendremos vacío así perderemos el front-end más tarde y luego
vamos a tener nuestro back-end con nuestra carga para enviar por correo electrónico primero vamos a tener nuestro Tokio para
todo lo que va a ser una sincronización también usaremos algún rasgo futuro y luego
vamos a usar esta flecha que eliminará un poco de la placa de borde para los errores, luego en
el lado json lib usaremos las cajas de celdas en las bibliotecas web usaremos warp y luego
en las bibliotecas DB usaremos sqlx para el ejecutor db y SQLB, que en realidad es un pequeño
generador de sql experimental que he estado montando, pero esto es completamente opcional aquí, está bien,
ahora vamos a crear nuestra fuente main.rs, hola mundo muy simple y por ahora vamos
a silenciar la advertencia como vamos a compilar el código y, finalmente, ordenaremos esto,
presione guardar y luego la carpeta backend, hacemos una carga, ejecutamos y ejecutamos nuestro hola mundo hasta ahora todo bien, está
bien, centrémonos en este archivo solo aquí por ahora nuestra aplicación vamos a tener tres
módulos principales y ese será el modelo de modo que será nuestra capa de modelo o
capa de datos de alguna manera y luego vamos a tener un mod de seguridad y luego vamos a tener un
modo web que van a ser los tres módulos que vamos a tener y para ellos
vamos a crear una carpeta para cada uno de ellos porque vamos a tener más de un archivo
así que vamos a tener el modo de punto modelo dot rs luego vamos a tener security dot mode.rs
y luego vamos a tener web mod dot rs centrado en nuestra capa de modelo o capa de datos y
vamos a crear aquí un archivo Léame donde vamos a poner nuestra línea de comando y, por lo tanto, para
la base de datos que vamos a usar, nuestra ejecución de la ventana acoplable vamos a usar el puerto predeterminado de postgres
y luego la contraseña del usuario de postgres,  los usuarios raíz serán postgres y luego
usaremos postgres14 y luego Eventualmente, opcionalmente realmente no lo vamos a usar aquí, pero podemos
en otro terminal hacer un comando docker como este  por ejemplo, tenemos un comando p-sql en esta base de datos
así que ahora que lo tenemos, vamos a copiar este agregar una nueva terminal con el nombre neta base que
no nos confundiremos más tarde y luego aquí pegamos esta línea de comando y eso creará una base de datos
aquí a la que podemos conectarnos y ahora podemos volver a nuestra línea de comando aquí, así que ahora vamos a
cerrar este archivo, volvemos a nuestro backend y vamos a crear nuestro primer submódulo que
será solo una base de datos aquí, así que lo primero que vamos a hacer es definir el tipo para la base de datos
y el tipo aquí será solo un alias de tipo db que será el pull y ese sería un
objeto sql  x de postgres y ambos son tipos sqlx  , por lo que vamos a importarlos aquí en nuestra
aplicación, así que lo primero que haremos es crear un nuevo método, un método de bajo nivel solo
para este módulo que va a crear nuestra nueva herramienta db, tomará el host, la base de datos, el
nombre del usuario, la contraseña y la conexión máxima, devolverá el resultado db y por ahora lo haré.
devolver el error de sql x vamos a crear nuestra cadena de conexión esta es la forma en que
funciona el formato sql x va a ser postgres el usuario la contraseña el host y la contraseña del usuario de la base de datos
host db y luego vamos a usar pg pull opción de sql x para crear el grupo de base de datos
vamos a dar la conexión máxima aquí y luego el tiempo de espera será
codificado a 500 milisegundos y luego le damos a nuestra cadena de conexión, presione guardar
y todo debería estar bien ahora la aplicación no llamará a este método directamente aquí
habrá demasiada información para el resto del código, por lo que solo tenemos un pub a sync fn init db que en
realidad recreará la base de datos todo el tiempo, pero obviamente en producción que solo creará
el grupo de base de datos apropiado como puede ser utilizado en el resto del código, devolverá
result db sql x0 y lo llamaremos new db pool y, como queremos estar un poco
organizados aquí, vamos a tener alguna constante para definir las propiedades de la base de datos raíz por ahora
y más adelante vamos a ver cómo hacemos la aplicación uno y vamos a
agregarlos aquí a los parámetros de la función por ahora el grupo máximo de conexiones aquí será uno
así que ahora vamos a hacer nuestro primero prueba unitaria, por lo que estará en blanco por ahora,
será la prueba de configuración, obviamente, usaremos nuestro método init, el público,
solo por ahora y luego nos aseguraremos de que estamos usando la prueba de Tokio porque es va a ser
asíncrono y luego la conversión aquí, que tendrá más sentido más adelante, es repetir la ruta del módulo
aquí, por lo que tenemos el módulo subrayado db subrayado el nombre de la función y luego, eventualmente,
también podrían ser sufijos para tener los diferentes estados de la prueba y ahora vamos a ejecutar
la prueba, pero para eso vamos a usar cargo watch, por lo que vamos a tener un cargo watch
dash queue para quiet dash c para clear dash watch solo iba a ver la carpeta de origen porque
vamos a cambiar otros archivos y no queremos reiniciar el servidor todo el tiempo y
luego tenemos la x para ejecutar, por lo que hará una prueba de carga que sería nuestro filtro, esa es
la razón por la que tenemos esta convención de nomenclatura, puede tener su propias estrategias que está completamente
bien obviamente y luego vamos a tener otros dos parámetros que tienes que dar con guión guión
uno es para asegurarse de que tenemos un subproceso uno y eso es porque tenemos toda esta base de datos
y vamos a crear y volver a crear la base de datos y, por lo tanto, para asegurarnos de que no funcionen entre
sí, los ejecutaremos como un subproceso uno, hacer que sean multiproceso es posible solo más
trabajo y por ahora solo nos vamos a centrar en eso y luego el siguiente pequeño truco aquí es
tener una captura no solo para el desarrollo y eso nos permite tener algo de impresión para que
podamos ver lo que vamos a probar y luego reemplazamos la impresión por los activos y
luego todo está atado voy a seleccionar esto y voy a copiar y pegar aquí que
debería funcionar completamente bien y es normal porque no tenemos nada aquí en la
prueba, así que esta tiene que tener éxito, pero al menos todo se está compilando bien y ahora lo único
que vamos a agregar por ahora es solo esto en una base de datos y si no falla que al menos la
conexión funcione, vamos a presionar guardar y todo pasa una preferencia personal que
tengo es tener la prueba de unidad en sus propios archivos es más clara para mí, así que la forma en que lo hago
es tomar el contenido de la prueba y voy a crear una carpeta aquí y mi convención
es que voy a ponerlos bajo prueba luego el nombre del archivo va a ser de nuevo un modelo de nombre plano
subrayado db dot rs y luego pongo mi prueba aquí y luego el truco aquí es que vuelvo
a la base de datos y rust tiene un atributo genial que es y luego puedo poner una ruta relativa como este modelo
subrayado db.rs ahora presiono guardar y todo funciona como antes, pero ahora tengo mis geniales subrayado
carpetas de prueba donde voy a tener todas mis pruebas a veces podría ponerlas en una llamada de jerarquía
tipo de carpeta estructura pero al principio me gusta tenerlos planos, es muy fácil ver cuál es
su prueba y nuevamente porque la conversión de prueba aquí siempre estamos repitiendo el modelo 3, entonces puedo
probar muy fácilmente cualquier módulo 3 que quiera, está bien, así que ahora es el momento para crear nuestra base de datos sql, así que la
forma en que me gusta crearla es con archivos sql, así que lo que vamos a hacer es crear
una carpeta sql y dentro de la carpeta vamos a crear el primer archivo aquí que va a
ser 0 0 y vamos a ordenarlos así recreate db y, por convención, el 0 0 se
ejecutará como una raíz de postgres, primero vamos a soltar la base de datos y vamos a
llamar a nuestra base de datos appdb y vamos a eliminar al usuario nuevamente, esto es solo para el desarrollo,
obviamente, y luego, como está maduro, entonces no tiene esta forma, tiene una forma incremental de hacerlo
con los esquemas que tiene en producción, pero para el desarrollo temprano, esto es muy, muy rápido y
luego obviamente creamos el usuario de la aplicación de usuario con cualquier contraseña que desee y luego la base de datos de la aplicación y
ahora tenemos nuestro primer archivo sql de db recreado y el segundo archivo sql que
vamos a crear va a ser cero cree un esquema y lo ejecutaremos como el
usuario de la aplicación primero, vamos a crear un estado de tareas pendientes como un postgresql con una cláusula final abierta
y luego crearemos nuestra tabla para hacer con la identificación que será nuestra celda el número aquí
y el cid y el tiempo c por conversión, el id c será el id de usuario de la persona que ha creado
la tarea y el tiempo c es un tiempo de pregunta, así que aquí vamos a establecerlo de forma predeterminada ahora
y no funcionará.

Ni siquiera tiene que ser parte de la API de la nube y luego tenemos el título y luego tenemos el
estado con el nombre que acabamos de crear y eso no sería nuevo y el valor predeterminado estará
abierto ahora un pequeño truco aquí comenzamos todas nuestras identificaciones, las que están aquí, comenzamos
en 1000 de esta manera aquí cuando hacemos pruebas unitarias o lo que sea, si estamos por debajo de 1000, sabemos
que cuando lo creamos con esa identificación no se superpondrá en este episodio aquí realmente no vamos a
crear la tabla de usuarios, deberíamos tener una tabla de usuarios con el cid, pero por ahora solo tenemos eso,
como podemos mostrar el patrón en el código más tarde, y ahora el último archivo que vamos a crear
es va a ser más un tipo de archivo dev y ese será nuestro devsid sql lo primero que
vamos a hacer aquí es crear un primero para hacer y nuevamente estamos creando con una identificación por debajo de mil
como no se superpone con el número de secuencia y aquí vamos a especificar el estado y
vamos a hacer que se cierre y solo por eso vamos a insertar otro y esta
vez no vamos a incluir el estado para que tomará el estado predeterminado y la convención
aquí es el título será solo para hacer y la identificación del título como podemos escribir nuestra prueba de unidad así
y ahora tenemos todo el archivo sql que necesitamos ahora volvemos a nuestro archivo db aquí y
solo vamos a centrarnos en este archivo por ahora, así que ahora queremos crear una función
que ejecutará nuestro archivo sql, el primer archivo se ejecutará como una raíz pg
y los otros dos archivos se ejecutarán como una aplicación rpg, por lo que es va a ser relativamente simple
hacemos nuestro async fn pxec vamos a tomar una base de datos y luego nuestro archivo que será solo una cadena
va a devolver el resultado nulo si está bien de lo contrario nuestro sql xero vamos a devolver
el estado correcto para hacer seguro de que compila, así que lo primero que vamos a hacer es leer
el archivo muy simple, usaremos una función de lectura en cadena desde el módulo fs, nos
aseguraremos de importarlo y luego solo haciendo un
error de mapa para imprimir el mensaje de error de una manera agradable y luego simplemente conectamos en cascada la
copia de seguridad de excepción y es por eso que tenemos el signo de interrogación aquí, por lo que devolverá exactamente
el mismo error si hay uno que es un sql xero entonces vamos a dividir los archivos sql en
declaraciones sql para que sean un vector de str y vamos a hacer una división de paul man
ahora mismo, que será una división de contenido en punto y coma y, obviamente, aquí es
posible que desee hacer una un poco más sofisticado porque si tiene otro
punto y coma como valores o comentarios, se romperá bien, ahora estamos listos para hacer la iteración en
nuestras declaraciones, así que vamos a hacer f4 sql en sql s, que es nuestra matriz en sql x the la forma en que ejecuta
una declaración es con una consulta sql x, le da la cadena sql y luego llama a ejecutar con su
base de datos y llama a esperar porque es asíncrono ahora lo que queremos hacer aquí es cada declaración si
hay un resultado limitado para detenernos solo vamos a imprimir un enlace nuevamente, esto es para desarrollo y
en producción nuevamente, esa podría no ser la forma correcta, así que vamos a hacer una coincidencia si está bien,
entonces estamos felices, así que vamos a regresar vacío y si hay un error, vamos
a imprimir y solo una advertencia p exec campo de archivo sql y luego vamos a dar
el curso que vendrá de nuestro sql x el archivo ex coma y luego eso es todo, presione guardar
y todo debería compilarse ahora que tenemos que podemos cerrar esta función y vamos a
centrarnos en nuestra base de datos de inicio y vamos a definir alguna otra constante aquí, las primeras
serán la información de la base de datos de la aplicación aquí, así que todas estas y obviamente eso provendrá
probablemente de archivos de configuración o variables de entorno si implementa en Kubernetes, pero en este momento solo
los estamos poniendo como constantes y luego el otro conjunto de restricciones que queremos es nuestro sql d, que será nuestra
carpeta sql y el sql que creamos que serán los únicos archivos que ejecutamos como usuario de postgres ahora que
sabemos que estamos listos para implementar nuestro nedb, por lo que esta última línea en realidad devolverá la
base de datos de la aplicación, pero por ahora la mantendremos como pg root como nosotros compilado y todo funciona bien
y luego lo primero que vamos a hacer es crear nuestra base de datos de aplicaciones
y para eso vamos a tener nuestro grupo de base de datos rootdb   que creamos el nuevo grupo aquí
y solo necesitamos tener una conexión máxima de uno y luego llamaremos a nuestra p exacta que
acabamos de crear con la base de datos rootdb y sql create para que se cree el usuario y la
base de datos presione guardar para asegurarse de que todo funcione hasta ahora todo bien ahora podemos devolver la aplicación pg
en lugar de la raíz pg, así que aquí solo vamos a cambiar con la aplicación pg y la conexión masiva,
podemos usar nuestra constante, vamos a presionar guardar y todo debería compilarse y todo funciona
aquí porque tenemos un válido conexión a este nuevo puerto de la base de datos de la aplicación, así que no creamos el esquema ,
vamos a hacer eso ahora, ejecute los archivos sql de la aplicación y para esto vamos a crear una base de datos de la aplicación, así que
simplemente copie esta que voy a copie eso aquí solo por aplicación y esa sería nuestra appdb y
esto es solo un grupo de conexiones que se usó para crear los archivos para ejecutar los archivos, luego vamos a
leer los directorios el sql allí y vamos a iterar y vamos a solo
vamos a extraer la ruta para que nos permita no tener demasiados tipos de enumeraciones anidadas y eso
nos dará un vector de beneficio pasado que tenemos nuestro pasado mudo porque en realidad queremos ordenarlo para
asegurarnos de tener el archivo sql en el orden correcto, por lo que esa es nuestra mejor práctica y luego vamos
a ejecutar cada archivo, por lo que vamos a iterar a través de todas las rutas del beneficio anterior que tenemos,
luego, si es un paso válido una cadena válida, necesitamos aceptar solo el dot sql y no el recreate así que
para eso es muy fácil hacer una ruta si la ruta termina con ese sql y pasar not sql recreate y
luego solo vamos a llamar a nuestro p exec up db y nuestra ruta que es una cadena ahora vamos
a esperar y vamos a hacer un signo de interrogación aquí, si hay un error, detendremos todo,
que generalmente la mayor parte del error será absorbido por el p exec de la forma en que lo
codificamos y vamos a presionar guardar olvidamos importar la mejora de la ruta, vamos  a
presionar guardar y todo debería compilarse y todo debería funcionar
porque no cambiamos nada solo ejecutamos algunos archivos para que nuestros archivos sql
sean válidos y estamos devolviendo ahora el appdb ahora si volvemos a nuestro modelo subrayado db prueba
podemos hacer una prueba muy simple por lo que nuestra mejor práctica aquí es la acción de la prueba y la verificación
será una verificación muy simple cuyo resultado será igual a la consulta sqlx así que esa es la forma sqlx
funciona y podemos hacer una selección de estrellas para hacer  vamos a buscar todo y eso devolverá
pgrows matriz de nuestra base de datos vamos a esperar con cuatro errores si hay uno y luego queremos
tener un activo y Solo vamos a comprobar que tenemos dos pendientes hasta ahora.
Buen resultado.

Número de semillas por hacer. Este es nuestro mensaje para asegurarnos de que sabemos lo que
probamos.
un poco demasiado complejo, pero en realidad, cuando comienza así, tiene
una forma muy rápida de iterar a través de su código, porque ahora puede cambiar sus archivos sql,
presione guardar en su rs y todo se volverá a crear y su prueba se volverá a ejecutar y nosotros.
Veré cómo más tarde esto será muy conveniente, está bien, hagamos un trabajo real ahora para que podamos
cerrar estos archivos y podamos ir a nuestro modo modelo y vamos a crear un nuevo modo ahora que
será el modo para do y eso será para hacer el archivo del módulo dot rs, presione guardar y todo
debería funcionar, probablemente podamos detener el reloj de carga por ahora y lo reiniciaremos más tarde, así que ahora estamos
en el negocio, así que primero vamos a crear nuestro objeto pendiente por lo que va a ser una
estructura pública para hacer y vamos a tener id i64 que se asigna al bigint en la base de datos
nuestro pub cid que también está comenzando, por lo que sería nuestra identificación de creador y luego nuestro título que será
ser una cadena y tendrá que estar activada, obviamente, una cosa que me gustaría hacer es crear una región
, por lo que este será el tipo de do, así que puedo colapsar el código de esta manera y
tener todos mis tipos aquí y luego colapsarlos   presione guardar ahora vamos a agregar algunos derivados y
el primero que vamos a hacer se llama sqlx desde raw y eso permitirá que sql x haga esta
magia cuando hacemos un from o buscamos luego sql x hará la magia y devolveremos esta estructura aquí,
por lo que es muy conveniente y vamos a hacer que también se depure y clone, por ahora no vamos a
tener el estado, mostraremos cómo hacer el estado más adelante entonces, después de que vamos a tener otra
región que será para hacer mac y mac en nuestro muro aquí en nuestro patrón es el
controlador de acceso modelo tiene un patrón similar a un dro pero está usando la construcción de óxido aquí, lo que significa
que ellos realmente no necesitan ser objetos, pueden ser solo una estructura con alguna función accesoria, por lo
que vamos a tener nuestra estructura pub para hacer mac no tiene que tener ninguna propiedad y luego
vamos a implementar nuestro primer método cruzado que será la lista, así que hacemos un
pub como lista de sincronización y eso tomará nuestra db que importará y devolverá un
vect of to do y por ahora devolveré sql x error lo primero que hacemos es creamos nuestra
consulta sql, así que seleccione que será por ahora un formulario de título de cid de consulta sin procesar para ordenar por ID decreciente, por lo
que ordenará a la inversa, que generalmente es lo que desea para este caso de uso, luego vamos a
construir el objeto de consulta sqlx y eso sería con query sql x query as y hacemos el turbo fish
aquí este puede ser deducido por el compilador y luego vamos a dar nuestra tarea pendiente y
vamos a dar nuestra cadena sql y luego voy a ejecutar la consulta, por lo que la forma en que funciona con
sql x es que tomas el objeto de consulta y haces una búsqueda o db y esperas y aquí voy a
alternar los tipos allí desde el analizador de óxido y podemos ver que tenemos un vector de tareas pendientes porque
aquí decimos consulta como y le dimos el pez turbo le dimos el tipo de tareas pendientes que es la forma en que se
codifica sqlx aquí y podemos hacer una búsqueda todo lo que devuelve un vector o una búsqueda que Veremos más adelante que
devuelve solo uno y ahora podemos devolver nuestras tareas pendientes pulse guardar y todo debería compilarse
o al menos descansar, el analizador no se quejó ahora, de hecho, aquí porque devolvemos el vector de
para hacer, el compilador tendrá suficiente información una vez que tengamos esta declaración aquí, de hecho,
podemos eliminar el turbofish, presione guardar y todo debería funcionar y si cambio las
incrustaciones de tipo, veré que el compilador dedujo que iba a ser un tipo de tareas pendientes y vamos
a usar los mismos patrones que usamos antes, lo que significa que vamos a poner nuestra
prueba unitaria en otro archivo aquí, que estará dentro del modelo para hacer dot rs, que será un modelo para
hacer dot rs, así que vamos a crear nuestra primera prueba muy simple usamos nuestra prueba de Tokio tenemos nuestro
modelo subrayado para hacer la lista de subrayado para seguir nuestra mejor práctica como accesorio que es básicamente
la configuración de la prueba vamos a tener nuestra base de datos la acción de la prueba será Llame a la
lista de tareas pendientes de mac mac con la base de datos y la espera nos aseguraremos de importar la base de datos
y luego importamos a la mac y luego, por ahora la verificación será muy simple, la verificación será un
conjunto igual y por ahora solo vamos a verificar cuántos elementos que serán herramientas vamos a
presionar guardar todo debería compilarse y ahora vamos a hacer nuestro reloj de carga pero
en lugar de tener nuestro modelo subrayado db vamos a tenemos nuestro modelo para hacer y
podemos hacer la lista, pero luego lo mantendremos de esta manera y luego veremos cómo va a medida que
agregamos más pruebas vamos a presionar guardar y boom en algún momento es casi demasiado bueno
para ser cierto, lo que podemos hacer es un println, vamos a tener de esta manera, se ve mejor
y luego será la depuración y hacemos nuestras tareas pendientes, presionamos guardar y luego boom, tenemos nuestras
dos tareas pendientes aquí de donde provienen.

la base de datos, así que obviamente podemos eliminar eso y podemos
agregar más pruebas, por ejemplo, podemos probar el to do 101, que será el primero, ya que
vamos del último al primero y luego podemos hacer la prueba para hacer uno cero, que debería
ser algo así ahora presionamos guardar y todo debería pasar y todo está
ajustado, así que aquí creamos los datos de prueba en el sql que es una estrategia que puede ser debitable pero es
solo para mostrar el contexto que podría tener aquí en su método que tiene un init db o seed testdb y
luego probar estos datos de la prueba en lugar de algo del exterior, pero esto es una parte
de esto, así que esto es bastante bueno, pero hay una cosa aquí que no es óptima es que la lista
en realidad es para un sql x, pero es posible que queramos incluirlo en nuestro propio error porque a veces
vamos a tener errores específicos del módulo y, por lo tanto, no queremos confiar en que todo sea un
error de una biblioteca externa, no coincidiría y la forma en que lo hacemos es volvemos aquí y el
patrón que estoy siguiendo y vamos a usar este error que nos permitirá
eliminar un poco de repetitivo y en este caso lo estoy asociando a este error porque el
error también se llamará error, así que no quiero que se superponga, en realidad funcionará porque es
solo una macro, pero se siente más limpio de esta manera, entonces, después de que tengamos nuestro pub en una flecha, ese
será nuestro error de modelo con derivar esta flecha y nosotros vamos a hacer que se depure también y luego
la forma en que funciona este error es que creas cualquier variante y puedes anotarlas así
con el error transparente y luego dices de dónde viene y le das un nombre aquí y
para que permite que cuando hagamos el signo de interrogación, el compilador ros haga lo correcto porque
esta macro de error creará todas las transformaciones correctas, por lo que ahora también podemos hacer una para los
errores de io y esos serán los dos errores por ahora que queremos como un pass-through
presionando guardar todo debería estar bien bien, ahora podemos ir a nuestro modelo y luego vamos a
usar el modelo de caja y podemos reemplazar esto por el error del modelo ahora si presionamos
guardar todo debería funcionar exactamente igual porque no probamos el error del modelo, así que
todo debería estar bien, así que tenemos nuestra lista y ahora vamos a codificar nuestra función de creación,
de manera muy similar, vamos a tener un pub y sincronizar nuestra función que sería crear nosotros tomaremos la
misma firma de la base de datos, todas las funciones de cred tendrán la misma firma base
y como los datos que podríamos hacer, pero eso realmente no tendría sentido porque no
queremos crear para tomar la identificación obviamente, así que vamos a crear un nuevo tipo que sería
un parche de datos que vamos a hacer después y eso devolverá el riel para hacer y con nuestro
error de modelo que acabamos de crear, entonces lo que vamos a hacer aquí es vuelva a subir y vamos
a crear nuestro extracto para hacer el parche y el concepto aquí es tener los valores del parche, por lo que sería una
opción porque todo será opcional, entonces tendremos el pub cid que sería una opción
de i64 nuestro título de publicación y esa sería una opción una cadena y ahora en nuestra función de creación vamos a
crear nuestra instrucción sql vamos a insertar sql en hacer y ese será el cid y el título
por ahora valores por lo que la mejor práctica que estamos lo que sigue es que vamos a usar la declaración de preparación
para todo y luego vamos a devolver la identificación la identificación el título y la forma en que
vamos a hacer nuestra consulta con sql x es que construimos nuestra consulta sql x consulta como
tuberfish, el primero que el compilador puede deducir y luego vamos a tener que
hacer, pasamos nuestro sql y luego la forma en que funciona es llamamos al enlace uno dos tres cuatro ids para
el cid, así que ese es el cid sí, no es el id y luego vamos a enlazar el data.title
unwrap vamos a regresar sin título y eso es solo por ahora porque luego
veremos cómo lo   optimizaremos y lo haremos mucho más dinámico y
luego, después de lo que vamos a hacer, vamos a hacer query dot fetch 1 esta vez pasamos el db su
signo de interrogación de peso y luego volvemos a hacer presionamos guardar, todo debería compilarse y
ahora podemos ir a nuestro modelo para hacer test y   vamos a crear una prueba para crear, así que  vamos a
crear, el accesorio será el mismo  , entonces vamos a tener la base de datos y  vamos a
tener como un accesorio que vamos a agregar nuestro corrección de datos, que es para el accesorio, esa es la pequeña
convención que sigo y va a implementar el título y el valor predeterminado, en realidad, es posible que nos hayamos
olvidado aquí para derivar con el valor predeterminado y clonar ahora volvemos a nuestra prueba, vamos a realizar la
acción de la prueba es muy simple de hacer, cree la base de datos y vamos a clonar el dispositivo de datos de modo
que podamos usarlo más tarde y luego eso devolverá la tarea creada y como verificación por ahora podemos
imprimir en línea vacía más simple para detectar la depuración y luego tenemos nuestra tarea pendiente creada, presione
guardar, olvidamos importar este, presione guardar y ahora todo funciona y tenemos
nuestros datos aquí, así que introdúzcalos, así que obviamente no queremos que la impresora entre y nosotros vamos a afirmar
el valor, podemos asegurarnos, por ejemplo, de que el id creado por hacer sea mayor o igual a
1000, así que eso es lo que hemos hecho en nuestra base de datos y luego vamos a verificar el título del
dispositivo con el título que acabamos de crear, presione guardar y todo debería salir bien, por lo que
una cosa que no hicimos fue implementar el estado de nuestra tarea pendiente y es un tipo personalizado, por lo que
necesitamos hacer un poco de trabajo personalizado, así que si vamos Volviendo a nuestro punto de tareas pendientes, vamos
a crear un pub en el estado de hacer y eso tendrá abrir y cerrar y el diseño aquí es solo para
volver a ponerlo aquí y también en el parche como ese ahora necesitamos para anotar el estado de tareas pendientes
con un par de anotaciones, así que en la primera tenemos que decirle a sqlx que ese es un tipo, así que la forma en que lo
haces es sql es tipo, vamos a tener un clon de depuración y también eq parcial y eq y que
permite hacer la igualdad y la comparación, entonces necesitamos decirle a sqlx que asigne esto a la enumeración de la base de datos que
habíamos creado en el archivo sql y para esto usamos la macro sqlx con el nombre del tipo de atributo y
luego pasamos este valor y eso es el nombre que teníamos en nuestro create schema.sql y, por último, aquí
estamos usando mayúsculas para seguir la conversión de óxido, pero en nuestro esquema estamos usando minúsculas, por
lo que sqlx tiene otra macro para eso y podemos cambiar el nombre de todas las variantes.

minúsculas y eso
pondrá todo en minúsculas, así que ahora lo que debemos hacer es asegurarnos de que cuando obtengamos los
datos de la base de datos vamos a agregar esto en la devolución, por lo que en la creación necesitamos
agregar estado porque eso es necesario para poder crear el objeto de tareas pendientes y lo mismo aquí
cuando hacemos la selección, debemos asegurarnos de devolver el estado y el orden no importa
sí, sqlx será divertido, así que ahora presionamos guardar y todo debería funcionar como antes, pero con el
estado, lo que significa que ahora, si volvemos aquí en nuestra prueba, podemos hacer una afirmación igual, por lo que
el dispositivo de datos será ninguno porque será el valor predeterminado que no estamos configurando.

activo,
pero en la base de datos tenemos abierto por defecto, por lo que aquí podemos tener un estado de tarea pendiente. Importamos el
cajón y lo compararemos con la tarea pendiente, creó el estado, presione guardar y es casi demasiado
bueno para ser verdad. todo funciona bien, así que ahora, si volvemos a nuestro to-do.rs, hay un par
de cosas que podemos hacer mejor, la primera aquí, que es importante, debería provenir del
contexto del usuario y veremos más adelante con la seguridad. capa cómo vamos a agregar
contexto de usuario a este método y luego lo que necesitamos corregir también es el segmento sql en este momento, estamos
usando una cadena estática y esto obviamente no escala realmente porque, por ejemplo, acabamos de agregar
estado a 2 parche, tuvimos que agregar esto a nuestra selección aquí también y, de hecho, ni siquiera lo estamos tomando, ya que
estamos creando el objeto, incluso si es parte de un parche pendiente, no lo estamos creando aquí, por lo que tiene
dos formas de para resolver este problema, una es usar un orm como, por ejemplo, d0 o algo así y
eso vinculará su estructura de datos a su esquema, lo que podría ser una opción si ese es su patrón,
la otra es usar un generador de sql que da un pequeño un poco más de flexibilidad para mapear sus
consultas sql que construye con un patrón de construcción en su estructura y eso es lo que vamos
a usar hoy y de hecho estoy creando uno ahora mismo y todavía está en fase de experimentación se
llama sql b pero de nuevo esto es completamente opcional y puede usar las bibliotecas que desee, por lo que la
forma en que funciona es más bien hacer la
consulta así para hacer, los datos
serán datos.

id cid title and status y luego eso devolverá insert sql builder y nuestro
insert sql builder tiene una interfaz similar y sql x query y eso es buscar uno para que
funcione igual y podemos desactivar la incrustación y para asegurarnos de que la implementación de datos falla, hay
un par de cosas que debemos hacer primero, cualquier miembro debe poder vincularse a sqlx y, de forma predeterminada, la
cadena i64 y todo eso, pero dado que el estado 2d es un tipo personalizado, solo necesitamos agregar algo
más y ese es nuestro macro enlazable sql b que básicamente se asegurará de que el estado de tareas pendientes tenga
la implementación correcta para ser delimitado como un valor x de sql ahora que tenemos que vamos a volver
a nuestro parche de tareas pendientes y vamos a agregue otra macro que será un campo sql b y
que le dará la información al generador de sql sobre las propiedades, solo obtendrá los valores
definidos de esta manera, un parche será un verdadero parche sql ahora si bajamos aquí vamos
a asegurarnos de que vamos a importar el rasgo como completo y ahora, antes de presionar guardar,
debemos asegurarnos de que los datos tengan un campo cid porque recuerde que antes lo teníamos codificado,
entonces, ¿qué vamos a hacer? lo que debemos hacer es asegurarnos de ir a este lugar y cuando tengamos nuestro dispositivo de datos,
agregaremos el cid solo por ahora, lo cambiaremos más tarde y volveremos a nuestro
to-do.rs, presione guardar y, con suerte, todo funciona, ahora no queremos tener que hacer un parche con
el cid porque el cid debe ser una cuestión del controlador de acceso del modelo y la persona que llama solo debe
pasar el contexto del usuario por nuestro diseño y no debería tener que pasar todos estos datos administrativos lo cual
es un flechazo en el tiempo, la identificación de la creación y luego, la identificación del modificador y el tiempo del modificador, así que la forma en que lo
haremos es primero, eliminaremos el cid para el parche de tareas pendientes para
evitar que alguien lo pase.

como un valor, ahora tenemos el error de compilación, así que
tendremos que eliminarlo de aquí y volvemos a nuestro to-do.rs, pero ahora debemos
asegurarnos de que lo estamos creando y ahí es donde El poder de un generador de sql es que puedo tener un modelo como
este donde tengo campos mutables y esos serán los campos de datos y puedo agregar un nuevo campo y la
forma en que agregamos es con una tupla, el primero es el nombre de la columna y el el segundo es un valor, así que aquí
vamos a dividirlo en uno, dos, tres, luego pasamos y ahora los datos vamos a pasar
los campos y presionamos la opción de comando guardar guardar para guardar todos los archivos y luego hacer boom todo
aprobado, ahora vamos a eliminar ese botón de guardar y luego podemos usar nuestro generador de sql aquí, así que,
en lugar de hacer eso, vamos a tener una secuela igual a led sb b, seleccione la tabla que se
hará y las columnas serán las Igual que arriba y ahora más bien
llamamos a la consulta, podemos simplemente hacer un sb fetch all tiene el mismo nombre y presionamos guardar y
todo debería funcionar bien y no lo hace y eso es lo bueno de la prueba unitaria
nos acabamos de dar cuenta de que no lo hicimos 't hacer el orden por, así que si volvemos aquí nos damos cuenta de
que en realidad el orden por no coincide, así que ahora lo que podemos hacer es ordenar por y la
forma en que ahora funciona sql b es que hacemos signo de exclamación para descender y luego id presione
guardar y luego boom funciona ahora podemos eliminar eso por lo que este begin2 se ve bastante bien ahora una cosa
que se arreglará es este valor codificado el patrón que vamos a seguir es que
cualquier modelo de controlador de acción tendrá que tome el contexto de usuario que tendrá la identificación de usuario
en la lista y será responsabilidad de la capa de seguridad asegurarse de crear el
contexto de usuario correcto y cuándo vamos a tener una capa web o incluso alguna capa de trabajo asíncrona que
será de un token, por lo que podemos movernos a nuestro archivo de seguridad, crearemos el error de nuestro módulo
más adelante, así que quiero asegurarme de que tenemos eso, lo que exportará este módulo de seguridad por ahora
será una estructura y será muy simple por ahora, pero después puede hacerlo más y más
avanzado, por lo que será un ctx de usuario y, por ahora, solo tenemos una identificación de usuario de publicación y ni siquiera
tendremos la identificación de usuario en la base de datos por ahora, pero lo haremos tenga todo listo, ya que más tarde será
pan comido agregarlo, por lo que ahora lo que queremos es un método que será una sincronización porque
probablemente tendrá que preguntar a la base de datos o a algunos servicios en el backend y eso será
un utx contexto de usuario del token, el token será una cadena, por lo que más tarde será un token de solo http
para el navegador y será un resultado usuario ctx y vamos a implementar el
error del módulo de seguridad aquí abajo así que ahora en este módulo estamos vamos a poner
todo en mod.rs, pero más adelante vamos a agregar más código que podría dividirse en otros archivos,
pero ahora vamos a poner el error aquí, así que esa sería nuestra enumeración de errores para la seguridad
y dentro solo vamos a tener el nombre de nuestro cliente, que será un token no válido y, en este
momento, la validación será muy, muy simple, así que vamos a hacer un token de coincidencia que es
una cadena que vamos a pasar vamos a especifique el turbofish que le dará la
información de tipo al método, por ejemplo, puede saber a qué tipo pasar y luego, si está bien,
devolveremos la autorización del usuario ctx ID de usuario y luego, si tenemos un error, no lo haremos Realmente
no me importa lo que es por ahora y solo vamos a devolver un error que
será nuestro error debajo del token incrustado, presione guardar, nada debería cambiar porque nadie
lo está llamando, pero ahora lo que podemos hacer es agregar el contexto del usuario a todos nuestros tareas pendientes, así que la forma en que vamos a
hacerlo es aquí utx, por lo que la convención es   vamos a usar utx o contexto de usuario y
esa sería una referencia del contexto de usuario y luego haremos lo mismo para
list porque, de hecho, más adelante usaremos el utx como también control de acceso, por lo que tener el control de acceso
como un nivel de marcación hace que toda la aplicación sea mucho   más segura, así que ahora, obviamente, nuestra prueba ya no se compila,
así que lo que vamos a hacer es como parte del accesorio, vamos a tener let utx igual a
utx del token y uno, dos, tres, no olvides poner el await y luego debemos asegurarnos
de llamar a nuestro método con una referencia de gtx y vamos a haga lo mismo para nuestra
lista de tareas pendientes y aquí nuevamente haga referencia a algunas opciones de comando tx guardar para guardar todos los archivos todo
se ejecuta y todo funciona, por lo que es bastante bueno una pequeña primera capa de seguridad casi nada pero
al menos la estructura de la misma y todo nuestras pruebas están funcionando bien, así que vamos a volver a
nuestro punto de tareas pendientes rs y vamos a terminar nuestra API de crédito antes de hacer eso, hay una pequeña
cosa que podemos hacer que sea un poco menos redundante y eso es el nombre de la tabla y las columnas, así que la
forma en que lo haremos por ahora será usando const, será muy simple, lo
haremos para hacer mac, lo pondremos en otro bloque solo para estar limpio y luego en proyectos más grandes,
incluso puede tener su marca 2d incluso si no es un objeto que su estructura 2dmac pueda implementar el
comercio de funciones asociativas y eso le permitirá tener más flexibilidad en el futuro, pero por
ahora para este tamaño de proyecto tener una tabla const y esa será una cadena estática y será
para hacer y luego para las columnas que vamos a hacer muy similar para que sean nuestras columnas el
tipo será una estática de cadenas estáticas y los valores son solo van a ser estos y ahora,
en lugar de tener que hacer la tabla, podemos tener la tabla propia y aquí el resultado tendrá esto, vamos a tener los dos
puntos propios, podemos hacer lo mismo para la lista y ahora podemos presionar guardar y
todo debería funciona exactamente igual, así que ahora podemos crear nuestro método de obtención, que
será una base de datos, tome la base de datos que vamos a hacer, subraye utx porque no la usaremos,
por ahora su ctx y ahora no serán los datos.

obviamente va a ser el id que
va a ser el resultado de i64 y el error del modelo muy similar sb equal sql b seleccione
la tabla self table que se autocolumna con dos puntos y luego vamos a usar el y
donde es igual al nombre de la columna id y el valor listo ahora tenemos nuestra tarea por hacer, así que vamos a
hacer un let para hacer una llamada hay b y vamos a hacer la búsqueda uno el punto db espera el
signo de interrogación y luego vamos a regresar cómo hacerlo presione guardar para asegurarse de que todo
se compile y haremos la prueba unitaria un poco más tarde para este y ahora a continuación
podemos hacer nuestra actualización será muy similar hacemos nuestra actualización vamos a crear el
sb, por lo que la actualización tomará la identificación y el parche de tareas pendientes, de manera muy similar, hacemos la
actualización de la tabla, los datos.

hacer la devolución que vamos a ejecutar, por lo que será posible hacer un sb igual y
será el mismo aquí y luego vamos a devolver la tarea pendiente, presione guardar y todo
debería compilarse, así que ahora puede ir a nuestro modelo para realizar la prueba, por lo que agregaremos uno para
obtener y obtener el mismo dispositivo y luego la acción aquí por ahora, pero solo
consultaremos el que tenemos en nuestro desarrollador semilla, así que vamos a hacer un let to do y vamos a
hacer un 2d mac obtener nuestro db rutx y el id será 100 que es el primero que es el último
en la lista punto espera pregunta marca y luego podemos hacer nuestra verificación, vamos a verificar
que la identificación es 100 y podemos probar también el título y sabemos que el título va a ser 200.
y el estado es realmente cercano en este así que lo hacemos para hacer el estado de la cláusula de estado
presione guardar y ahora tenemos la prueba del árbol y la creación de tareas pendientes está bien, así que
todo se ve bastante bien, está bien, ahora vamos a crear nuestra
prueba de actualización de tareas pendientes y vamos a sufijo está bien, vamos a ver por qué más tarde y luego vamos
a agregar nuestro accesorio, así que vamos a hacer el db, el utx, nuestro accesorio de datos y luego vamos
a crear nuestros nuevos datos como un accesorio de datos y luego vamos a preparar nuestro accesorio de datos de actualización,
luego vamos a hacer nuestra acción, que es solo la actualización y le daremos el
accesorio de datos de actualización que estamos clonando porque lo usaremos en la verificación a continuación y luego
solo vamos a hacer algunas verificaciones mínimas aquí que es que vamos a consultar la base de datos
nuevamente y luego solo vamos a asegurarnos  de que tenemos tres y luego verificamos la
identificación y el título que vamos a presionar guarde ahora deberíamos tener cuatro pruebas y ahora tenemos la
actualización bien hasta ahora todo bien ahora la razón por la cual tengo la actualización bien es porque de hecho aquí debería
tener el get ok que es cuando hacemos un get con una buena identificación qué sucede si hacemos un get con una identificación incorrecta,
por ejemplo, copiaremos y pegaremos nuestro get y lo llamaremos una identificación y
luego pasaremos una identificación aquí, que será 999 y porque queremos
probar que falla vamos a obtener el resultado vamos a eliminar el signo de interrogación porque
no queremos fallar si falla porque en realidad debería fallar y por ahora solo para ver qué
obtenemos estamos solo vamos a hacer una impresión del resultado, vamos a presionar
guardar, deberíamos ver cinco pruebas y vemos que nuestro vo no se encuentra, que en realidad es un
error de sql x, por lo que tiene sentido, pero podemos hacerlo un poco mejor porque en nuestro código cuando
tenemos este tipo de error, realmente queremos saber qué tipo de entidad es y es por eso que
envolvemos sql x en un error de modelo como podemos tener nuestros propios errores si es necesario para hacerlo
volveremos a nuestro modo para el modelo y agregaremos un error personalizado que
será una entidad no encontrada y tomará el nombre de la entidad, que es un nombre de tabla, también
tomará la identificación como una cadena y aquí creamos una cadena, por ejemplo, si más tarde queremos tener otro tipo o
identificadores compuestos, todo funcionará bien y con este paquete de error, la forma en que lo hace es
anotarlo con error y luego el mensaje que queremos tener, así que vamos a decir entidad no
encontrada el tipo de entidad y luego la identificación de la entidad que son los primeros parámetros y el segundo
parámetro presione guardar todo debería estar bien y obviamente todavía tenemos nuestro error de sqlx
así que ahora si vamos a nuestro resultado de tareas pendientes para haga el signo de interrogación que básicamente devolverá el
error de sqlx que se envolverá en un error de modelo lo que queremos aquí es diferir el
signo de interrogación de alguna manera y vamos a hacer un error de mapa que vamos a mapear el error y
obtendremos un error de sqlx y lo compararemos y si coincidimos con la regla de error de sqlx no encontrada
entonces vamos a devolver nuestro error específico aquí, que será nuestro error de modelo en t no
encontrado, damos el nombre de la tabla y el id a la cadena y si es un error de sql x del autor que no es una
regla no encontrada, lo envolveremos en nuestro error de modelo y la variante de error de sqlx
que teníamos antes, ahora no olvidemos haga el signo de interrogación y aquí podríamos
devolver eso, pero lo haremos de esta manera, vamos a presionar guardar,
todo debería compilarse y ahora, como hemos visto, tenemos nuestro error, que
ahora es una entidad no encontrada para hacer 999.

así que esa es información útil para la depuración posterior, así que si
volvemos a nuestro modelo para hacer y tenemos la identificación incorrecta, podemos eliminar el println y esta es la forma en que vamos a
probarlo, vamos a hacer coincidir el resultado que obtuvimos aquí y si está bien,
no debería estar bien, así que diremos que no debería tener éxito y si es una entidad no encontrada, que es lo que se
supone que debe hacer, seguiremos verificando el tipo y la identificación y si es otro
error de modelo, vamos a decir que obtuvimos el error incorrecto y decimos cuál vamos
a presionar guardar y aquí no hemos importado el modelo, así que importamos el modelo aquí, presione guardar y luego
todo debería funcionar bien, así que eso está bien, pero si volvemos a nuestra implementación de tareas pendientes,
querremos tener la misma lógica para nuestra actualización y, por lo tanto, no queremos copiar y pegar aquí, así que lo que
vamos a hacer es vamos a copiar la lógica de error de este mapa, por lo que vamos a crear un método que
tomará el resultado de tareas pendientes en sql xero, tomaremos la identificación estática y haremos el trabajo que
estábamos haciendo allí, así que solo haremos un resultado y nuestro error de mapa que tenemos allí ahora  vamos a
reemplazar esto, vamos a copiar eso volviendo a get y ahora razor
para hacer está bien, vamos a tenemos un método vamos a dar el resultado la
tabla propia y luego la identificación presione guardar y todo debería funcionar muy bien ahora que
tenemos que no queremos eso y devolveremos este presione guardar y todo
funcionará bien entonces obviamente, también deberíamos probar la actualización con la idea equivocada, pero por ahora,
este es un muy buen comienzo, así que ahora, para mostrar realmente el poder de lo que hemos creado, hagamos otro
requisito, por ejemplo, si queremos capturar la hora en la que estaban los datos.

modificado el
tiempo medio y m podríamos volver a nuestro sql seguiremos este patrón
aquí y vamos a agregar medio para la identificación del modificador y la hora de finalización que
será una zona horaria y nuestro diseño en este momento va a decir va a ser neuronal en la creación,
pero debe actualizarse para cada actualización, ahora regrese a mi lista de tareas pendientes y luego digamos que,
por ahora, realmente no necesitamos tenerlo como parte del valor de retorno de las tareas pendientes, pero queremos para asegurarnos de
que estamos capturando en la base de datos, por lo que lo único que debemos hacer es como un patrón que
hemos hecho para crear si queremos tener los campos aquí vamos a tener el valor de los campos que
crearemos aquí silenciar campos y campos de datos y ahora vamos a aumentar los campos
con el cid y ver el tiempo para que podamos hacer campos push mid y esa será nuestra identificación de usuario utx y
luego nuestros campos push c time y aquí en sql b tenemos una fila que le permite dar una
cadena estática que es una expresión, por lo que todavía está parametrizada porque es solo una
cadena estática, pero al menos puede poner expresiones y aquí no nos olvidamos de la forma en que
funciona la API, ¡vaya! ahora si presionamos guardar todo debería funcionar porque no hemos
cambiado nada, pero si fuéramos a buscar en la base de datos, esos dos campos estarán allí,
así que ahora, para completar, podemos crear nuestro método de eliminación, muy simple, tenemos nuestra eliminación con
nuestro utx y nuestro i64 vamos a tener nuestro constructor de sql que eliminamos y luego tenemos el
nombre de la tabla y luego la columna y luego la identificación, obviamente, luego vamos a hacer uno nuevo y luego
vamos a llamar al mismo método que teníamos el maneje el resultado de la fase uno con nuestra tabla
y nuestra identificación presione guardar todo se compilará volvemos a nuestro modelo para hacer la prueba vamos a
agregar nuestra función de prueba nuestra eliminación simple vamos a tener nuestro dispositivo igual
que siempre vamos a tener nuestra acción en este momento, simplemente vamos a eliminar nuestra tarea para
hacer 100 y luego vamos a hacer esta verificación así que nos aseguraremos de que se elimine
y de que el título sea para hacer 100.

entonces eso es para verifique que la devolución de datos tenga todos
los datos de la regla eliminada y luego podemos tener otra verificación, que es vamos a hacer la lista
de tareas pendientes y solo usaremos el sql b y nos aseguraremos que tenemos uno porque ahora
eliminamos el otro vamos a presionar guardar y luego todos nuestros archivos adjuntos se ejecutarán tenemos seis
ahora y todo se ve bien y la eliminación está aquí y eso es todo, esa es la primera
parte de construir un to-do mvc desde cero desde la base de datos hasta la interfaz de usuario web en el próximo
episodio codificaremos las capas web usando warp y luego
codificaremos la interfaz de usuario web hasta la próxima codificación feliz.

As found on YouTube

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *