@invariant--labs/foundation 1.1.2

package/src/validation/is-more-than-or-equal.decorator.ts

@@ -0,0 +1,52 @@
+import {
+  registerDecorator,
+  ValidationArguments,
+  ValidationOptions,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from "class-validator";
+
+import { isValidISODate } from "../utils";
+
+export function IsMoreThanOrEqual(property: string, validationOptions?: ValidationOptions) {
+  return function (object: object, propertyName: string) {
+    registerDecorator({
+      target: object.constructor,
+      propertyName,
+      constraints: [property],
+      options: validationOptions,
+      validator: IsMoreThanOrEqualConstraint,
+    });
+  };
+}
+
+@ValidatorConstraint({ name: "isMoreThanOrEqual" })
+class IsMoreThanOrEqualConstraint implements ValidatorConstraintInterface {
+  validate(value: unknown, args: ValidationArguments) {
+    const relatedPropertyName = args.constraints[0] as string;
+    const relatedValue = (args.object as Record<string, unknown>)[relatedPropertyName];
+
+    if (!relatedValue) {
+      return true;
+    }
+
+    if (typeof value === "number" && typeof relatedValue === "number") {
+      return value >= relatedValue;
+    }
+
+    if (value instanceof Date && relatedValue instanceof Date) {
+      return +value >= +relatedValue;
+    }
+
+    if (typeof value === "string" && typeof relatedValue === "string" && isValidISODate(value) && isValidISODate(relatedValue)) {
+      return +new Date(value) >= +new Date(relatedValue);
+    }
+
+    throw new Error("Unsupported comparison");
+  }
+
+  defaultMessage(args: ValidationArguments) {
+    const relatedPropertyName = args.constraints[0] as string;
+    return `${args.property} must be more than or equal ${relatedPropertyName}`;
+  }
+}

package/src/validation/is-more-than.decorator.spec.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "@jest/globals";
+import { validate } from "class-validator";
+
+import { IsMoreThan } from "./is-more-than.decorator";
+
+class Dto {
+  min: number;
+  @IsMoreThan("min")
+  max: number;
+}
+
+describe("IsMoreThan", () => {
+  it("should pass when value is greater", async () => {
+    const dto = Object.assign(new Dto(), { min: 5, max: 10 });
+    const errors = await validate(dto);
+    expect(errors).toHaveLength(0);
+  });
+
+  it("should fail when value is equal", async () => {
+    const dto = Object.assign(new Dto(), { min: 5, max: 5 });
+    const errors = await validate(dto);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it("should fail when value is less", async () => {
+    const dto = Object.assign(new Dto(), { min: 10, max: 5 });
+    const errors = await validate(dto);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it("should pass when related value is falsy", async () => {
+    const dto = Object.assign(new Dto(), { min: 0, max: 5 });
+    const errors = await validate(dto);
+    expect(errors).toHaveLength(0);
+  });
+});

package/src/validation/is-more-than.decorator.ts

@@ -0,0 +1,52 @@
+import {
+  registerDecorator,
+  ValidationArguments,
+  ValidationOptions,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from "class-validator";
+
+import { isValidISODate } from "../utils";
+
+export function IsMoreThan(property: string, validationOptions?: ValidationOptions) {
+  return function (object: object, propertyName: string) {
+    registerDecorator({
+      target: object.constructor,
+      propertyName,
+      constraints: [property],
+      options: validationOptions,
+      validator: IsMoreThanConstraint,
+    });
+  };
+}
+
+@ValidatorConstraint({ name: "isMoreThan" })
+class IsMoreThanConstraint implements ValidatorConstraintInterface {
+  validate(value: unknown, args: ValidationArguments) {
+    const relatedPropertyName = args.constraints[0] as string;
+    const relatedValue = (args.object as Record<string, unknown>)[relatedPropertyName];
+
+    if (!relatedValue) {
+      return true;
+    }
+
+    if (typeof value === "number" && typeof relatedValue === "number") {
+      return value > relatedValue;
+    }
+
+    if (value instanceof Date && relatedValue instanceof Date) {
+      return +value > +relatedValue;
+    }
+
+    if (typeof value === "string" && typeof relatedValue === "string" && isValidISODate(value) && isValidISODate(relatedValue)) {
+      return +new Date(value) > +new Date(relatedValue);
+    }
+
+    throw new Error("Unsupported comparison");
+  }
+
+  defaultMessage(args: ValidationArguments) {
+    const relatedPropertyName = args.constraints[0] as string;
+    return `${args.property} must be more than ${relatedPropertyName}`;
+  }
+}

package/src/validation/is-time-string.decorator.spec.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "@jest/globals";
+import { validate } from "class-validator";
+
+import { IsTimeString } from "./is-time-string.decorator";
+
+class Dto {
+  @IsTimeString()
+  time: unknown;
+}
+
+describe("IsTimeString", () => {
+  it("should accept HH:mm:ss format", async () => {
+    const dto = Object.assign(new Dto(), { time: "14:30:00" });
+    const errors = await validate(dto);
+    expect(errors).toHaveLength(0);
+  });
+
+  it("should accept compact HHmmss format", async () => {
+    const dto = Object.assign(new Dto(), { time: "143000" });
+    const errors = await validate(dto);
+    expect(errors).toHaveLength(0);
+  });
+
+  it("should reject invalid time strings", async () => {
+    const dto = Object.assign(new Dto(), { time: "25:00:00" });
+    const errors = await validate(dto);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it("should reject non-string values", async () => {
+    const dto = Object.assign(new Dto(), { time: 1430 });
+    const errors = await validate(dto);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+});

package/src/validation/is-time-string.decorator.ts

@@ -0,0 +1,29 @@
+import {
+  registerDecorator,
+  ValidationArguments,
+  ValidationOptions,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from "class-validator";
+
+export function IsTimeString(validationOptions?: ValidationOptions) {
+  return function (object: object, propertyName: string) {
+    registerDecorator({
+      target: object.constructor,
+      propertyName,
+      options: validationOptions,
+      validator: IsTimeStringConstraint,
+    });
+  };
+}
+
+@ValidatorConstraint({ name: "isTimeString" })
+class IsTimeStringConstraint implements ValidatorConstraintInterface {
+  validate(value: unknown) {
+    return typeof value === "string" && /^(([01]\d|2[0-3]):?[0-5]\d:?[0-5]\d+)$/.test(value);
+  }
+
+  defaultMessage(args: ValidationArguments) {
+    return `${args.property} must be in HH:mm:ss format`;
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["."],
+  "exclude": ["node_modules", "test", "dist", "jest.config.ts", "jest.setup.ts", "**/*spec.ts"]
+}
+

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "declaration": true,
+    "baseUrl": "./",
+    "module": "CommonJS",
+    "target": "ES2022",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "sourceMap": true,
+    "incremental": true,
+    "skipLibCheck": true,
+    "skipDefaultLibCheck": true,
+    "noImplicitAny": true,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+    "esModuleInterop": true,
+    "importHelpers": true,
+    "resolveJsonModule": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "strictPropertyInitialization": false,
+    "allowImportingTsExtensions": false,
+    "paths": {
+      "@invariant-labs/foundation": ["./src/index"]
+    }
+  },
+  "exclude": ["node_modules"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": ["jest", "node"],
+    "allowJs": true,
+    "isolatedModules": true
+  },
+  "include": [
+    "jest.config.ts",
+    "**/*.spec.ts",
+    "**/*.integration.ts",
+    "**/*.e2e.ts"
+  ]
+}