1
00:00:01,140 --> 00:00:03,050
‫Jonas: Sigamos ahora escribiendo nuestra función

2
00:00:03,050 --> 00:00:04,773
‫de protección de middleware.

3
00:00:06,420 --> 00:00:08,910
‫Entonces, en la última lección, leímos

4
00:00:08,910 --> 00:00:10,990
‫el token del encabezado de

5
00:00:10,990 --> 00:00:14,080
‫autorización y luego verificamos si el token realmente existe.

6
00:00:14,080 --> 00:00:15,023
‫Así que aquí mismo.

7
00:00:15,880 --> 00:00:19,890
‫Y a continuación, tenemos el paso de verificación del token.

8
00:00:19,890 --> 00:00:21,880
‫Y espero que recuerden que

9
00:00:21,880 --> 00:00:24,520
‫en este paso verificamos si alguien manipuló

10
00:00:24,520 --> 00:00:27,500
‫los datos o también si el token ya caducó.

11
00:00:27,500 --> 00:00:31,840
‫Así que ya usamos, desde el paquete de token web JSON, la función

12
00:00:31,840 --> 00:00:33,180
‫de asignación de

13
00:00:33,180 --> 00:00:35,623
‫función, y ahora usaremos la función de verificación.

14
00:00:36,820 --> 00:00:39,333
‫Así que al igual que antes, jwt. Verifique, y luego

15
00:00:43,000 --> 00:00:46,630
‫allí, como puede imaginar, pasamos el token para que el algoritmo

16
00:00:46,630 --> 00:00:49,160
‫pueda leer la carga útil y luego

17
00:00:49,160 --> 00:00:52,133
‫recordar que este paso también necesita el secreto.

18
00:00:53,250 --> 00:00:56,870
‫Básicamente, para crear la firma de prueba.

19
00:00:56,870 --> 00:01:00,743
‫Entonces ese secreto es el proceso. env. JWT_SECRET.

20
00:01:03,470 --> 00:01:04,610
‫¿Recuérdalo?

21
00:01:04,610 --> 00:01:05,860
‫Ahora, como tercer

22
00:01:05,860 --> 00:01:09,003
‫argumento, esta función realmente requiere una función de devolución de llamada.

23
00:01:10,090 --> 00:01:12,180
‫Entonces, esta devolución de llamada se

24
00:01:12,180 --> 00:01:14,850
‫ejecutará tan pronto como se complete la verificación.

25
00:01:14,850 --> 00:01:16,840
‫Entonces ve que esta verificación

26
00:01:16,840 --> 00:01:19,564
‫aquí es en realidad una función asincrónica.

27
00:01:19,564 --> 00:01:22,540
‫Entonces verificará un token, y luego, cuando esté

28
00:01:22,540 --> 00:01:23,620
‫listo, llamará

29
00:01:23,620 --> 00:01:27,040
‫a la función de devolución de llamada que podamos especificar.

30
00:01:27,040 --> 00:01:29,910
‫Ahora, hemos estado trabajando con promesas todo

31
00:01:29,910 --> 00:01:33,159
‫el tiempo, y realmente no quiero romper ese patrón aquí.

32
00:01:33,159 --> 00:01:37,000
‫Y entonces, realmente vamos a prometer esta función.

33
00:01:37,000 --> 00:01:40,370
‫Básicamente, hacer que devuelva una promesa.

34
00:01:40,370 --> 00:01:42,660
‫Y de esa manera, podemos usar async

35
00:01:42,660 --> 00:01:45,613
‫await como cualquier otra función async que hemos estado usando.

36
00:01:46,820 --> 00:01:48,050
‫Entonces, para hacer

37
00:01:48,050 --> 00:01:51,050
‫eso, Node en realidad tiene una función promisify incorporada.

38
00:01:51,050 --> 00:01:53,650
‫Todo lo que necesitamos hacer para

39
00:01:53,650 --> 00:01:56,663
‫usarlo es requerir el módulo util incorporado.

40
00:01:58,695 --> 00:02:00,895
‫Así que hagámoslo desde arriba, en realidad.

41
00:02:02,900 --> 00:02:07,900
‫Entonces eso creará un objeto llamado util, require ...

42
00:02:10,740 --> 00:02:13,400
‫Muy bien, eso significa utilidad.

43
00:02:13,400 --> 00:02:15,420
‫Eso no es lo que quería.

44
00:02:15,420 --> 00:02:16,960
‫Eso significa utilidad.

45
00:02:16,960 --> 00:02:20,300
‫Y luego, vamos a utilizar el método promisify.

46
00:02:20,300 --> 00:02:22,900
‫Pero como solo usaremos ese método, podemos

47
00:02:22,900 --> 00:02:24,603
‫hacerlo más fácilmente.

48
00:02:25,578 --> 00:02:26,990
‫Entonces, en lugar

49
00:02:26,990 --> 00:02:30,610
‫de hacer esto, simplemente podemos desestructurar ese objeto y

50
00:02:30,610 --> 00:02:32,823
‫tomar promisificar directamente desde allí.

51
00:02:35,388 --> 00:02:38,453
‫Entonces, nuevamente, esto solo está usando la desestructuración de ES6.

52
00:02:41,182 --> 00:02:43,230
‫Bien, ahora es muy fácil de usar.

53
00:02:43,230 --> 00:02:46,127
‫Todo lo que tenemos que hacer es realmente llamar a promisificar.

54
00:02:47,434 --> 00:02:51,463
‫Así que promisifique y luego pase la función allí.

55
00:02:53,500 --> 00:02:56,080
‫Y ahora, todo esto aquí es una función

56
00:02:56,080 --> 00:02:56,970
‫que debemos

57
00:02:56,970 --> 00:02:59,190
‫llamar, que luego devolverá una promesa.

58
00:02:59,190 --> 00:03:01,810
‫Entonces aquí, en realidad llamamos a la función.

59
00:03:01,810 --> 00:03:03,900
‫Y esto devolverá una promesa,

60
00:03:03,900 --> 00:03:08,300
‫por lo que podemos esperarlo y almacenar el resultado en una variable.

61
00:03:08,300 --> 00:03:10,390
‫Entonces, el valor de resultado de la

62
00:03:10,390 --> 00:03:12,350
‫promesa será en realidad los datos

63
00:03:12,350 --> 00:03:15,823
‫decodificados, por lo que la carga útil decodificada de este token web JSON.

64
00:03:17,600 --> 00:03:19,360
‫Así que déjame llamarlo decodificado aquí.

65
00:03:19,360 --> 00:03:20,193
‫Está bien.

66
00:03:20,193 --> 00:03:23,490
‫Y podemos esperar porque ya dijimos que

67
00:03:23,490 --> 00:03:25,453
‫es una función asincrónica.

68
00:03:27,670 --> 00:03:30,850
‫Y ahora, solo para ver que realmente

69
00:03:30,850 --> 00:03:34,730
‫funciona, registremos también estos datos decodificados en la consola.

70
00:03:34,730 --> 00:03:38,143
‫Y de hecho, podemos eliminar esta consola. cerrar sesión en el token.

71
00:03:39,050 --> 00:03:40,400
‫Ese que ya no necesitamos.

72
00:03:42,140 --> 00:03:46,560
‫Intentemos enviar esta solicitud nuevamente, y sí, pero esta vez

73
00:03:46,560 --> 00:03:49,990
‫activando este encabezado de autorización para

74
00:03:49,990 --> 00:03:54,850
‫que enviemos un token web JSON junto con la solicitud.

75
00:03:54,850 --> 00:03:55,940
‫Entonces eso lo envió.

76
00:03:55,940 --> 00:03:58,540
‫Y ahora, de hecho, tenemos acceso a los

77
00:03:58,540 --> 00:04:02,070
‫datos y, por lo tanto, ahora tenemos acceso a la ruta protegida.

78
00:04:02,070 --> 00:04:02,903
‫¿Okey?

79
00:04:02,903 --> 00:04:06,203
‫Pero lo que quería ver es este objeto decodificado aquí.

80
00:04:07,230 --> 00:04:09,910
‫Y entonces este debería ser el ID de usuario.

81
00:04:09,910 --> 00:04:12,530
‫Así que echemos un vistazo a eso en Postman nuevamente.

82
00:04:12,530 --> 00:04:13,423
‫Entonces 62a42.

83
00:04:15,520 --> 00:04:18,740
‫Y entonces, de hecho, bueno, ¿dónde tenemos eso?

84
00:04:18,740 --> 00:04:20,193
‫Echemos un vistazo a Compass.

85
00:04:21,240 --> 00:04:24,813
‫Y de hecho, el ID de este usuario es 62a42.

86
00:04:27,160 --> 00:04:29,347
‫Y eso significa que realmente tenemos

87
00:04:29,347 --> 00:04:31,340
‫nuestra carga útil correcta aquí.

88
00:04:31,340 --> 00:04:33,420
‫Básicamente, la identificación de usuario correcta.

