feat(guard-clause): init

Author: TorinAsakura

.pnp.cjs

@@ -0,0 +1,37 @@
+{
+  "name": "@atls/guard-clause",
+  "version": "0.0.0",
+  "license": "BSD-3-Clause",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./src/index.ts"
+  },
+  "main": "src/index.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "yarn library build",
+    "prepack": "yarn run build",
+    "postpack": "rm -rf dist"
+  },
+  "dependencies": {
+    "validator": "^13.9.0"
+  },
+  "devDependencies": {
+    "@types/validator": "^13.7.17"
+  },
+  "publishConfig": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": {
+        "import": "./dist/index.js",
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts"
+  }
+}

packages/guard-clause/package.json

@@ -0,0 +1 @@
+export type DecoratorFactoryFn = (target: any, propertyKey: string, parameterIndex: number) => void

packages/guard-clause/src/decorators/against/decorator.interfaces.ts

@@ -0,0 +1,17 @@
+import type { AbstractGuardExtensionFactoryOptions } from '../../factory/index.js'
+import type { DecoratorFactoryFn }                   from './decorator.interfaces.js'
+
+import { GuardFactory }                              from '../../factory/index.js'
+import { NotEmptyGuardExtensionFactory }             from '../../extensions/index.js'
+
+export const EmptyDecoratorFactory = (
+    parameter: string,
+    options?: AbstractGuardExtensionFactoryOptions['options']
+  ) =>
+  (): DecoratorFactoryFn =>
+    function Empty(target: any, propertyKey: string, parameterIndex: number): void {
+      GuardFactory.register(NotEmptyGuardExtensionFactory, target, propertyKey, parameterIndex, {
+        parameter,
+        options,
+      })
+    }

packages/guard-clause/src/decorators/against/empty.decorator.factory.ts

@@ -0,0 +1,31 @@
+import type { AbstractGuardExtensionFactoryOptions } from '../../factory/index.js'
+
+import { EmptyDecoratorFactory }                     from './empty.decorator.factory.js'
+import { NotUUIDDecoratorFactory }                   from './not-uuid.decorator.factory.js'
+import { NotNumberBetweenDecoratorFactory }          from './not-number-between.decorator.factory.js'
+import { NotInstanceDecoratorFactory }               from './not-instance.decorator.factory.js'
+import { NotIntegerDecoratorFactory }                from './not-integer.decorator.factory.js'
+import { NotEnumDecoratorFactory }                   from './not-enum.decorator.factory.js'
+import { NotOneOfDecoratorFactory }                  from './not-one-of.decorator.factory.js'
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+const factory = (name: string, options?: AbstractGuardExtensionFactoryOptions['options']) => ({
+  Empty: EmptyDecoratorFactory(name, options),
+  NotUUID: NotUUIDDecoratorFactory(name, options),
+  NotInstance: NotInstanceDecoratorFactory(name, options),
+  NotNumberBetween: NotNumberBetweenDecoratorFactory(name, options),
+  NotInteger: NotIntegerDecoratorFactory(name, options),
+  NotEnum: NotEnumDecoratorFactory(name, options),
+  NotOneOf: NotOneOfDecoratorFactory(name, options),
+})
+
+export const Against = (
+  name: string
+): ReturnType<typeof factory> & {
+  Optional: ReturnType<typeof factory>
+  Each: ReturnType<typeof factory>
+} => ({
+  ...factory(name),
+  Optional: factory(name, { optional: true }),
+  Each: factory(name, { each: true }),
+})

packages/guard-clause/src/decorators/against/index.ts

@@ -0,0 +1,20 @@
+import type { AbstractGuardExtensionFactoryOptions } from '../../factory/index.js'
+import type { DecoratorFactoryFn }                   from './decorator.interfaces.js'
+
+import { GuardFactory }                              from '../../factory/index.js'
+import { NotEnumGuardExtensionFactory }              from '../../extensions/index.js'
+
+export const NotEnumDecoratorFactory = (
+    parameter: string,
+    options?: AbstractGuardExtensionFactoryOptions['options']
+  ) =>
+  (targetEnum: object): DecoratorFactoryFn =>
+    function NotEnum(target: any, propertyKey: string, parameterIndex: number): void {
+      GuardFactory.register(NotEnumGuardExtensionFactory, target, propertyKey, parameterIndex, {
+        parameter,
+        options,
+        metadata: {
+          targetEnum,
+        },
+      })
+    }

