@tsed/passport 8.11.0 → 8.11.2-rc.1

package/src/decorators/authorize.spec.ts

@@ -1,96 +0,0 @@
-import {Store} from "@tsed/core";
-import {Controller, inject} from "@tsed/di";
-import {Middleware, UseBefore} from "@tsed/platform-middlewares";
-import {Get, getSpec} from "@tsed/schema";
-
-import {Authorize, PassportMiddleware} from "../index.js";
-
-@Middleware()
-class AuthoriseBucket {
-  use() {}
-}
-
-describe("@Authorize", () => {
-  it("should store data", () => {
-    class Test {
-      @Authorize("local", {
-        security: {
-          test: ["scope"]
-        }
-      })
-      test() {}
-    }
-
-    const store = Store.fromMethod(Test, "test");
-
-    expect(store.get(PassportMiddleware)).toEqual({
-      method: "authorize",
-      options: {
-        security: {
-          test: ["scope"]
-        }
-      },
-      originalUrl: true,
-      protocol: "local"
-    });
-  });
-  it("should store data (without originalUrl)", () => {
-    class Test {
-      @Authorize("local", {
-        security: {
-          test: ["scope"]
-        },
-        originalUrl: false
-      })
-      test() {}
-    }
-
-    const store = Store.fromMethod(Test, "test");
-
-    expect(store.get(PassportMiddleware)).toEqual({
-      method: "authorize",
-      options: {
-        security: {
-          test: ["scope"]
-        },
-        originalUrl: false
-      },
-      originalUrl: false,
-      protocol: "local"
-    });
-  });
-  it("should support inheritance", async () => {
-    abstract class AbstractAdminController {
-      @Get("/allEntries")
-      getAllEntries(): Promise<unknown> {
-        return Promise.resolve({});
-      }
-    }
-
-    @Authorize("loginAuthProvider")
-    @Controller("/admin")
-    class AdminController extends AbstractAdminController {}
-
-    @Controller("/admin/bucket")
-    @UseBefore(AuthoriseBucket)
-    class BucketAdminController extends AbstractAdminController {}
-
-    expect(getSpec(AdminController)).toMatchSnapshot();
-    expect(getSpec(BucketAdminController)).toMatchSnapshot();
-    expect(Reflect.getOwnPropertyDescriptor(AdminController.prototype, "getAllEntries")).toBeDefined();
-    expect(Reflect.getOwnPropertyDescriptor(BucketAdminController.prototype, "getAllEntries")).not.toBeDefined();
-
-    const adminController = inject(AdminController);
-
-    expect(await adminController.getAllEntries()).toEqual({});
-
-    expect(Store.fromMethod(BucketAdminController, "getAllEntries").get(PassportMiddleware)).toEqual(undefined);
-    expect(Store.fromMethod(AbstractAdminController, "getAllEntries").get(PassportMiddleware)).toEqual(undefined);
-    expect(Store.fromMethod(AdminController, "getAllEntries").get(PassportMiddleware)).toEqual({
-      method: "authorize",
-      options: {},
-      originalUrl: true,
-      protocol: "loginAuthProvider"
-    });
-  });
-});

package/src/decorators/authorize.ts

@@ -1,25 +0,0 @@
-import {useDecorators} from "@tsed/core";
-import {UseAuth} from "@tsed/platform-middlewares";
-import {Security} from "@tsed/schema";
-import {AuthenticateOptions} from "passport";
-
-import {PassportMiddleware} from "../middlewares/PassportMiddleware.js";
-
-export interface AuthorizeOptions extends AuthenticateOptions {
-  security?: Record<string, string[]>;
-  originalUrl?: boolean;
-}
-
-export function Authorize(protocol: string | string[] = "*", options: AuthorizeOptions = {}): Function {
-  return useDecorators(
-    UseAuth(PassportMiddleware, {
-      protocol,
-      method: "authorize",
-      originalUrl: options.originalUrl === undefined ? true : options.originalUrl,
-      options
-    }),
-    ...Object.entries(options.security || {}).map(([key, value]) => {
-      return Security(key, ...value);
-    })
-  );
-}

package/src/decorators/protocol.ts

