@tsed/passport 8.0.1 → 8.0.2

package/src/middlewares/PassportMiddleware.spec.ts

@@ -0,0 +1,301 @@
+import {Unauthorized} from "@tsed/exceptions";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import Passport from "passport";
+
+import {PassportException} from "../errors/PassportException.js";
+import {PassportMiddleware} from "./PassportMiddleware.js";
+
+function createContextFixture(options = {}) {
+  return PlatformTest.createRequestContext({
+    event: {
+      request: PlatformTest.createRequest(options)
+    }
+  });
+}
+
+describe("PassportMiddleware", () => {
+  beforeEach(() => {
+    PlatformTest.create();
+    vi.spyOn(Passport, "authenticate").mockImplementation(() => (req: any, res: any, next: any) => {
+      return next();
+    });
+    vi.spyOn(Passport, "authorize").mockImplementation(() => (req: any, res: any, next: any) => {
+      return next();
+    });
+  });
+  afterEach(() => {
+    PlatformTest.reset();
+  });
+  it("should call passport with local", async () => {
+    // GIVEN
+    const middleware = await PlatformTest.invoke<PassportMiddleware>(PassportMiddleware);
+    const context = createContextFixture();
+
+    vi.spyOn(middleware.protocolsService, "getProtocolsNames").mockReturnValue(["local"]);
+
+    context.endpoint = {
+      store: {
+        get: vi.fn().mockReturnValue({
+          options: {},
+          protocol: "local",
+          method: "authenticate"
+        })
+      }
+    } as any;
+
+    // WHEN
+    await middleware.use(context);
+
+    // THEN
+    expect(Passport.authenticate).toHaveBeenCalledWith("local", {failWithError: true});
+  });
+  it("should skip auth when user is authenticated", async () => {
+    // GIVEN
+    const middleware = await PlatformTest.invoke<PassportMiddleware>(PassportMiddleware);
+    const context = createContextFixture();
+
+    vi.spyOn(middleware.protocolsService, "getProtocolsNames").mockReturnValue(["local"]);
+
+    context.getRequest().user = {};
+    context.getRequest().isAuthenticated = () => {
+      return true;
+    };
+
+    context.endpoint = {
+      store: {
+        get: vi.fn().mockReturnValue({
+          options: {},
+          protocol: "local",
+          method: "authenticate"
+        })
+      }
+    } as any;
+
+    // WHEN
+    await middleware.use(context);
+
+    // THEN
+    return expect(Passport.authenticate).not.toHaveBeenCalled();
+  });
+
+  it("should call passport with defaults protocols", async () => {
+    // GIVEN
+    const middleware = await PlatformTest.invoke<PassportMiddleware>(PassportMiddleware);
+    vi.spyOn(middleware.protocolsService, "getProtocolsNames").mockReturnValue(["local", "basic"]);
+
+    const context = createContextFixture();
+
+    context.endpoint = {
+      store: {
+        get: vi.fn().mockReturnValue({
+          options: {},
+          protocol: "*",
+          method: "authenticate"
+        })
+      }
+    } as any;
+
+    // WHEN
+    await middleware.use(context);
+
+    // THEN
+    expect(Passport.authenticate).toHaveBeenCalledWith(["local", "basic"], {failWithError: true});
+  });
+  it("should call passport with :protocol", async () => {
+    // GIVEN
+    const middleware = await PlatformTest.invoke<PassportMiddleware>(PassportMiddleware);
+    vi.spyOn(middleware.protocolsService, "getProtocolsNames").mockReturnValue(["local", "basic"]);
+
+    const context = createContextFixture({
+      url: "/",
+      originalUrl: "/rest",
+      query: {
+        protocol: "basic"
+      }
+    });
+
+    context.endpoint = {
+      store: {
+        get: vi.fn().mockReturnValue({
+          options: {},
+          protocol: ":protocol",
+          method: "authenticate"
+        })
+      }
+    } as any;
+
+    // WHEN
+    await middleware.use(context);
+
+    // THEN
+    expect(context.getRequest().url).toBe(context.getRequest().originalUrl);
+    expect(Passport.authenticate).toHaveBeenCalledWith("basic", {failWithError: true});
+  });
+  it("should call passport with authorize", async () => {
+    // GIVEN
+    const middleware = await PlatformTest.invoke<PassportMiddleware>(PassportMiddleware);
+    vi.spyOn(middleware.protocolsService, "getProtocolsNames").mockReturnValue(["local", "basic"]);
+
+    const context = createContextFixture({
+      url: "/",
+      originalUrl: "/rest",
+      query: {
+        protocol: "basic"
+      }
+    });
+
+    context.endpoint = {
+      store: {
+        get: vi.fn().mockReturnValue({
+          options: {},
+          protocol: ":protocol",
+          method: "authorize"
+        })
+      }
+    } as any;
+
+    // WHEN
+    await middleware.use(context);
+
+    // THEN
+    expect(context.getRequest().url).toBe(context.getRequest().originalUrl);
+    expect(Passport.authorize).toHaveBeenCalledWith("basic", {failWithError: true});
+  });
+  it("should throw errors", async () => {
+    // GIVEN
+    const middleware = await PlatformTest.invoke<PassportMiddleware>(PassportMiddleware);
+    vi.spyOn(middleware.protocolsService, "getProtocolsNames").mockReturnValue(["local", "basic"]);
+
+    const context = createContextFixture();
+    context.endpoint = {
+      store: {
+        get: vi.fn().mockReturnValue({
+          options: {},
+          protocol: ":protocol",
+          method: "authenticate"
+        })
+      }
+    } as any;
+
+    // WHEN
+    let actualError;
+    try {
+      await middleware.use(context);
+    } catch (er) {
+      actualError = er;
+    }
+
+    // THEN
+    expect(actualError).toBeInstanceOf(Unauthorized);
+  });
+  it("should throw errors from passport (AuthenticationError)", async () => {
+    // GIVEN
+    const middleware = await PlatformTest.invoke<PassportMiddleware>(PassportMiddleware);
+    vi.spyOn(middleware.protocolsService, "getProtocolsNames").mockReturnValue(["local", "basic"]);
+
+    (Passport.authenticate as any).mockImplementation(() => (req: any, res: any, next: any) => {
+      const error: any = {message: "message"};
+      error.name = "AuthenticationError";
+      error.status = 400;
+
+      return next(error);
+    });
+
+    const context = createContextFixture();
+
+    context.endpoint = {
+      store: {
+        get: vi.fn().mockReturnValue({
+          options: {},
+          protocol: "*",
+          method: "authenticate"
+        })
+      }
+    } as any;
+
+    // WHEN
+    let actualError;
+    try {
+      await middleware.use(context);
+    } catch (er) {
+      actualError = er;
+    }
+
+    // THEN
+    expect(actualError).toBeInstanceOf(PassportException);
+    expect(actualError.message).toBe("message");
+    expect(actualError.status).toBe(400);
+  });
+  it("should throw errors from passport (AnyError)", async () => {
+    // GIVEN
+    const middleware = await PlatformTest.invoke<PassportMiddleware>(PassportMiddleware);
+    vi.spyOn(middleware.protocolsService, "getProtocolsNames").mockReturnValue(["local", "basic"]);
+
+    (Passport.authenticate as any).mockImplementation(() => (req: any, res: any, next: any) => {
+      const error: any = {message: "message"};
+      error.name = "Any";
+
+      return next(error);
+    });
+
+    const context = createContextFixture();
+
+    context.endpoint = {
+      store: {
+        get: vi.fn().mockReturnValue({
+          options: {},
+          protocol: "*",
+          method: "authenticate"
+        })
+      }
+    } as any;
+
+    // WHEN
+    let actualError;
+    try {
+      await middleware.use(context);
+    } catch (er) {
+      actualError = er;
+    }
+
+    // THEN
+    expect(actualError).toBeInstanceOf(PassportException);
+    expect(actualError.message).toBe("message");
+    expect(actualError.status).toBe(500);
+  });
+  it("should throw errors from passport (Error)", async () => {
+    // GIVEN
+    const middleware = await PlatformTest.invoke<PassportMiddleware>(PassportMiddleware);
+    vi.spyOn(middleware.protocolsService, "getProtocolsNames").mockReturnValue(["local", "basic"]);
+
+    (Passport.authenticate as any).mockImplementation(() => (req: any, res: any, next: any) => {
+      const error: any = new Error("message");
+
+      return next(error);
+    });
+
+    const context = createContextFixture();
+
+    context.endpoint = {
+      store: {
+        get: vi.fn().mockReturnValue({
+          options: {},
+          protocol: "*",
+          method: "authenticate"
+        })
+      }
+    } as any;
+
+    // WHEN
+    let actualError;
+    try {
+      await middleware.use(context);
+    } catch (er) {
+      actualError = er;
+    }
+
+    // THEN
+    expect(actualError).toBeInstanceOf(Error);
+    expect(actualError.message).toBe("message");
+  });
+});

