feat: Add support for primitives and undefined values

* test: add more test scenarios

* feat: add support to more types

* restore: restore last version

Author: arnold095

.gitignore

@@ -1,2 +1,3 @@
 node_modules/
-dist/
+dist/
+.idea/

src/Primitives.ts

@@ -7,16 +7,20 @@ type MethodsAndProperties<T> = { [key in keyof T]: T[key] };
 
 type Properties<T> = Omit<MethodsAndProperties<T>, Methods<T>>;
 
-type ValueObjectValue<T> = {
-  [key in keyof T]: T[key] extends { value: unknown }
-    ? Pick<T[key], "value">["value"]
-    : T[key] extends Array<{ value: unknown }>
-    ? Pick<T[key][number], "value">["value"][]
-    : T[key] extends Array<Object>
-    ? Primitives<T[key][number]>[]
-    : T[key] extends Object
-    ? Primitives<T[key]>
-    : T[key];
-};
+type PrimitiveTypes = string | number | boolean | Date | undefined | null;
+
+type ValueObjectValue<T> = T extends PrimitiveTypes
+  ? T
+  : T extends { value: infer U }
+  ? U
+  : T extends Array<{ value: infer U }>
+  ? U[]
+  : T extends Array<infer U>
+  ? Array<ValueObjectValue<U>>
+  : T extends { [K in keyof Properties<T>]: infer U }
+  ? { [K in keyof Properties<T>]: ValueObjectValue<U> }
+  : never;
 
-export type Primitives<T> = ValueObjectValue<Properties<T>>;
+export type Primitives<T> = {
+  [key in keyof Properties<T>]: ValueObjectValue<T[key]>;
+};

tests/Primitives.test.ts

@@ -1,10 +1,12 @@
 import { expectTypeOf } from "expect-type";
 
-import { Primitives } from "../src/Primitives";
+import { Primitives } from "../src";
 import { Course } from "./Course";
 import { DeliveryInfo } from "./DeliveryInfo";
 import { Learner } from "./Learner";
+import { Product } from "./Product";
 import { User } from "./User";
+import { Video } from "./Video";
 
 describe("Primitives", () => {
   it("should ensure to only return primitive properties excluding methods", () => {
@@ -52,4 +54,27 @@ describe("Primitives", () => {
 
     expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
   });
+
+  it("should get primitive type in case it is not a value object", () => {
+    type actualPrimitives = Primitives<Product>;
+
+    type expectedPrimitives = {
+      readonly active: boolean;
+      readonly createdAt: Date;
+    };
+
+    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+  });
+
+  it("should infer the optional properties", () => {
+    type actualPrimitives = Primitives<Video>;
+
+    type expectedPrimitives = {
+      readonly id: string;
+      readonly name: string | undefined;
+      readonly duration: number | undefined;
+    };
+
+    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+  });
 });

tests/Product.ts

@@ -0,0 +1,15 @@
+import { Primitives } from "../src";
+
+export class Product {
+  constructor(
+    public readonly active: boolean,
+    public readonly createdAt: Date
+  ) {}
+
+  toPrimitives(): Primitives<Product> {
+    return {
+      active: this.active,
+      createdAt: this.createdAt,
+    };
+  }
+}

tests/Video.ts

@@ -0,0 +1,19 @@
+import { Primitives } from "../src";
+import { VideoId } from "./VideoId";
+import { VideoName } from "./VideoName";
+
+export class Video {
+  public constructor(
+    public readonly id: VideoId,
+    public readonly name: VideoName | undefined,
+    public readonly duration: number | undefined
+  ) {}
+
+  public toPrimitives(): Primitives<Video> {
+    return {
+      id: this.id.value,
+      name: this.name?.value,
+      duration: this.duration,
+    };
+  }
+}

tests/VideoId.ts

@@ -0,0 +1,3 @@
+import { StringValueObject } from "./StringValueObject";
+
+export class VideoId extends StringValueObject {}

tests/VideoName.ts

@@ -0,0 +1,3 @@
+import { StringValueObject } from "./StringValueObject";
+
+export class VideoName extends StringValueObject {}