@tsed/passport 8.0.1 → 8.0.3

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/passport",
   "description": "Passport package for Ts.ED framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -27,12 +28,12 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/platform-http": "8.0.1",
-    "@tsed/platform-router": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.3",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/platform-http": "8.0.3",
+    "@tsed/platform-router": "8.0.3",
+    "@tsed/typescript": "8.0.3",
     "@types/passport": "1.0.16",
     "@types/passport-http": "0.3.11",
     "@types/passport-local": "1.0.38",
@@ -46,7 +47,7 @@
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/platform-http": "8.0.1",
+    "@tsed/platform-http": "8.0.3",
     "passport": ">=0.4.1"
   },
   "peerDependenciesMeta": {

package/src/PassportModule.spec.ts

@@ -0,0 +1,75 @@
+import "../src/index.js";
+
+import {PlatformApplication} from "@tsed/platform-http";
+import {PlatformTest} from "@tsed/platform-http/testing";
+import Passport from "passport";
+
+import {PassportModule} from "./PassportModule.js";
+
+vi.mock("passport");
+
+beforeEach(() => {
+  (Passport.initialize as any).mockReturnValue("initializeMiddleware");
+  (Passport.session as any).mockReturnValue("sessionMiddleware");
+});
+describe("PassportModule", () => {
+  describe("passport.session() - disabled", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        PLATFORM_NAME: "express",
+        passport: {
+          disableSession: true
+        }
+      })
+    );
+    afterEach(PlatformTest.reset);
+    it("should not add the passport.session to the express application", async () => {
+      const app = {
+        use: vi.fn()
+      };
+      const passportModule = await PlatformTest.invoke<PassportModule>(PassportModule, [
+        {
+          token: PlatformApplication,
+          use: app
+        }
+      ]);
+
+      passportModule.$beforeRoutesInit();
+
+      expect(app.use).toHaveBeenCalledWith("initializeMiddleware");
+      expect(app.use).not.toHaveBeenCalledWith("sessionMiddleware");
+      expect(Passport.initialize).toHaveBeenCalledWith({userProperty: undefined});
+    });
+  });
+
+  describe("passport.session() - enabled", () => {
+    beforeEach(() =>
+      PlatformTest.create({
+        PLATFORM_NAME: "express",
+        passport: {
+          disableSession: false
+        }
+      })
+    );
+    afterEach(PlatformTest.reset);
+
+    it("should add the passport.session to the express application", async () => {
+      const app = {
+        use: vi.fn()
+      };
+      const passportModule = await PlatformTest.invoke<PassportModule>(PassportModule, [
+        {
+          token: PlatformApplication,
+          use: app
+        }
+      ]);
+
+      passportModule.$beforeRoutesInit();
+
+      expect(app.use).toHaveBeenCalledWith("initializeMiddleware");
+      expect(app.use).toHaveBeenCalledWith("sessionMiddleware");
+      expect(Passport.initialize).toHaveBeenCalledWith({userProperty: undefined});
+      expect(Passport.session).toHaveBeenCalledWith({pauseStream: undefined});
+    });
+  });
+});

package/src/PassportModule.ts

@@ -0,0 +1,58 @@
+import {Constant, Inject, Module, type OnInit, Provider} from "@tsed/di";
+import {Logger} from "@tsed/logger";
+import {BeforeRoutesInit, PlatformApplication} from "@tsed/platform-http";
+import Passport from "passport";
+
+import {PassportSerializerService} from "./services/PassportSerializerService.js";
+import {ProtocolsService} from "./services/ProtocolsService.js";
+
+/**
+ * @ignore
+ */
+@Module()
+export class PassportModule implements OnInit, BeforeRoutesInit {
+  @Constant("passport.userProperty")
+  userProperty: string;
+
+  @Constant("passport.pauseStream")
+  pauseStream: boolean;
+
+  @Constant("passport.disableSession", false)
+  disableSession: boolean;
+
+  @Constant("PLATFORM_NAME")
+  platformName: string;
+
+  @Inject()
+  logger: Logger;
+
+  constructor(
+    private app: PlatformApplication,
+    private protocolsService: ProtocolsService,
+    private passportSerializer: PassportSerializerService
+  ) {}
+
+  async $onInit(): Promise<any> {
+    Passport.serializeUser(this.passportSerializer.serialize.bind(this.passportSerializer));
+    Passport.deserializeUser(this.passportSerializer.deserialize.bind(this.passportSerializer));
+
+    const promises = this.protocolsService.getProtocols().map((provider: Provider) => this.protocolsService.invoke(provider));
+
+    await Promise.all(promises);
+    return undefined;
+  }
+
+  $beforeRoutesInit(): void | Promise<any> {
+    const {userProperty, pauseStream} = this;
+    switch (this.platformName) {
+      case "express":
+        this.app.use(Passport.initialize({userProperty}));
+        !this.disableSession && this.app.use(Passport.session({pauseStream}));
+
+        return;
+
+      default:
+        this.logger.warn(`Platform "${this.platformName}" not supported by @tsed/passport`);
+    }
+  }
+}