package/src/middlewares/PassportMiddleware.ts

@@ -0,0 +1,36 @@
+import {Inject} from "@tsed/di";
+import {Middleware} from "@tsed/platform-middlewares";
+import {Context} from "@tsed/platform-params";
+
+import {ProtocolsService} from "../services/ProtocolsService.js";
+import {getProtocolsFromRequest} from "../utils/getProtocolsFromRequest.js";
+
+@Middleware()
+export class PassportMiddleware {
+  @Inject(ProtocolsService)
+  protocolsService: ProtocolsService;
+
+  shouldSkip(ctx: Context) {
+    const request = ctx.getRequest();
+    return request.user && request.isAuthenticated();
+  }
+
+  async use(@Context() ctx: Context) {
+    const endpoint = ctx.endpoint;
+    const request = ctx.getRequest();
+
+    if (this.shouldSkip(ctx)) {
+      return;
+    }
+    const {options, protocol, method, originalUrl = true} = endpoint.store.get(PassportMiddleware);
+    const protocols = getProtocolsFromRequest(request, protocol, this.protocolsService.getProtocolsNames());
+
+    if (originalUrl) {
+      request.url = request.originalUrl;
+    }
+
+    await (method === "authenticate"
+      ? this.protocolsService.authenticate(protocols, options, ctx)
+      : this.protocolsService.authorize(protocols, options, ctx));
+  }
+}