89
00:04:33,420 --> 00:04:36,460
‫Luego, también tenemos la marca de tiempo de la fecha

90
00:04:36,460 --> 00:04:39,500
‫de creación y de la fecha de vencimiento del token.

91
00:04:39,500 --> 00:04:40,700
‫Entonces esto está funcionando.

92
00:04:40,700 --> 00:04:43,710
‫Pero ahora intentemos manipular la carga útil de

93
00:04:43,710 --> 00:04:44,563
‫este token.

94
00:04:47,088 --> 00:04:49,090
‫Copiemos aquí de nuevo.

95
00:04:49,090 --> 00:04:52,443
‫Pero luego voy al depurador de JWT.

96
00:04:54,640 --> 00:04:57,023
‫Así que de nuevo, en jwt. io.

97
00:05:00,290 --> 00:05:02,363
‫Así que quitemos esto.

98
00:05:03,310 --> 00:05:06,010
‫Y ahora lo que voy a hacer es cambiar algunos

99
00:05:06,010 --> 00:05:09,260
‫datos aquí y luego cambiará el token codificado aquí, que luego

100
00:05:09,260 --> 00:05:11,010
‫puedo seguir adelante y copiar.

101
00:05:12,420 --> 00:05:14,693
‫Así que simplemente reemplacemos, en

102
00:05:15,580 --> 00:05:19,050
‫realidad, solo reemplazaré estos dos números aquí

103
00:05:19,050 --> 00:05:20,940
‫con algo diferente.

104
00:05:20,940 --> 00:05:23,590
‫Y así, como ves, esto cambió la ficha aquí.

105
00:05:23,590 --> 00:05:26,040
‫Y ahora, intentaré obtener acceso a

106
00:05:26,040 --> 00:05:27,470
‫esa ruta

107
00:05:27,470 --> 00:05:30,373
‫protegida utilizando este token web JSON manipulado.

108
00:05:31,460 --> 00:05:33,133
‫Vale, ¿tiene sentido?

109
00:05:34,100 --> 00:05:37,023
‫Así que solo para ver si funciona correctamente.

110
00:05:38,632 --> 00:05:39,970
‫Así que estoy

111
00:05:39,970 --> 00:05:42,660
‫copiando este aquí ahora y pegando este otro diferente.

112
00:05:42,660 --> 00:05:47,310
‫Entonces, si ahora envío esta solicitud, obtenemos un error.

113
00:05:47,310 --> 00:05:48,250
‫Que bien.

114
00:05:48,250 --> 00:05:50,843
‫Entonces, vemos que el nombre del error es

115
00:05:51,840 --> 00:05:54,220
‫JsonWebTokenError y tenemos una firma no válida.

116
00:05:54,220 --> 00:05:55,160
‫Que bien.

117
00:05:55,160 --> 00:05:57,650
‫Eso es exactamente lo que estábamos buscando.

118
00:05:57,650 --> 00:06:00,210
‫Entonces ese es uno de los dos errores que pueden ocurrir.

119
00:06:00,210 --> 00:06:02,853
‫El otro es que el token ya ha caducado.

120
00:06:04,359 --> 00:06:07,180
‫Este se llama JsonWebTokenError y, en

121
00:06:07,180 --> 00:06:10,890
‫realidad, sigamos adelante y manejemos este error ahora.

122
00:06:10,890 --> 00:06:12,240
‫Y la forma

123
00:06:12,240 --> 00:06:16,470
‫en que podríamos hacerlo es agregando un bloque try-catch aquí.

124
00:06:16,470 --> 00:06:17,460
‫¿Derecha?

125
00:06:17,460 --> 00:06:19,600
‫Entonces, justo después de hacer este

126
00:06:19,600 --> 00:06:21,510
‫código, podríamos introducir un bloque

127
00:06:21,510 --> 00:06:24,260
‫de prueba, y luego en la captura, crearíamos

128
00:06:24,260 --> 00:06:26,290
‫errores que se enviarían al cliente.

129
00:06:26,290 --> 00:06:28,070
‫Ahora, en lugar de hacerlo de

130
00:06:28,070 --> 00:06:30,970
‫esa manera, en realidad quiero usar nuestro middleware global de

131
00:06:30,970 --> 00:06:33,290
‫manejo de errores para hacer eso por nosotros.

132
00:06:33,290 --> 00:06:35,850
‫Así que no nos gusta hacer el manejo de errores aquí mismo

133
00:06:35,850 --> 00:06:37,220
‫en nuestra función de middleware.

134
00:06:37,220 --> 00:06:41,140
‫En cambio, generalmente lo delegamos al controlador de errores.

135
00:06:41,140 --> 00:06:43,940
‫Entonces, hagamos exactamente lo mismo aquí.

136
00:06:43,940 --> 00:06:46,710
‫Entonces controlador de errores.

137
00:06:46,710 --> 00:06:48,600
‫Y luego es exactamente lo

138
00:06:48,600 --> 00:06:50,930
‫mismo que tenemos con nuestros otros errores aquí.

139
00:06:50,930 --> 00:06:54,210
‫Entonces, por ejemplo, el error de validación proviene de Mongoose, es

140
00:06:54,210 --> 00:06:55,670
‫decir, de otra biblioteca.

141
00:06:55,670 --> 00:06:59,060
‫Y ahora, este error en realidad proviene de otra

142
00:06:59,060 --> 00:07:02,180
‫biblioteca y también tiene su propio nombre.

143
00:07:02,180 --> 00:07:03,470
‫Así que consigamos eso.

144
00:07:03,470 --> 00:07:04,820
‫Y es JsonWebTokenError.

145
00:07:06,900 --> 00:07:07,940
‫Está bien.

146
00:07:07,940 --> 00:07:09,923
‫Entonces, hagamos algo muy similar aquí.

147
00:07:11,850 --> 00:07:12,683
‫Así que si. nombre es

148
00:07:15,477 --> 00:07:19,310
‫este, entonces el error debe ser igual para manejar el error.

149
00:07:19,310 --> 00:07:23,463
‫Bueno.

150
00:07:27,010 --> 00:07:27,843
‫Así que sigamos

151
00:07:27,843 --> 00:07:30,430
‫adelante y creemos esta función, de hecho, en algún lugar de aquí.

152
00:07:30,430 --> 00:07:31,953
‫Y este es realmente extremadamente simple.

153
00:07:35,782 --> 00:07:37,810
‫Todo lo que hace es tomar un error

154
00:07:37,810 --> 00:07:39,760
‫y luego devolver un nuevo AppError.

155
00:07:39,760 --> 00:07:41,433
‫¿Okey?

156
00:07:44,480 --> 00:07:45,320
‫Entonces, en

157
00:07:45,320 --> 00:07:48,950
‫esta función de flecha de ES6, como espero que sepa, podemos escribir estas frases

158
00:07:48,950 --> 00:07:50,790
‫ingeniosas en las que ni siquiera tenemos

159
00:07:50,790 --> 00:07:53,610
‫que especificar las llaves y tampoco la palabra clave return.

160
00:07:53,610 --> 00:07:55,610
‫Así que esto devolverá

161
00:07:55,610 --> 00:07:58,670
‫automática e implícitamente todo lo que pongamos aquí.

162
00:07:58,670 --> 00:08:00,123
‫¿Derecha?

163
00:08:01,010 --> 00:08:01,843
‫Entonces,

164
00:08:01,843 --> 00:08:04,763
‫lo que queremos decir aquí es simplemente, token

165
00:08:05,980 --> 00:08:07,273
‫inválido, inicie sesión nuevamente.

166
00:08:09,580 --> 00:08:12,640
‫Y luego, el código de error, como antes,

167
00:08:12,640 --> 00:08:15,000
‫es un 401 para No autorizado.

168
00:08:15,000 --> 00:08:17,463
‫Ahora, esto solo funciona, recuerde, en producción.

169
00:08:19,497 --> 00:08:22,410
‫Entonces, si hiciéramos esto ahora de

170
00:08:22,410 --> 00:08:24,883
‫nuevo, obtendríamos exactamente lo mismo.

171
00:08:24,883 --> 00:08:27,730
‫Entonces, regresemos aquí y ejecutemos

172
00:08:27,730 --> 00:08:29,890
‫esto en producción.

173
00:08:29,890 --> 00:08:32,340
‫Entonces npm run start: production.

174
00:08:32,340 --> 00:08:37,340
‫Sí, así como así.

175
00:08:39,470 --> 00:08:40,733
‫Entonces, si intentamos

176
00:08:41,650 --> 00:08:43,890
‫esto ahora nuevamente, veamos si obtenemos nuestro error.

177
00:08:43,890 --> 00:08:45,630
‫Y de hecho, lo hacemos.

178
00:08:45,630 --> 00:08:47,840
‫Entonces, si, en este momento, un usuario en

179
00:08:47,840 --> 00:08:50,040
‫producción intenta acceder a nuestra aplicación con

