@smartsoft001/auth-shell-nestjs 2.76.0 → 2.81.0

package/index.js

@@ -0,0 +1,454 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// packages/auth/shell/nestjs/src/lib/controllers/token/token.controller.ts
+import { Body, Controller, Post, Req } from "@nestjs/common";
+var TokenController = class {
+  constructor(service) {
+    this.service = service;
+  }
+  create(req, httpReq) {
+    return this.service.create(req, httpReq);
+  }
+};
+__decorateClass([
+  Post(),
+  __decorateParam(0, Body()),
+  __decorateParam(1, Req())
+], TokenController.prototype, "create", 1);
+TokenController = __decorateClass([
+  Controller("token")
+], TokenController);
+
+// packages/auth/shell/nestjs/src/lib/nestjs.module.ts
+import { HttpModule } from "@nestjs/axios";
+import { Module } from "@nestjs/common";
+import { JwtModule } from "@nestjs/jwt";
+import { PassportModule } from "@nestjs/passport";
+import { TypeOrmModule } from "@nestjs/typeorm";
+
+// packages/auth/domain/src/lib/entities/user.entity.ts
+import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+var User = class {
+};
+__decorateClass([
+  PrimaryGeneratedColumn()
+], User.prototype, "id", 2);
+__decorateClass([
+  Column("permissions")
+], User.prototype, "permissions", 2);
+__decorateClass([
+  Column("username")
+], User.prototype, "username", 2);
+__decorateClass([
+  Column("password")
+], User.prototype, "password", 2);
+__decorateClass([
+  Column("disabled")
+], User.prototype, "disabled", 2);
+__decorateClass([
+  Column("lastLoginDate")
+], User.prototype, "lastLoginDate", 2);
+__decorateClass([
+  Column("authRefreshToken")
+], User.prototype, "authRefreshToken", 2);
+__decorateClass([
+  Column("facebookUserId")
+], User.prototype, "facebookUserId", 2);
+__decorateClass([
+  Column("googleUserId")
+], User.prototype, "googleUserId", 2);
+User = __decorateClass([
+  Entity("users")
+], User);
+
+// packages/auth/domain/src/lib/feature-create-token/token.factory.ts
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Guid as Guid2 } from "guid-typescript";
+
+// packages/shared/models/src/lib/symbols.ts
+var SYMBOL_MODEL = Symbol.for("smartsoft:model");
+var SYMBOL_FIELD = Symbol.for("smartsoft:field");
+
+// packages/shared/models/src/lib/decorators/model/model.decorator.ts
+import "reflect-metadata";
+
+// packages/shared/models/src/lib/decorators/field/field.decorator.ts
+import "reflect-metadata";
+
+// packages/shared/utils/src/lib/services/password/password.service.ts
+import * as md5_ from "md5";
+var md5 = md5_;
+var PasswordService = class _PasswordService {
+  /**
+   * Hash password text
+   * @param p {string} - text
+   * @return - hashed text
+   */
+  static hash(p) {
+    return Promise.resolve(md5(p));
+  }
+  /**
+   * Compare password text with hashed text
+   * @param p {string} - password text
+   * @param h {string} - hashed text
+   */
+  static async compare(p, h) {
+    const hp = await _PasswordService.hash(p);
+    return hp === h;
+  }
+};
+
+// packages/shared/utils/src/lib/services/object/object.service.ts
+import { stringify } from "flatted";
+
+// packages/shared/utils/src/lib/services/guid/guid.service.ts
+import { Guid } from "guid-typescript";
+
+// packages/shared/utils/src/lib/services/array/array.service.ts
+import * as _ from "lodash";
+
+// packages/shared/domain-core/src/lib/errors.ts
+var DomainValidationError = class _DomainValidationError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.type = _DomainValidationError;
+  }
+};
+
+// packages/auth/domain/src/lib/feature-create-token/token.factory.ts
+var TokenFactory = class {
+  constructor(config, repository, jwtService, fbService, googleService) {
+    this.config = config;
+    this.repository = repository;
+    this.jwtService = jwtService;
+    this.fbService = fbService;
+    this.googleService = googleService;
+    this._invalidUsernameOrPasswordMessage = "Invalid username or password";
+  }
+  static getQuery(config, customProvider = false) {
+    switch (config.grant_type) {
+      case "fb":
+        return { facebookUserId: config.fb_user_id };
+      case "google":
+        return { googleUserId: config.google_user_id };
+      case "password":
+        return { username: config.username };
+      case "refresh_token":
+        return { authRefreshToken: config.refresh_token };
+      default:
+        if (!customProvider) {
+          throw new DomainValidationError("Invalid grand type");
+        }
+        return null;
+    }
+  }
+  static checkDisabled(user) {
+    if (user.disabled)
+      throw new DomainValidationError("user disabled");
+  }
+  async create(options) {
+    if (options.request.grant_type === "fb") {
+      options.request.fb_user_id = await this.fbService.getUserId(
+        options.request.fb_token
+      );
+    }
+    if (options.request.grant_type === "google") {
+      options.request.google_user_id = await this.googleService.getUserId(
+        options.request.google_token
+      );
+    }
+    this.valid(options.request);
+    const query = TokenFactory.getQuery(
+      options.request,
+      !!options.userProvider
+    );
+    const user = options.userProvider ? await options.userProvider.get(query, options.request, options.httpReq) : await this.repository.findOne(query);
+    if (!options.validationProvider || !options.validationProvider.replace) {
+      this.checkUser(options.request, user);
+      TokenFactory.checkDisabled(user);
+      await this.checkPassword(options.request, user);
+    }
+    if (options.validationProvider) {
+      await options.validationProvider.check({
+        request: options.request,
+        user
+      });
+    }
+    const refreshToken = Guid2.raw();
+    await this.repository.update(
+      {
+        ...query,
+        disabled: { $ne: true }
+      },
+      {
+        lastLoginDate: /* @__PURE__ */ new Date(),
+        authRefreshToken: refreshToken
+      }
+    );
+    const payload = {
+      permissions: user.permissions,
+      scope: options.request.scope
+    };
+    if (options.payloadProvider) {
+      await options.payloadProvider.change(payload, {
+        user,
+        request: options.request,
+        httpReq: options.httpReq
+      });
+    }
+    return {
+      expired_in: this.config.expiredIn,
+      token_type: "bearer",
+      access_token: this.jwtService.sign(payload, {
+        expiresIn: this.config.expiredIn,
+        subject: user.username
+      }),
+      refresh_token: refreshToken,
+      username: user.username
+    };
+  }
+  checkUser(config, user) {
+    if (!user)
+      throw new DomainValidationError(
+        config.grant_type === "password" ? this._invalidUsernameOrPasswordMessage : "Invalid token"
+      );
+  }
+  async checkPassword(config, user) {
+    if (config.grant_type === "password" && !await PasswordService.compare(config.password, user.password))
+      throw new DomainValidationError(this._invalidUsernameOrPasswordMessage);
+  }
+  valid(req) {
+    if (!req)
+      throw new DomainValidationError("config is empty");
+    if (!req.grant_type)
+      throw new DomainValidationError("grant_type is empty");
+    if (req.grant_type === "password") {
+      if (!req.username)
+        throw new DomainValidationError("username is empty");
+      if (!req.password)
+        throw new DomainValidationError("password is empty");
+      if (!req.client_id)
+        throw new DomainValidationError("client_id is empty");
+      if (!this.config.clients.some((c) => c === req.client_id))
+        throw new DomainValidationError("client_id is incorrect");
+    } else if (req.grant_type === "refresh_token") {
+      if (!req.refresh_token)
+        throw new DomainValidationError("refresh_token is empty");
+    } else if (req.grant_type === "fb") {
+      if (!req.fb_token)
+        throw new DomainValidationError("fb_token is empty");
+      if (!req.fb_user_id)
+        throw new DomainValidationError("fb_user_id is empty");
+    } else if (req.grant_type === "google") {
+      if (!req.google_token)
+        throw new DomainValidationError("google_token is empty");
+      if (!req.google_user_id)
+        throw new DomainValidationError("google_user_id is empty");
+    }
+  }
+};
+TokenFactory = __decorateClass([
+  Injectable(),
+  __decorateParam(1, InjectRepository(User))
+], TokenFactory);
+
+// packages/auth/domain/src/lib/feature-create-token/token.config.ts
+import { Injectable as Injectable2 } from "@nestjs/common";
+var TokenConfig = class {
+  constructor() {
+    this.clients = [];
+  }
+};
+TokenConfig = __decorateClass([
+  Injectable2()
+], TokenConfig);
+
+// packages/auth/domain/src/lib/feature-create-token/token-payload.provider.ts
+var AUTH_TOKEN_PAYLOAD_PROVIDER = "AUTH_TOKEN_PAYLOAD_PROVIDER";
+
+// packages/auth/domain/src/lib/feature-create-token/token-validation.provider.ts
+var AUTH_TOKEN_VALIDATION_PROVIDER = "AUTH_TOKEN_VALIDATION_PROVIDER";
+
+// packages/auth/domain/src/lib/feature-create-token/token-user.provider.ts
+var AUTH_TOKEN_USER_PROVIDER = "AUTH_TOKEN_USER_PROVIDER";
+
+// packages/auth/domain/src/index.ts
+var DOMAIN_SERVICES = [TokenFactory];
+var ENTITIES = [User];
+
+// packages/auth/shell/app-services/src/lib/services/auth/auth.service.ts
+import { Injectable as Injectable3, Logger } from "@nestjs/common";
+var AuthService = class {
+  constructor(factory, moduleRef) {
+    this.factory = factory;
+    this.moduleRef = moduleRef;
+  }
+  create(req, httpReq) {
+    return this.factory.create({
+      httpReq,
+      request: req,
+      payloadProvider: this.getPayloadProvider(),
+      validationProvider: this.getValidationProvider(),
+      userProvider: this.getUserProvider()
+    });
+  }
+  getPayloadProvider() {
+    try {
+      return this.moduleRef.get(AUTH_TOKEN_PAYLOAD_PROVIDER, {
+        strict: false
+      });
+    } catch (e) {
+      Logger.debug(e.message, AuthService.name);
+    }
+    return null;
+  }
+  getValidationProvider() {
+    try {
+      return this.moduleRef.get(AUTH_TOKEN_VALIDATION_PROVIDER, {
+        strict: false
+      });
+    } catch (e) {
+      Logger.debug(e.message, AuthService.name);
+    }
+    return null;
+  }
+  getUserProvider() {
+    try {
+      return this.moduleRef.get(AUTH_TOKEN_USER_PROVIDER, {
+        strict: false
+      });
+    } catch (e) {
+      Logger.debug(e.message, AuthService.name);
+    }
+    return null;
+  }
+};
+AuthService = __decorateClass([
+  Injectable3()
+], AuthService);
+
+// packages/shared/fb/src/lib/fb.service.ts
+import { Injectable as Injectable4 } from "@nestjs/common";
+var FbService = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getUserId(token) {
+    const { data } = await this.http.get("https://graph.facebook.com/me?access_token=" + token).toPromise();
+    return data.id;
+  }
+  async getData(token) {
+    const { data } = await this.http.get(
+      "https://graph.facebook.com/me?fields=email,id&access_token=" + token
+    ).toPromise();
+    return data;
+  }
+};
+FbService = __decorateClass([
+  Injectable4()
+], FbService);
+
+// packages/shared/google/src/lib/google.service.ts
+import { Injectable as Injectable5 } from "@nestjs/common";
+var GoogleService = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async getUserId(token) {
+    const { data } = await this.http.get(
+      "https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=" + token
+    ).toPromise();
+    return data.user_id;
+  }
+  async getData(token) {
+    const { data } = await this.http.get(
+      "https://www.googleapis.com/oauth2/v1/tokeninfo?access_token=" + token
+    ).toPromise();
+    return {
+      id: data.user_id,
+      email: data.email
+    };
+  }
+};
+GoogleService = __decorateClass([
+  Injectable5()
+], GoogleService);
+
+// packages/auth/shell/nestjs/src/lib/nestjs.module.ts
+var AuthShellNestjsModule = class {
+  static forRoot(options) {
+    return {
+      module: AuthShellNestjsModule,
+      controllers: [TokenController],
+      providers: [
+        { provide: TokenConfig, useValue: options.tokenConfig },
+        AuthService,
+        FbService,
+        GoogleService,
+        ...DOMAIN_SERVICES
+      ],
+      imports: [
+        HttpModule,
+        TypeOrmModule.forFeature(ENTITIES),
+        PassportModule.register({ defaultStrategy: "jwt", session: false }),
+        JwtModule.register({
+          secret: options.tokenConfig.secretOrPrivateKey,
+          signOptions: {
+            expiresIn: options.tokenConfig.expiredIn
+          }
+        })
+      ],
+      exports: [FbService, GoogleService]
+    };
+  }
+};
+AuthShellNestjsModule = __decorateClass([
+  Module({})
+], AuthShellNestjsModule);
+var AuthShellNestjsCoreModule = class {
+  static forRoot(options) {
+    return {
+      module: AuthShellNestjsModule,
+      providers: [
+        { provide: TokenConfig, useValue: options.tokenConfig },
+        AuthService,
+        ...DOMAIN_SERVICES
+      ],
+      exports: [
+        AuthService,
+        ...DOMAIN_SERVICES,
+        { provide: TokenConfig, useValue: options.tokenConfig }
+      ],
+      imports: [
+        TypeOrmModule.forFeature(ENTITIES),
+        PassportModule.register({ defaultStrategy: "jwt", session: false }),
+        JwtModule.register({
+          secret: options.tokenConfig.secretOrPrivateKey,
+          signOptions: {
+            expiresIn: options.tokenConfig.expiredIn
+          }
+        })
+      ]
+    };
+  }
+};
+AuthShellNestjsCoreModule = __decorateClass([
+  Module({})
+], AuthShellNestjsCoreModule);
+export {
+  AuthShellNestjsCoreModule,
+  AuthShellNestjsModule,
+  TokenController
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartsoft001/auth-shell-nestjs",
-  "version": "2.76.0",
+  "version": "2.81.0",
   "description": "Utils for authorization",
   "repository": {
     "type": "git",

package/src/lib/controllers/token/token.controller.d.ts

@@ -0,0 +1,8 @@
+import { Request } from 'express';
+import { IAuthToken, IAuthTokenRequest } from '@smartsoft001/auth-domain';
+import { AuthService } from '@smartsoft001/auth-shell-app-services';
+export declare class TokenController {
+    private readonly service;
+    constructor(service: AuthService);
+    create(req: IAuthTokenRequest, httpReq: Request): Promise<IAuthToken>;
+}

package/src/lib/nestjs.module.d.ts

@@ -0,0 +1,12 @@
+import { DynamicModule } from '@nestjs/common';
+import { TokenConfig } from '@smartsoft001/auth-domain';
+export declare class AuthShellNestjsModule {
+    static forRoot(options: {
+        tokenConfig: TokenConfig;
+    }): DynamicModule;
+}
+export declare class AuthShellNestjsCoreModule {
+    static forRoot(options: {
+        tokenConfig: TokenConfig;
+    }): DynamicModule;
+}

package/.eslintrc.json

@@ -1,26 +0,0 @@
-{
-  "extends": ["../../../../.eslintrc.json"],
-  "ignorePatterns": ["!**/*"],
-  "rules": {
-    "import/order": "off"
-  },
-  "overrides": [
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.ts", "*.tsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": "package.json",
-      "parser": "jsonc-eslint-parser",
-      "rules": {}
-    }
-  ]
-}

package/jest.config.ts

@@ -1,26 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: 'auth-shell-nestjs',
-  preset: '../../../../jest.preset.js',
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]sx?$': [
-      'ts-jest',
-      {
-        tsConfig: '<rootDir>/tsconfig.spec.json',
-      },
-    ],
-  },
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
-  coverageDirectory: '../../../../coverage/packages/auth/shell/nestjs',
-  /* TODO: Update to latest Jest snapshotFormat
-   * By default Nx has kept the older style of Jest Snapshot formats
-   * to prevent breaking of any existing tests with snapshots.
-   * It's recommend you update to the latest format.
-   * You can do this by removing snapshotFormat property
-   * and running tests with --update-snapshot flag.
-   * Example: From within the project directory, run "nx test --update-snapshot"
-   * More info: https://jestjs.io/docs/upgrading-to-jest29#snapshot-format
-   */
-  snapshotFormat: { escapeString: true, printBasicPrototype: true },
-};