package/src/services/PassportSerializerService.spec.ts

@@ -0,0 +1,51 @@
+import {PlatformTest} from "@tsed/platform-http/testing";
+
+import {PassportSerializerService, UserInfo} from "../index.js";
+
+describe("PassportSerializerService", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(PlatformTest.reset);
+
+  it(
+    "should serialize model",
+    PlatformTest.inject([PassportSerializerService], async (service: PassportSerializerService) => {
+      const userInfo = new UserInfo();
+
+      userInfo.id = "id";
+      userInfo.email = "email@email.fr";
+      userInfo.password = "password";
+
+      const result = await new Promise((resolve) => service.serialize(userInfo, (...args: any[]) => resolve(args)));
+
+      expect(result).toEqual([null, '{"id":"id","email":"email@email.fr"}']);
+    })
+  );
+
+  it(
+    "should deserialize model",
+    PlatformTest.inject([PassportSerializerService], async (service: PassportSerializerService) => {
+      const result = await new Promise((resolve) =>
+        service.deserialize('{"id":"id","email":"email@email.fr"}', (...args: any[]) => resolve(args))
+      );
+
+      expect(result).toEqual([
+        null,
+        {
+          email: "email@email.fr",
+          id: "id"
+        }
+      ]);
+    })
+  );
+
+  it(
+    "should catch error when deserializing model",
+    PlatformTest.inject([PassportSerializerService], async (service: PassportSerializerService) => {
+      const result: any = await new Promise((resolve) =>
+        service.deserialize('{"id":"id","email":"email@email.fr}', (...args: any[]) => resolve(args))
+      );
+
+      expect(result[0].message).toEqual("Unterminated string in JSON at position 35");
+    })
+  );
+});