package/src/contants/constants.ts

@@ -0,0 +1 @@
+export const PROVIDER_TYPE_PROTOCOL = "protocol";

package/src/decorators/__snapshots__/authorize.spec.ts.snap

@@ -0,0 +1,53 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`@Authorize > should support inheritance 1`] = `
+{
+  "paths": {
+    "/admin/allEntries": {
+      "get": {
+        "operationId": "abstractAdminControllerGetAllEntries",
+        "parameters": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+          },
+        },
+        "tags": [
+          "AdminController",
+        ],
+      },
+    },
+  },
+  "tags": [
+    {
+      "name": "AdminController",
+    },
+  ],
+}
+`;
+
+exports[`@Authorize > should support inheritance 2`] = `
+{
+  "paths": {
+    "/admin/bucket/allEntries": {
+      "get": {
+        "operationId": "abstractAdminControllerGetAllEntries",
+        "parameters": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+          },
+        },
+        "tags": [
+          "BucketAdminController",
+        ],
+      },
+    },
+  },
+  "tags": [
+    {
+      "name": "BucketAdminController",
+    },
+  ],
+}
+`;

package/src/decorators/args.spec.ts

@@ -0,0 +1,28 @@
+import {ParamTypes} from "@tsed/platform-params";
+import {JsonParameterStore} from "@tsed/schema";
+
+import {Arg, Args} from "./args.js";
+
+describe("@Args", () => {
+  it("should register a new parameter instance with the correct property", () => {
+    class Ctrl {
+      test(@Args() args: any[]) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.expression).toBe("PROTOCOL_ARGS");
+    expect(param.paramType).toBe(ParamTypes.$CTX);
+  });
+});
+
+describe("@Arg", () => {
+  it("should register a new parameter instance with the correct property", () => {
+    class Ctrl {
+      test(@Arg(0) args: any[]) {}
+    }
+
+    const param = JsonParameterStore.get(Ctrl, "test", 0);
+    expect(param.expression).toBe("PROTOCOL_ARGS.0");
+    expect(param.paramType).toBe(ParamTypes.$CTX);
+  });
+});

package/src/decorators/args.ts

@@ -0,0 +1,14 @@
+import {useDecorators} from "@tsed/core";
+import {Context} from "@tsed/platform-params";
+
+/**
+ * Inject args resolve by the passport strategy on verify method.
+ * @decorator
+ */
+export function Args() {
+  return useDecorators(Context("PROTOCOL_ARGS"));
+}
+
+export function Arg(index: number) {
+  return useDecorators(Context(`PROTOCOL_ARGS.${index}`));
+}

package/src/decorators/authenticate.spec.ts

@@ -0,0 +1,55 @@
+import {Store} from "@tsed/core";
+import {Security} from "@tsed/schema";
+
+import {Authenticate, PassportMiddleware} from "../index.js";
+
+describe("@Authenticate", () => {
+  it("should store data", () => {
+    class Test {
+      @Authenticate("local", {
+        security: {
+          test: ["scope"]
+        }
+      })
+      test() {}
+    }
+
+    const store = Store.fromMethod(Test, "test");
+
+    expect(store.get(PassportMiddleware)).toEqual({
+      method: "authenticate",
+      options: {
+        security: {
+          test: ["scope"]
+        }
+      },
+      protocol: "local",
+      originalUrl: true
+    });
+  });
+  it("should store data (without originalUrl)", () => {
+    class Test {
+      @Authenticate("local", {
+        security: {
+          test: ["scope"]
+        },
+        originalUrl: false
+      })
+      test() {}
+    }
+
+    const store = Store.fromMethod(Test, "test");
+
+    expect(store.get(PassportMiddleware)).toEqual({
+      method: "authenticate",
+      options: {
+        security: {
+          test: ["scope"]
+        },
+        originalUrl: false
+      },
+      protocol: "local",
+      originalUrl: false
+    });
+  });
+});

package/src/decorators/authenticate.ts

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

package/src/decorators/authorize.spec.ts

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

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

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

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

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

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

package/src/index.ts

@@ -0,0 +1,22 @@
+/**
+ * @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

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

package/src/interfaces/OnInstall.ts

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

package/src/interfaces/OnVerify.ts

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

package/src/interfaces/ProtocolMethods.ts

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

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

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