package/project.json

@@ -1,37 +0,0 @@
-{
-  "name": "auth-shell-nestjs",
-  "$schema": "../../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/auth/shell/nestjs/src",
-  "projectType": "library",
-  "tags": ["scope:auth", "type:shell"],
-  "targets": {
-    "lint": {
-      "executor": "@nx/eslint:lint",
-      "outputs": ["{options.outputFile}"],
-      "options": {
-        "lintFilePatterns": [
-          "packages/auth/shell/nestjs/**/*.{ts,tsx,js,jsx}",
-          "packages/auth/shell/nestjs/package.json"
-        ]
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/packages/auth/shell/nestjs"],
-      "options": {
-        "jestConfig": "packages/auth/shell/nestjs/jest.config.ts"
-      }
-    },
-    "build": {
-      "executor": "@nx/esbuild:esbuild",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/packages/auth/shell/nestjs",
-        "tsConfig": "packages/auth/shell/nestjs/tsconfig.lib.json",
-        "packageJson": "packages/auth/shell/nestjs/package.json",
-        "main": "packages/auth/shell/nestjs/src/index.ts",
-        "assets": ["packages/auth/shell/nestjs/*.md"]
-      }
-    }
-  }
-}

package/src/lib/controllers/token/token.controller.ts

@@ -1,18 +0,0 @@
-import { Body, Controller, Post, Req } from '@nestjs/common';
-import { Request } from 'express';
-
-import { IAuthToken, IAuthTokenRequest } from '@smartsoft001/auth-domain';
-import { AuthService } from '@smartsoft001/auth-shell-app-services';
-
-@Controller('token')
-export class TokenController {
-  constructor(private readonly service: AuthService) {}
-
-  @Post()
-  create(
-    @Body() req: IAuthTokenRequest,
-    @Req() httpReq: Request,
-  ): Promise<IAuthToken> {
-    return this.service.create(req, httpReq);
-  }
-}

