3.1.0

.gitlab-ci.yml

@@ -1,140 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-    - .npmci_cache/
-  key: '$CI_BUILD_STAGE'
-
-stages:
-  - security
-  - test
-  - release
-  - metadata
-
-before_script:
-  - npm install -g @shipzone/npmci
-
-# ====================
-# security stage
-# ====================
-mirror:
-  stage: security
-  script:
-    - npmci git mirror
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-auditProductionDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --production --ignore-scripts
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=prod --production
-  tags:
-    - docker
-  allow_failure: true
-
-auditDevDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --ignore-scripts
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=dev
-  tags:
-    - docker
-  allow_failure: true
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-testBuild:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-release:
-  stage: release
-  script:
-    - npmci node install stable
-    - npmci npm publish
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  only:
-    - tags
-  script:
-    - npmci command npm install -g typescript
-    - npmci npm prepare
-    - npmci npm install
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install lts
-    - npmci command npm install -g @git.zone/tsdoc
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command tsdoc
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true

changelog.md

@@ -0,0 +1,26 @@
+# Changelog
+
+## 2024-08-25 - 3.1.0 - feat(core)
+Added Guard Handling and Removed npmci from CI
+
+- Refactored Guard and GuardSet classes for better modularization
+- Introduced GuardError for detailed error handling
+- Updated dependencies versions in package.json
+- Removed `npmci` configuration from GitLab CI
+
+## 2024-05-30 - 3.0.0 to 3.0.2 - Core and API updates
+Series of updates and fixes.
+
+- BREAKING CHANGE(api): changed API to be more concise
+- fix(core): update
+
+## 2022-03-21 - 1.0.5 to 2.0.1 - Core updates and new org scheme
+Multiple updates including breaking changes and new organizational scheme.
+
+- BREAKING CHANGE(core): updated to esm
+- switch to new org scheme
+
+## 2019-08-07 - 1.0.3 to 1.0.5 - Core updates
+Fixes for core components.
+
+- fix(core): update

npmextra.json

