﻿1
00:00:01,210 --> 00:00:04,370
‫Instructor: En esta lección, implementemos una mejor

2
00:00:04,370 --> 00:00:07,853
‫forma de detectar errores en todas nuestras funciones asíncronas.

3
00:00:09,310 --> 00:00:12,180
‫Entonces, en este momento, en todas

4
00:00:12,180 --> 00:00:15,750
‫nuestras funciones asíncronas, tenemos estos bloques try catch, ¿verdad?

5
00:00:15,750 --> 00:00:20,430
‫Entonces, recuerde cómo agregamos a todas estas funciones de control este intento

6
00:00:20,430 --> 00:00:23,930
‫y luego este bloque de captura, ¿de acuerdo?

7
00:00:23,930 --> 00:00:26,430
‫Y todas tienen esto porque todas

8
00:00:26,430 --> 00:00:28,900
‫son funciones asíncronas y así es

9
00:00:28,900 --> 00:00:31,930
‫como generalmente detectamos los errores dentro de

10
00:00:31,930 --> 00:00:33,863
‫una función asíncrona.

11
00:00:34,800 --> 00:00:37,100
‫Entonces, usando un bloque try catch.

12
00:00:37,100 --> 00:00:41,170
‫Ahora, eso realmente hace que nuestro código se vea desordenado y desenfocado, por

13
00:00:41,170 --> 00:00:44,740
‫lo que el objetivo de este método createTour aquí, por ejemplo,

14
00:00:44,740 --> 00:00:46,560
‫es simplemente ejecutar este código.

15
00:00:46,560 --> 00:00:48,500
‫En realidad, no queremos perder el

16
00:00:48,500 --> 00:00:49,934
‫tiempo con el

17
00:00:49,934 --> 00:00:53,450
‫manejo de errores aquí, por lo que ahora mismo tenemos

18
00:00:53,450 --> 00:00:55,690
‫estos dos bloques adicionales, intente capturar, y

19
00:00:55,690 --> 00:00:57,900
‫con eso viene esta sangría adicional

20
00:00:57,900 --> 00:01:01,730
‫aquí y nuevamente, esto realmente hace que nuestro código no parezca limpio.

21
00:01:01,730 --> 00:01:03,550
‫Realmente no está enfocado.

22
00:01:03,550 --> 00:01:05,940
‫Además, tenemos mucho código duplicado aquí porque

23
00:01:05,940 --> 00:01:07,830
‫en cada uno de estos

24
00:01:07,830 --> 00:01:10,310
‫controladores tenemos un bloque de captura bastante similar.

25
00:01:10,310 --> 00:01:12,250
‫Entonces, en todo esto, todo

26
00:01:12,250 --> 00:01:14,690
‫lo que estamos haciendo es enviar esta respuesta.

27
00:01:14,690 --> 00:01:17,490
‫Y esa respuesta en realidad ni siquiera se

28
00:01:17,490 --> 00:01:20,900
‫enviaría aquí, sino en nuestro middleware global de manejo de errores,

29
00:01:20,900 --> 00:01:23,010
‫recuerde, pero ese es otro tema.

30
00:01:23,010 --> 00:01:24,910
‫Por ahora, lo que estoy

31
00:01:24,910 --> 00:01:27,170
‫tratando de enfocar aquí es que

32
00:01:27,170 --> 00:01:30,840
‫estos bloques de captura de prueba dentro de cada una de nuestras

33
00:01:30,840 --> 00:01:34,010
‫funciones asíncronas no son ideales, así que ahora intentemos solucionarlo.

34
00:01:34,010 --> 00:01:37,100
‫Y la solución es básicamente sacar el bloque try

35
00:01:37,100 --> 00:01:39,890
‫catch de aquí y ponerlo en un nivel

36
00:01:39,890 --> 00:01:41,450
‫superior en otra función.

37
00:01:41,450 --> 00:01:43,000
‫Básicamente, lo que vamos

38
00:01:43,000 --> 00:01:44,470
‫a hacer es

39
00:01:44,470 --> 00:01:49,326
‫crear una función y luego envolver esta función asíncrona en esa función.

