@smartsoft001/auth-shell-app-services 2.76.0 → 2.80.0

package/index.js

@@ -0,0 +1,315 @@
+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/app-services/src/lib/services/auth/auth.service.ts
+import { Injectable as Injectable3, Logger } from "@nestjs/common";
+
+// 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/shell/app-services/src/lib/services/auth/auth.service.ts
+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);
+export {
+  AuthService
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartsoft001/auth-shell-app-services",
-  "version": "2.76.0",
+  "version": "2.80.0",
   "description": "Utils to authorization",
   "repository": {
     "type": "git",

package/src/lib/services/auth/auth.service.d.ts

@@ -0,0 +1,12 @@
+import { ModuleRef } from '@nestjs/core';
+import { Request } from 'express';
+import { IAuthToken, IAuthTokenRequest, TokenFactory } from '@smartsoft001/auth-domain';
+export declare class AuthService {
+    private factory;
+    private moduleRef;
+    constructor(factory: TokenFactory, moduleRef: ModuleRef);
+    create(req: IAuthTokenRequest, httpReq?: Request): Promise<IAuthToken>;
+    private getPayloadProvider;
+    private getValidationProvider;
+    private getUserProvider;
+}

package/src/lib/services/{index.ts → index.d.ts}

@@ -1,5 +1,3 @@
 import { AuthService } from './auth/auth.service';
-
 export * from './auth/auth.service';
-
-export const SERVICES = [AuthService];
+export declare const SERVICES: (typeof AuthService)[];

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-app-services',
-  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/app-services',
-  /* 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,44 +0,0 @@
-{
-  "name": "auth-shell-app-services",
-  "$schema": "../../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/auth/shell/app-services/src",
-  "projectType": "library",
-  "targets": {
-    "lint": {
-      "executor": "@nx/eslint:lint",
-      "outputs": ["{options.outputFile}"],
-      "options": {
-        "lintFilePatterns": [
-          "packages/auth/shell/app-services/**/*.{ts,tsx,js,jsx}",
-          "packages/auth/shell/app-services/package.json"
-        ]
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/packages/auth/shell/app-services"],
-      "options": {
-        "jestConfig": "packages/auth/shell/app-services/jest.config.ts"
-      }
-    },
-    "build": {
-      "executor": "@nx/esbuild:esbuild",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/packages/auth/shell/app-services",
-        "tsConfig": "packages/auth/shell/app-services/tsconfig.lib.json",
-        "packageJson": "packages/auth/shell/app-services/package.json",
-        "main": "packages/auth/shell/app-services/src/index.ts",
-        "assets": ["packages/auth/shell/app-services/*.md"]
-      }
-    },
-    "deploy": {
-      "executor": "ngx-deploy-npm:deploy",
-      "options": {
-        "access": "public",
-        "distFolderPath": "dist/packages/auth/shell/app-services"
-      },
-      "dependsOn": ["build"]
-    }
-  }
-}

package/src/lib/services/auth/auth.service.spec.ts