180
00:08:50,040 --> 00:08:52,930
‫un token no válido, entonces solo recibe este mensaje de error.

181
00:08:52,930 --> 00:08:55,890
‫¿Está bien?

182
00:08:55,890 --> 00:08:57,120
‫Entonces ese es el primer error que podemos obtener.

183
00:08:57,120 --> 00:08:59,920
‫Pero otro es que el usuario intenta acceder

184
00:08:59,920 --> 00:09:01,560
‫a la aplicación

185
00:09:01,560 --> 00:09:03,500
‫con un token ya caducado.

186
00:09:03,500 --> 00:09:06,147
‫Entonces, ahora intentemos crear ese error.

187
00:09:06,147 --> 00:09:08,733
‫Y para hacer eso, cambiaré

188
00:09:09,683 --> 00:09:13,080
‫el tiempo que tarda el token en caducar.

189
00:09:13,080 --> 00:09:14,943
‫Entonces, ahora mismo, tenemos 90 días.

190
00:09:17,811 --> 00:09:19,190
‫Digámoslo como cinco segundos.

191
00:09:19,190 --> 00:09:22,183
‫Bueno.

192
00:09:23,078 --> 00:09:23,911
‫Dale una oportunidad.

193
00:09:23,911 --> 00:09:24,870
‫Y ahora intente iniciar sesión nuevamente.

194
00:09:24,870 --> 00:09:26,823
‫Así que guardemos este aquí también.

195
00:09:28,090 --> 00:09:30,943
‫Entonces, en usuarios, y luego inicie sesión.

196
00:09:32,920 --> 00:09:37,043
‫Entonces podemos iniciar sesión y luego nos dará un nuevo token,

197
00:09:39,060 --> 00:09:43,100
‫pero este token solo es válido por cinco segundos.

198
00:09:43,100 --> 00:09:46,100
‫Y entonces, estos cinco segundos deberían haber pasado en este punto.

199
00:09:46,100 --> 00:09:49,550
‫Así que ahora copiaré este token e intentaré acceder a

200
00:09:49,550 --> 00:09:51,690
‫nuestra ruta protegida usando ese token.

201
00:09:51,690 --> 00:09:55,713
‫Así que pégalo aquí.

202
00:09:58,529 --> 00:09:59,362
‫Y ahora, veamos qué obtenemos.

203
00:09:59,362 --> 00:10:01,630
‫Y de hecho, por alguna razón, funcionó.

204
00:10:01,630 --> 00:10:04,280
‫Así que echemos un vistazo a nuestro depurador JWT nuevamente.

205
00:10:04,280 --> 00:10:08,593
‫Y dice, creado el 2 de mayo, pero vence

206
00:10:11,620 --> 00:10:14,160
‫solo el 31 de julio.

207
00:10:14,160 --> 00:10:16,720
‫Entonces, algo salió mal en esa creación simbólica, supongo.

208
00:10:16,720 --> 00:10:21,023
‫Entonces, cambiemos esto aquí nuevamente.

209
00:10:22,140 --> 00:10:23,810
‫Y solo voy a poner cinco aquí.

210
00:10:23,810 --> 00:10:25,993
‫Y entonces, cinco deberían

211
00:10:27,270 --> 00:10:30,340
‫permanecer durante cinco milisegundos, o incluso puedo poner

212
00:10:30,340 --> 00:10:32,630
‫5000, que deberían ser cinco segundos.

213
00:10:32,630 --> 00:10:34,733
‫Bueno.

214
00:10:37,680 --> 00:10:38,890
‫Así que déjame guardarlo ahora de nuevo para reiniciar el servidor.

215
00:10:38,890 --> 00:10:42,363
‫Pruébalo otra vez.

216
00:10:43,240 --> 00:10:44,570
‫Así que inicie sesión de nuevo aquí.

217
00:10:44,570 --> 00:10:46,113
‫Está bien.

218
00:10:47,680 --> 00:10:48,600
‫Así que ahora todo

219
00:10:48,600 --> 00:10:52,930
‫lo que tenemos que hacer es básicamente esperar cinco segundos, y ese tiempo ya debería haber pasado en este punto.

220
00:10:52,930 --> 00:10:56,933
‫Pégalo aquí de nuevo.

221
00:11:00,230 --> 00:11:01,500
‫Y vamos.

222
00:11:01,500 --> 00:11:03,560
‫Y de hecho, obtenemos un error.

223
00:11:03,560 --> 00:11:05,860
‫Ahora recuerde cómo este es

224
00:11:05,860 --> 00:11:09,850
‫básicamente el error estándar que obtenemos en caso de que no

225
00:11:09,850 --> 00:11:13,230
‫manejemos correctamente ese error en nuestro manejo de errores.

226
00:11:13,230 --> 00:11:14,700
‫¿Derecha?

227
00:11:14,700 --> 00:11:15,750
‫Así que echemos un vistazo al error.

228
00:11:15,750 --> 00:11:18,840
‫Y de hecho, lo tenemos aquí en la consola.

229
00:11:18,840 --> 00:11:21,350
‫Veamos de dónde viene eso.

230
00:11:21,350 --> 00:11:24,620
‫Y sí, viene de este lugar.

231
00:11:24,620 --> 00:11:26,673
‫Entonces este es el caso en el que tenemos un error desconocido.

232
00:11:27,760 --> 00:11:31,690
‫Recuerde, entonces es un error que no está marcado como

233
00:11:31,690 --> 00:11:34,090
‫un error operativo y, por lo

234
00:11:34,090 --> 00:11:35,640
‫tanto, queremos registrarlo.

235
00:11:35,640 --> 00:11:37,543
‫Así que lo registramos aquí y

236
00:11:38,500 --> 00:11:39,650
‫luego enviamos este mensaje

237
00:11:39,650 --> 00:11:42,150
‫de error genérico al cliente, el que acabamos de

238
00:11:42,150 --> 00:11:43,270
‫ver en Postman.

239
00:11:43,270 --> 00:11:45,610
‫Pero aquí tenemos los detalles de este error.

240
00:11:45,610 --> 00:11:48,100
‫Y entonces, este tiene el nombre de TokenExpiredError.

241
00:11:48,100 --> 00:11:51,480
‫Está bien.

242
00:11:51,480 --> 00:11:52,313
‫Entonces, ahora manejemos este también.

243
00:11:52,313 --> 00:11:55,360
‫Así que lo estoy copiando ahora y luego

244
00:11:55,360 --> 00:11:57,171
‫creo otro si aquí.

245
00:11:57,171 --> 00:12:02,171
‫Entonces, si el error. nombre es igual a este, bueno,

246
00:12:02,300 --> 00:12:07,300
‫entonces, digamos, manejeJWTExpiredError

247
00:12:08,980 --> 00:12:10,343
‫con

248
00:12:12,711 --> 00:12:14,461
‫la flecha.

249
00:12:18,640 --> 00:12:20,233
‫Copiemos y pongámoslo aquí.

250
00:12:22,568 --> 00:12:25,750
‫Y esto, por supuesto, es muy similar al anterior.

251
00:12:33,186 --> 00:12:37,770
‫Tu token ha caducado.

252
00:12:37,770 --> 00:12:40,493
‫Inicie sesión de nuevo.

253
00:12:43,940 --> 00:12:45,193
‫Y nuevamente, con un código de error 401.

254
00:12:48,670 --> 00:12:51,423
‫Bien, intentémoslo de nuevo.

255
00:12:52,360 --> 00:12:54,270
‫Y ese es exactamente el mensaje de

256
00:12:54,270 --> 00:12:56,043
‫error que ahora deberíamos ver aquí.

257
00:12:56,043 --> 00:12:58,023
‫Está bien.

258
00:12:59,430 --> 00:13:00,263
‫Y de hecho lo es.

259
00:13:00,263 --> 00:13:01,263
‫Excelente.

260
00:13:02,480 --> 00:13:03,520
‫Terminemos el proceso aquí

261
00:13:03,520 --> 00:13:04,980
‫e iniciemos en modo de desarrollo, por supuesto.

262
00:13:04,980 --> 00:13:07,560
‫Entonces npm

263
00:13:07,560 --> 00:13:10,213
‫comienza, y está bien.

264
00:13:11,700 --> 00:13:13,740
‫Así que este, no necesitamos más, así que cerrándolo.

265
00:13:13,740 --> 00:13:17,460
‫O en realidad, solucionemos este pequeño error aquí, porque de hecho,

266
00:13:17,460 --> 00:13:19,880
‫no usamos este error aquí en absoluto.

267
00:13:19,880 --> 00:13:23,113
‫Así que deshagámonos de eso.

268
00:13:24,170 --> 00:13:25,423
‫Y luego aquí abajo, no necesitamos pasarlo allí.

269
00:13:29,260 --> 00:13:32,063
‫Frio.

270
00:13:39,290 --> 00:13:40,123
‫Por supuesto, también debemos volver a cambiar esto a 90 días.