40
00:01:49,326 --> 00:01:50,630
‫¿Está bien?

41
00:01:50,630 --> 00:01:53,333
‫Y déjame llamarlo catchAsync.

42
00:01:56,960 --> 00:02:00,290
‫Así que catchAsync, y lo llamo de esta manera

43
00:02:00,290 --> 00:02:02,380
‫porque el objetivo de

44
00:02:02,380 --> 00:02:05,410
‫esta función es simplemente detectar nuestros errores asincrónicos.

45
00:02:05,410 --> 00:02:06,613
‫Tan simple, ¿verdad?

46
00:02:07,500 --> 00:02:09,840
‫Entonces, en esta

47
00:02:09,840 --> 00:02:13,660
‫función catchAsync, pasaremos una función, ¿de acuerdo?

48
00:02:13,660 --> 00:02:16,820
‫Y recuerde, la función que vamos a

49
00:02:16,820 --> 00:02:19,030
‫pasar es básicamente esta.

50
00:02:19,030 --> 00:02:21,678
‫Entonces, ahora que estamos trabajando con este

51
00:02:21,678 --> 00:02:25,420
‫ejemplo, la función que pasaremos a catchAsync es esta

52
00:02:25,420 --> 00:02:27,840
‫función porque aquí es donde queremos

53
00:02:27,840 --> 00:02:30,033
‫detectar los errores asincrónicos.

54
00:02:31,030 --> 00:02:32,563
‫Así que hagámoslo de verdad.

55
00:02:34,090 --> 00:02:39,090
‫Entonces fn, y luego envuelva toda esa función allí.

56
00:02:40,950 --> 00:02:43,340
‫Entonces, a continuación, lo que tenemos que hacer

57
00:02:43,340 --> 00:02:45,440
‫es llamar a esta función aquí.

58
00:02:46,670 --> 00:02:49,640
‫Así que llámelo, y esta función

59
00:02:49,640 --> 00:02:53,810
‫debería recibir solicitud, respuesta y, de hecho, también siguiente.

60
00:02:53,810 --> 00:02:57,440
‫Así que este de aquí también debería tener next y

61
00:02:57,440 --> 00:02:58,860
‫todos los demás,

62
00:02:58,860 --> 00:03:01,260
‫porque recuerde, necesitamos la función next

63
00:03:01,260 --> 00:03:03,540
‫para pasarle el error para que

64
00:03:03,540 --> 00:03:05,660
‫ese error pueda ser manejado

65
00:03:05,660 --> 00:03:08,470
‫en el middleware global de manejo de errores.

66
00:03:08,470 --> 00:03:10,360
‫Entonces, todas estas funciones necesitarán solicitud,

67
00:03:10,360 --> 00:03:12,063
‫respuesta y lo siguiente.

68
00:03:12,950 --> 00:03:14,540
‫Pero dejémoslo para más tarde.

69
00:03:14,540 --> 00:03:17,090
‫Por ahora, centrémonos realmente en nuestro catchAsync aquí.

70
00:03:19,180 --> 00:03:22,120
‫Entonces, esta función aquí que pasamos a async,

71
00:03:22,120 --> 00:03:24,290
‫que ahora se llama fn aquí,

72
00:03:24,290 --> 00:03:26,040
‫es una función asincrónica.

73
00:03:26,040 --> 00:03:28,080
‫Y recuerda que las

74
00:03:28,080 --> 00:03:30,490
‫funciones asincrónicas devuelven promesas, ¿verdad?

75
00:03:30,490 --> 00:03:33,500
‫Y cuando hay un error dentro de

76
00:03:33,500 --> 00:03:37,310
‫una función asincrónica, eso básicamente significa que la promesa es rechazada.

77
00:03:37,310 --> 00:03:40,160
‫Y entonces aquí, donde realmente llamamos a esa función,

78
00:03:40,160 --> 00:03:41,893
‫podemos detectar ese error.

79
00:03:43,790 --> 00:03:46,040
‫Así que lo capturamos aquí, en

80
00:03:46,040 --> 00:03:48,590
‫lugar de atraparlo en el bloque try catch.

