feat: add unknown properties support (#11)

* test: add Metadata class and test for inferring primitive properties from metadata * fix: update ValueObjectValue type to handle unknown key properties * test: refine title test case to infer properties with unknown type * chore: update package version Co-authored-by: Javier Ferrer González <[email protected]>
CodelyTV · Sep 4, 2024 · 617e4df · 617e4df
1 parent f11bad7
commit 617e4df
Show file tree

Hide file tree

Showing 5 changed files with 28 additions and 4 deletions.
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@codelytv/primitives-type",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "Type entity primitives from value objects",
   "keywords": [
     "typescript",

diff --git a/src/Primitives.ts b/src/Primitives.ts
@@ -17,8 +17,10 @@ type ValueObjectValue<T> = T extends PrimitiveTypes
   ? U[]
   : T extends Array<infer U>
   ? Array<ValueObjectValue<U>>
-  : T extends { [K in keyof Properties<T>]: infer U }
+  : T extends { [K in keyof Properties<T>]: unknown }
   ? { [K in keyof Properties<T>]: ValueObjectValue<Properties<T>[K]> }
+  : T extends unknown
+  ? T
   : never;
 
 export type Primitives<T> = {

diff --git a/tests/Metadata.ts b/tests/Metadata.ts
@@ -0,0 +1,11 @@
+import { Primitives } from "../src";
+
+export class Metadata {
+  constructor(public readonly data: Record<string, unknown>) {}
+
+  toPrimitives(): Primitives<Metadata> {
+    return {
+      data: this.data,
+    };
+  }
+}
diff --git a/tests/Primitives.test.ts b/tests/Primitives.test.ts
@@ -4,6 +4,7 @@ import { Primitives } from "../src";
 import { Course } from "./Course";
 import { DeliveryInfo } from "./DeliveryInfo";
 import { Learner } from "./Learner";
+import { Metadata } from "./Metadata";
 import { Product } from "./Product";
 import { User } from "./User";
 import { Video } from "./Video";
@@ -79,4 +80,14 @@ describe("Primitives", () => {
 
     expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
   });
+
+  it("should infer properties with unknown type", () => {
+    type actualPrimitives = Primitives<Metadata>;
+
+    type expectedPrimitives = {
+      readonly data: Record<string, unknown>;
+    };
+
+    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+  });
 });