271
00:13:41,060 --> 00:13:44,423
‫Está bien.

272
00:13:47,200 --> 00:13:48,040
‫Entonces,

273
00:13:48,040 --> 00:13:51,560
‫para estar realmente seguros, inicie sesión aquí nuevamente,

274
00:13:51,560 --> 00:13:52,803
‫copiemos el

275
00:13:53,830 --> 00:13:55,513
‫token y colóquelo aquí.

276
00:13:56,680 --> 00:13:59,050
‫Ahora, este proceso aquí de copiar el

277
00:13:59,050 --> 00:14:01,750
‫token y luego pegarlo aquí en este encabezado puede

278
00:14:01,750 --> 00:14:04,190
‫parecer un poco extraño, y de hecho lo

279
00:14:04,190 --> 00:14:05,640
‫arreglaremos en uno

280
00:14:05,640 --> 00:14:07,230
‫de los videos futuros para

281
00:14:07,230 --> 00:14:09,030
‫que, básicamente, este proceso ocurra automáticamente.

282
00:14:09,030 --> 00:14:12,070
‫Pero ahora, lo importante es que en realidad

283
00:14:12,070 --> 00:14:13,970
‫ha vuelto a funcionar ahora.

284
00:14:13,970 --> 00:14:16,750
‫Entonces podemos deshacernos de esta consola. inicie sesión aquí y continúe con

285
00:14:16,750 --> 00:14:21,027
‫el siguiente paso.

286
00:14:21,027 --> 00:14:24,250
‫Y podríamos detenernos aquí ahora si quisiéramos.

287
00:14:24,250 --> 00:14:27,010
‫Y de nuevo, la mayoría de los

288
00:14:27,010 --> 00:14:30,130
‫tutoriales que encontrarás allí, de hecho, se detendrían aquí.

289
00:14:30,130 --> 00:14:32,420
‫Pero esto todavía no es lo suficientemente seguro.

290
00:14:32,420 --> 00:14:35,210
‫Entonces, por ejemplo, ¿qué pasa si el usuario

291
00:14:35,210 --> 00:14:37,550
‫ha sido eliminado mientras tanto?

292
00:14:37,550 --> 00:14:39,840
‫Entonces, el token seguirá existiendo, pero si el

293
00:14:39,840 --> 00:14:41,800
‫usuario ya no existe, entonces

294
00:14:41,800 --> 00:14:43,900
‫en realidad no queremos iniciar sesión, ¿verdad?

295
00:14:43,900 --> 00:14:47,780
‫O peor aún, ¿qué pasa si el usuario realmente ha

296
00:14:47,780 --> 00:14:50,070
‫cambiado su contraseña después de que

297
00:14:50,070 --> 00:14:52,130
‫se haya emitido el token?

298
00:14:52,130 --> 00:14:54,360
‫Bueno, eso tampoco debería funcionar, ¿verdad?

299
00:14:54,360 --> 00:14:56,950
‫Por ejemplo, imagine que alguien

300
00:14:56,950 --> 00:15:00,750
‫robó el token web JSON de un usuario.

301
00:15:00,750 --> 00:15:01,870
‫Pero luego, para

302
00:15:01,870 --> 00:15:04,380
‫protegerse contra eso, el usuario cambia su contraseña.

303
00:15:04,380 --> 00:15:06,770
‫Y así, por supuesto, ese token antiguo que se

304
00:15:06,770 --> 00:15:09,270
‫emitió antes del cambio de contraseña ya no debería ser válido.

305
00:15:09,270 --> 00:15:12,940
‫Por lo que no debe aceptarse el acceso a rutas protegidas.

306
00:15:12,940 --> 00:15:16,906
‫Entonces, ese es el tipo de cosas que implementaremos aquí en

307
00:15:16,906 --> 00:15:19,550
‫el paso tres y el paso cuatro.

308
00:15:19,550 --> 00:15:22,060
‫Entonces, lo primero que debe hacer es verificar si el

309
00:15:22,060 --> 00:15:23,120
‫usuario todavía existe.

310
00:15:23,120 --> 00:15:26,060
‫Y entonces, ese debería ser el más fácil.

311
00:15:26,060 --> 00:15:28,690
‫Así que digamos, Usuario. findById.

312
00:15:28,690 --> 00:15:32,463
‫Entonces, esta es la razón por la

313
00:15:36,568 --> 00:15:38,440
‫que ahora tenemos la ID en

314
00:15:38,440 --> 00:15:40,540
‫la carga útil, porque ahora podemos usar esa

315
00:15:40,540 --> 00:15:42,767
‫ID y consultar al usuario usando solo esa ID.

316
00:15:42,767 --> 00:15:46,530
‫Tan decodificado. identificación.

317
00:15:46,530 --> 00:15:49,390
‫¿Está bien?

318
00:15:49,390 --> 00:15:50,223
‫Entonces eso debería encontrar al nuevo usuario.

319
00:15:50,223 --> 00:15:53,110
‫Y, por supuesto, debemos esperar eso y

320
00:15:53,110 --> 00:15:55,860
‫luego almacenarlo en una variable.

321
00:15:55,860 --> 00:15:59,560
‫Lo llamo freshUser.

322
00:15:59,560 --> 00:16:01,480
‫¿Está bien?

323
00:16:03,148 --> 00:16:03,981
‫Porque no es realmente un usuario nuevo.

324
00:16:03,981 --> 00:16:05,460
‫Eso es solo cuando creamos uno.

325
00:16:05,460 --> 00:16:07,300
‫Pero esto no es realmente nuevo, en realidad es

326
00:16:07,300 --> 00:16:09,030
‫solo el usuario basado en la ID decodificada.

327
00:16:09,030 --> 00:16:12,980
‫¿Okey?

328
00:16:12,980 --> 00:16:13,870
‫Y podemos

329
00:16:13,870 --> 00:16:16,833
‫hacer esto para que podamos estar 100% seguros de que

330
00:16:16,833 --> 00:16:18,990
‫la identificación es realmente correcta, porque si lo

331
00:16:18,990 --> 00:16:22,460
‫hicimos hasta este punto del código aquí, entonces eso significa que el

332
00:16:22,460 --> 00:16:25,110
‫proceso de verificación que tenemos anteriormente, aquí, fue exitoso.

333
00:16:25,110 --> 00:16:28,200
‫De lo contrario, esto habría provocado un error

334
00:16:28,200 --> 00:16:30,220
‫que habría impedido que la

335
00:16:30,220 --> 00:16:31,490
‫función continuara.

336
00:16:31,490 --> 00:16:33,410
‫Y entonces, nuevamente, este proceso

337
00:16:33,410 --> 00:16:36,660
‫de verificación aquí está a cargo de la verificación si

338
00:16:36,660 --> 00:16:38,620
‫nadie alteró la identificación que está

339
00:16:38,620 --> 00:16:40,900
‫en la carga útil de este token.

340
00:16:40,900 --> 00:16:43,033
‫Y así, debido a eso, podemos

341
00:16:43,970 --> 00:16:46,970
‫estar 100% seguros de que el usuario para el que

342
00:16:46,970 --> 00:16:50,600
‫hemos emitido el JWT es exactamente aquel cuyo ID está ahora dentro

343
00:16:50,600 --> 00:16:52,790
‫de la carga útil decodificada, entonces este.

344
00:16:52,790 --> 00:16:56,810
‫¿Okey?

345
00:16:56,810 --> 00:16:57,690
‫Entonces, el proceso de verificación es realmente clave.

346
00:16:57,690 --> 00:17:00,440
‫Es realmente lo que hace que todo esto funcione.

347
00:17:00,440 --> 00:17:02,440
‫De todos modos, ahora lo que tenemos que hacer es

348
00:17:04,730 --> 00:17:06,410
‫comprobar si realmente hay un nuevo usuario.

349
00:17:06,410 --> 00:17:09,570
‫Y si no, bueno, claro, vamos a

350
00:17:09,570 --> 00:17:11,570
‫devolver un nuevo error.

351
00:17:11,570 --> 00:17:13,844
‫Entonces, si no hay freshUser,

352
00:17:13,844 --> 00:17:16,577
‫regrese de este middleware y llame al

353
00:17:19,880 --> 00:17:22,100
‫siguiente con un error.

354
00:17:22,100 --> 00:17:24,083
‫Entonces, este es un patrón que hemos estado

355
00:17:24,920 --> 00:17:27,100
‫viendo una y otra vez en este punto, ¿verdad?

356
00:17:27,100 --> 00:17:29,403
‫Entonces el token ya no

357
00:17:30,350 --> 00:17:31,490
‫existe.

358
00:17:35,470 --> 00:17:39,173
‫Y de hecho, es al revés.

359
00:17:40,810 --> 00:17:42,750
‫Entonces, en realidad, el usuario

360
00:17:42,750 --> 00:17:45,200
‫que pertenece al token ya no existe.