81
00:03:48,590 --> 00:03:53,590
‫Entonces captura, y error, y luego siguiente, y pasa el error.

82
00:03:57,040 --> 00:03:58,160
‫Y podemos

83
00:03:58,160 --> 00:04:01,810
‫simplificar esto, pero por ahora eliminemos el bloque try

84
00:04:01,810 --> 00:04:05,103
‫catch aquí, y simplemente concéntrese en esta pieza.

85
00:04:07,580 --> 00:04:08,920
‫Así que esto

86
00:04:08,920 --> 00:04:12,110
‫es todo lo que queremos y ya no necesitamos el

87
00:04:12,110 --> 00:04:15,660
‫bloque try catch, nuevamente, porque ese catch ahora se transfiere básicamente

88
00:04:15,660 --> 00:04:17,113
‫a aquí, a esta línea.

89
00:04:18,500 --> 00:04:20,350
‫Ya no es un bloque

90
00:04:20,350 --> 00:04:22,560
‫de captura, porque aquí es más

91
00:04:22,560 --> 00:04:26,060
‫fácil usar la promesa de que devuelve la función fn.

92
00:04:26,060 --> 00:04:29,640
‫Entonces, nuevamente, esta función fn es esta función, por

93
00:04:29,640 --> 00:04:32,270
‫lo que la que pasamos a catchAsync,

94
00:04:32,270 --> 00:04:34,650
‫y que devolverá una promesa.

95
00:04:34,650 --> 00:04:37,100
‫Y de hecho, noté aquí que

96
00:04:37,100 --> 00:04:40,110
‫esto, por supuesto, debería llamarse catchAsync, ¿de acuerdo?

97
00:04:40,110 --> 00:04:41,800
‫Y luego, esa función

98
00:04:41,800 --> 00:04:45,447
‫que pasamos a catchAsync, esta es, por supuesto, fn.

99
00:04:45,447 --> 00:04:46,280
‫¿Está bien?

100
00:04:46,280 --> 00:04:48,980
‫Entonces el argumento que pasamos allí.

101
00:04:48,980 --> 00:04:51,590
‫Ahora, en realidad, hay dos grandes problemas con la forma

102
00:04:51,590 --> 00:04:54,180
‫en que esto se implementa en este momento

103
00:04:54,180 --> 00:04:57,240
‫y, por lo tanto, de esta manera, realmente no funcionaría en absoluto.

104
00:04:57,240 --> 00:04:59,340
‫Entonces, el primero, esta llamada de función

105
00:04:59,340 --> 00:05:03,213
‫aquí no tiene forma de conocer la solicitud, la respuesta y el siguiente.

106
00:05:04,300 --> 00:05:07,460
‫No los pasamos a catchAsync aquí, por lo que

107
00:05:07,460 --> 00:05:09,300
‫realmente no hay forma

108
00:05:09,300 --> 00:05:12,693
‫de que la función conozca los valores de estos parámetros.

109
00:05:13,658 --> 00:05:15,610
‫Y en segundo lugar,

110
00:05:15,610 --> 00:05:18,473
‫aquí mismo estamos llamando a la función asíncrona.

111
00:05:20,290 --> 00:05:22,290
‫Y para ver esto un poco mejor, eliminémonos

112
00:05:23,200 --> 00:05:24,873
‫por completo de este código.

113
00:05:26,370 --> 00:05:29,520
‫Así que aquí tenemos catchAsync y luego lo llamamos

114
00:05:29,520 --> 00:05:31,153
‫usando paréntesis, por supuesto.

115
00:05:32,350 --> 00:05:34,900
‫Y luego, dentro de catchAsync, también estamos llamando

116
00:05:34,900 --> 00:05:37,760
‫de inmediato a la función fn, y no es

117
00:05:37,760 --> 00:05:40,130
‫así como se supone que funcione.

118
00:05:40,130 --> 00:05:43,060
‫Así que createTour aquí debería ser realmente una función, pero

119
00:05:43,060 --> 00:05:45,840
‫no el resultado de llamar a una función.

