@tsed/passport 8.11.1 → 8.11.2-rc.1

package/src/services/ProtocolsService.spec.ts

@@ -1,166 +0,0 @@
-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"}]);
-  });
-});

package/src/services/ProtocolsService.ts

@@ -1,169 +0,0 @@
-import {promisify} from "node:util";
-
-import {ancestorsOf} from "@tsed/core";
-import {Inject, Injectable, InjectorService, Provider} from "@tsed/di";
-import {Unauthorized} from "@tsed/exceptions";
-import {PlatformContext, PlatformHandler} from "@tsed/platform-http";
-import Passport, {Strategy} from "passport";
-
-import {PROVIDER_TYPE_PROTOCOL} from "../contants/constants.js";
-import {PassportException} from "../errors/PassportException.js";
-import {PassportMessage} from "../errors/PassportMessage.js";
-import type {ProtocolMethods} from "../interfaces/ProtocolMethods.js";
-import type {ProtocolOptions} from "../interfaces/ProtocolOptions.js";
-
-/**
- * @ignore
- */
-@Injectable()
-export class ProtocolsService {
-  readonly strategies: Map<string, Strategy> = new Map();
-
-  @Inject()
-  protected platformHandler: PlatformHandler;
-
-  @Inject()
-  private injector: InjectorService;
-
-  public getProtocols(): Provider[] {
-    return this.injector.getProviders(PROVIDER_TYPE_PROTOCOL);
-  }
-
-  public getProtocolsNames(): string[] {
-    return Array.from(this.strategies.keys());
-  }
-
-  /**
-   * Invoke provider and bind it to passport.
-   * @param provider
-   */
-  async invoke(provider: Provider) {
-    let {name, useStrategy: strategy, settings} = this.getOptions(provider);
-    const protocol = this.injector.get<ProtocolMethods & Record<string, any>>(provider.provide)!;
-
-    if (protocol.$beforeInstall) {
-      settings = (await protocol.$beforeInstall(settings)) || settings;
-    }
-
-    const instance = new strategy(settings, this.createHandler(provider));
-
-    this.strategies.set(name, instance);
-
-    Passport.use(name, instance);
-
-    if (protocol.$onInstall) {
-      await protocol.$onInstall(instance);
-    }
-
-    protocol.$strategy = instance;
-
-    return protocol;
-  }
-
-  /**
-   * Call authenticate passport method.
-   * @param protocols
-   * @param options
-   * @param ctx
-   */
-  public authenticate(protocols: string | string[], options: Record<string, any>, ctx: PlatformContext) {
-    return this.call("authenticate", protocols, options, ctx);
-  }
-
-  /**
-   * Call authorize passport method.
-   * @param protocols
-   * @param options
-   * @param ctx
-   */
-  public authorize(protocols: string | string[], options: Record<string, any>, ctx: PlatformContext) {
-    return this.call("authorize", protocols, options, ctx);
-  }
-
-  /**
-   * Call passport authenticate or authorize depending on the chosen method.
-   * @param method
-   * @param protocols
-   * @param options
-   * @param ctx
-   * @private
-   */
-  private async call(
-    method: "authenticate" | "authorize",
-    protocols: string | string[],
-    options: Record<string, any>,
-    ctx: PlatformContext
-  ) {
-    const request = ctx.getRequest();
-    const response = ctx.getResponse();
-    protocols = ([] as string[]).concat(protocols);
-
-    if (protocols.length === 0) {
-      throw new Unauthorized("Not authorized");
-    }
-
-    try {
-      options.failWithError = true;
-      // @ts-ignore
-      const fn = promisify(Passport[method](protocols.length === 1 ? protocols[0] : protocols, options));
-
-      await fn(request, response);
-    } catch (er) {
-      if (!ancestorsOf(er).includes(Error)) {
-        throw new PassportException(er);
-      }
-
-      throw er;
-    }
-  }
-
-  /**
-   * Create strategy options based on decorator metadata and global configuration
-   * @param provider
-   * @private
-   */
-  private getOptions(provider: Provider<any>): ProtocolOptions {
-    const {name} = provider.store.get("protocol");
-    const {useStrategy = Strategy, settings = {}}: ProtocolOptions = this.injector.settings.get(`passport.protocols.${name}`) || {};
-
-    return {
-      name,
-      useStrategy,
-      settings: {
-        ...settings,
-        passReqToCallback: true
-      }
-    };
-  }
-
-  /**
-   * Create the verifier handler for passport
-   * @param provider
-   * @private
-   */
-  private createHandler(provider: Provider) {
-    const middleware = this.platformHandler.createCustomHandler(provider, "$onVerify");
-
-    return async (req: any, ...args: any[]) => {
-      const done = args[args.length - 1];
-
-      if (req.$ctx) {
-        req.$ctx.set("PROTOCOL_ARGS", args.slice(0, -1));
-
-        try {
-          await middleware(req.$ctx);
-
-          done(null, ...[].concat(req.$ctx.data));
-        } catch (err) {
-          if (err instanceof PassportMessage) {
-            done(null, false, {...err.opts, message: err.message});
-          } else {
-            done(err, false, {message: err.message});
-          }
-        }
-      } else {
-        done(new Error("Headers already sent"), false, {message: "Headers already sent"});
-      }
-    };
-  }
-}

