ts-fortress 2.2.1 → 2.2.2

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
+      }
+    });
   });
 });

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

@@ -39,6 +39,15 @@ describe('record strict composition tests', () => {
       }
     });
 
+    test('pickedType validate returns input as-is for OK cases', () => {
+      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
+      }
+    });
+
     test('rejects data with excess properties (inherits strict behavior)', () => {
       const dataWithExcess = { id: '123', name: 'John', extra: 'not allowed' };
 
@@ -94,6 +103,15 @@ describe('record strict composition tests', () => {
       }
     });
 
+    test('omittedType validate returns input as-is for OK cases', () => {
+      const input = { id: '123', name: 'John' };
+      const result = omittedType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('rejects data with excess properties (inherits strict behavior)', () => {
       const dataWithExcess = { id: '123', name: 'John', extra: 'not allowed' };
 
@@ -123,6 +141,7 @@ describe('record strict composition tests', () => {
 
       if (Result.isOk(result)) {
         expect(result.value).toStrictEqual({
+          age: 25,
           id: '123',
           name: 'John',
         });
@@ -150,6 +169,15 @@ describe('record strict composition tests', () => {
       }
     });
 
+    test('partialType validate returns input as-is for OK cases', () => {
+      const input = { id: '123', name: 'John' };
+      const result = partialType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('accepts empty object (all fields optional)', () => {
       const emptyData = {};
 
@@ -164,6 +192,15 @@ describe('record strict composition tests', () => {
       }
     });
 
+    test('partialType validate returns input as-is for empty object', () => {
+      const input = {};
+      const result = partialType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('rejects data with excess properties (inherits strict behavior)', () => {
       const dataWithExcess = { id: '123', name: 'John', extra: 'not allowed' };
 
@@ -206,6 +243,18 @@ describe('record strict composition tests', () => {
       }
     });
 
+    test('partiallyPartialType validate returns input as-is for OK cases', () => {
+      const partiallyPartialType = partial(strictBaseRecord, {
+        keysToBeOptional: ['age', 'email'],
+      });
+      const input = { id: '123', name: 'John' };
+      const result = partiallyPartialType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('partially partial rejects missing required fields', () => {
       const partiallyPartialType = partial(strictBaseRecord, {
         keysToBeOptional: ['age', 'email'],
@@ -362,6 +411,17 @@ describe('record strict composition tests', () => {
       }
     });
 
+    test('pickedPartialType validate returns input as-is for OK cases', () => {
+      const partialType = partial(strictBaseRecord);
+      const pickedPartialType = pick(partialType, ['id', 'name']);
+      const input = { id: '123', name: 'John' };
+      const result = pickedPartialType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('partial of pick of strict record', () => {
       const pickedType = pick(strictBaseRecord, ['id', 'name']);
       const partialPickedType = partial(pickedType);
@@ -381,6 +441,17 @@ describe('record strict composition tests', () => {
       }
     });
 
+    test('partialPickedType validate returns input as-is for OK cases', () => {
+      const pickedType = pick(strictBaseRecord, ['id', 'name']);
+      const partialPickedType = partial(pickedType);
+      const input = { id: '123' };
+      const result = partialPickedType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('nested compositions reject excess properties', () => {
       const partialType = partial(strictBaseRecord);
       const pickedPartialType = pick(partialType, ['id', 'name']);

package/src/record/record.mts

@@ -1,12 +1,14 @@
-import { isRecord, Result, tp } from 'ts-data-forge';
+import { Arr, isRecord, Result, tp } 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';
 
 export const record = <const R extends ReadonlyRecord<string, Type<unknown>>>(
   source: R,
@@ -48,32 +50,31 @@ export const record = <const R extends ReadonlyRecord<string, Type<unknown>>>(
       ]);
     }
 
-    const defaultErrors: readonly ValidationError[] = Object.entries(
-      source,
-    ).flatMap(([k, valueType]) => {
-      if (!Object.hasOwn(a, k)) {
-        if (source[k]?.optional === true) return [];
-
-        return [
-          {
-            path: [k],
-            actualValue: a,
-            typeName: typeNameFilled,
-            expectedType: typeNameFilled,
-            message: `Missing required key "${k}"`,
-          } satisfies ValidationErrorWithMessage,
-        ];
-      }
-
-      const v = a[k];
-      const res = valueType.validate(v);
-
-      if (Result.isErr(res)) {
-        return prependPathToValidationErrors(res.value, k);
-      }
-
-      return [];
-    });
+    const defaultErrors: readonly ValidationError[] = Arr.generate(
+      function* () {
+        for (const [k, valueType] of Object.entries(source)) {
+          if (!Object.hasOwn(a, k)) {
+            if (source[k]?.optional !== true) {
+              yield {
+                path: [k],
+                actualValue: a,
+                typeName: typeNameFilled,
+                expectedType: typeNameFilled,
+                message: `Missing required key "${k}"`,
+              } satisfies ValidationErrorWithMessage;
+            }
+          } else {
+            // The case where the key exists in the object
+            const v = a[k];
+            const res = valueType.validate(v);
+
+            if (Result.isErr(res)) {
+              yield* prependPathToValidationErrors(res.value, k);
+            }
+          }
+        }
+      },
+    );
 
     // Check for excess properties if allowExcessProperties is false
     if (!allowExcessProperties) {

package/src/record/record.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 { optional } from './optional.mjs';
 import { record } from './record.mjs';
 
@@ -143,6 +143,19 @@ describe('record', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = {
+        year: 2023,
+        month: 6,
+        date: 15,
+      };
+      const result = ymd.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 
   describe('fill', () => {
@@ -311,6 +324,18 @@ describe('partial record', () => {
         ]);
       }
     });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = {
+        year: 2024,
+        month: 8,
+      };
+      const result = ymd.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
   });
 
   describe('fill', () => {

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

@@ -1,7 +1,7 @@
 import { expectType, Result } from 'ts-data-forge';
 import { number, string } from '../primitives/index.mjs';
 import { type TypeOf } from '../type.mjs';
-import { validationErrorsToMessages } from '../validation-error.mjs';
+import { validationErrorsToMessages } from '../utils/index.mjs';
 import { record, strictRecord } from './record.mjs';
 
 describe('strictRecord', () => {
@@ -49,6 +49,15 @@ describe('strictRecord', () => {
       }
     });
 
+    test('validate returns input as-is for OK cases', () => {
+      const input = { name: 'John', age: 30 };
+      const result = userType.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      if (Result.isOk(result)) {
+        expect(result.value).toBe(input); // ✅ same reference
+      }
+    });
+
     test('falsy case - excess properties', () => {
       const userWithExtra = { name: 'John', age: 30, extra: 'not allowed' };
 

package/src/type.mts

@@ -1,5 +1,5 @@
 import { type Result } from 'ts-data-forge';
-import { type ValidationError } from './validation-error.mjs';
+import { type ValidationError } from './utils/index.mjs';
 
 /**
  * - `typeName` : Name for this type

package/src/utils/create-assert-fn.mts

@@ -3,7 +3,7 @@ import { type Type } from '../type.mjs';
 import {
   validationErrorsToMessages,
   type ValidationError,
-} from '../validation-error.mjs';
+} from './validation-error.mjs';
 
 const validationResultToString = (result: readonly ValidationError[]): string =>
   `\n${validationErrorsToMessages(result).join(',\n')}`;

package/src/utils/create-cast-fn.mts

@@ -3,7 +3,7 @@ import { type Type } from '../type.mjs';
 import {
   validationErrorsToMessages,
   type ValidationError,
-} from '../validation-error.mjs';
+} from './validation-error.mjs';
 
 const validationResultToString = (result: readonly ValidationError[]): string =>
   `\n${validationErrorsToMessages(result).join(',\n')}`;

package/src/utils/create-primitive-type.mts

@@ -1,8 +1,8 @@
 import { Result } from 'ts-data-forge';
 import { type Type } from '../type.mjs';
-import { createPrimitiveValidationError } from '../validation-error.mjs';
 import { createAssertFn } from './create-assert-fn.mjs';
 import { createCastFn } from './create-cast-fn.mjs';
+import { createPrimitiveValidationError } from './validation-error.mjs';
 
 export const createPrimitiveType = <A extends Primitive>({
   typeName,

package/src/utils/index.mts

@@ -3,3 +3,4 @@ export * from './create-cast-fn.mjs';
 export * from './create-is-fn.mjs';
 export * from './create-primitive-type.mjs';
 export * from './create-type.mjs';
+export * from './validation-error.mjs';

package/dist/validation-error.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation-error.d.mts","sourceRoot":"","sources":["../src/validation-error.mts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,iFAAiF;IACjF,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,8CAA8C;IAC9C,WAAW,EAAE,OAAO,CAAC;IACrB,sCAAsC;IACtC,YAAY,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,iBAAiB,CACxD,UAAU,CAAC,eAAe,EAAE,SAAS,CAAC,GAAG,QAAQ,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CACvE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAI,OAAO,eAAe,KAAG,MASjE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GACrC,QAAQ,SAAS,eAAe,EAAE,KACjC,SAAS,MAAM,EAA0C,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,6BAA6B,GACxC,QAAQ,SAAS,eAAe,EAAE,EAClC,aAAa,MAAM,KAClB,SAAS,eAAe,EAItB,CAAC;AAEN;;GAEG;AACH,eAAO,MAAM,8BAA8B,GACzC,QAAQ,SAAS,eAAe,EAAE,EAClC,OAAO,MAAM,KACZ,SAAS,eAAe,EAC8B,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,8BAA8B,GAAI,0CAI5C,QAAQ,CAAC;IACV,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,KAAG,eAMH,CAAC"}

package/dist/validation-error.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation-error.mjs","sources":["../src/validation-error.mts"],"sourcesContent":[null],"names":[],"mappings":"AAoBA;;AAEG;AACI,MAAM,wBAAwB,GAAG,CAAC,KAAsB,KAAY;IACzE,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,GAAG,CAAA,IAAA,EAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA,CAAE,GAAG,EAAE;AAC1E,IAAA,MAAM,aAAa,GAAG,OAAO,KAAK,CAAC,WAAW;AAE9C,IAAA,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE;AAC/B,QAAA,OAAO,GAAG,KAAK,CAAC,OAAO,CAAA,EAAG,OAAO,EAAE;IACrC;IAEA,OAAO,CAAA,SAAA,EAAY,KAAK,CAAC,YAAY,GAAG,OAAO,CAAA,MAAA,EAAS,aAAa,CAAA,CAAE;AACzE;AAEA;;;AAGG;AACI,MAAM,0BAA0B,GAAG,CACxC,MAAkC,KACZ,MAAM,CAAC,GAAG,CAAC,wBAAwB;AAE3D;;AAEG;MACU,6BAA6B,GAAG,CAC3C,MAAkC,EAClC,WAAmB,KAEnB,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,MAAM;AACrB,IAAA,GAAG,KAAK;IACR,IAAI,EAAE,CAAC,WAAW,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC;AACnC,CAAA,CAAC;AAEJ;;AAEG;MACU,8BAA8B,GAAG,CAC5C,MAAkC,EAClC,KAAa,KAEb,6BAA6B,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE;AAExD;;AAEG;AACI,MAAM,8BAA8B,GAAG,CAAC,EAC7C,WAAW,EACX,YAAY,EACZ,QAAQ,GAKR,MAAuB;AACvB,IAAA,IAAI,EAAE,EAAE;IACR,WAAW;IACX,YAAY;IACZ,QAAQ;AACR,IAAA,OAAO,EAAE,SAAS;AACnB,CAAA;;;;"}