120
00:05:45,840 --> 00:05:47,810
‫Pero eso es lo que está sucediendo ahora mismo.

121
00:05:47,810 --> 00:05:49,940
‫Así que ahora mismo se

122
00:05:49,940 --> 00:05:54,310
‫está llamando a catchAsync, que luego llama a esta función aquí, ¿de acuerdo?

123
00:05:54,310 --> 00:05:56,890
‫Y de nuevo, esta función no debería llamarse,

124
00:05:56,890 --> 00:05:59,360
‫sino que debería sentarse aquí y esperar

125
00:05:59,360 --> 00:06:01,460
‫hasta que express la llame.

126
00:06:01,460 --> 00:06:03,310
‫Y Express, por supuesto, lo

127
00:06:03,310 --> 00:06:05,400
‫llamará tan pronto como alguien llegue

128
00:06:05,400 --> 00:06:08,390
‫a la ruta que necesita esta función de control.

129
00:06:08,390 --> 00:06:11,980
‫Entonces, la solución a eso es básicamente hacer que la

130
00:06:11,980 --> 00:06:15,030
‫función catchAsync devuelva otra función que luego se

131
00:06:15,030 --> 00:06:18,060
‫asignará a createTour y para que esa función

132
00:06:18,060 --> 00:06:19,640
‫se pueda llamar

133
00:06:19,640 --> 00:06:21,483
‫más tarde cuando sea necesario.

134
00:06:23,294 --> 00:06:24,394
‫Así que hagámoslo aquí.

135
00:06:25,590 --> 00:06:28,480
‫Así que regresemos una función anónima y recordemos

136
00:06:28,480 --> 00:06:30,890
‫que esta es la función a

137
00:06:30,890 --> 00:06:32,900
‫la que express llamará.

138
00:06:32,900 --> 00:06:35,380
‫Y aquí es donde

139
00:06:35,380 --> 00:06:38,423
‫especificamos solicitud, respuesta y siguiente.

140
00:06:41,120 --> 00:06:43,763
‫En realidad falta la flecha aquí.

141
00:06:47,230 --> 00:06:48,480
‫Y esta bien.

142
00:06:48,480 --> 00:06:49,890
‫Y eso es todo.

143
00:06:49,890 --> 00:06:52,420
‫Esa es nuestra función catchAsync.

144
00:06:52,420 --> 00:06:54,610
‫Solo recuerde cómo dije que

145
00:06:54,610 --> 00:06:56,840
‫podríamos simplificarlo y eso es solo

146
00:06:56,840 --> 00:06:59,110
‫porque, en JavaScript, podemos simplificarlo así, así

147
00:06:59,110 --> 00:07:01,777
‫que todo lo que necesitamos pasar aquí es

148
00:07:01,777 --> 00:07:04,020
‫la función, y luego se llamará automáticamente

149
00:07:04,020 --> 00:07:06,810
‫con el parámetro que recibe esta devolución de llamada.

150
00:07:06,810 --> 00:07:09,263
‫Entonces es lo mismo que escribir a continuación.

151
00:07:11,500 --> 00:07:13,290
‫Así que recapitulemos aquí.

152
00:07:13,290 --> 00:07:16,490
‫Entonces, para deshacernos de nuestros bloques try catch,

153
00:07:16,490 --> 00:07:19,230
‫simplemente ajustamos nuestra función asincrónica

154
00:07:19,230 --> 00:07:23,010
‫dentro de la función catchAsync que acabamos de crear.

155
00:07:23,010 --> 00:07:26,160
‫Esta función devolverá una nueva función anónima,

156
00:07:26,160 --> 00:07:27,690
‫que es

157
00:07:27,690 --> 00:07:31,660
‫esta aquí, que luego se asignará a createTour.

158
00:07:31,660 --> 00:07:34,200
‫Y, básicamente, es esta función aquí

159
00:07:34,200 --> 00:07:36,940
‫la que se llamará tan pronto como

160
00:07:36,940 --> 00:07:40,010
‫se cree un nuevo recorrido utilizando el controlador createTour.

161
00:07:40,010 --> 00:07:42,960
‫Y es por eso que tiene exactamente