package/src/utils/getProtocolsFromRequest.spec.ts

@@ -1,97 +0,0 @@
-import {getProtocolsFromRequest} from "./getProtocolsFromRequest.js";
-
-describe("getProtocolsFromRequest", () => {
-  it("should allow all protocol (from default protocols)", () => {
-    const defaultProtocols = ["default"];
-    const req = {};
-    const result = getProtocolsFromRequest(req, "*", defaultProtocols);
-
-    expect(result).toEqual(["default"]);
-  });
-
-  it("should allow all protocol (from default protocols - array)", () => {
-    const defaultProtocols = ["default"];
-    const req = {};
-    const result = getProtocolsFromRequest(req, ["*"], defaultProtocols);
-
-    expect(result).toEqual(["default"]);
-  });
-
-  it("should return providers", () => {
-    const defaultProtocols = ["default"];
-    const req = {};
-    const result = getProtocolsFromRequest(req, ["basic", "local"], defaultProtocols);
-
-    expect(result).toEqual(["basic", "local"]);
-  });
-
-  it("should get protocol from request (params)", () => {
-    const defaultProtocols = ["default"];
-    const req = {
-      params: {
-        protocol: "basic"
-      }
-    };
-    const result = getProtocolsFromRequest(req, ":protocol", defaultProtocols);
-
-    expect(result).toEqual(["basic"]);
-  });
-
-  it("should not get protocol from request", () => {
-    const defaultProtocols = ["default"];
-    const req = {
-      params: {}
-    };
-    const result = getProtocolsFromRequest(req, ":protocol", defaultProtocols);
-
-    expect(result).toEqual([]);
-  });
-
-  it("should get protocol from request (query)", () => {
-    const defaultProtocols = ["default"];
-    const req = {
-      query: {
-        protocol: "basic"
-      }
-    };
-    const result = getProtocolsFromRequest(req, ":protocol", defaultProtocols);
-
-    expect(result).toEqual(["basic"]);
-  });
-
-  it("should get protocol from request (body)", () => {
-    const defaultProtocols = ["default"];
-    const req = {
-      body: {
-        protocol: "basic"
-      }
-    };
-    const result = getProtocolsFromRequest(req, ":protocol", defaultProtocols);
-
-    expect(result).toEqual(["basic"]);
-  });
-
-  it("should return basic protocol", () => {
-    const defaultProtocols = ["default"];
-    const req = {
-      params: {
-        protocol: "basic"
-      }
-    };
-    const result = getProtocolsFromRequest(req, "basic", defaultProtocols);
-
-    expect(result).toEqual(["basic"]);
-  });
-
-  it("should not return protocol when protocol doesn't match", () => {
-    const defaultProtocols = ["default"];
-    const req = {
-      params: {
-        protocol: "basic"
-      }
-    };
-    const result = getProtocolsFromRequest(req, "other", defaultProtocols);
-
-    expect(result).toEqual([]);
-  });
-});

package/src/utils/getProtocolsFromRequest.ts

@@ -1,41 +0,0 @@
-import {isArray} from "@tsed/core";
-
-/**
- * @ignore
- */
-function getProtocolName(req: any) {
-  const {query = {}, params = {}, body = {}} = req;
-
-  return params.protocol || query.protocol || body.protocol;
-}
-
-/**
- * @ignore
- */
-export function getProtocolsFromRequest(req: any, protocol: string | string[], defaultProtocols: string[]): string[] {
-  if (!isArray(protocol)) {
-    if (protocol === "*") {
-      return defaultProtocols;
-    }
-
-    const protocolReq = getProtocolName(req);
-
-    if (protocol === ":protocol") {
-      return [protocolReq].filter(Boolean);
-    }
-
-    if (protocolReq && protocolReq !== protocol) {
-      return [];
-    }
-
-    return [protocol];
-  }
-
-  const protocols: string[] = protocol;
-
-  if (protocols.includes("*")) {
-    return defaultProtocols;
-  }
-
-  return protocols;
-}

package/vitest.config.mts

@@ -1,21 +0,0 @@
-// @ts-ignore
-import {presets} from "@tsed/vitest/presets";
-import {defineConfig} from "vitest/config";
-
-export default defineConfig(
-  {
-    ...presets,
-    test: {
-      ...presets.test,
-      coverage: {
-        ...presets.test.coverage,
-        thresholds: {
-          statements: 0,
-          branches: 0,
-          functions: 0,
-          lines: 0
-        }
-      }
-    }
-  }
-);