361
00:17:47,170 --> 00:17:48,680
‫¿Derecha?

362
00:17:48,680 --> 00:17:49,513
‫Y luego, el 401.

363
00:17:49,513 --> 00:17:51,297
‫Bueno.

364
00:17:53,780 --> 00:17:54,920
‫Así que probemos esto una vez más.

365
00:17:54,920 --> 00:17:57,860
‫Y de hecho creemos un nuevo usuario para eso.

366
00:17:57,860 --> 00:18:00,843
‫Así que prueba con la misma contraseña para que siempre

367
00:18:02,620 --> 00:18:04,880
‫usemos la misma aquí solo para hacer nuestras

368
00:18:04,880 --> 00:18:06,590
‫pruebas un poco más fáciles.

369
00:18:06,590 --> 00:18:09,160
‫Y sé que todas estas pruebas aquí hacen

370
00:18:09,160 --> 00:18:11,070
‫que el video tome bastante tiempo,

371
00:18:11,070 --> 00:18:14,440
‫pero por supuesto, es muy importante que probemos todo lo que

372
00:18:14,440 --> 00:18:15,900
‫hacemos, especialmente en

373
00:18:15,900 --> 00:18:17,950
‫un tema tan importante como la autenticación.

374
00:18:17,950 --> 00:18:21,713
‫Así que ahora estoy usando este JWT aquí, así que

375
00:18:23,071 --> 00:18:27,780
‫lo pego aquí, pero por supuesto, antes de enviar la solicitud, continuaré

376
00:18:27,780 --> 00:18:30,630
‫y eliminaré ese usuario de inmediato.

377
00:18:30,630 --> 00:18:33,573
‫¿Okey?

378
00:18:34,650 --> 00:18:35,690
‫De nuevo, supongamos que

379
00:18:35,690 --> 00:18:37,690
‫alguien creó un usuario y luego inició sesión,

380
00:18:37,690 --> 00:18:40,020
‫y digamos, luego de un tiempo, el usuario fue eliminado.

381
00:18:40,020 --> 00:18:43,500
‫Pero mientras tanto, alguien podría haber obtenido acceso a ese

382
00:18:43,500 --> 00:18:44,333
‫JWT

383
00:18:44,333 --> 00:18:47,410
‫y ahora podría intentar iniciar sesión como ese

384
00:18:47,410 --> 00:18:50,030
‫usuario que, de hecho, ya fue eliminado.

385
00:18:50,030 --> 00:18:52,580
‫Y entonces, nuevamente, no debemos permitir que eso suceda.

386
00:18:52,580 --> 00:18:55,520
‫Permítanme eliminar este usuario aquí ahora.

387
00:18:55,520 --> 00:18:57,713
‫Y ahí vamos.

388
00:18:59,010 --> 00:18:59,943
‫Entonces, probémoslo ahora.

389
00:19:01,720 --> 00:19:03,630
‫Y nuevamente, tenga en cuenta que el

390
00:19:03,630 --> 00:19:07,060
‫usuario que pertenece al ID que está en esta carga útil ya no está allí.

391
00:19:07,060 --> 00:19:10,690
‫Así que veamos.

392
00:19:10,690 --> 00:19:12,040
‫Y, de hecho, recibimos este mensaje de error que acabamos de crear.

393
00:19:12,040 --> 00:19:16,313
‫Entonces ese también está funcionando.

394
00:19:17,520 --> 00:19:20,200
‫Y vayamos al último.

395
00:19:20,200 --> 00:19:22,400
‫Entonces, paso número cuatro, verifique si el usuario

396
00:19:22,400 --> 00:19:23,830
‫ha cambiado recientemente su contraseña.

397
00:19:23,830 --> 00:19:27,070
‫Básicamente, después de que se emitió el token.

398
00:19:27,070 --> 00:19:30,100
‫Y para implementar esta prueba, crearemos otro

399
00:19:30,100 --> 00:19:31,550
‫método de instancia.

400
00:19:31,550 --> 00:19:34,260
‫Básicamente, un método que

401
00:19:34,260 --> 00:19:37,030
‫estará disponible en todos los documentos.

402
00:19:37,030 --> 00:19:38,330
‫Entonces, los documentos son instancias de un modelo.

403
00:19:38,330 --> 00:19:41,410
‫¿Está bien?

404
00:19:41,410 --> 00:19:42,243
‫Y hacemos esto

405
00:19:42,243 --> 00:19:44,490
‫porque es bastante código lo que necesitamos para esta verificación.

406
00:19:44,490 --> 00:19:46,540
‫Entonces, en realidad, este código

407
00:19:46,540 --> 00:19:50,040
‫pertenece al modelo de usuario y no al controlador.

408
00:19:50,040 --> 00:19:51,970
‫¿Okey?

409
00:19:51,970 --> 00:19:52,803
‫Entonces, hagámoslo

410
00:19:52,803 --> 00:19:55,050
‫como lo hicimos antes para verificar la contraseña.

411
00:19:55,050 --> 00:19:57,270
‫Entonces, en el modelo de usuario,

412
00:19:57,270 --> 00:19:59,840
‫ya implementamos este método de instancia estática correctPassword, ¿recuerdas?

413
00:19:59,840 --> 00:20:04,710
‫Y entonces, ahora creemos otro.

414
00:20:04,710 --> 00:20:06,903
‫Entonces userSchema. métodos. changePasswordAfter.

415
00:20:08,339 --> 00:20:13,339
‫Así que funciona, y en

416
00:20:22,390 --> 00:20:24,550
‫esta función, pasaremos la marca de tiempo JWT.

417
00:20:24,550 --> 00:20:27,530
‫Básicamente, esa marca de tiempo que dice cuándo

418
00:20:27,530 --> 00:20:29,630
‫se emitió el token.

419
00:20:29,630 --> 00:20:32,190
‫Así que llamemos a eso JWTTimestamp.

420
00:20:32,190 --> 00:20:34,437
‫Está bien.

421
00:20:40,310 --> 00:20:41,143
‫Y de forma predeterminada, devolveremos falso de este método.

422
00:20:41,143 --> 00:20:44,600
‫Y eso significará que el usuario no ha cambiado

423
00:20:44,600 --> 00:20:45,720
‫su contraseña

424
00:20:45,720 --> 00:20:48,320
‫después de que se emitió el token.

425
00:20:48,320 --> 00:20:50,410
‫¿Okey?

426
00:20:50,410 --> 00:20:51,860
‫Pongamos eso aquí, devuelva falso, básicamente por defecto.

427
00:20:51,860 --> 00:20:56,860
‫Bueno.

428
00:20:58,470 --> 00:20:59,303
‫Pero también

429
00:20:59,303 --> 00:21:02,987
‫tenemos if this, y recordemos que en un método de instancia, la

430
00:21:02,987 --> 00:21:05,827
‫palabra clave this siempre apunta al documento actual.

431
00:21:05,827 --> 00:21:09,477
‫Y entonces, aquí tenemos acceso a las propiedades.

432
00:21:09,477 --> 00:21:13,210
‫Ahora, en realidad, necesitamos crear un campo ahora en nuestro esquema para

433
00:21:13,210 --> 00:21:16,280
‫la fecha en la que se cambió la contraseña.

434
00:21:16,280 --> 00:21:18,750
‫Entonces no tenemos eso todavía.

435
00:21:18,750 --> 00:21:20,050
‫Así que agregémoslo rápidamente aquí.

436
00:21:21,200 --> 00:21:23,713
‫Entonces passwordChangedAt, y el tipo

437
00:21:25,980 --> 00:21:27,813
‫será una Fecha.

438
00:21:31,320 --> 00:21:34,520
‫Ahora, esta propiedad passwordChangedAt aquí siempre

439
00:21:34,520 --> 00:21:37,890
‫se cambiará, por supuesto, cuando alguien

440
00:21:37,890 --> 00:21:40,160
‫cambie la contraseña.

441
00:21:40,160 --> 00:21:42,910
‫Entonces, en este momento, no tenemos esa lógica en ningún lado, por

442
00:21:42,910 --> 00:21:45,270
‫lo que en ningún lugar estamos definiendo esta propiedad.

443
00:21:45,270 --> 00:21:48,743
‫Entonces, la mayoría de los documentos, la mayoría

444
00:21:49,630 --> 00:21:53,230
‫de los usuarios, simplemente no tendrán esta propiedad en

445
00:21:53,230 --> 00:21:56,720
‫sus datos, por lo tanto, en su objeto, ¿verdad?

446
00:21:56,720 --> 00:21:58,600
‫Y entonces, por supuesto, tenemos que probar eso.

447
00:21:58,600 --> 00:22:01,363
‫¿Okey?

448
00:22:03,430 --> 00:22:04,610
‫Entonces, si existe

449
00:22:04,610 --> 00:22:07,740
‫la propiedad passwordChangedAt, solo entonces queremos hacer la comparación.