162
00:07:42,960 --> 00:07:47,520
‫la misma firma aquí que esta función asincrónica, con solicitud, respuesta y siguiente.

163
00:07:47,520 --> 00:07:49,740
‫Ahora, lo que hará esta función

164
00:07:49,740 --> 00:07:51,320
‫aquí es que llamará a

165
00:07:51,320 --> 00:07:53,440
‫la función que pasamos inicialmente, así

166
00:07:53,440 --> 00:07:54,990
‫que esta aquí,

167
00:07:54,990 --> 00:07:58,270
‫y luego ejecutará todo el código que está allí.

168
00:07:58,270 --> 00:08:00,670
‫Ahora, dado que aquí es una función asincrónica,

169
00:08:00,670 --> 00:08:02,380
‫devolverá una promesa y,

170
00:08:02,380 --> 00:08:05,610
‫por lo tanto, en caso de que haya un error en

171
00:08:05,610 --> 00:08:08,400
‫esta promesa o, en otras palabras, en caso de

172
00:08:08,400 --> 00:08:11,090
‫que sea rechazada, podemos detectar el error que

173
00:08:11,090 --> 00:08:15,193
‫sucedió usando el método de captura que es disponible en todas las promesas.

174
00:08:16,560 --> 00:08:19,510
‫Y al final, es este método de captura aquí

175
00:08:19,510 --> 00:08:22,670
‫el que pasará el error a la siguiente función

176
00:08:22,670 --> 00:08:24,780
‫que luego hará que nuestro

177
00:08:24,780 --> 00:08:27,943
‫error termine en nuestro middleware global de manejo de errores.

178
00:08:28,890 --> 00:08:31,020
‫Así que aquí, esta línea de

179
00:08:31,020 --> 00:08:33,510
‫código, es realmente donde ocurre toda la magia,

180
00:08:33,510 --> 00:08:35,440
‫y esto es, de hecho,

181
00:08:35,440 --> 00:08:38,893
‫lo que nos permite deshacernos del bloque catch que teníamos anteriormente.

182
00:08:39,770 --> 00:08:40,603
‫Y una

183
00:08:40,603 --> 00:08:43,710
‫nota: esto es bastante complicado de entender y en

184
00:08:43,710 --> 00:08:46,460
‫caso de que no esté 100% claro, no

185
00:08:46,460 --> 00:08:48,943
‫se preocupe, no es tan importante.

186
00:08:49,792 --> 00:08:53,010
‫En realidad, se trata de averiguar cómo funciona

187
00:08:53,010 --> 00:08:56,460
‫exactamente el código asincrónico detrás de escena en JavaScript.

188
00:08:56,460 --> 00:09:00,100
‫Así que no se trata tanto de Express o Node. js, esto trata

189
00:09:00,100 --> 00:09:04,060
‫más sobre cómo funciona el código asincrónico.

190
00:09:04,060 --> 00:09:06,560
‫De todos modos, si ahora creamos un nuevo

191
00:09:06,560 --> 00:09:08,040
‫recorrido y ocurre

192
00:09:08,040 --> 00:09:10,440
‫algún error, por ejemplo, de una entrada

193
00:09:10,440 --> 00:09:13,450
‫no válida, entonces ese error, por supuesto, debería detectarse

194
00:09:13,450 --> 00:09:15,120
‫aquí en esta función de

195
00:09:15,120 --> 00:09:18,270
‫captura, y luego se propagará a nuestro middleware de manejo

196
00:09:18,270 --> 00:09:21,870
‫de errores y de modo que uno luego enviará de vuelta

197
00:09:21,870 --> 00:09:24,570
‫la respuesta de error que se espera que recibamos.

198
00:09:24,570 --> 00:09:26,973
‫Y ahora probemos eso.

199
00:09:28,080 --> 00:09:30,500
‫Así que crea un nuevo recorrido.

200
00:09:30,500 --> 00:09:32,030
‫Aquí tenemos el

201
00:09:32,030 --> 00:09:35,223
‫cuerpo, y ahora eliminemos uno de estos campos obligatorios.