package/src/services/PassportSerializerService.ts

@@ -0,0 +1,38 @@
+import {Type} from "@tsed/core";
+import {Constant, Service} from "@tsed/di";
+import {deserialize, serialize} from "@tsed/json-mapper";
+
+import {UserInfo} from "../domain/UserInfo.js";
+
+/**
+ * @ignore
+ */
+@Service()
+export class PassportSerializerService {
+  @Constant("passport.userInfoModel", UserInfo)
+  private model: Type<UserInfo> | boolean;
+
+  serialize(user: UserInfo, done: any) {
+    try {
+      const obj = serialize(user, {type: this.model});
+
+      // remove password from serialized object
+      obj.password = undefined;
+
+      done(null, JSON.stringify(obj));
+    } catch (er) {
+      // istanbul ignore next
+      done(er);
+    }
+  }
+
+  deserialize(obj: any, done: any) {
+    try {
+      const user = deserialize(JSON.parse(obj), {type: this.model});
+
+      done(null, user);
+    } catch (er) {
+      done(er);
+    }
+  }
+}

package/src/services/ProtocolsService.spec.ts

@@ -0,0 +1,166 @@
+import {runInContext} from "@tsed/di";
+import {Req} from "@tsed/platform-http";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import Passport from "passport";
+
+import {PassportMessage} from "../errors/PassportMessage.js";
+import {Protocol, ProtocolsService} from "../index.js";
+
+// tslint:disable-next-line:variable-name
+const Strategy = vi.fn();
+
+describe("ProtocolsService", () => {
+  @Protocol({
+    name: "local",
+    useStrategy: Strategy as any,
+    settings: {
+      prop1: "prop1",
+      prop2: "prop2"
+    }
+  })
+  class LocalProtocol {
+    $beforeInstall(settings: any) {
+      return Promise.resolve(settings);
+    }
+
+    $onInstall() {}
+
+    $onVerify(@Req() req: Req) {
+      return {id: 0};
+    }
+  }
+
+  beforeEach(() =>
+    PlatformTest.create({
+      passport: {
+        protocols: {
+          local: {
+            settings: {
+              prop2: "prop2-server",
+              prop3: "prop3"
+            }
+          }
+        }
+      }
+    })
+  );
+  afterEach(PlatformTest.reset);
+
+  beforeEach(() => {
+    vi.spyOn(LocalProtocol.prototype, "$onInstall");
+    vi.spyOn(LocalProtocol.prototype, "$onVerify");
+    vi.spyOn(LocalProtocol.prototype, "$beforeInstall");
+    vi.spyOn(Passport, "use").mockReturnValue(undefined as any);
+    Strategy.mockReset();
+  });
+
+  it("should create a protocol", async () => {
+    const protocolService = PlatformTest.get<ProtocolsService>(ProtocolsService);
+    // GIVEN
+    const provider = PlatformTest.injector.getProvider(LocalProtocol)!;
+
+    // WHEN
+    const result = await protocolService.invoke(provider);
+
+    // THEN
+    expect(result).toBeInstanceOf(LocalProtocol);
+    expect(result.$onInstall).toHaveBeenCalledWith(protocolService.strategies.get("local"));
+    expect(result.$beforeInstall).toHaveBeenCalledWith({
+      passReqToCallback: true,
+      prop1: "prop1",
+      prop2: "prop2-server",
+      prop3: "prop3"
+    });
+    expect(Passport.use).toHaveBeenCalledWith("local", protocolService.strategies.get("local"));
+    expect(Strategy).toHaveBeenCalledWith(
+      {
+        passReqToCallback: true,
+        prop1: "prop1",
+        prop2: "prop2-server",
+        prop3: "prop3"
+      },
+      expect.any(Function)
+    );
+    expect(protocolService.getProtocolsNames().includes("local")).toEqual(true);
+  });
+
+  it("should call metadata", async () => {
+    const protocolService = PlatformTest.get<ProtocolsService>(ProtocolsService);
+    // GIVEN
+    (LocalProtocol.prototype.$onVerify as any).mockReturnValue({id: 0});
+    const provider = PlatformTest.injector.getProvider(LocalProtocol)!;
+    const $ctx = PlatformTest.createRequestContext();
+
+    // WHEN
+    const protocol = await protocolService.invoke(provider);
+
+    const resultDone: any = await new Promise((resolve) => {
+      const verify = Strategy.mock.calls[0][1];
+
+      return runInContext($ctx, () => verify($ctx.getRequest(), "test", (...args: any[]) => resolve(args)));
+    });
+
+    // THEN
+    expect(resultDone).toEqual([null, {id: 0}]);
+    expect(protocol.$onVerify).toHaveBeenCalledWith($ctx.getRequest(), $ctx);
+  });
+
+  it("should call metadata and catch error", async () => {
+    const protocolService = PlatformTest.get<ProtocolsService>(ProtocolsService);
+    // GIVEN
+    const error = new Error("message");
+    (LocalProtocol.prototype.$onVerify as any).mockRejectedValue(error);
+
+    const provider = PlatformTest.injector.getProvider(LocalProtocol)!;
+    const $ctx = PlatformTest.createRequestContext();
+
+    // WHEN
+    const result = await protocolService.invoke(provider);
+    const resultDone: any = await new Promise((resolve) => {
+      const verify = Strategy.mock.calls[0][1];
+
+      return runInContext($ctx, () => verify($ctx.getRequest(), "test", (...args: any[]) => resolve(args)));
+    });
+
+    // THEN
+    expect(result.$onVerify).toHaveBeenCalledWith($ctx.getRequest(), $ctx);
+    expect(resultDone).toEqual([error, false, {message: "message"}]);
+  });
+
+  it("should call metadata and catch PassportMessage", async () => {
+    const protocolService = PlatformTest.get<ProtocolsService>(ProtocolsService);
+    // GIVEN
+    const error = new PassportMessage("message", {type: "allow"});
+    (LocalProtocol.prototype.$onVerify as any).mockRejectedValue(error);
+
+    const provider = PlatformTest.injector.getProvider(LocalProtocol)!;
+    const $ctx = PlatformTest.createRequestContext();
+
+    // WHEN
+    const result = await protocolService.invoke(provider);
+    const resultDone: any = await new Promise((resolve) => {
+      const verify = Strategy.mock.calls[0][1];
+
+      return runInContext($ctx, () => verify($ctx.getRequest(), "test", (...args: any[]) => resolve(args)));
+    });
+
+    // THEN
+    expect(result.$onVerify).toHaveBeenCalledWith($ctx.getRequest(), $ctx);
+    expect(resultDone).toEqual([null, false, {message: "message", type: "allow"}]);
+  });
+
+  it("should call metadata and catch missing $ctx", async () => {
+    const protocolService = PlatformTest.get<ProtocolsService>(ProtocolsService);
+    // GIVEN
+    const provider = PlatformTest.injector.getProvider(LocalProtocol)!;
+
+    // WHEN
+    await protocolService.invoke(provider);
+    const resultDone: any = await new Promise((resolve) => {
+      Strategy.mock.calls[0][1]({}, "test", (...args: any[]) => resolve(args));
+    });
+
+    // THEN
+    expect(resultDone).toEqual([new Error("Headers already sent"), false, {message: "Headers already sent"}]);
+  });
+});