@smartsoft001/auth-domain 1.1.91 → 2.68.0

package/.eslintrc.json

@@ -0,0 +1,26 @@
+{
+  "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/README.md

@@ -1,6 +1,165 @@
-# auth-domain
+# @smartsoft001/auth-domain
 
-This library was generated with [Nx](https://nx.dev).
+## Installation
+
+`npm i @smartsoft001/auth-domain`
+
+## Token Factory
+
+### create
+Creates a new authentication token based on the provided credentials and grant type.
+
+<table>
+    <thead>
+        <tr>
+            <td>Param</td>
+            <td>Description</td>
+        </tr>
+    </thead>
+    <tr>
+        <td>options.request: IAuthTokenRequest</td>
+        <td>The authentication request containing credentials and grant type.</td>
+    </tr>
+    <tr>
+        <td>options.httpReq?: Request</td>
+        <td>Optional HTTP request object for context.</td>
+    </tr>
+    <tr>
+        <td>options.payloadProvider?: ITokenPayloadProvider</td>
+        <td>Optional provider for customizing JWT payload.</td>
+    </tr>
+    <tr>
+        <td>options.validationProvider?: ITokenValidationProvider</td>
+        <td>Optional provider for custom validation rules.</td>
+    </tr>
+    <tr>
+        <td>options.userProvider?: ITokenUserProvider</td>
+        <td>Optional provider for custom user retrieval.</td>
+    </tr>
+</table>
+
+## Interfaces
+
+### IAuthTokenRequest
+
+<table>
+    <thead>
+        <tr>
+            <td>Property</td>
+            <td>Description</td>
+        </tr>
+    </thead>
+    <tr>
+        <td>grant_type</td>
+        <td>"password" | "refresh_token" | "fb" | "google"</td>
+    </tr>
+    <tr>
+        <td>username?</td>
+        <td>Required for password grant type</td>
+    </tr>
+    <tr>
+        <td>password?</td>
+        <td>Required for password grant type</td>
+    </tr>
+    <tr>
+        <td>refresh_token?</td>
+        <td>Required for refresh_token grant type</td>
+    </tr>
+    <tr>
+        <td>fb_token?</td>
+        <td>Required for fb grant type</td>
+    </tr>
+    <tr>
+        <td>google_token?</td>
+        <td>Required for google grant type</td>
+    </tr>
+    <tr>
+        <td>scope?</td>
+        <td>Optional scope for the token</td>
+    </tr>
+    <tr>
+        <td>client_id?</td>
+        <td>Required for password, fb, and google grant types</td>
+    </tr>
+</table>
+
+### IAuthToken
+
+<table>
+    <thead>
+        <tr>
+            <td>Property</td>
+            <td>Description</td>
+        </tr>
+    </thead>
+    <tr>
+        <td>access_token</td>
+        <td>JWT token for authentication</td>
+    </tr>
+    <tr>
+        <td>refresh_token</td>
+        <td>Token for obtaining new access tokens</td>
+    </tr>
+    <tr>
+        <td>expired_in</td>
+        <td>Token expiration time in seconds</td>
+    </tr>
+    <tr>
+        <td>token_type</td>
+        <td>Always 'bearer'</td>
+    </tr>
+    <tr>
+        <td>username?</td>
+        <td>Optional username of authenticated user</td>
+    </tr>
+</table>
+
+## Providers
+
+### ITokenPayloadProvider
+
+<table>
+    <thead>
+        <tr>
+            <td>Method</td>
+            <td>Description</td>
+        </tr>
+    </thead>
+    <tr>
+        <td>change(basePayload, data)</td>
+        <td>Modifies the JWT payload before token creation</td>
+    </tr>
+</table>
+
+### ITokenValidationProvider
+
+<table>
+    <thead>
+        <tr>
+            <td>Method</td>
+            <td>Description</td>
+        </tr>
+    </thead>
+    <tr>
+        <td>check(data)</td>
+        <td>Performs custom validation during token creation</td>
+    </tr>
+</table>
+
+### ITokenUserProvider
+
+<table>
+    <thead>
+        <tr>
+            <td>Method</td>
+            <td>Description</td>
+        </tr>
+    </thead>
+    <tr>
+        <td>get(query, request, httpReq?)</td>
+        <td>Custom logic for user retrieval during authentication</td>
+    </tr>
+</table>
 
 ## Running unit tests
 

package/jest.config.ts

@@ -0,0 +1,26 @@
+/* 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@smartsoft001/auth-domain",
-  "version": "1.1.91",
-  "description": "Utils to authorization",
+  "version": "2.68.0",
+  "description": "Utils for authorization",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/emiljuchnikowski/smartsoft.git"
@@ -11,34 +11,5 @@
     "oauth",
     "angular",
     "nestjs"
-  ],
-  "dependencies": {
-    "@angular/common": "16.1.3",
-    "@angular/core": "16.1.3",
-    "@angular/platform-browser-dynamic": "16.1.3",
-    "@nestjs/axios": "3.0.0",
-    "@nestjs/common": "^10.0.5",
-    "@nestjs/jwt": "^10.1.0",
-    "@nestjs/typeorm": "^10.0.0",
-    "express": "4.18.2",
-    "flatted": "^3.2.4",
-    "guid-typescript": "1.0.9",
-    "lodash": "^4.17.20",
-    "md5": "2.3.0",
-    "reflect-metadata": "0.1.13",
-    "rxjs": "7.8.1",
-    "typeorm": "0.3.17"
-  },
-  "peerDependencies": {
-    "@smartsoft001/domain-core": "1.1.91",
-    "@smartsoft001/fb": "1.1.91",
-    "@smartsoft001/google": "1.1.91",
-    "@smartsoft001/models": "1.1.91",
-    "@smartsoft001/users": "1.1.91",
-    "@smartsoft001/utils": "1.1.91",
-    "util": "0.12.5",
-    "tslib": "2.5.3"
-  },
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts"
+  ]
 }

package/project.json

@@ -0,0 +1,44 @@
+{
+  "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/index.ts

@@ -0,0 +1,9 @@
+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];

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

@@ -0,0 +1,34 @@
+
+import { IEntity } from '@smartsoft001/domain-core';
+import { IUser, IUserCredentials } from '@smartsoft001/users';
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@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

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

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

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

@@ -0,0 +1,13 @@
+import { IAuthTokenRequest } from './interfaces';
+import { User } from '../entities/user.entity';
+
+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

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

@@ -0,0 +1,193 @@
+import { JwtService } from '@nestjs/jwt';
+import { Test } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { DomainValidationError } from '@smartsoft001/domain-core';
+import { FbService } from '@smartsoft001/fb';
+import { GoogleService } from '@smartsoft001/google';
+import { PasswordService } from '@smartsoft001/utils';
+import { Repository } from 'typeorm';
+
+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);
+    });
+  });
+});