package/src/lib/nestjs.module.ts

@@ -1,74 +0,0 @@
-import { HttpModule } from '@nestjs/axios';
-import { DynamicModule, Module } from '@nestjs/common';
-import { JwtModule } from '@nestjs/jwt';
-import { PassportModule } from '@nestjs/passport';
-import { TypeOrmModule } from '@nestjs/typeorm';
-
-import {
-  DOMAIN_SERVICES,
-  ENTITIES,
-  TokenConfig,
-} from '@smartsoft001/auth-domain';
-import { AuthService } from '@smartsoft001/auth-shell-app-services';
-import { FbService } from '@smartsoft001/fb';
-import { GoogleService } from '@smartsoft001/google';
-
-import { TokenController } from './controllers/token/token.controller';
-
-@Module({})
-export class AuthShellNestjsModule {
-  static forRoot(options: { tokenConfig: TokenConfig }): DynamicModule {
-    return {
-      module: AuthShellNestjsModule,
-      controllers: [TokenController],
-      providers: [
-        { provide: TokenConfig, useValue: options.tokenConfig },
-        AuthService,
-        FbService,
-        GoogleService,
-        ...DOMAIN_SERVICES,
-      ],
-      imports: [
-        HttpModule,
-        TypeOrmModule.forFeature(ENTITIES),
-        PassportModule.register({ defaultStrategy: 'jwt', session: false }),
-        JwtModule.register({
-          secret: options.tokenConfig.secretOrPrivateKey,
-          signOptions: {
-            expiresIn: options.tokenConfig.expiredIn,
-          },
-        }),
-      ],
-      exports: [FbService, GoogleService],
-    };
-  }
-}
-
-@Module({})
-export class AuthShellNestjsCoreModule {
-  static forRoot(options: { tokenConfig: TokenConfig }): DynamicModule {
-    return {
-      module: AuthShellNestjsModule,
-      providers: [
-        { provide: TokenConfig, useValue: options.tokenConfig },
-        AuthService,
-        ...DOMAIN_SERVICES,
-      ],
-      exports: [
-        AuthService,
-        ...DOMAIN_SERVICES,
-        { provide: TokenConfig, useValue: options.tokenConfig },
-      ],
-      imports: [
-        TypeOrmModule.forFeature(ENTITIES),
-        PassportModule.register({ defaultStrategy: 'jwt', session: false }),
-        JwtModule.register({
-          secret: options.tokenConfig.secretOrPrivateKey,
-          signOptions: {
-            expiresIn: options.tokenConfig.expiredIn,
-          },
-        }),
-      ],
-    };
-  }
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../../../tsconfig.base.json",
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "outDir": "../../../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "exclude": ["**/*.spec.ts", "**/*.test.ts", "jest.config.ts"],
-  "include": ["**/*.ts"]
-}

package/tsconfig.spec.json

@@ -1,20 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../../../dist/out-tsc",
-    "module": "commonjs",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "**/*.spec.ts",
-    "**/*.test.ts",
-    "**/*.spec.tsx",
-    "**/*.test.tsx",
-    "**/*.spec.js",
-    "**/*.test.js",
-    "**/*.spec.jsx",
-    "**/*.test.jsx",
-    "**/*.d.ts",
-    "jest.config.ts"
-  ]
-}