@smartsoft001/auth-domain 2.75.0 → 2.80.0

package/index.js

@@ -0,0 +1,282 @@
+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/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";
+var ITokenPayloadProvider = class {
+};
+
+// packages/auth/domain/src/lib/feature-create-token/token-validation.provider.ts
+var AUTH_TOKEN_VALIDATION_PROVIDER = "AUTH_TOKEN_VALIDATION_PROVIDER";
+var ITokenValidationProvider = class {
+};
+
+// packages/auth/domain/src/lib/feature-create-token/token-user.provider.ts
+var AUTH_TOKEN_USER_PROVIDER = "AUTH_TOKEN_USER_PROVIDER";
+var ITokenUserProvider = class {
+};
+
+// packages/auth/domain/src/index.ts
+var DOMAIN_SERVICES = [TokenFactory];
+var ENTITIES = [User];
+export {
+  AUTH_TOKEN_PAYLOAD_PROVIDER,
+  AUTH_TOKEN_USER_PROVIDER,
+  AUTH_TOKEN_VALIDATION_PROVIDER,
+  DOMAIN_SERVICES,
+  ENTITIES,
+  ITokenPayloadProvider,
+  ITokenUserProvider,
+  ITokenValidationProvider,
+  TokenConfig,
+  TokenFactory,
+  User
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartsoft001/auth-domain",
-  "version": "2.75.0",
+  "version": "2.80.0",
   "description": "Utils for authorization",
   "repository": {
     "type": "git",

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

@@ -1,9 +1,6 @@
 import { User } from './lib/entities/user.entity';
 import { TokenFactory } from './lib/feature-create-token/token.factory';
-
 export * from './lib/entities';
 export * from './lib/feature-create-token';
-
-export const DOMAIN_SERVICES = [TokenFactory];
-
-export const ENTITIES = [User];
+export declare const DOMAIN_SERVICES: (typeof TokenFactory)[];
+export declare const ENTITIES: (typeof User)[];

package/src/lib/entities/user.entity.d.ts

@@ -0,0 +1,13 @@
+import { IEntity } from '@smartsoft001/domain-core';
+import { IUser, IUserCredentials } from '@smartsoft001/users';
+export declare class User implements IEntity<string>, IUser, IUserCredentials {
+    id: string;
+    permissions: Array<string>;
+    username: string;
+    password: string;
+    disabled: boolean;
+    lastLoginDate: Date;
+    authRefreshToken: string;
+    facebookUserId?: string;
+    googleUserId?: string;
+}

package/src/lib/feature-create-token/interfaces.d.ts

@@ -0,0 +1,39 @@
+import { IUserCredentials } from '@smartsoft001/users';
+export type IAuthTokenRequest = IAuthTokenRequestPassword | IAuthTokenRequestRefreshToken | IAuthTokenRequestCustom | IAuthTokenRequestFb | IAuthTokenRequestGoogle;
+export interface IAuthTokenRequestFb extends IUserCredentials {
+    grant_type: 'fb';
+    fb_token: string;
+    fb_user_id?: string;
+    scope?: string;
+    client_id: string;
+}
+export interface IAuthTokenRequestGoogle extends IUserCredentials {
+    grant_type: 'google';
+    google_token: string;
+    google_user_id?: string;
+    scope?: string;
+    client_id: string;
+}
+export interface IAuthTokenRequestPassword extends IUserCredentials {
+    grant_type: 'password';
+    username: string;
+    password: string;
+    scope?: string;
+    client_id: string;
+}
+export interface IAuthTokenRequestRefreshToken {
+    grant_type: 'refresh_token';
+    refresh_token: string;
+    scope?: string;
+}
+export interface IAuthToken {
+    access_token: string;
+    refresh_token: string;
+    expired_in: number;
+    token_type: 'bearer';
+    username?: string;
+}
+export interface IAuthTokenRequestCustom {
+    grant_type: string;
+    [key: string]: string;
+}

package/src/lib/feature-create-token/token-payload.provider.d.ts

@@ -0,0 +1,11 @@
+import { Request } from 'express';
+import { IAuthTokenRequest } from './interfaces';
+import { User } from '../entities/user.entity';
+export declare const AUTH_TOKEN_PAYLOAD_PROVIDER = "AUTH_TOKEN_PAYLOAD_PROVIDER";
+export declare abstract class ITokenPayloadProvider {
+    abstract change(basePayload: any, data: {
+        request?: IAuthTokenRequest;
+        user?: User;
+        httpReq?: Request;
+    }): Promise<void>;
+}

package/src/lib/feature-create-token/token-user.provider.d.ts

@@ -0,0 +1,7 @@
+import { Request } from 'express';
+import { IAuthTokenRequest } from './interfaces';
+import { User } from '../entities/user.entity';
+export declare const AUTH_TOKEN_USER_PROVIDER = "AUTH_TOKEN_USER_PROVIDER";
+export declare abstract class ITokenUserProvider {
+    abstract get(baseQuery: Partial<User>, request: IAuthTokenRequest, httpReq?: Request): Promise<User>;
+}

package/src/lib/feature-create-token/token-validation.provider.d.ts

@@ -0,0 +1,10 @@
+import { IAuthTokenRequest } from './interfaces';
+import { User } from '../entities';
+export declare const AUTH_TOKEN_VALIDATION_PROVIDER = "AUTH_TOKEN_VALIDATION_PROVIDER";
+export declare abstract class ITokenValidationProvider {
+    abstract replace?: boolean;
+    abstract check(data: {
+        request?: IAuthTokenRequest;
+        user?: User;
+    }): Promise<void>;
+}

package/src/lib/feature-create-token/token.config.d.ts

@@ -0,0 +1,5 @@
+export declare class TokenConfig {
+    expiredIn: number;
+    clients: Array<string>;
+    secretOrPrivateKey: string;
+}

package/src/lib/feature-create-token/token.factory.d.ts

@@ -0,0 +1,39 @@
+import { JwtService } from '@nestjs/jwt';
+import { Request } from 'express';
+import { Repository } from 'typeorm';
+import { IFactory } from '@smartsoft001/domain-core';
+import { FbService } from '@smartsoft001/fb';
+import { GoogleService } from '@smartsoft001/google';
+import { User } from '../entities';
+import { IAuthToken, IAuthTokenRequest } from './interfaces';
+import { ITokenPayloadProvider } from './token-payload.provider';
+import { ITokenUserProvider } from './token-user.provider';
+import { ITokenValidationProvider } from './token-validation.provider';
+import { TokenConfig } from './token.config';
+export declare class TokenFactory implements IFactory<IAuthToken, {
+    httpReq?: Request;
+    request: IAuthTokenRequest;
+    payloadProvider?: ITokenPayloadProvider;
+    validationProvider?: ITokenValidationProvider;
+    userProvider?: ITokenUserProvider;
+}> {
+    private config;
+    private repository;
+    private jwtService;
+    private fbService;
+    private googleService;
+    private _invalidUsernameOrPasswordMessage;
+    constructor(config: TokenConfig, repository: Repository<User>, jwtService: JwtService, fbService: FbService, googleService: GoogleService);
+    static getQuery(config: IAuthTokenRequest, customProvider?: boolean): Partial<User>;
+    static checkDisabled(user: User): void;
+    create(options: {
+        httpReq?: Request;
+        request: IAuthTokenRequest;
+        payloadProvider?: ITokenPayloadProvider;
+        validationProvider?: ITokenValidationProvider;
+        userProvider?: ITokenUserProvider;
+    }): Promise<IAuthToken>;
+    private checkUser;
+    private checkPassword;
+    private valid;
+}

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

package/src/lib/entities/user.entity.ts

@@ -1,34 +0,0 @@
-import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
-
-import { IEntity } from '@smartsoft001/domain-core';
-import { IUser, IUserCredentials } from '@smartsoft001/users';
-
-@Entity('users')
-export class User implements IEntity<string>, IUser, IUserCredentials {
-  @PrimaryGeneratedColumn()
-  id: string;
-
-  @Column('permissions')
-  permissions: Array<string>;
-
-  @Column('username')
-  username: string;
-
-  @Column('password')
-  password: string;
-
-  @Column('disabled')
-  disabled: boolean;
-
-  @Column('lastLoginDate')
-  lastLoginDate: Date;
-
-  @Column('authRefreshToken')
-  authRefreshToken: string;
-
-  @Column('facebookUserId')
-  facebookUserId?: string;
-
-  @Column('googleUserId')
-  googleUserId?: string;
-}

package/src/lib/feature-create-token/interfaces.ts

@@ -1,51 +0,0 @@
-import { IUserCredentials } from '@smartsoft001/users';
-
-export type IAuthTokenRequest =
-  | IAuthTokenRequestPassword
-  | IAuthTokenRequestRefreshToken
-  | IAuthTokenRequestCustom
-  | IAuthTokenRequestFb
-  | IAuthTokenRequestGoogle;
-
-export interface IAuthTokenRequestFb extends IUserCredentials {
-  grant_type: 'fb';
-  fb_token: string;
-  fb_user_id?: string;
-  scope?: string;
-  client_id: string;
-}
-
-export interface IAuthTokenRequestGoogle extends IUserCredentials {
-  grant_type: 'google';
-  google_token: string;
-  google_user_id?: string;
-  scope?: string;
-  client_id: string;
-}
-
-export interface IAuthTokenRequestPassword extends IUserCredentials {
-  grant_type: 'password';
-  username: string;
-  password: string;
-  scope?: string;
-  client_id: string;
-}
-
-export interface IAuthTokenRequestRefreshToken {
-  grant_type: 'refresh_token';
-  refresh_token: string;
-  scope?: string;
-}
-
-export interface IAuthToken {
-  access_token: string;
-  refresh_token: string;
-  expired_in: number;
-  token_type: 'bearer';
-  username?: string;
-}
-
-export interface IAuthTokenRequestCustom {
-  grant_type: string;
-  [key: string]: string;
-}

package/src/lib/feature-create-token/token-payload.provider.ts

@@ -1,17 +0,0 @@
-import { Request } from 'express';
-
-import { IAuthTokenRequest } from './interfaces';
-import { User } from '../entities/user.entity';
-
-export const AUTH_TOKEN_PAYLOAD_PROVIDER = 'AUTH_TOKEN_PAYLOAD_PROVIDER';
-
-export abstract class ITokenPayloadProvider {
-  abstract change(
-    basePayload,
-    data: {
-      request?: IAuthTokenRequest;
-      user?: User;
-      httpReq?: Request;
-    },
-  ): Promise<void>;
-}

package/src/lib/feature-create-token/token-user.provider.ts

@@ -1,14 +0,0 @@
-import { Request } from 'express';
-
-import { IAuthTokenRequest } from './interfaces';
-import { User } from '../entities/user.entity';
-
-export const AUTH_TOKEN_USER_PROVIDER = 'AUTH_TOKEN_USER_PROVIDER';
-
-export abstract class ITokenUserProvider {
-  abstract get(
-    baseQuery: Partial<User>,
-    request: IAuthTokenRequest,
-    httpReq?: Request,
-  ): Promise<User>;
-}

package/src/lib/feature-create-token/token-validation.provider.ts

@@ -1,13 +0,0 @@
-import { IAuthTokenRequest } from './interfaces';
-import { User } from '../entities';
-
-export const AUTH_TOKEN_VALIDATION_PROVIDER = 'AUTH_TOKEN_VALIDATION_PROVIDER';
-
-export abstract class ITokenValidationProvider {
-  abstract replace?: boolean;
-
-  abstract check(data: {
-    request?: IAuthTokenRequest;
-    user?: User;
-  }): Promise<void>;
-}

package/src/lib/feature-create-token/token.config.ts

@@ -1,8 +0,0 @@
-import { Injectable } from '@nestjs/common';
-
-@Injectable()
-export class TokenConfig {
-  expiredIn: number;
-  clients: Array<string> = [];
-  secretOrPrivateKey: string;
-}

package/src/lib/feature-create-token/token.factory.spec.ts

@@ -1,194 +0,0 @@
-import { JwtService } from '@nestjs/jwt';
-import { Test } from '@nestjs/testing';
-import { getRepositoryToken } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-
-import { DomainValidationError } from '@smartsoft001/domain-core';
-import { FbService } from '@smartsoft001/fb';
-import { GoogleService } from '@smartsoft001/google';
-import { PasswordService } from '@smartsoft001/utils';
-
-import { User } from '../entities';
-import { TokenConfig } from './token.config';
-import { TokenFactory } from './token.factory';
-
-describe('auth-domain: TokenFactory', () => {
-  let tokenFactory: TokenFactory;
-  let repository: Repository<User>;
-  let jwtService: JwtService;
-  let fbService: FbService;
-  let googleService: GoogleService;
-
-  beforeEach(async () => {
-    const module = await Test.createTestingModule({
-      providers: [
-        TokenFactory,
-        {
-          provide: TokenConfig,
-          useValue: {
-            expiredIn: 3600,
-            clients: ['test-client'],
-          },
-        },
-        {
-          provide: getRepositoryToken(User),
-          useValue: {
-            findOne: jest.fn(),
-            update: jest.fn(),
-          },
-        },
-        {
-          provide: JwtService,
-          useValue: {
-            sign: jest.fn(),
-          },
-        },
-        {
-          provide: FbService,
-          useValue: {
-            getUserId: jest.fn(),
-          },
-        },
-        {
-          provide: GoogleService,
-          useValue: {
-            getUserId: jest.fn(),
-          },
-        },
-      ],
-    }).compile();
-
-    tokenFactory = module.get<TokenFactory>(TokenFactory);
-    repository = module.get<Repository<User>>(getRepositoryToken(User));
-    jwtService = module.get<JwtService>(JwtService);
-    fbService = module.get<FbService>(FbService);
-    googleService = module.get<GoogleService>(GoogleService);
-  });
-
-  describe('getQuery', () => {
-    it('should return query for password grant type', () => {
-      const query = TokenFactory.getQuery({
-        grant_type: 'password',
-        username: 'test',
-      });
-      expect(query).toEqual({ username: 'test' });
-    });
-
-    it('should return query for refresh_token grant type', () => {
-      const query = TokenFactory.getQuery({
-        grant_type: 'refresh_token',
-        refresh_token: 'token',
-      });
-      expect(query).toEqual({ authRefreshToken: 'token' });
-    });
-
-    it('should return query for fb grant type', () => {
-      const query = TokenFactory.getQuery({
-        grant_type: 'fb',
-        fb_user_id: 'fb123',
-      });
-      expect(query).toEqual({ facebookUserId: 'fb123' });
-    });
-
-    it('should return query for google grant type', () => {
-      const query = TokenFactory.getQuery({
-        grant_type: 'google',
-        google_user_id: 'g123',
-      });
-      expect(query).toEqual({ googleUserId: 'g123' });
-    });
-
-    it('should throw error for invalid grant type', () => {
-      expect(() => TokenFactory.getQuery({ grant_type: 'invalid' })).toThrow(
-        DomainValidationError,
-      );
-    });
-  });
-
-  describe('checkDisabled', () => {
-    it('should throw error when user is disabled', () => {
-      const user = { disabled: true } as User;
-      expect(() => TokenFactory.checkDisabled(user)).toThrow(
-        DomainValidationError,
-      );
-    });
-  });
-
-  describe('create', () => {
-    beforeEach(() => {
-      jest.spyOn(PasswordService, 'compare').mockResolvedValue(true);
-    });
-
-    it('should create token for valid password credentials', async () => {
-      const user = { username: 'test', permissions: ['read'] };
-      (repository.findOne as jest.Mock).mockResolvedValue(user);
-      (jwtService.sign as jest.Mock).mockReturnValue('signed-token');
-
-      const result = await tokenFactory.create({
-        request: {
-          grant_type: 'password',
-          username: 'test',
-          password: 'test',
-          client_id: 'test-client',
-        },
-      });
-
-      expect(result.token_type).toBe('bearer');
-    });
-
-    it('should create token for valid fb credentials', async () => {
-      const user = { username: 'fb-user', permissions: ['read'] };
-      (fbService.getUserId as jest.Mock).mockResolvedValue('fb123');
-      (repository.findOne as jest.Mock).mockResolvedValue(user);
-      (jwtService.sign as jest.Mock).mockReturnValue('signed-token');
-
-      const result = await tokenFactory.create({
-        request: {
-          grant_type: 'fb',
-          fb_token: 'token',
-        },
-      });
-
-      expect(result.token_type).toBe('bearer');
-    });
-
-    it('should create token for valid google credentials', async () => {
-      const user = { username: 'google-user', permissions: ['read'] };
-      (googleService.getUserId as jest.Mock).mockResolvedValue('g123');
-      (repository.findOne as jest.Mock).mockResolvedValue(user);
-      (jwtService.sign as jest.Mock).mockReturnValue('signed-token');
-
-      const result = await tokenFactory.create({
-        request: {
-          grant_type: 'google',
-          google_token: 'token',
-        },
-      });
-
-      expect(result.token_type).toBe('bearer');
-    });
-
-    it('should throw error for invalid request', async () => {
-      await expect(
-        tokenFactory.create({
-          request: {} as any,
-        }),
-      ).rejects.toThrow(DomainValidationError);
-    });
-
-    it('should throw error when user is not found', async () => {
-      (repository.findOne as jest.Mock).mockResolvedValue(null);
-
-      await expect(
-        tokenFactory.create({
-          request: {
-            grant_type: 'password',
-            username: 'test',
-            password: 'test',
-            client_id: 'test-client',
-          },
-        }),
-      ).rejects.toThrow(DomainValidationError);
-    });
-  });
-});

package/src/lib/feature-create-token/token.factory.ts

@@ -1,200 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { JwtService } from '@nestjs/jwt';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Request } from 'express';
-import { Guid } from 'guid-typescript';
-import { Repository } from 'typeorm';
-
-import { DomainValidationError, IFactory } from '@smartsoft001/domain-core';
-import { FbService } from '@smartsoft001/fb';
-import { GoogleService } from '@smartsoft001/google';
-import { PasswordService } from '@smartsoft001/utils';
-
-import { User } from '../entities';
-import { IAuthToken, IAuthTokenRequest } from './interfaces';
-import { ITokenPayloadProvider } from './token-payload.provider';
-import { ITokenUserProvider } from './token-user.provider';
-import { ITokenValidationProvider } from './token-validation.provider';
-import { TokenConfig } from './token.config';
-
-@Injectable()
-export class TokenFactory
-  implements
-    IFactory<
-      IAuthToken,
-      {
-        httpReq?: Request;
-        request: IAuthTokenRequest;
-        payloadProvider?: ITokenPayloadProvider;
-        validationProvider?: ITokenValidationProvider;
-        userProvider?: ITokenUserProvider;
-      }
-    >
-{
-  private _invalidUsernameOrPasswordMessage = 'Invalid username or password';
-
-  constructor(
-    private config: TokenConfig,
-    @InjectRepository(User) private repository: Repository<User>,
-    private jwtService: JwtService,
-    private fbService: FbService,
-    private googleService: GoogleService,
-  ) {}
-
-  static getQuery(
-    config: IAuthTokenRequest,
-    customProvider = false,
-  ): Partial<User> {
-    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: User) {
-    if (user.disabled) throw new DomainValidationError('user disabled');
-  }
-
-  async create(options: {
-    httpReq?: Request;
-    request: IAuthTokenRequest;
-    payloadProvider?: ITokenPayloadProvider;
-    validationProvider?: ITokenValidationProvider;
-    userProvider?: ITokenUserProvider;
-  }): Promise<IAuthToken> {
-    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 as any);
-
-    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 = Guid.raw();
-    await this.repository.update(
-      {
-        ...query,
-        disabled: { $ne: true },
-      } as any,
-      {
-        lastLoginDate: 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,
-    };
-  }
-
-  private checkUser(config: IAuthTokenRequest, user: User): void {
-    if (!user)
-      throw new DomainValidationError(
-        config.grant_type === 'password'
-          ? this._invalidUsernameOrPasswordMessage
-          : 'Invalid token',
-      );
-  }
-
-  private async checkPassword(
-    config: IAuthTokenRequest,
-    user: User,
-  ): Promise<void> {
-    if (
-      config.grant_type === 'password' &&
-      !(await PasswordService.compare(config.password, user.password))
-    )
-      throw new DomainValidationError(this._invalidUsernameOrPasswordMessage);
-  }
-
-  private valid(req: NonNullable<IAuthTokenRequest>): void {
-    if (!req) throw new DomainValidationError('config is empty');
-    if (!req.grant_type) throw new DomainValidationError('grant_type is empty');
-
-    // password
-    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');
-
-      // refres token
-    } else if (req.grant_type === 'refresh_token') {
-      if (!req.refresh_token)
-        throw new DomainValidationError('refresh_token is empty');
-
-      // fb token
-    } 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');
-    }
-  }
-}

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,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "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"
-  ]
-}