450
00:22:07,740 --> 00:22:11,510
‫¿Okey?

451
00:22:11,510 --> 00:22:12,343
‫Pero si

452
00:22:12,343 --> 00:22:16,010
‫no es así, si passwordChanged no existe, bueno, eso significa que el usuario

453
00:22:16,010 --> 00:22:17,640
‫nunca ha cambiado la contraseña

454
00:22:17,640 --> 00:22:20,020
‫y, por lo tanto, podemos simplemente devolver false.

455
00:22:20,020 --> 00:22:23,171
‫Nuevamente, ese es nuestro valor predeterminado, lo que significa

456
00:22:23,171 --> 00:22:25,560
‫que el usuario no ha cambiado

457
00:22:25,560 --> 00:22:28,190
‫la contraseña después de esta marca de tiempo.

458
00:22:28,190 --> 00:22:30,540
‫Bueno.

459
00:22:30,540 --> 00:22:31,373
‫Y

460
00:22:31,373 --> 00:22:35,760
‫ahora, para empezar, iniciemos sesión en la consola. passwordChangedAt, y por supuesto, el JWTTimestamp también, solo para

461
00:22:35,760 --> 00:22:37,933
‫que

462
00:22:39,370 --> 00:22:42,010
‫podamos ver cómo podemos compararlos.

463
00:22:42,010 --> 00:22:44,950
‫Está bien.

464
00:22:44,950 --> 00:22:45,783
‫Y ahora necesitamos

465
00:22:47,560 --> 00:22:49,690
‫crear un usuario que tenga esta propiedad, ¿de acuerdo?

466
00:22:49,690 --> 00:22:52,720
‫Y nuevamente, más adelante en la sección, cuando

467
00:22:52,720 --> 00:22:54,260
‫implementaremos la lógica para

468
00:22:54,260 --> 00:22:57,280
‫cambiar la contraseña, es cuando estableceremos esta propiedad.

469
00:22:57,280 --> 00:22:59,760
‫¿Okey?

470
00:22:59,760 --> 00:23:00,593
‫Pero ahora

471
00:23:00,593 --> 00:23:04,140
‫lo configuraremos artificialmente, básicamente, aquí cuando creemos un nuevo usuario.

472
00:23:04,140 --> 00:23:06,260
‫¿Okey?

473
00:23:06,260 --> 00:23:07,093
‫Pongamos eso aquí.

474
00:23:08,690 --> 00:23:10,130
‫Y aquí, cualquier fecha, de hecho, servirá.

475
00:23:10,130 --> 00:23:12,810
‫Digamos que el 30 de abril de 2019 aquí.

476
00:23:12,810 --> 00:23:17,810
‫Y entonces eso debería ser analizado en MongoDB sin problemas.

477
00:23:18,430 --> 00:23:21,313
‫Probemos eso, veamos si funciona.

478
00:23:22,460 --> 00:23:24,293
‫Y eso no funcionó.

479
00:23:25,210 --> 00:23:26,520
‫Entonces realmente no pudo analizar la fecha, digamos.

480
00:23:26,520 --> 00:23:29,913
‫Y de hecho, necesito comenzar con el año

481
00:23:30,980 --> 00:23:33,710
‫y luego el día al final.

482
00:23:33,710 --> 00:23:36,400
‫Entonces 2019 y luego 30 de abril.

483
00:23:36,400 --> 00:23:41,050
‫Inténtelo de nuevo.

484
00:23:41,050 --> 00:23:42,103
‫Y entonces ves que ahora realmente está funcionando.

485
00:23:43,190 --> 00:23:45,300
‫Entonces tenemos esta fecha analizada aquí.

486
00:23:45,300 --> 00:23:48,210
‫¿Okey?

487
00:23:48,210 --> 00:23:49,350
‫Ahora, para ver realmente

488
00:23:49,350 --> 00:23:51,910
‫el resultado de esto, por supuesto, necesitamos llamar a este método.

489
00:23:51,910 --> 00:23:55,040
‫¿Okey?

490
00:23:55,040 --> 00:23:56,560
‫Así que eso es lo que haremos aquí en el paso cuatro.

491
00:23:56,560 --> 00:23:59,033
‫¿Okey?

492
00:24:00,010 --> 00:24:01,110
‫Y entonces, recuerde

493
00:24:01,110 --> 00:24:04,630
‫que podemos llamar a este método de instancia en un documento de usuario.

494
00:24:04,630 --> 00:24:06,200
‫Tan freshUser. changePasswordAfter, y luego esa

495
00:24:06,200 --> 00:24:09,197
‫marca de tiempo.

496
00:24:14,837 --> 00:24:17,370
‫Entonces eso es decodificado. iat, por lo que se emitió en, básicamente.

497
00:24:17,370 --> 00:24:22,370
‫Está bien.

498
00:24:25,450 --> 00:24:26,350
‫Así que veamos simplemente el resultado de hacer eso.

499
00:24:26,350 --> 00:24:29,130
‫Y entonces, por supuesto, esto debería ahora, no

500
00:24:29,130 --> 00:24:32,953
‫aquí, por lo que debería registrar estos dos valores en la consola.

501
00:24:33,870 --> 00:24:37,123
‫Bueno.

502
00:24:39,320 --> 00:24:40,153
‫Ahora, por supuesto,

503
00:24:40,153 --> 00:24:43,170
‫necesito iniciar sesión exactamente con este usuario, así que con la prueba,

504
00:24:43,170 --> 00:24:44,223
‫así que aquí vamos.

505
00:24:47,780 --> 00:24:48,853
‫Iniciar sesión.

506
00:24:50,250 --> 00:24:51,173
‫Copie este token aquí nuevamente.

507
00:24:53,090 --> 00:24:56,200
‫Y nuevamente, básicamente vamos a automatizar

508
00:24:56,200 --> 00:24:59,580
‫eso en el próximo video, de hecho.

509
00:24:59,580 --> 00:25:01,233
‫Bueno.

510
00:25:02,740 --> 00:25:03,700
‫Pégalo aquí.

511
00:25:03,700 --> 00:25:04,673
‫Y ahora, tenemos este error aquí.

512
00:25:05,670 --> 00:25:08,312
‫Así que escribí mal el nombre de esta función aquí.

513
00:25:08,312 --> 00:25:13,312
‫Bueno, copiémoslo.

514
00:25:13,670 --> 00:25:14,920
‫Pruébalo otra vez.

515
00:25:16,410 --> 00:25:17,403
‫Oh hombre.

516
00:25:18,780 --> 00:25:20,150
‫¿Qué va mal ahora?

517
00:25:20,150 --> 00:25:21,823
‫Y veo que simplemente olvidé este registro aquí.

518
00:25:25,420 --> 00:25:27,633
‫Entonces otro error estúpido.

519
00:25:28,752 --> 00:25:30,090
‫Probablemente lo vio venir.

520
00:25:30,090 --> 00:25:32,320
‫Pero ahora aquí vamos.

521
00:25:32,320 --> 00:25:33,550
‫Así que todo

522
00:25:33,550 --> 00:25:35,120
‫funcionó bien, y todo lo que

523
00:25:35,120 --> 00:25:37,450
‫realmente queríamos ver por ahora eran estos dos resultados.

524
00:25:37,450 --> 00:25:39,560
‫Así que básicamente tenemos este aquí en este

525
00:25:39,560 --> 00:25:43,110
‫formato de fecha, y luego el otro en esta marca de tiempo de milisegundos

526
00:25:43,110 --> 00:25:43,943
‫o segundos aquí.

527
00:25:43,943 --> 00:25:47,600
‫Y entonces, ahora necesitamos convertir este passwordChangedAt

528
00:25:47,600 --> 00:25:51,670
‫también en una marca de tiempo como esa.

529
00:25:51,670 --> 00:25:54,240
‫¿Está bien?

530
00:25:54,240 --> 00:25:55,073
‫Y entonces, para eso, creemos una nueva variable.

531
00:25:55,073 --> 00:25:57,853
‫Así que cambió la marca de tiempo.

532
00:25:59,560 --> 00:26:01,330
‫Y podemos usar esto. passwordChangedAt. consigue tiempo.

533
00:26:03,800 --> 00:26:06,100
‫¿Okey?

534
00:26:12,730 --> 00:26:13,563
‫Y esa

535
00:26:13,563 --> 00:26:16,913
‫es una de las muchas funciones de fecha que nos brinda JavaScript.

536
00:26:16,913 --> 00:26:18,563
‫Está bien.

537
00:26:19,450 --> 00:26:20,960
‫Y ahora, comparemos rápidamente

538
00:26:20,960 --> 00:26:23,760
‫estos dos porque, en realidad, aún no estamos listos.

539
00:26:23,760 --> 00:26:26,253
‫Así que enviándolo solo para ver los resultados aquí.

540
00:26:28,770 --> 00:26:31,930
‫Entonces, lo que vemos aquí básicamente es que