@@ -1,114 +0,0 @@
-import { ModuleRef } from '@nestjs/core';
-import { Test, TestingModule } from '@nestjs/testing';
-import { Request } from 'express';
-
-import {
-  AUTH_TOKEN_PAYLOAD_PROVIDER,
-  AUTH_TOKEN_USER_PROVIDER,
-  AUTH_TOKEN_VALIDATION_PROVIDER,
-  IAuthToken,
-  TokenFactory,
-} from '@smartsoft001/auth-domain';
-
-import { AuthService } from './auth.service';
-
-describe('auth-shell-app-services: AuthService', () => {
-  let service: AuthService;
-  let moduleRef: ModuleRef;
-  let tokenFactory: TokenFactory;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        AuthService,
-        {
-          provide: TokenFactory,
-          useValue: {
-            create: jest.fn(),
-          },
-        },
-        {
-          provide: ModuleRef,
-          useValue: {
-            get: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    service = module.get<AuthService>(AuthService);
-    moduleRef = module.get<ModuleRef>(ModuleRef);
-    tokenFactory = module.get<TokenFactory>(TokenFactory);
-  });
-
-  describe('create', () => {
-    it('should call TokenFactory.create with correct parameters when no providers are available', async () => {
-      const request = { grant_type: 'password' };
-      const httpReq = {} as Request;
-      const expectedToken = { token_type: 'bearer' } as IAuthToken;
-
-      (moduleRef.get as jest.Mock).mockImplementation(() => {
-        throw new Error('Not found');
-      });
-      (tokenFactory.create as jest.Mock).mockResolvedValue(expectedToken);
-
-      const result = await service.create(request, httpReq);
-
-      expect(result).toEqual(expectedToken);
-    });
-
-    it('should include payload provider when available', async () => {
-      const request = { grant_type: 'password' };
-      const payloadProvider = { change: jest.fn() };
-
-      (moduleRef.get as jest.Mock).mockImplementation((token) => {
-        if (token === AUTH_TOKEN_PAYLOAD_PROVIDER) {
-          return payloadProvider;
-        }
-        throw new Error('Not found');
-      });
-
-      await service.create(request);
-
-      expect(
-        (tokenFactory.create as jest.Mock).mock.calls[0][0].payloadProvider,
-      ).toBe(payloadProvider);
-    });
-
-    it('should include validation provider when available', async () => {
-      const request = { grant_type: 'password' };
-      const validationProvider = { check: jest.fn() };
-
-      (moduleRef.get as jest.Mock).mockImplementation((token) => {
-        if (token === AUTH_TOKEN_VALIDATION_PROVIDER) {
-          return validationProvider;
-        }
-        throw new Error('Not found');
-      });
-
-      await service.create(request);
-
-      expect(
-        (tokenFactory.create as jest.Mock).mock.calls[0][0].validationProvider,
-      ).toBe(validationProvider);
-    });
-
-    it('should include user provider when available', async () => {
-      const request = { grant_type: 'password' };
-      const userProvider = { get: jest.fn() };
-
-      (moduleRef.get as jest.Mock).mockImplementation((token) => {
-        if (token === AUTH_TOKEN_USER_PROVIDER) {
-          return userProvider;
-        }
-        throw new Error('Not found');
-      });
-
-      await service.create(request);
-
-      expect(
-        (tokenFactory.create as jest.Mock).mock.calls[0][0].userProvider,
-      ).toBe(userProvider);
-    });
-  });
-});

package/src/lib/services/auth/auth.service.ts

@@ -1,66 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
-import { Request } from 'express';
-
-import {
-  AUTH_TOKEN_PAYLOAD_PROVIDER,
-  AUTH_TOKEN_USER_PROVIDER,
-  AUTH_TOKEN_VALIDATION_PROVIDER,
-  IAuthToken,
-  IAuthTokenRequest,
-  ITokenPayloadProvider,
-  ITokenUserProvider,
-  ITokenValidationProvider,
-  TokenFactory,
-} from '@smartsoft001/auth-domain';
-
-@Injectable()
-export class AuthService {
-  constructor(
-    private factory: TokenFactory,
-    private moduleRef: ModuleRef,
-  ) {}
-
-  create(req: IAuthTokenRequest, httpReq?: Request): Promise<IAuthToken> {
-    return this.factory.create({
-      httpReq: httpReq,
-      request: req,
-      payloadProvider: this.getPayloadProvider(),
-      validationProvider: this.getValidationProvider(),
-      userProvider: this.getUserProvider(),
-    }) as Promise<IAuthToken>;
-  }
-
-  private getPayloadProvider(): ITokenPayloadProvider {
-    try {
-      return this.moduleRef.get(AUTH_TOKEN_PAYLOAD_PROVIDER, {
-        strict: false,
-      });
-    } catch (e) {
-      Logger.debug(e.message, AuthService.name);
-    }
-    return null;
-  }
-
-  private getValidationProvider(): ITokenValidationProvider {
-    try {
-      return this.moduleRef.get(AUTH_TOKEN_VALIDATION_PROVIDER, {
-        strict: false,
-      });
-    } catch (e) {
-      Logger.debug(e.message, AuthService.name);
-    }
-    return null;
-  }
-
-  private getUserProvider(): ITokenUserProvider {
-    try {
-      return this.moduleRef.get(AUTH_TOKEN_USER_PROVIDER, {
-        strict: false,
-      });
-    } catch (e) {
-      Logger.debug(e.message, AuthService.name);
-    }
-    return null;
-  }
-}

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"
-  ]
-}