feat!: convert Date type to number (#18)

Co-authored-by: Javier Ferrer González <javier.ferrer@codely.com>

Author: rgomezcasas

src/Primitives.ts

@@ -7,21 +7,27 @@ type MethodsAndProperties<T> = { [key in keyof T]: T[key] };
 
 type Properties<T> = Omit<MethodsAndProperties<T>, Methods<T>>;
 
-type PrimitiveTypes = string | number | boolean | Date | undefined | null;
+type PrimitiveTypes = string | number | boolean | undefined | null;
+
+type DateToNumber<T> = T extends Date ? number : T;
 
 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>]: unknown }
-					? { [K in keyof Properties<T>]: ValueObjectValue<Properties<T>[K]> }
-					: T extends unknown
-						? T
-						: never;
+	: T extends Date
+		? number
+		: T extends { value: infer U }
+			? DateToNumber<U>
+			: T extends Array<{ value: infer U }>
+				? DateToNumber<U>[]
+				: T extends Array<infer U>
+					? Array<ValueObjectValue<U>>
+					: T extends { [K in keyof Properties<T>]: unknown }
+						? {
+								[K in keyof Properties<T>]: ValueObjectValue<Properties<T>[K]>;
+							}
+						: T extends unknown
+							? DateToNumber<T>
+							: never;
 
 export type Primitives<T> = {
 	[key in keyof Properties<T>]: ValueObjectValue<T[key]>;

tests/Primitives.test.ts

@@ -6,6 +6,7 @@ import { DeliveryInfo } from "./DeliveryInfo";
 import { Learner } from "./Learner";
 import { Metadata } from "./Metadata";
 import { Product } from "./Product";
+import { Step } from "./Step";
 import { User } from "./User";
 import { Video } from "./Video";
 
@@ -63,7 +64,18 @@ describe("Primitives", () => {
 
 		type expectedPrimitives = {
 			readonly active: boolean;
-			readonly createdAt: Date;
+			readonly name: string;
+		};
+
+		expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+	});
+
+	it("should get primitive number type from Date", () => {
+		type actualPrimitives = Primitives<Step>;
+
+		type expectedPrimitives = {
+			readonly name: string;
+			readonly publishedAt: number;
 		};
 
 		expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();

tests/Product.ts

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

tests/Step.ts

@@ -0,0 +1,15 @@
+import { Primitives } from "../src";
+
+export class Step {
+	constructor(
+		public readonly name: string,
+		public readonly publishedAt: Date,
+	) {}
+
+	toPrimitives(): Primitives<Step> {
+		return {
+			name: this.name,
+			publishedAt: this.publishedAt.getTime(),
+		};
+	}
+}