@@ -1,29 +0,0 @@
-import {StoreSet, useDecorators} from "@tsed/core";
-import {Configuration, Injectable} from "@tsed/di";
-
-import {PROVIDER_TYPE_PROTOCOL} from "../contants/constants.js";
-import {ProtocolOptions} from "../interfaces/ProtocolOptions.js";
-
-/**
- * Declare a new Protocol base on a Passport Strategy
- *
- * @decorator
- * @class
- */
-export function Protocol<T = any>(options: ProtocolOptionsDecorator<T>) {
-  return useDecorators(
-    Injectable({
-      type: PROVIDER_TYPE_PROTOCOL
-    }),
-    StoreSet("protocol", options),
-    Configuration({
-      passport: {
-        protocols: {
-          [options.name]: options
-        }
-      }
-    })
-  );
-}
-
-export type ProtocolOptionsDecorator<T = any> = {name: string} & Partial<ProtocolOptions<T>>;

package/src/domain/UserInfo.ts

@@ -1,13 +0,0 @@
-import {Format, Property} from "@tsed/schema";
-
-export class UserInfo {
-  @Property()
-  id: string;
-
-  @Property()
-  @Format("email")
-  email: string;
-
-  @Property()
-  password: string;
-}

package/src/errors/PassportException.ts

@@ -1,8 +0,0 @@
-import {Exception} from "@tsed/exceptions";
-
-export class PassportException extends Exception {
-  constructor(error: any) {
-    super(error.status || 500, error.message);
-    this.name = error.name || this.name;
-  }
-}

package/src/errors/PassportMessage.ts

@@ -1,10 +0,0 @@
-import {Unauthorized} from "@tsed/exceptions";
-
-export class PassportMessage extends Unauthorized {
-  constructor(
-    message: string,
-    public opts: Record<string, unknown> = {}
-  ) {
-    super(message);
-  }
-}

package/src/index.ts

@@ -1,22 +0,0 @@
-/**
- * @file Automatically generated by @tsed/barrels.
- */
-export * from "./contants/constants.js";
-export * from "./decorators/args.js";
-export * from "./decorators/authenticate.js";
-export * from "./decorators/authorize.js";
-export * from "./decorators/protocol.js";
-export * from "./domain/UserInfo.js";
-export * from "./errors/PassportException.js";
-export * from "./errors/PassportMessage.js";
-export * from "./interfaces/BeforeInstall.js";
-export * from "./interfaces/interfaces.js";
-export * from "./interfaces/OnInstall.js";
-export * from "./interfaces/OnVerify.js";
-export * from "./interfaces/ProtocolMethods.js";
-export * from "./interfaces/ProtocolOptions.js";
-export * from "./middlewares/PassportMiddleware.js";
-export * from "./PassportModule.js";
-export * from "./services/PassportSerializerService.js";
-export * from "./services/ProtocolsService.js";
-export * from "./utils/getProtocolsFromRequest.js";

package/src/interfaces/BeforeInstall.ts

@@ -1,3 +0,0 @@
-export interface BeforeInstall<Settings = any> {
-  $beforeInstall(setting: Settings): Promise<Settings> | Settings | void;
-}

package/src/interfaces/OnInstall.ts

@@ -1,5 +0,0 @@
-import {Strategy} from "passport";
-
-export interface OnInstall {
-  $onInstall(strategy: Strategy): void | Promise<void>;
-}

package/src/interfaces/OnVerify.ts

@@ -1,3 +0,0 @@
-export interface OnVerify {
-  $onVerify(...args: any[]): Promise<any | any[]> | any | any[];
-}

package/src/interfaces/ProtocolMethods.ts

@@ -1,5 +0,0 @@
-import {BeforeInstall} from "./BeforeInstall.js";
-import {OnInstall} from "./OnInstall.js";
-import {OnVerify} from "./OnVerify.js";
-
-export interface ProtocolMethods<Settings = any> extends OnVerify, OnInstall, BeforeInstall<Settings> {}

package/src/interfaces/ProtocolOptions.ts

@@ -1,8 +0,0 @@
-import {Type} from "@tsed/core";
-import {Strategy} from "passport";
-
-export interface ProtocolOptions<Settings = any> {
-  name: string;
-  useStrategy: Type<Strategy>;
-  settings: Settings;
-}

package/src/interfaces/interfaces.ts

@@ -1,21 +0,0 @@
-import {Type} from "@tsed/core";
-import {PassportStatic} from "passport";
-
-import {ProtocolOptions} from "./ProtocolOptions.js";
-
-declare global {
-  namespace TsED {
-    interface Configuration {
-      passport: {
-        userProperty?: string;
-        pauseStream?: string;
-        disableSession?: boolean;
-        userInfoModel?: Type<any> | false;
-        module?: PassportStatic;
-        protocols?: {
-          [protocolName: string]: Partial<ProtocolOptions>;
-        };
-      };
-    }
-  }
-}

package/src/middlewares/PassportMiddleware.spec.ts

@@ -1,301 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

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