ts-fortress 2.0.4 → 2.2.0

package/src/record/record-allow-excess-properties.test.mts

@@ -0,0 +1,180 @@
+import { Result } from 'ts-data-forge';
+import { number } from '../primitives/index.mjs';
+import { validationErrorsToMessages } from '../validation-error.mjs';
+import { record } from './record.mjs';
+
+describe('record allowExcessProperties option', () => {
+  const strictRecord = record(
+    {
+      name: number(0),
+      age: number(0),
+    },
+    { allowExcessProperties: false },
+  );
+
+  const permissiveRecord = record(
+    {
+      name: number(0),
+      age: number(0),
+    },
+    { allowExcessProperties: true },
+  );
+
+  const defaultRecord = record({
+    name: number(0),
+    age: number(0),
+  });
+
+  test('allowExcessProperties: false - rejects excess properties', () => {
+    const dataWithExcess = {
+      name: 42,
+      age: 25,
+      extra: 'not allowed',
+    };
+
+    expect(strictRecord.is(dataWithExcess)).toBe(false);
+
+    const result = strictRecord.validate(dataWithExcess);
+    expect(Result.isErr(result)).toBe(true);
+
+    if (Result.isErr(result)) {
+      expect(result.value).toStrictEqual([
+        {
+          path: ['extra'],
+          actualValue: 'not allowed',
+          typeName: '{ name: number, age: number }',
+          expectedType: '{ name: number, age: number }',
+          message: 'Excess property "extra" is not allowed',
+        },
+      ]);
+
+      expect(validationErrorsToMessages(result.value)).toStrictEqual([
+        'Excess property "extra" is not allowed at extra',
+      ]);
+    }
+  });
+
+  test('allowExcessProperties: false - accepts valid data without excess properties', () => {
+    const validData = {
+      name: 42,
+      age: 25,
+    };
+
+    expect(strictRecord.is(validData)).toBe(true);
+
+    const result = strictRecord.validate(validData);
+    expect(Result.isOk(result)).toBe(true);
+
+    if (Result.isOk(result)) {
+      expect(result.value).toStrictEqual({
+        name: 42,
+        age: 25,
+      });
+    }
+  });
+
+  test('allowExcessProperties: true - accepts excess properties', () => {
+    const dataWithExcess = {
+      name: 42,
+      age: 25,
+      extra: 'allowed',
+    };
+
+    expect(permissiveRecord.is(dataWithExcess)).toBe(true);
+
+    const result = permissiveRecord.validate(dataWithExcess);
+    expect(Result.isOk(result)).toBe(true);
+
+    if (Result.isOk(result)) {
+      expect(result.value).toStrictEqual({
+        name: 42,
+        age: 25,
+        extra: 'allowed',
+      });
+    }
+  });
+
+  test('default behavior - allows excess properties (allowExcessProperties defaults to true)', () => {
+    const dataWithExcess = {
+      name: 42,
+      age: 25,
+      extra: 'allowed by default',
+    };
+
+    expect(defaultRecord.is(dataWithExcess)).toBe(true);
+
+    const result = defaultRecord.validate(dataWithExcess);
+    expect(Result.isOk(result)).toBe(true);
+
+    if (Result.isOk(result)) {
+      expect(result.value).toStrictEqual({
+        name: 42,
+        age: 25,
+        extra: 'allowed by default',
+      });
+    }
+  });
+
+  test('allowExcessProperties: false - multiple excess properties', () => {
+    const dataWithMultipleExcess = {
+      name: 42,
+      age: 25,
+      extra1: 'not allowed 1',
+      extra2: 'not allowed 2',
+    };
+
+    const result = strictRecord.validate(dataWithMultipleExcess);
+    expect(Result.isErr(result)).toBe(true);
+
+    if (Result.isErr(result)) {
+      expect(result.value).toHaveLength(2);
+      expect(result.value).toStrictEqual([
+        {
+          path: ['extra1'],
+          actualValue: 'not allowed 1',
+          typeName: '{ name: number, age: number }',
+          expectedType: '{ name: number, age: number }',
+          message: 'Excess property "extra1" is not allowed',
+        },
+        {
+          path: ['extra2'],
+          actualValue: 'not allowed 2',
+          typeName: '{ name: number, age: number }',
+          expectedType: '{ name: number, age: number }',
+          message: 'Excess property "extra2" is not allowed',
+        },
+      ]);
+    }
+  });
+
+  test('allowExcessProperties: false - combines with other validation errors', () => {
+    const invalidData = {
+      name: 'invalid', // should be number
+      age: 25,
+      extra: 'not allowed',
+    };
+
+    const result = strictRecord.validate(invalidData);
+    expect(Result.isErr(result)).toBe(true);
+
+    if (Result.isErr(result)) {
+      expect(result.value).toHaveLength(2);
+      // First error: invalid type for 'name'
+      expect(result.value[0]).toStrictEqual({
+        path: ['name'],
+        actualValue: 'invalid',
+        expectedType: 'number',
+        typeName: 'number',
+        message: undefined,
+      });
+      // Second error: excess property
+      expect(result.value[1]).toStrictEqual({
+        path: ['extra'],
+        actualValue: 'not allowed',
+        typeName: '{ name: number, age: number }',
+        expectedType: '{ name: number, age: number }',
+        message: 'Excess property "extra" is not allowed',
+      });
+    }
+  });
+});