541
00:26:31,930 --> 00:26:33,610
‫este aquí es

542
00:26:33,610 --> 00:26:36,580
‫ahora, básicamente, en segundos, y este en milisegundos.

543
00:26:36,580 --> 00:26:38,210
‫Entonces es 1000 veces más.

544
00:26:38,210 --> 00:26:40,540
‫Entonces, sabemos que necesitamos dividir esto entre

545
00:26:40,540 --> 00:26:43,340
‫1000 y luego analizar todo esto como un número entero.

546
00:26:45,630 --> 00:26:48,583
‫Y para eso usamos parseInt.

547
00:26:50,550 --> 00:26:52,820
‫Entonces, otra función de JavaScript que está disponible para números.

548
00:26:52,820 --> 00:26:57,180
‫Y luego también necesitamos especificar la base.

549
00:26:57,180 --> 00:27:00,320
‫Así que este es un número de base 10.

550
00:27:00,320 --> 00:27:02,920
‫¿Está bien?

551
00:27:02,920 --> 00:27:03,970
‫Y ahora, de nuevo, veamos el resultado.

552
00:27:03,970 --> 00:27:07,373
‫Y ahora, eso parece mucho más amigable.

553
00:27:10,120 --> 00:27:13,360
‫Bueno.

554
00:27:13,360 --> 00:27:14,193
‫Entonces, ahora devolvamos nuestro resultado.

555
00:27:14,193 --> 00:27:17,040
‫Y nuevamente, tenga en cuenta que los medios falsos no cambian.

556
00:27:17,040 --> 00:27:22,040
‫¿Okey?

557
00:27:24,500 --> 00:27:25,520
‫Y no cambiado

558
00:27:25,520 --> 00:27:30,207
‫básicamente significa que el día o la hora en que se emitió el token es menor

559
00:27:32,300 --> 00:27:34,240
‫que la marca de tiempo modificada.

560
00:27:34,240 --> 00:27:37,893
‫¿Okey?

561
00:27:40,280 --> 00:27:41,113
‫Entonces, solo como un ejemplo

562
00:27:44,330 --> 00:27:45,830
‫aquí, digamos que el token se emitió en el momento 100.

563
00:27:45,830 --> 00:27:49,327
‫Pero luego, cambiamos la contraseña, digamos, en el momento 200.

564
00:27:50,460 --> 00:27:53,843
‫¿Okey?

565
00:27:55,240 --> 00:27:56,073
‫Entonces, cambiamos la

566
00:27:56,073 --> 00:27:57,609
‫contraseña después de que se emitió

567
00:27:57,609 --> 00:27:59,840
‫el token y, por lo tanto, esto ahora es cierto.

568
00:27:59,840 --> 00:28:01,940
‫¿Está bien?

569
00:28:01,940 --> 00:28:03,379
‫Y eso es exactamente lo que queremos volver

570
00:28:03,379 --> 00:28:04,810
‫aquí, porque falso significa que no ha

571
00:28:04,810 --> 00:28:06,910
‫cambiado y, por tanto, verdadero, por supuesto, significa que ha cambiado.

572
00:28:06,910 --> 00:28:09,200
‫Y eso es exactamente lo que tenemos aquí.

573
00:28:09,200 --> 00:28:11,980
‫Pero ahora, digamos que la contraseña se cambió

574
00:28:11,980 --> 00:28:13,410
‫por última vez

575
00:28:13,410 --> 00:28:15,810
‫en 200, pero solo después de eso,

576
00:28:15,810 --> 00:28:18,640
‫emitimos el token, digamos, en el momento 300.

577
00:28:18,640 --> 00:28:21,260
‫¿Y entonces, 300, menos de 200?

578
00:28:21,260 --> 00:28:23,660
‫No, eso es falso.

579
00:28:23,660 --> 00:28:25,160
‫Y entonces, devolvemos falso, lo que nuevamente significa que no ha cambiado.

580
00:28:25,160 --> 00:28:29,200
‫Y por eso usamos este signo menos aquí.

581
00:28:29,200 --> 00:28:32,720
‫¿Okey?

582
00:28:32,720 --> 00:28:33,553
‫Regresemos a nuestro controlador y realmente usemos esto.

583
00:28:36,800 --> 00:28:41,800
‫Entonces, si realmente se cambió la contraseña, bueno,

584
00:28:45,480 --> 00:28:49,910
‫en este caso, realmente queremos un error.

585
00:28:49,910 --> 00:28:53,030
‫Entonces regrese a continuación, nuevamente, un nuevo AppError.

586
00:28:53,030 --> 00:28:57,623
‫Recientemente...

587
00:29:02,970 --> 00:29:04,220
‫Inicie sesión de nuevo.

588
00:29:11,790 --> 00:29:13,620
‫Bueno.

589
00:29:13,620 --> 00:29:15,030
‫Y una vez más, código 401.

590
00:29:15,030 --> 00:29:18,363
‫Está bien.

591
00:29:19,770 --> 00:29:20,820
‫Nuevamente, esto volverá

592
00:29:20,820 --> 00:29:23,220
‫a ser verdadero si el usuario realmente cambió su contraseña.

593
00:29:23,220 --> 00:29:25,790
‫Y entonces, si todo esto aquí es cierto,

594
00:29:25,790 --> 00:29:28,540
‫bueno, entonces exactamente en ese caso es cuando

595
00:29:28,540 --> 00:29:30,600
‫queremos que suceda este error.

596
00:29:30,600 --> 00:29:33,220
‫¿Está bien?

597
00:29:33,220 --> 00:29:34,820
‫Así que ese fue en realidad el último paso.

598
00:29:34,820 --> 00:29:37,510
‫Bueno.

599
00:29:37,510 --> 00:29:38,952
‫Entonces, básicamente, si el código puede llegar hasta

600
00:29:38,952 --> 00:29:41,030
‫el final de este código aquí, solo entonces, se ejecutará el siguiente.

601
00:29:41,030 --> 00:29:45,410
‫Y luego, con el siguiente, pasamos al siguiente controlador

602
00:29:45,410 --> 00:29:49,100
‫de ruta, lo que significa efectivamente otorgar acceso

603
00:29:49,100 --> 00:29:51,470
‫a esa ruta protegida.

604
00:29:51,470 --> 00:29:52,783
‫De hecho, pongamos eso aquí.

605
00:29:53,750 --> 00:29:55,740
‫Otorgar acceso a ruta protegida.

606
00:29:55,740 --> 00:30:00,740
‫¿Okey?

607
00:30:02,340 --> 00:30:03,597
‫Porque eso es realmente todo lo que hace lo siguiente.

608
00:30:03,597 --> 00:30:05,310
‫A continuación, nos lleva al siguiente

609
00:30:05,310 --> 00:30:08,070
‫middleware, que suele ser, entonces, el propio controlador de ruta, por

610
00:30:08,070 --> 00:30:10,880
‫lo que es el que devuelve los datos que estaban protegidos.

611
00:30:10,880 --> 00:30:14,550
‫Bueno.

612
00:30:14,550 --> 00:30:15,383
‫Solo una última

613
00:30:15,383 --> 00:30:18,540
‫cosa que queremos hacer aquí es poner todos los datos del usuario en la solicitud.

614
00:30:18,540 --> 00:30:22,930
‫Entonces, simplemente podemos decir, req, entonces solicitar,. usuario será igual a

615
00:30:22,930 --> 00:30:27,100
‫freshUser.

616
00:30:27,100 --> 00:30:30,510
‫Bueno.

617
00:30:30,510 --> 00:30:31,343
‫Y nuevamente, por

618
00:30:31,343 --> 00:30:32,430
‫supuesto, el código solo llega

619
00:30:32,430 --> 00:30:34,930
‫a este punto aquí en caso de que todo sea correcto.

620
00:30:34,930 --> 00:30:37,470
‫¿Okey?

621
00:30:37,470 --> 00:30:38,303
‫Entonces, esto aquí

622
00:30:38,303 --> 00:30:40,710
‫podría ser útil en algún momento en el futuro.

623
00:30:40,710 --> 00:30:42,110
‫Excelente.

624
00:30:43,150 --> 00:30:43,983
‫Probemos esto una vez más.

625
00:30:43,983 --> 00:30:46,450
‫Y básicamente, este cambio ya es pasado.

626
00:30:46,450 --> 00:30:51,450
‫Y entonces, este token que tenemos aquí, o en realidad,

627
00:30:51,820 --> 00:30:53,840
‫podría haber reutilizado

628
00:30:53,840 --> 00:30:56,890
‫solo este en lugar de registrarlo nuevamente.

629
00:30:56,890 --> 00:30:58,520
‫Pero de todos modos, este token

630
00:30:58,520 --> 00:31:00,500
‫se emitió después de que se cambiara la contraseña.

631
00:31:00,500 --> 00:31:02,344
‫Y entonces, este token ahora debería funcionar.

632
00:31:02,344 --> 00:31:04,920
‫Así que inicie sesión de

