ts-fortress 2.2.1 → 2.3.0

package/src/primitives/undefined.test.mts

@@ -175,5 +175,14 @@ describe('undefinedType', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = undefined;
+      const result = undefinedType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 });

package/src/record/key-value-record.mts

@@ -1,12 +1,14 @@
-import { isRecord, Result } from 'ts-data-forge';
+import { Arr, isRecord, Result } from 'ts-data-forge';
 import { type Type, type TypeOf } from '../type.mjs';
-import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
 import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
   createPrimitiveValidationError,
   prependPathToValidationErrors,
   type ValidationError,
   type ValidationErrorWithMessage,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 
 type RecordResultType<
   K extends Type<string>,
@@ -36,43 +38,39 @@ export const keyValueRecord = <K extends Type<string>, V extends Type<unknown>>(
       ]);
     }
 
-    const errors: readonly ValidationError[] = Object.entries(a).flatMap(
-      ([k, v]) => {
-        const keyErrors = (() => {
+    const errors: readonly ValidationError[] = Arr.generate(function* () {
+      for (const [k, v] of Object.entries(a)) {
+        {
           const res = keyType.validate(k);
-          return Result.isErr(res)
-            ? [
-                {
-                  path: [],
-                  actualValue: k,
-                  expectedType: typeName,
-                  message: `The key of the record is expected to be <${keyType.typeName}>`,
-                  typeName,
-                } satisfies ValidationErrorWithMessage,
-                ...res.value,
-              ]
-            : [];
-        })();
 
-        const valueErrors = (() => {
+          if (Result.isErr(res)) {
+            yield {
+              path: [],
+              actualValue: k,
+              expectedType: typeName,
+              message: `The key of the record is expected to be <${keyType.typeName}>`,
+              typeName,
+            } satisfies ValidationErrorWithMessage;
+
+            yield* res.value;
+          }
+        }
+        {
           const res = valueType.validate(v);
-          return Result.isErr(res)
-            ? [
-                {
-                  path: [],
-                  actualValue: v,
-                  expectedType: typeName,
-                  message: `The value of the record is expected to be <${valueType.typeName}>`,
-                  typeName,
-                } satisfies ValidationErrorWithMessage,
-                ...prependPathToValidationErrors(res.value, k),
-              ]
-            : [];
-        })();
+          if (Result.isErr(res)) {
+            yield {
+              path: [],
+              actualValue: v,
+              expectedType: typeName,
+              message: `The value of the record is expected to be <${valueType.typeName}>`,
+              typeName,
+            } satisfies ValidationErrorWithMessage;
 
-        return [...keyErrors, ...valueErrors];
-      },
-    );
+            yield* prependPathToValidationErrors(res.value, k);
+          }
+        }
+      }
+    });
 
     if (errors.length > 0) {
       return Result.err(errors);

package/src/record/key-value-record.test.mts

@@ -4,7 +4,7 @@ import { type TypeOf } from '../type.mjs';
 import {
   type ValidationError,
   validationErrorsToMessages,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 import { keyValueRecord } from './key-value-record.mjs';
 
 describe('keyValueRecord', () => {
@@ -74,6 +74,19 @@ describe('keyValueRecord', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input: UnknownRecord = {
+        year: 2000,
+        month: 12,
+        date: 25,
+      };
+      const result = strNumRecord.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('falsy case', () => {
       const x: UnknownRecord = {
         year: 2000,

package/src/record/keyof.test.mts

@@ -1,7 +1,7 @@
 import { expectType, Result } from 'ts-data-forge';
 import { number } from '../primitives/index.mjs';
 import { type Type, type TypeOf } from '../type.mjs';
-import { validationErrorsToMessages } from '../validation-error.mjs';
+import { validationErrorsToMessages } from '../utils/index.mjs';
 import { keyof } from './keyof.mjs';
 import { record } from './record.mjs';
 
@@ -61,6 +61,15 @@ describe('keyof', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = 'year';
+      const result = ymdKey.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('falsy case', () => {
       const x: unknown = 'minutes';
 

package/src/record/omit.mts

@@ -1,7 +1,11 @@
 import { expectType, isRecord, Obj, Result } from 'ts-data-forge';
 import { type Type, type TypeOf } from '../type.mjs';
-import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
-import { createPrimitiveValidationError } from '../validation-error.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  createPrimitiveValidationError,
+} from '../utils/index.mjs';
 
 /** Creates a record type with keys omitted. */
 export const omit = <
@@ -43,9 +47,8 @@ export const omit = <
 
     const baseValidationResult = recordType.validate(objectFilled);
 
-    return Result.map(baseValidationResult, Obj.omit(keysToOmit)) as ReturnType<
-      Type<V>['validate']
-    >;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    return Result.map(baseValidationResult, () => a as V);
   };
 
   const fill: Type<V>['fill'] = (a) => Obj.omit(recordType.fill(a), keysToOmit);

package/src/record/omit.test.mts

@@ -1,7 +1,7 @@
 import { expectType, Result } from 'ts-data-forge';
 import { number } from '../primitives/index.mjs';
 import { type Type, type TypeOf } from '../type.mjs';
-import { validationErrorsToMessages } from '../validation-error.mjs';
+import { validationErrorsToMessages } from '../utils/index.mjs';
 import { omit } from './omit.mjs';
 import { record } from './record.mjs';
 
@@ -73,6 +73,51 @@ describe('omit', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input: UnknownRecord = {
+        year: 2000,
+        month: 12,
+      };
+      const result = ym.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
+    test('truthy case with additional keys', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 12,
+        aaa: 999,
+      };
+
+      const result = ym.validate(x);
+      expect(Result.isOk(result)).toBe(true);
+
+      if (Result.isOk(result)) {
+        expectType<typeof result.value, Ym>('=');
+        expect(result.value).toStrictEqual({
+          year: 2000,
+          month: 12,
+          aaa: 999,
+        });
+      }
+    });
+
+    test('validate returns input as-is for OK cases with additional keys', () => {
+      const input: UnknownRecord = {
+        year: 2000,
+        month: 12,
+        aaa: 999,
+      };
+      const result = ym.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('falsy case', () => {
       const x: UnknownRecord = {
         year: 2000,

package/src/record/partial.mts

@@ -1,7 +1,11 @@
 import { expectType, ISet, isRecord, Obj, Result } from 'ts-data-forge';
 import { type Type, type TypeOf } from '../type.mjs';
-import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
-import { createPrimitiveValidationError } from '../validation-error.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  createPrimitiveValidationError,
+} from '../utils/index.mjs';
 
 /**
  * Creates a Partial type. If keysToBeOptional is set, only those keys are
@@ -58,9 +62,7 @@ export const partial = <
     const validationResult = recordType.validate(objectFilled);
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    return Result.map(validationResult, Obj.pick(Object.keys(a))) as ReturnType<
-      Type<V>['validate']
-    >;
+    return Result.map(validationResult, () => a as V);
   };
 
   const fill: Type<V>['fill'] = (a) => {

package/src/record/partial.test.mts

@@ -4,7 +4,7 @@ import { type Type, type TypeOf } from '../type.mjs';
 import {
   type ValidationError,
   validationErrorsToMessages,
-} from '../validation-error.mjs';
+} from '../utils/index.mjs';
 import { optional } from './optional.mjs';
 import { partial } from './partial.mjs';
 import { record } from './record.mjs';
@@ -88,6 +88,19 @@ describe('partial', () => {
         }
       });
 
+      test('validate returns input as-is for OK cases', () => {
+        const input: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 25,
+        };
+        const result = ymd.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
       test('truthy case optional keys', () => {
         const x: UnknownRecord = {};
 
@@ -100,6 +113,51 @@ describe('partial', () => {
         }
       });
 
+      test('validate returns input as-is for empty object', () => {
+        const input: UnknownRecord = {};
+        const result = ymd.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
+      test('truthy case with additional keys', () => {
+        const x: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 25,
+          aaa: 999,
+        };
+
+        const result = ymd.validate(x);
+        expectType<typeof result, Result<Ymd, readonly ValidationError[]>>('=');
+        expect(Result.isOk(result)).toBe(true);
+
+        if (Result.isOk(result)) {
+          expect(result.value).toStrictEqual({
+            year: 2000,
+            month: 12,
+            date: 25,
+            aaa: 999,
+          });
+        }
+      });
+
+      test('validate returns input as-is for OK cases with additional keys', () => {
+        const input: UnknownRecord = {
+          year: 2000,
+          month: 12,
+          date: 25,
+          aaa: 999,
+        };
+        const result = ymd.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
       test('falsy case 1', () => {
         const x: UnknownRecord = {
           year: 2000,
@@ -287,6 +345,18 @@ describe('partial', () => {
         }
       });
 
+      test('partiallyPartialType validate returns input as-is for OK cases', () => {
+        const input: UnknownRecord = {
+          year: 2000,
+          month: 12,
+        };
+        const result = ymd.validate(input);
+        expect(Result.isOk(result)).toBe(true);
+        if (Result.isOk(result)) {
+          expect(result.value).toBe(input); // ✅ same reference
+        }
+      });
+
       test('falsy case', () => {
         const x: UnknownRecord = {
           year: 2000,

package/src/record/pick.mts

@@ -1,7 +1,11 @@
 import { expectType, isRecord, Obj, Result } from 'ts-data-forge';
 import { type Type, type TypeOf } from '../type.mjs';
-import { createAssertFn, createCastFn, createIsFn } from '../utils/index.mjs';
-import { createPrimitiveValidationError } from '../validation-error.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  createPrimitiveValidationError,
+} from '../utils/index.mjs';
 
 /** Creates a record type with keys picked. */
 export const pick = <
@@ -44,9 +48,7 @@ export const pick = <
     const baseValidationResult = recordType.validate(objectFilled);
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    return Result.map(baseValidationResult, Obj.pick(keysToPick)) as ReturnType<
-      Type<V>['validate']
-    >;
+    return Result.map(baseValidationResult, () => a as V);
   };
 
   const fill: Type<V>['fill'] = (a) =>

package/src/record/pick.test.mts

@@ -1,7 +1,7 @@
 import { expectType, Result } from 'ts-data-forge';
 import { number } from '../primitives/index.mjs';
 import { type Type, type TypeOf } from '../type.mjs';
-import { validationErrorsToMessages } from '../validation-error.mjs';
+import { validationErrorsToMessages } from '../utils/index.mjs';
 import { pick } from './pick.mjs';
 import { record } from './record.mjs';
 
@@ -73,6 +73,51 @@ describe('pick', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input: UnknownRecord = {
+        year: 2000,
+        month: 12,
+      };
+      const result = ym.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
+    test('truthy case with additional keys', () => {
+      const x: UnknownRecord = {
+        year: 2000,
+        month: 12,
+        aaa: 999,
+      };
+
+      const result = ym.validate(x);
+      expect(Result.isOk(result)).toBe(true);
+
+      if (Result.isOk(result)) {
+        expectType<typeof result.value, Ym>('=');
+        expect(result.value).toStrictEqual({
+          year: 2000,
+          month: 12,
+          aaa: 999,
+        });
+      }
+    });
+
+    test('validate returns input as-is for OK cases with additional keys', () => {
+      const input: UnknownRecord = {
+        year: 2000,
+        month: 12,
+        aaa: 999,
+      };
+      const result = ym.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('falsy case', () => {
       const x: UnknownRecord = {
         year: 2000,

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

@@ -1,6 +1,6 @@
 import { Result } from 'ts-data-forge';
 import { number } from '../primitives/index.mjs';
-import { validationErrorsToMessages } from '../validation-error.mjs';
+import { validationErrorsToMessages } from '../utils/index.mjs';
 import { record } from './record.mjs';
 
 describe('record allowExcessProperties option', () => {
@@ -73,6 +73,15 @@ describe('record allowExcessProperties option', () => {
     }
   });
 
+  test('strictRecord validate returns input as-is for OK cases', () => {
+    const input = { name: 42, age: 25 };
+    const result = strictRecord.validate(input);
+    expect(Result.isOk(result)).toBe(true);
+    if (Result.isOk(result)) {
+      expect(result.value).toBe(input); // ✅ same reference
+    }
+  });
+
   test('allowExcessProperties: true - accepts excess properties', () => {
     const dataWithExcess = {
       name: 42,
@@ -94,6 +103,15 @@ describe('record allowExcessProperties option', () => {
     }
   });
 
+  test('permissiveRecord validate returns input as-is for OK cases', () => {
+    const input = { name: 42, age: 25, extra: 'allowed' };
+    const result = permissiveRecord.validate(input);
+    expect(Result.isOk(result)).toBe(true);
+    if (Result.isOk(result)) {
+      expect(result.value).toBe(input); // ✅ same reference
+    }
+  });
+
   test('default behavior - allows excess properties (allowExcessProperties defaults to true)', () => {
     const dataWithExcess = {
       name: 42,
@@ -115,6 +133,15 @@ describe('record allowExcessProperties option', () => {
     }
   });
 
+  test('defaultRecord validate returns input as-is for OK cases', () => {
+    const input = { name: 42, age: 25, extra: 'allowed by default' };
+    const result = defaultRecord.validate(input);
+    expect(Result.isOk(result)).toBe(true);
+    if (Result.isOk(result)) {
+      expect(result.value).toBe(input); // ✅ same reference
+    }
+  });
+
   test('allowExcessProperties: false - multiple excess properties', () => {
     const dataWithMultipleExcess = {
       name: 42,

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

@@ -48,6 +48,16 @@ describe('record strict composition - simple tests', () => {
         expect(result.value).toStrictEqual({ id: '123', name: 'John' });
       }
     });
+
+    test('pickedType validate returns input as-is for OK cases', () => {
+      const pickedType = pick(strictRecord, ['id', 'name']);
+      const input = { id: '123', name: 'John' };
+      const result = pickedType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 
   describe('omit behavior with strict record', () => {
@@ -108,6 +118,15 @@ describe('record strict composition - simple tests', () => {
       expect(Result.isErr(result)).toBe(true);
     });
 
+    test('strictRecord validate returns input as-is for OK cases', () => {
+      const input = { id: '123', name: 'John', age: 25 };
+      const result = strictRecord.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('permissive record accepts excess properties', () => {
       const data = { id: '123', name: 'John', age: 25, extra: 'allowed' };
 
@@ -115,6 +134,15 @@ describe('record strict composition - simple tests', () => {
       expect(Result.isOk(result)).toBe(true);
     });
 
+    test('permissiveRecord validate returns input as-is for OK cases', () => {
+      const input = { id: '123', name: 'John', age: 25, extra: 'allowed' };
+      const result = permissiveRecord.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('pick from strict record rejects excess properties', () => {
       const strictPicked = pick(strictRecord, ['id', 'name']);
       const data = { id: '123', name: 'John', extra: 'not allowed' };
@@ -130,5 +158,15 @@ describe('record strict composition - simple tests', () => {
       const result = permissivePicked.validate(data);
       expect(Result.isOk(result)).toBe(true);
     });
+
+    test('permissivePicked validate returns input as-is for OK cases', () => {
+      const permissivePicked = pick(permissiveRecord, ['id', 'name']);
+      const input = { id: '123', name: 'John', extra: 'allowed' };
+      const result = permissivePicked.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 });