202
00:09:36,440 --> 00:09:37,273
‫Está bien.

203
00:09:37,273 --> 00:09:40,223
‫Y eso debería desencadenar un error, así que veamos.

204
00:09:41,220 --> 00:09:44,920
‫Y, de hecho, la validación de nuestro recorrido falló, que es

205
00:09:44,920 --> 00:09:46,910
‫exactamente el mensaje de error

206
00:09:46,910 --> 00:09:49,090
‫que se suponía que íbamos a recibir.

207
00:09:49,090 --> 00:09:53,220
‫Ahora aquí, ve este error interno del servidor 500, que se debe simplemente

208
00:09:53,220 --> 00:09:55,710
‫al hecho de que en este momento

209
00:09:55,710 --> 00:09:57,500
‫el error que se propagó al

210
00:09:57,500 --> 00:09:59,280
‫middleware de manejo de

211
00:09:59,280 --> 00:10:02,110
‫errores no tenía ningún código de estado especificado, por

212
00:10:02,110 --> 00:10:05,190
‫lo que recuerde que nuestro valor predeterminado es 500 y

213
00:10:05,190 --> 00:10:08,310
‫ese es el único que luego fue enviado de vuelta.

214
00:10:08,310 --> 00:10:10,060
‫Y, por supuesto, tenemos que arreglar

215
00:10:10,060 --> 00:10:13,173
‫eso y lo haremos en una conferencia posterior de este curso.

216
00:10:14,730 --> 00:10:17,030
‫Por ahora, lo que importa aquí

217
00:10:17,030 --> 00:10:20,420
‫es que, en primer lugar, nuestra función catchAsync funciona según lo

218
00:10:20,420 --> 00:10:23,700
‫previsto y, en segundo lugar, que el error en realidad se

219
00:10:23,700 --> 00:10:26,900
‫propagó, por lo que fue detectado por nuestro middleware de

220
00:10:26,900 --> 00:10:30,223
‫manejo de errores globales, que luego envió esta respuesta al cliente.

221
00:10:32,520 --> 00:10:35,360
‫Ahora vayamos a exportar esta función de

222
00:10:35,360 --> 00:10:38,010
‫captura a su propio archivo.

223
00:10:38,010 --> 00:10:39,950
‫Así que lo tomaré de

224
00:10:39,950 --> 00:10:42,200
‫aquí y crearé solo otro archivo en

225
00:10:42,200 --> 00:10:43,843
‫nuestra carpeta de utilidades.

226
00:10:47,060 --> 00:10:51,123
‫Así que catchAsync. js.

227
00:10:55,470 --> 00:11:00,470
‫Y hasta aquí, módulo. las exportaciones deberían ser solo esto.

228
00:11:04,650 --> 00:11:09,450
‫Y eso debería funcionar bien.

229
00:11:09,450 --> 00:11:11,340
‫De vuelta en nuestro controlador de

230
00:11:11,340 --> 00:11:13,373
‫viaje, por supuesto, ahora necesitamos importar esta función.

231
00:11:18,970 --> 00:11:21,840
‫Y, como de costumbre, debemos subir una

232
00:11:22,840 --> 00:11:25,690
‫carpeta y luego a nuestra carpeta de

233
00:11:25,690 --> 00:11:27,733
‫utilidades y luego catchAsync.

234
00:11:30,810 --> 00:11:32,840
‫Muy bien, y ahora todo

235
00:11:32,840 --> 00:11:36,080
‫lo que tenemos que hacer es deshacernos de

236
00:11:36,080 --> 00:11:40,593
‫todos estos bloques de captura y envolver todos los manejadores en catchAsync.

237
00:11:42,210 --> 00:11:43,793
‫Así que hagámoslo.

238
00:11:47,610 --> 00:11:52,610
‫Primero envuelva y luego elimine estos bloques.

239
00:11:57,030 --> 00:12:00,220
‫Guárdelo para reformatearlo y aquí vamos.

240
00:12:00,220 --> 00:12:03,310
‫Y ahora es simplemente un proceso de repetir

241
00:12:03,310 --> 00:12:06,821
‫esto hasta que todos los recorridos, o, lo siento,