633
00:31:04,920 --> 00:31:07,500
‫nuevo e intentemos con este token.

634
00:31:10,900 --> 00:31:13,203
‫Y de hecho, tenemos acceso.

635
00:31:18,020 --> 00:31:20,030
‫Ahora, moviéndonos a Compass para cambiar esa fecha.

636
00:31:20,030 --> 00:31:22,853
‫Bueno.

637
00:31:24,511 --> 00:31:26,010
‫Digámoslo un mes después.

638
00:31:26,010 --> 00:31:27,657
‫Y entonces, eso será en

639
00:31:27,657 --> 00:31:30,780
‫el futuro, al menos, en mi futuro cuando esté grabando este video.

640
00:31:30,780 --> 00:31:34,150
‫Por supuesto, lo hará en un momento posterior.

641
00:31:34,150 --> 00:31:36,640
‫Entonces, para probar esto, por favor ponga esto en su futuro.

642
00:31:36,640 --> 00:31:40,373
‫Entonces, en el futuro de la fecha en la que

643
00:31:41,420 --> 00:31:43,060
‫estás viendo este video.

644
00:31:43,060 --> 00:31:44,710
‫Entonces, si vuelvo

645
00:31:45,960 --> 00:31:50,960
‫a Postman e inicio sesión nuevamente, está bien, entonces si inicio sesión nuevamente ahora

646
00:31:53,860 --> 00:31:56,430
‫e intento acceder a esa ruta, bueno,

647
00:31:56,430 --> 00:31:58,710
‫entonces este token se emitirá, básicamente,

648
00:31:58,710 --> 00:32:01,420
‫después de que se haya cambiado la contraseña.

649
00:32:01,420 --> 00:32:03,553
‫O incluso antes de que se haya cambiado la contraseña.

650
00:32:08,680 --> 00:32:10,590
‫Entonces, perdón por esa confusión.

651
00:32:10,590 --> 00:32:12,610
‫Entonces, la contraseña se cambió el 30 de

652
00:32:12,610 --> 00:32:15,800
‫mayo, pero este token se emitió el 2 de mayo, y así, antes.

653
00:32:15,800 --> 00:32:19,650
‫Básicamente, ahora es como si el usuario hubiera cambiado su contraseña después

654
00:32:19,650 --> 00:32:21,950
‫de que se emitió el token.

655
00:32:21,950 --> 00:32:25,880
‫Y esa es exactamente la situación en la que no queremos dar acceso

656
00:32:25,880 --> 00:32:27,341
‫a la ruta protegida.

657
00:32:27,341 --> 00:32:31,070
‫Y entonces, esto ahora debería reflejar eso.

658
00:32:31,070 --> 00:32:35,170
‫Y, de hecho, el usuario cambió recientemente

659
00:32:35,170 --> 00:32:38,740
‫la contraseña, inicie sesión nuevamente.

660
00:32:38,740 --> 00:32:40,280
‫Excelente.

661
00:32:40,280 --> 00:32:41,240
‫Entonces eso ahora funciona.

662
00:32:41,240 --> 00:32:42,953
‫Así que nuestro middleware de protección ahora está completamente implementado.

663
00:32:43,870 --> 00:32:48,000
‫Vamos a deshacernos de esta consola. inicie sesión aquí.

664
00:32:48,000 --> 00:32:51,620
‫Ya no necesito ese.

665
00:32:51,620 --> 00:32:53,820
‫Y esta bien.

666
00:32:53,820 --> 00:32:55,800
‫Así que recapitulemos rápidamente, y este video

667
00:32:55,800 --> 00:32:57,230
‫se está ejecutando muy

668
00:32:57,230 --> 00:32:59,520
‫largo, un poco más de lo que esperaba.

669
00:32:59,520 --> 00:33:01,330
‫Pero es realmente

670
00:33:01,330 --> 00:33:03,820
‫importante comprender y explicar cómo funciona

671
00:33:03,820 --> 00:33:06,700
‫todo esto y por qué es importante.

672
00:33:06,700 --> 00:33:07,810
‫Entonces, prefiero eso a hacer este video mucho más corto.

673
00:33:07,810 --> 00:33:12,710
‫Por supuesto, podría simplemente escribir el código, pero entonces no entenderías realmente lo

674
00:33:12,710 --> 00:33:14,127
‫que está pasando.

675
00:33:14,127 --> 00:33:17,330
‫Entonces esta parte ya la entendimos.

676
00:33:17,330 --> 00:33:19,410
‫Luego, en esta parte, también creo,

677
00:33:19,410 --> 00:33:21,680
‫así que aquí es donde ocurre la verificación,

678
00:33:21,680 --> 00:33:24,060
‫básicamente para ver si la carga útil del

679
00:33:24,060 --> 00:33:26,570
‫token no ha sido manipulada por algún tercero malicioso.

680
00:33:26,570 --> 00:33:30,900
‫¿Okey?

681
00:33:30,900 --> 00:33:31,733
‫Y dado que

682
00:33:31,733 --> 00:33:33,730
‫llegamos a este código aquí, significa que nadie cambió

683
00:33:33,730 --> 00:33:36,790
‫el token web JSON y, por lo tanto, podemos obtener un usuario nuevo.

684
00:33:36,790 --> 00:33:39,350
‫Básicamente, podemos obtener el usuario

685
00:33:39,350 --> 00:33:41,690
‫actual, llamémoslo currentUser.

686
00:33:41,690 --> 00:33:43,650
‫¿Por qué no?

687
00:33:43,650 --> 00:33:44,483
‫Entonces aquí, aquí y también aquí.

688
00:33:45,450 --> 00:33:47,993
‫¿Okey?

689
00:33:49,670 --> 00:33:50,503
‫Entonces podemos obtener el

690
00:33:50,503 --> 00:33:53,020
‫usuario actual de esa ID que se acaba de decodificar de la carga útil.

691
00:33:53,020 --> 00:33:55,023
‫Ahora, si el currentUser no existe, entonces

692
00:33:56,100 --> 00:33:58,260
‫esto es lo que estamos probando aquí,

693
00:33:58,260 --> 00:34:00,660
‫bueno, entonces en ese caso no queremos dar acceso

694
00:34:00,660 --> 00:34:01,990
‫a la ruta,

695
00:34:01,990 --> 00:34:04,290
‫y en su lugar crear este nuevo error.

696
00:34:04,290 --> 00:34:06,343
‫Pero si el usuario existe, bueno,

697
00:34:07,400 --> 00:34:08,870
‫llegamos al punto número

698
00:34:08,870 --> 00:34:12,030
‫cuatro, donde luego verificamos si ha ocurrido un cambio de

699
00:34:12,030 --> 00:34:15,060
‫contraseña después de que se emitió el token, ¿verdad?

700
00:34:15,060 --> 00:34:18,060
‫Y si lo hizo, de nuevo, creamos un nuevo error.

701
00:34:18,060 --> 00:34:21,200
‫Y si no fue así, entonces llegamos hasta

702
00:34:21,200 --> 00:34:22,720
‫el final de

703
00:34:22,720 --> 00:34:24,460
‫la función de middleware, donde

704
00:34:24,460 --> 00:34:26,750
‫luego asignamos el currentUser a solicitar. user para que podamos usarlo en

705
00:34:26,750 --> 00:34:30,640
‫una siguiente función de middleware.

706
00:34:30,640 --> 00:34:33,860
‫¿Okey?

707
00:34:33,860 --> 00:34:34,693
‫Porque recuerda,

708
00:34:34,693 --> 00:34:37,030
‫este objeto de solicitud, este es el que

709
00:34:37,030 --> 00:34:38,950
‫viaja, básicamente, de middleware a middleware.

710
00:34:38,950 --> 00:34:40,660
‫Entonces, si queremos pasar datos de

711
00:34:40,660 --> 00:34:42,330
‫un middleware al siguiente, simplemente

712
00:34:42,330 --> 00:34:44,600
‫podemos poner algunas cosas en el objeto de

713
00:34:44,600 --> 00:34:47,860
‫solicitud, y luego esos datos estarán disponibles en un momento posterior.

714
00:34:47,860 --> 00:34:51,220
‫Está bien.

715
00:34:51,220 --> 00:34:52,053
‫Eso es todo.

716
00:34:52,053 --> 00:34:52,886
‫Este es

717
00:34:52,886 --> 00:34:54,560
‫un algoritmo de protección de rutas

718
00:34:54,560 --> 00:34:58,300
‫muy sofisticado y muy completo, básicamente, pero creo que es realmente importante hacerlo

719
00:34:58,300 --> 00:34:59,740
‫lo mejor que podamos.

720
00:34:59,740 --> 00:35:02,820
‫De todos modos, me alegro de ver que llegaste

721
00:35:02,820 --> 00:35:04,990
‫al final de este gran video, y

722
00:35:04,990 --> 00:35:07,050
‫te veré en el siguiente.