packages/guard-clause/src/decorators/against/not-enum.decorator.factory.ts

@@ -0,0 +1,21 @@
+import type { AbstractGuardExtensionFactoryOptions } from '../../factory/index.js'
+import type { DecoratorFactoryFn }                   from './decorator.interfaces.js'
+
+import { GuardFactory }                              from '../../factory/index.js'
+import { NotInstanceGuardExtensionFactory }          from '../../extensions/index.js'
+
+export const NotInstanceDecoratorFactory = (
+    parameter: string,
+    options?: AbstractGuardExtensionFactoryOptions['options']
+  ) =>
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  (targetTypeConstructor: Function): DecoratorFactoryFn =>
+    function NotInstance(target: any, propertyKey: string, parameterIndex: number): void {
+      GuardFactory.register(NotInstanceGuardExtensionFactory, target, propertyKey, parameterIndex, {
+        parameter,
+        options,
+        metadata: {
+          targetTypeConstructor,
+        },
+      })
+    }

packages/guard-clause/src/decorators/against/not-instance.decorator.factory.ts

@@ -0,0 +1,17 @@
+import type { AbstractGuardExtensionFactoryOptions } from '../../factory/index.js'
+import type { DecoratorFactoryFn }                   from './decorator.interfaces.js'
+
+import { GuardFactory }                              from '../../factory/index.js'
+import { NotIntegerGuardExtensionFactory }           from '../../extensions/index.js'
+
+export const NotIntegerDecoratorFactory = (
+    parameter: string,
+    options?: AbstractGuardExtensionFactoryOptions['options']
+  ) =>
+  (): DecoratorFactoryFn =>
+    function NotInteger(target: any, propertyKey: string, parameterIndex: number): void {
+      GuardFactory.register(NotIntegerGuardExtensionFactory, target, propertyKey, parameterIndex, {
+        parameter,
+        options,
+      })
+    }

packages/guard-clause/src/decorators/against/not-integer.decorator.factory.ts

@@ -0,0 +1,27 @@
+import type { AbstractGuardExtensionFactoryOptions } from '../../factory/index.js'
+import type { DecoratorFactoryFn }                   from './decorator.interfaces.js'
+
+import { GuardFactory }                              from '../../factory/index.js'
+import { NotNumberBetweenGuardExtensionFactory }     from '../../extensions/index.js'
+
+export const NotNumberBetweenDecoratorFactory = (
+    parameter: string,
+    options?: AbstractGuardExtensionFactoryOptions['options']
+  ) =>
+  (from: number, to: number): DecoratorFactoryFn =>
+    function NotNumberBetween(target: any, propertyKey: string, parameterIndex: number): void {
+      GuardFactory.register(
+        NotNumberBetweenGuardExtensionFactory,
+        target,
+        propertyKey,
+        parameterIndex,
+        {
+          parameter,
+          options,
+          metadata: {
+            from,
+            to,
+          },
+        }
+      )
+    }

packages/guard-clause/src/decorators/against/not-number-between.decorator.factory.ts

@@ -0,0 +1,20 @@
+import type { AbstractGuardExtensionFactoryOptions } from '../../factory/index.js'
+import type { DecoratorFactoryFn }                   from './decorator.interfaces.js'
+
+import { GuardFactory }                              from '../../factory/index.js'
+import { NotOneOfGuardExtensionFactory }             from '../../extensions/index.js'
+
+export const NotOneOfDecoratorFactory = (
+    parameter: string,
+    options?: AbstractGuardExtensionFactoryOptions['options']
+  ) =>
+  (oneOf: object): DecoratorFactoryFn =>
+    function NotOneOf(target: any, propertyKey: string, parameterIndex: number): void {
+      GuardFactory.register(NotOneOfGuardExtensionFactory, target, propertyKey, parameterIndex, {
+        parameter,
+        options,
+        metadata: {
+          oneOf,
+        },
+      })
+    }