@@ -10,19 +10,24 @@
       "license": "MIT",
       "projectDomain": "push.rocks",
       "keywords": [
+        "typescript",
         "validation",
         "guards",
-        "typescript",
         "async",
         "nodejs",
         "express",
         "middleware",
-        "data validation",
         "security",
         "input validation",
         "API",
+        "data validation",
         "custom validation",
-        "composite validation"
+        "composite validation",
+        "form validation",
+        "server-side validation",
+        "backend validation",
+        "smartrequest",
+        "typedserver"
       ]
     }
   },

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@push.rocks/smartguard",
-  "version": "2.0.2",
+  "version": "3.1.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@push.rocks/smartguard",
-      "version": "2.0.2",
+      "version": "3.1.0",
       "license": "MIT",
       "dependencies": {
         "@push.rocks/smartpromise": "^3.0.2",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartguard",
-  "version": "2.0.2",
+  "version": "3.1.0",
   "private": false,
   "description": "A TypeScript library for creating and managing validation guards, aiding in data validation and security checks.",
   "main": "dist_ts/index.js",
@@ -15,14 +15,14 @@
   },
   "devDependencies": {
     "@api.global/typedserver": "^3.0.50",
-    "@git.zone/tsbuild": "^2.1.66",
-    "@git.zone/tsrun": "^1.2.46",
+    "@git.zone/tsbuild": "^2.1.84",
+    "@git.zone/tsrun": "^1.2.49",
     "@git.zone/tstest": "^1.0.77",
-    "@push.rocks/tapbundle": "^5.0.8",
-    "@types/node": "^20.12.13"
+    "@push.rocks/tapbundle": "^5.0.24",
+    "@types/node": "^22.5.0"
   },
   "dependencies": {
-    "@push.rocks/smartpromise": "^4.0.2",
+    "@push.rocks/smartpromise": "^4.0.4",
     "@push.rocks/smartrequest": "^2.0.15"
   },
   "files": [
@@ -41,19 +41,24 @@
     "last 1 chrome versions"
   ],
   "keywords": [
+    "typescript",
     "validation",
     "guards",
-    "typescript",
     "async",
     "nodejs",
     "express",
     "middleware",
-    "data validation",
     "security",
     "input validation",
     "API",
+    "data validation",
     "custom validation",
-    "composite validation"
+    "composite validation",
+    "form validation",
+    "server-side validation",
+    "backend validation",
+    "smartrequest",
+    "typedserver"
   ],
   "homepage": "https://code.foss.global/push.rocks/smartguard",
   "repository": {

readme.md

@@ -1,5 +1,5 @@
 # @push.rocks/smartguard
-A library for creating and managing validation guards.
+A TypeScript library for creating and managing validation guards, aiding in data validation and security checks.
 
 ## Install
 
@@ -55,10 +55,10 @@ const stringValidationSet = new GuardSet<string>([isStringGuard, isNotEmptyGuard
 
 ### Executing Guards
 
-To execute a guard or a set of guards against data, you use the `executeGuardWithData` method for a single guard, or `executeGuardsWithData` method for a `GuardSet`.
+To execute a guard or a set of guards against data, you use the `execGuardWithData` method for a single guard, or `execGuardsWithData` method for a `GuardSet`.
 
 ```typescript
-const isValidString = await isStringGuard.executeGuardWithData('Hello World!');
+const isValidString = await isStringGuard.execGuardWithData('Hello World!');
 console.log(isValidString); // true
 
 const areValidStrings = await stringValidationSet.executeGuardsWithData('Hello World!');
@@ -84,7 +84,7 @@ const isValidAddressGuard = new Guard<string>(async (address) => {
 `@push.rocks/smartguard` can easily integrate with frameworks like Express by utilizing guards within middleware functions. This allows you to perform validations before a request reaches your route handlers.
 
 ```typescript
-import * as express from 'express';
+import express from 'express';
 import { Guard } from '@push.rocks/smartguard';
 
 const app = express();
@@ -94,7 +94,7 @@ const isAuthorizedUserGuard = new Guard<express.Request>(async (req) => {
 });
 
 app.use(async (req, res, next) => {
-  const isAuthorized = await isAuthorizedUserGuard.executeGuardWithData(req);
+  const isAuthorized = await isAuthorizedUserGuard.execGuardWithData(req);
   if (!isAuthorized) {
     res.status(403).send('Unauthorized');
     return;
@@ -145,7 +145,7 @@ const validApiResponseGuard = new Guard(async (url: string) => {
   return response.status === 200;
 });
 
-const isValidResponse = await validApiResponseGuard.executeGuardWithData('https://example.com/api/data');
+const isValidResponse = await validApiResponseGuard.execGuardWithData('https://example.com/api/data');
 console.log(isValidResponse); // true if the API response status is 200
 ```
 
@@ -172,9 +172,9 @@ const isPasswordStrong = new Guard<string>(async (password) => {
 
 // Combining guards using GuardSet
 const registrationValidationSet = new GuardSet<{ username: string, email: string, password: string }>([
-  new Guard(async (data) => isUsernameValid.executeGuardWithData(data.username)),
-  new Guard(async (data) => isEmailValid.executeGuardWithData(data.email)),
-  new Guard(async (data) => isPasswordStrong.executeGuardWithData(data.password))
+  new Guard(async (data) => isUsernameValid.execGuardWithData(data.username)),
+  new Guard(async (data) => isEmailValid.execGuardWithData(data.email)),
+  new Guard(async (data) => isPasswordStrong.execGuardWithData(data.password))
 ]);
 
 // Form data to validate
@@ -218,9 +218,9 @@ const isPostalCodeValid = new Guard<string>(async (postalCode) => {
 });
 
 const isAddressValid = new Guard<UserProfile['address']>(async (address) => {
-  const streetValid = await isStreetValid.executeGuardWithData(address.street);
-  const cityValid = await isCityValid.executeGuardWithData(address.city);
-  const postalCodeValid = await isPostalCodeValid.executeGuardWithData(address.postalCode);
+  const streetValid = await isStreetValid.execGuardWithData(address.street);
+  const cityValid = await isCityValid.execGuardWithData(address.city);
+  const postalCodeValid = await isPostalCodeValid.execGuardWithData(address.postalCode);
   return streetValid && cityValid && postalCodeValid;
 });
 
@@ -234,9 +234,9 @@ const isEmailValid = new Guard<string>(async (email) => {
 });
 
 const userProfileValidationSet = new GuardSet<UserProfile>([
-  new Guard(async (data) => isUsernameValid.executeGuardWithData(data.username)),
-  new Guard(async (data) => isEmailValid.executeGuardWithData(data.email)),
-  new Guard(async (data) => isAddressValid.executeGuardWithData(data.address))
+  new Guard(async (data) => isUsernameValid.execGuardWithData(data.username)),
+  new Guard(async (data) => isEmailValid.execGuardWithData(data.email)),
+  new Guard(async (data) => isAddressValid.execGuardWithData(data.address))
 ]);
 
 const userProfile = {
@@ -255,11 +255,174 @@ console.log(userProfileValidationResults.every(result => result)); // true if us
 
 In this example, we created a nested guard structure to validate a user profile object that includes address information. Each nested object is validated individually using its specific guards.
 
-### Summary
+### Dynamic Guards
 
-`@push.rocks/smartguard` provides a powerful framework for creating and managing validation guards in JavaScript and TypeScript applications. The library's flexibility allows it to handle simple boolean checks, asynchronous operations, integration with external APIs, and complex composite validations. Its use of `Guard` and `GuardSet` classes ensures that validations are both modular and reusable.
+There can be situations when you need to create guards dynamically based on some conditions or input. `@push.rocks/smartguard` allows you to create and use such dynamic guards effortlessly.
 
-Whether you are validating form inputs, securing APIs, or ensuring data integrity in your backend services, `@push.rocks/smartguard` simplifies the process and makes your code cleaner and more maintainable.
+```typescript
+import { Guard, GuardSet } from '@push.rocks/smartguard';
+
+const createDynamicGuard = (minLength: number) => new Guard<string>(async (data) => {
+  return data.length >= minLength;
+});
+
+const flexibleLengthGuardSet = (length: number) => new GuardSet<string>([createDynamicGuard(length)]);
+
+const dynamicGuard = flexibleLengthGuardSet(5);
+
+const isValid = await dynamicGuard.executeGuardsWithData('Hello, world!');
+console.log(isValid.every(result => result)); // true because the length of 'Hello, world!' is more than 5
+```
+
+In the example above, we created a dynamic guard based on a minimum length and then evaluated some data against it.
+
+### Validating Complex Data Structures
+
+There can often be a need to validate complex data structures with nested arrays or objects. Using a combination of `Guard` and `GuardSet`, you can effectively handle validations of such complex structures.
+
+```typescript
+interface BlogPost {
+  title: string;
+  content: string;
+  tags: string[];
+  author: {
+    name: string;
+    email: string;
+  };
+}
+
+const isStringGuard = new Guard<string>(async (data) => {
+  return typeof data === 'string';
+});
+
+const isNonEmptyStringGuard = new Guard<string>(async (data) => {
+  return await isStringGuard.execGuardWithData(data) && data.trim().length > 0;
+});
+
+const isStringArrayGuard = new Guard<string[]>(async (data) => {
+  return Array.isArray(data) && data.every(item => typeof item === 'string');
+});
+
+const isEmailGuard = new Guard<string>(async (data) => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return typeof data === 'string' && emailRegex.test(data);
+});
+
+const isAuthorGuardSet = new GuardSet<BlogPost['author']>([
+  new Guard(async (data) => await isNonEmptyStringGuard.execGuardWithData(data.name)),
+  new Guard(async (data) => await isEmailGuard.execGuardWithData(data.email))
+]);
+
+const isBlogPostGuardSet = new GuardSet<BlogPost>([
+  new Guard(async (data) => await isNonEmptyStringGuard.execGuardWithData(data.title)),
+  new Guard(async (data) => await isNonEmptyStringGuard.execGuardWithData(data.content)),
+  new Guard(async (data) => await isStringArrayGuard.execGuardWithData(data.tags)),
+  new Guard(async (data) => await isAuthorGuardSet.executeGuardsWithData(data.author).then(results => results.every(result => result)))
+]);
+
+const blogPost: BlogPost = {
+  title: 'Introduction to Smart Guard',
+  content: 'Smart Guard is a TypeScript library for creating and managing validation guards...',
+  tags: ['typescript', 'validation', 'library'],
+  author: {
+    name: 'John Doe',
+    email: 'johndoe@example.com'
+  }
+};
+
+const blogPostValidationResults = await isBlogPostGuardSet.executeGuardsWithData(blogPost);
+console.log(blogPostValidationResults.every(result => result)); // true if the blog post is valid
+```
+
+In this example, we created different guards to validate various parts of a complex `BlogPost` object. Notice how we used nested `GuardSet` instances to validate the `author` object.
+
+### Asynchronous Validations
+
+`@push.rocks/smartguard` supports asynchronous guard functions, making it possible to perform validations that involve network requests or other asynchronous operations.
+
+```typescript
+import { Guard } from '@push.rocks/smartguard';
+import { smartrequest } from '@push.rocks/smartrequest';
+
+const isApiKeyValidGuard = new Guard<string>(async (apiKey) => {
+  const response = await smartrequest.request(`https://api.example.com/validate?key=${apiKey}`, { method: 'GET' });
+  return response.status === 200;
+});
+
+const apiKey = 'some-api-key';
+const isApiKeyValid = await isApiKeyValidGuard.execGuardWithData(apiKey);
+console.log(isApiKeyValid); // true if the API key is valid
+```
+
+In this example, the guard performs an asynchronous API request to validate an API key.
+
+### Default Error Handling
+
+When using `@push.rocks/smartguard`, you can take advantage of built-in error handling mechanisms. If a guard fails, it throws an error that you can catch and handle accordingly.
+
+```typescript
+import { Guard, passGuardsOrReject } from '@push.rocks/smartguard';
+
+const isNonEmptyStringGuard = new Guard<string>(async (data) => {
+  return typeof data === 'string' && data.trim().length > 0;
+});
+
+const validateInput = async (input: string) => {
+  try {
+    await passGuardsOrReject(input, [isNonEmptyStringGuard]);
+    console.log('Input is valid');
+  } catch (error) {
+    console.error('Validation failed:', error.message);
+  }
+};
+
+await validateInput(''); // Will print "Validation failed: Guard failed"
+await validateInput('Valid input'); // Will print "Input is valid"
+```
+
+In this example, we use the `passGuardsOrReject` function to validate an input. If the input is invalid, `passGuardsOrReject` throws an error that is caught and handled in the `catch` block.
+
+### Extending Guard Functionalities
+
+Sometimes, you may need to extend or customize the functionalities of a guard to suit specific requirements. `@push.rocks/smartguard` allows you to extend the `Guard` class to create specialized guards.
+
+```typescript
+import { Guard } from '@push.rocks/smartguard';
+
+class MinLengthGuard extends Guard<string> {
+  constructor(private minLength: number) {
+    super(async (data) => {
+      return typeof data === 'string' && data.length >= this.minLength;
+    });
+  }
+}
+
+const minLengthGuard = new MinLengthGuard(10);
+
+const isLongEnough = await minLengthGuard.execGuardWithData('Hello, world!');
+console.log(isLongEnough); // true because the length of 'Hello, world!' is more than 10
+```
+
+In this example, we create a `MinLengthGuard` class that extends `Guard` and validates a string based on its minimum length.
+
+## License and Legal Information
+
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+
+### Company Information
+
+Task Venture Capital GmbH  
+Registered at District court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
 
 ## License and Legal Information
 

test/test.node.ts

@@ -3,10 +3,10 @@ import * as smartguard from '../ts/index.js';
 import * as typedserver from '@api.global/typedserver';
 import * as smartrequest from '@push.rocks/smartrequest';
 
-let smartexpressInstance: typedserver.servertools.Server;
+let typedserverInstance: typedserver.servertools.Server;
 
 tap.test('should create a demo smartexpress instance', async () => {
-  smartexpressInstance = new typedserver.servertools.Server({
+  typedserverInstance = new typedserver.servertools.Server({
     cors: true,
     forceSsl: false,
     defaultAnswer: async () => 'hi there',
@@ -30,10 +30,10 @@ tap.test('should be able to create smartguards for a request', async () => {
     }
   });
 
-  smartexpressInstance.addRoute(
+  typedserverInstance.addRoute(
     '/testroute',
     new typedserver.servertools.Handler('ALL', async (req, res) => {
-      await smartguard.passGuards(
+      await smartguard.passGuardsOrReject(
         {
           req,
           res,
@@ -49,7 +49,7 @@ tap.test('should be able to create smartguards for a request', async () => {
 });
 
 tap.test('should start server with guards in place', async () => {
-  await smartexpressInstance.start();
+  await typedserverInstance.start();
 });
 
 tap.test('should execute a request', async () => {
@@ -59,7 +59,7 @@ tap.test('should execute a request', async () => {
 });
 
 tap.test('should end the demo smartexpress instance', async () => {
-  await smartexpressInstance.stop();
+  await typedserverInstance.stop();
 });
 
 tap.start();

ts/00_commitinfo_data.ts

@@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
   name: '@push.rocks/smartguard',
-  version: '2.0.2',
+  version: '3.1.0',
   description: 'A TypeScript library for creating and managing validation guards, aiding in data validation and security checks.'
 }

ts/classes.guard.ts

@@ -0,0 +1,35 @@
+import * as plugins from './smartguard.plugins.js';
+
+export type TGuardFunction<T> = (dataArg: T) => Promise<boolean>;
+
+export interface IGuardOptions {
+  name?: string;
+  failedHint?: string;
+}
+
+export class Guard<T> {
+  private guardFunction: TGuardFunction<T>;
+  public options: IGuardOptions;
+  constructor(guardFunctionArg: TGuardFunction<T>, optionsArg?: IGuardOptions) {
+    this.guardFunction = guardFunctionArg;
+    this.options = optionsArg;
+  }
+
+  /**
+   * executes the guard against a data argument;
+   * @param dataArg
+   */
+  public async exec(dataArg: T) {
+    const result = await this.guardFunction(dataArg);
+    return result;
+  }
+
+  public async getFailedHint(dataArg: T) {
+    const result = await this.exec(dataArg);
+    if (!result) {
+      return this.options.failedHint;
+    } else {
+      return null;
+    }
+  }
+}

ts/classes.guarderror.ts

@@ -0,0 +1,8 @@
+import * as plugins from './smartguard.plugins.js';
+
+export class GuardError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'GuardError';
+  }
+}

ts/classes.guardset.ts

@@ -0,0 +1,87 @@
+import * as plugins from './smartguard.plugins.js';
+import { Guard, type TGuardFunction } from './classes.guard.js';
+
+export interface IExecOptions {
+  mode?: 'parallel' | 'serial';
+  stopOnFail?: boolean;
+} 
+
+/**
+ * Extended GuardSet that inherits from Guard
+ * and provides additional functionalities.
+ */
+export class GuardSet<T> extends Guard<T> {
+  public guards: Array<Guard<T>>;
+
+  constructor(guardArray: Array<Guard<T>> = []) {
+    super(async (dataArg: T) => {
+      return this.allGuardsPass(dataArg);
+    })
+    this.guards = guardArray;
+  }
+
+  /**
+   * executes all guards in all guardSets against a data argument
+   * @param dataArg
+   */
+  public async execAllWithData(dataArg: T, optionsArg: IExecOptions = {
+    mode: 'parallel',
+    stopOnFail: false
+  }): Promise<boolean[]> {
+    const resultPromises: Array<Promise<boolean>> = [];
+    
+    for (const guard of this.guards) {
+      const guardResultPromise = guard.exec(dataArg);
+      if (optionsArg.mode === 'serial') {
+        await guardResultPromise;
+      }
+      resultPromises.push(guardResultPromise);
+      if (optionsArg.stopOnFail) {
+        if (!await guardResultPromise) {
+          return await Promise.all(resultPromises);
+        }
+      }
+    }
+
+    const results = await Promise.all(resultPromises);
+    return results;
+  }
+
+  /**
+   * checks if all guards pass
+   * @param dataArg
+   */
+  public async allGuardsPass(dataArg: T, optionsArg: IExecOptions = {
+    mode: 'parallel',
+    stopOnFail: false
+  }): Promise<boolean> {
+    const results = await this.execAllWithData(dataArg, optionsArg);
+    return results.every(result => result);
+  }
+
+  /**
+   * checks if any guard passes
+   * @param dataArg
+   */
+  public async anyGuardsPass(dataArg: T): Promise<boolean> {
+    const results = await this.execAllWithData(dataArg, {
+      mode: 'parallel',
+      stopOnFail: false
+    });
+    return results.some(result => result);
+  }
+
+  /**
+   * returns the first reason for why something fails
+   * @param dataArg
+   * @returns 
+   */
+  public getFailedHint (dataArg: T): Promise<string> {
+    for (const guard of this.guards) {
+      const failedHint = guard.getFailedHint(dataArg);
+      if (failedHint) {
+        return failedHint;
+      }
+    }
+  }
+}

ts/index.ts

@@ -1,18 +1,19 @@
 import * as plugins from './smartguard.plugins.js';
-import { Guard } from './smartguard.classes.guard.js';
-import { GuardSet } from './smartguard.classes.guardset.js';
-export * from './smartguard.classes.guard.js';
+import { Guard } from './classes.guard.js';
+export * from './classes.guarderror.js';
+export * from './classes.guard.js';
+export * from './classes.guardset.js';
 
-export const passGuards = async <T>(dataArg: T, guards: Array<Guard<T>>) => {
-  const done = plugins.smartpromise.defer();
+import { GuardSet } from './classes.guardset.js';
+import { GuardError } from './classes.guarderror.js';
+export const passGuardsOrReject = async <T>(dataArg: T, guards: Array<Guard<T>>) => {
   const guardSet = new GuardSet<T>(guards);
-  const results = await guardSet.executeGuardsWithData(dataArg);
-  for (const result of results) {
-    if (!result) {
-      return;
-    }
+  const result = await guardSet.allGuardsPass(dataArg);
+  if (!result) {
+    const failedHint = await guardSet.getFailedHint(dataArg);
+    throw new GuardError(`Guards failed:
+${failedHint}
+    `);
   }
-  done.resolve();
-  await done.promise;
-  return;
+  return ;
 };

ts/smartguard.classes.guard.ts

@@ -1,19 +0,0 @@
-import * as plugins from './smartguard.plugins.js';
-
-export type TGuardFunction<T> = (dataArg: T) => Promise<boolean>;
-
-export class Guard<T> {
-  private guardFunction: TGuardFunction<T>;
-  constructor(guardFunctionArg: TGuardFunction<T>) {
-    this.guardFunction = guardFunctionArg;
-  }
-
-  /**
-   * executes the guard against a data argument;
-   * @param dataArg
-   */
-  public async executeGuardWithData(dataArg: T) {
-    const result = await this.guardFunction(dataArg);
-    return result;
-  }
-}

ts/smartguard.classes.guardset.ts

@@ -1,23 +0,0 @@
-import * as plugins from './smartguard.plugins.js';
-import { Guard } from './smartguard.classes.guard.js';
-
-/**
- * a guardSet is a set of guards that need to be fulfilled
- */
-export class GuardSet<T> {
-  public guards: Array<Guard<T>>;
-  public passed: boolean;
-  constructor(guardsArrayArg: Array<Guard<T>>) {
-    this.guards = guardsArrayArg;
-  }
-
-  public async executeGuardsWithData(dataArg: T) {
-    const resultPromises: Array<Promise<boolean>> = [];
-    for (const guard of this.guards) {
-      const resultPromise = guard.executeGuardWithData(dataArg);
-      resultPromises.push(resultPromise);
-    }
-    const results = Promise.all(resultPromises);
-    return results;
-  }
-}

ts/smartguard.plugins.ts

@@ -1,4 +1,6 @@
+// @push.rocks scope
 import * as smartpromise from '@push.rocks/smartpromise';
 
 // pushrocks scope
 export { smartpromise };
+