package/src/record/record-strict-composition-simple.test.mts

@@ -0,0 +1,134 @@
+import { Result } from 'ts-data-forge';
+import { number, string } from '../primitives/index.mjs';
+import { omit } from './omit.mjs';
+import { partial } from './partial.mjs';
+import { pick } from './pick.mjs';
+import { record } from './record.mjs';
+
+describe('record strict composition - simple tests', () => {
+  // Base strict record type
+  const strictRecord = record(
+    {
+      id: string(''),
+      name: string(''),
+      age: number(0),
+    },
+    { allowExcessProperties: false },
+  );
+
+  describe('pick behavior with strict record', () => {
+    test('pick inherits strict validation from base record', () => {
+      const pickedType = pick(strictRecord, ['id', 'name']);
+
+      // Test with excess property
+      const dataWithExcess = { id: '123', name: 'John', extra: 'not allowed' };
+
+      const result = pickedType.validate(dataWithExcess);
+      expect(Result.isErr(result)).toBe(true);
+
+      if (Result.isErr(result)) {
+        const excessError = result.value.find(
+          (error) =>
+            error.message?.includes(
+              'Excess property "extra" is not allowed',
+            ) === true,
+        );
+        expect(excessError).toBeDefined();
+      }
+    });
+
+    test('pick accepts valid data and fills missing fields', () => {
+      const pickedType = pick(strictRecord, ['id', 'name']);
+      const validData = { id: '123', name: 'John' };
+
+      const result = pickedType.validate(validData);
+      expect(Result.isOk(result)).toBe(true);
+
+      if (Result.isOk(result)) {
+        expect(result.value).toStrictEqual({ id: '123', name: 'John' });
+      }
+    });
+  });
+
+  describe('omit behavior with strict record', () => {
+    test('omit inherits strict validation from base record', () => {
+      const omittedType = omit(strictRecord, ['age']);
+
+      // Test with excess property
+      const dataWithExcess = { id: '123', name: 'John', extra: 'not allowed' };
+
+      const result = omittedType.validate(dataWithExcess);
+      expect(Result.isErr(result)).toBe(true);
+
+      if (Result.isErr(result)) {
+        const excessError = result.value.find(
+          (error) =>
+            error.message?.includes(
+              'Excess property "extra" is not allowed',
+            ) === true,
+        );
+        expect(excessError).toBeDefined();
+      }
+    });
+  });
+
+  describe('partial behavior with strict record', () => {
+    test('partial inherits strict validation from base record', () => {
+      const partialType = partial(strictRecord);
+
+      // Test with excess property
+      const dataWithExcess = { id: '123', extra: 'not allowed' };
+
+      const result = partialType.validate(dataWithExcess);
+      expect(Result.isErr(result)).toBe(true);
+
+      if (Result.isErr(result)) {
+        const excessError = result.value.find(
+          (error) =>
+            error.message?.includes(
+              'Excess property "extra" is not allowed',
+            ) === true,
+        );
+        expect(excessError).toBeDefined();
+      }
+    });
+  });
+
+  describe('behavior comparison: strict vs permissive', () => {
+    const permissiveRecord = record({
+      id: string(''),
+      name: string(''),
+      age: number(0),
+    }); // allowExcessProperties defaults to true
+
+    test('strict record rejects excess properties', () => {
+      const data = { id: '123', name: 'John', age: 25, extra: 'not allowed' };
+
+      const result = strictRecord.validate(data);
+      expect(Result.isErr(result)).toBe(true);
+    });
+
+    test('permissive record accepts excess properties', () => {
+      const data = { id: '123', name: 'John', age: 25, extra: 'allowed' };
+
+      const result = permissiveRecord.validate(data);
+      expect(Result.isOk(result)).toBe(true);
+    });
+
+    test('pick from strict record rejects excess properties', () => {
+      const strictPicked = pick(strictRecord, ['id', 'name']);
+      const data = { id: '123', name: 'John', extra: 'not allowed' };
+
+      const result = strictPicked.validate(data);
+      expect(Result.isErr(result)).toBe(true);
+    });
+
+    test('pick from permissive record accepts excess properties', () => {
+      const permissivePicked = pick(permissiveRecord, ['id', 'name']);
+      const data = { id: '123', name: 'John', extra: 'allowed' };
+
+      const result = permissivePicked.validate(data);
+      expect(Result.isOk(result)).toBe(true);
+    });
+  });
+});