242
00:12:06,821 --> 00:12:09,633
‫hasta que todos los controladores hayan terminado.

243
00:12:13,070 --> 00:12:14,760
‫Bien, guarde rápido.

244
00:12:14,760 --> 00:12:16,740
‫Este ya está hecho.

245
00:12:16,740 --> 00:12:18,763
‫El siguiente es la actualización.

246
00:12:26,920 --> 00:12:28,483
‫Y solo falta uno más.

247
00:12:36,380 --> 00:12:37,870
‫O en realidad, eso no es cierto.

248
00:12:37,870 --> 00:12:40,403
‫Allí abajo tenemos aún más funciones asincrónicas.

249
00:12:52,530 --> 00:12:57,203
‫Así que nos desharemos de la captura y el intento aquí.

250
00:12:59,150 --> 00:13:01,100
‫Y creo que este es el último.

251
00:13:04,020 --> 00:13:05,483
‫Y sí, de hecho lo es.

252
00:13:12,390 --> 00:13:15,000
‫Muy bien, ahora otra cosa que

253
00:13:15,000 --> 00:13:19,040
‫debemos hacer es agregar junto a todos ellos aquí también.

254
00:13:19,040 --> 00:13:20,793
‫Pero claro, no en mayúsculas.

255
00:13:21,690 --> 00:13:22,960
‫Bueno.

256
00:13:22,960 --> 00:13:25,480
‫Y permítanme seleccionarlos todos aquí para que

257
00:13:28,170 --> 00:13:30,683
‫solo tenga que escribirlos una vez.

258
00:13:33,140 --> 00:13:35,943
‫Y eso se sumaba a todos ellos.

259
00:13:38,390 --> 00:13:42,063
‫Y ahora creo que hemos terminado con esta parte.

260
00:13:43,270 --> 00:13:46,310
‫Probemos de nuevo muy rápidamente, no con este,

261
00:13:46,310 --> 00:13:48,733
‫sino aquí con, no con este

262
00:13:49,950 --> 00:13:52,000
‫también, así que hemos terminado.

263
00:13:55,330 --> 00:13:57,140
‫Y voy a intentar hacer

264
00:13:57,140 --> 00:14:01,870
‫un recorrido pero con una identificación no válida, así que veamos qué sucede aquí.

265
00:14:01,870 --> 00:14:04,250
‫Y de hecho, recibimos nuestro mensaje de

266
00:14:04,250 --> 00:14:06,950
‫error y nuevamente con el código de estado 500,

267
00:14:06,950 --> 00:14:08,640
‫que no es correcto, recuerde,

268
00:14:08,640 --> 00:14:10,050
‫pero nos ocuparemos

269
00:14:10,050 --> 00:14:11,930
‫de eso en un momento posterior.

270
00:14:11,930 --> 00:14:15,130
‫Así que ahora mismo, déjame mostrarte que aquí

271
00:14:15,130 --> 00:14:19,920
‫es de donde viene el 500 porque ahora mismo no hay un

272
00:14:19,920 --> 00:14:22,200
‫código de estado dentro del error

273
00:14:22,200 --> 00:14:24,310
‫que obtenemos porque estos errores,

274
00:14:24,310 --> 00:14:27,940
‫en realidad provienen de Mongoose, por lo que no

275
00:14:27,940 --> 00:14:29,730
‫tenemos forma de

276
00:14:29,730 --> 00:14:32,390
‫agregar un estado. código a estos errores.

277
00:14:32,390 --> 00:14:35,370
‫O en realidad, por supuesto, podríamos hacerlo, pero eso

278
00:14:35,370 --> 00:14:37,950
‫sería aún más confuso y, por lo

279
00:14:37,950 --> 00:14:40,330
‫tanto, encontraremos otra forma más adelante en

280
00:14:40,330 --> 00:14:41,443
‫esta sección.

281
00:14:42,510 --> 00:14:45,840
‫Por ahora, estoy muy contento con el resultado que tenemos

282
00:14:45,840 --> 00:14:48,773
‫aquí y eso es todo para esta conferencia.

