From a8003da29ccf6a1a7418a19c4585fefe74aad852 Mon Sep 17 00:00:00 2001
From: FerbDev <fsepulveda02@icloud.com>
Date: Sun, 25 Feb 2024 19:35:54 -0300
Subject: [PATCH 1/2] Add MutablePrimitives.ts for cases when create editable
 object

---
 src/MutablePrimitives.ts        | 30 ++++++++++++
 src/index.ts                    |  3 +-
 tests/MutablePrimitives.test.ts | 81 +++++++++++++++++++++++++++++++++
 3 files changed, 113 insertions(+), 1 deletion(-)
 create mode 100644 src/MutablePrimitives.ts
 create mode 100644 tests/MutablePrimitives.test.ts

diff --git a/src/MutablePrimitives.ts b/src/MutablePrimitives.ts
new file mode 100644
index 0000000..26e55c3
--- /dev/null
+++ b/src/MutablePrimitives.ts
@@ -0,0 +1,30 @@
+/* eslint-disable @typescript-eslint/ban-types */
+type Methods<T> = {
+  [P in keyof T]: T[P] extends Function ? P : never;
+}[keyof T];
+
+type MethodsAndProperties<T> = { [key in keyof T]: T[key] };
+
+type NonReadonly<T> = {
+  -readonly [P in keyof T]: T[P];
+};
+
+type Properties<T> = Omit<MethodsAndProperties<NonReadonly<T>>, Methods<T>>;
+
+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<Properties<T>[K]> }
+          : never;
+
+export type MutablePrimitives<T> = {
+  [key in keyof Properties<T>]: ValueObjectValue<T[key]>;
+};
\ No newline at end of file
diff --git a/src/index.ts b/src/index.ts
index 6e993fc..96cc1b3 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,3 +1,4 @@
 import { Primitives } from "./Primitives";
+import { MutablePrimitives } from "./MutablePrimitives";
 
-export { Primitives };
+export { Primitives, MutablePrimitives };
diff --git a/tests/MutablePrimitives.test.ts b/tests/MutablePrimitives.test.ts
new file mode 100644
index 0000000..2ad8906
--- /dev/null
+++ b/tests/MutablePrimitives.test.ts
@@ -0,0 +1,81 @@
+import { expectTypeOf } from "expect-type";
+import { MutablePrimitives } 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("MutablePrimitives", () => {
+  it("should ensure to only return primitive properties excluding methods", () => {
+    type actualPrimitives = MutablePrimitives<Course>;
+
+    type expectedPrimitives = {
+       courseId: string;
+    };
+
+    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+  });
+
+  it("should get primitive array type from value object array", () => {
+    type actualPrimitives = MutablePrimitives<Learner>;
+
+    type expectedPrimitives = {
+       enrolledCourses: string[];
+    };
+
+    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+  });
+
+  it("should generate nested primitive object", () => {
+    type actualPrimitives = MutablePrimitives<User>;
+
+    type expectedPrimitives = {
+       address: {
+         city: string;
+         street: string;
+         number: number;
+      };
+    };
+
+    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+  });
+
+  it("should generate nested primitive type from array of value objects prop", () => {
+    type actualPrimitives = MutablePrimitives<DeliveryInfo>;
+
+    type expectedPrimitives = {
+       addresses: {
+         city: string;
+         street: string;
+         number: number;
+      }[];
+    };
+
+    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+  });
+
+  it("should get primitive type in case it is not a value object", () => {
+    type actualPrimitives = MutablePrimitives<Product>;
+
+    type expectedPrimitives = {
+       active: boolean;
+       createdAt: Date;
+    };
+
+    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+  });
+
+  it("should infer the optional properties", () => {
+    type actualPrimitives = MutablePrimitives<Video>;
+
+    type expectedPrimitives = {
+       id: string;
+       name: string | undefined;
+       duration: number | undefined;
+    };
+
+    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+  });
+});

From 7c5d61b3a4462ca2805ab05bcbf420a204cd0bbf Mon Sep 17 00:00:00 2001
From: FerbDev <fsepulveda02@icloud.com>
Date: Wed, 28 Feb 2024 14:56:06 -0300
Subject: [PATCH 2/2] Fix Lint and type unknown because infer u no used

---
 src/MutablePrimitives.ts        | 18 +++++++++---------
 src/Primitives.ts               |  2 +-
 src/index.ts                    |  4 ++--
 tests/MutablePrimitives.test.ts | 31 ++++++++++++++++---------------
 4 files changed, 28 insertions(+), 27 deletions(-)

diff --git a/src/MutablePrimitives.ts b/src/MutablePrimitives.ts
index 26e55c3..eb4025d 100644
--- a/src/MutablePrimitives.ts
+++ b/src/MutablePrimitives.ts
@@ -16,15 +16,15 @@ 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<Properties<T>[K]> }
-          : never;
+  ? 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]> }
+  : never;
 
 export type MutablePrimitives<T> = {
   [key in keyof Properties<T>]: ValueObjectValue<T[key]>;
-};
\ No newline at end of file
+};
diff --git a/src/Primitives.ts b/src/Primitives.ts
index d620f2a..7facfb5 100644
--- a/src/Primitives.ts
+++ b/src/Primitives.ts
@@ -17,7 +17,7 @@ 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]> }
   : never;
 
diff --git a/src/index.ts b/src/index.ts
index 96cc1b3..253806b 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,4 +1,4 @@
-import { Primitives } from "./Primitives";
 import { MutablePrimitives } from "./MutablePrimitives";
+import { Primitives } from "./Primitives";
 
-export { Primitives, MutablePrimitives };
+export { MutablePrimitives, Primitives };
diff --git a/tests/MutablePrimitives.test.ts b/tests/MutablePrimitives.test.ts
index 2ad8906..d88dbe3 100644
--- a/tests/MutablePrimitives.test.ts
+++ b/tests/MutablePrimitives.test.ts
@@ -1,4 +1,5 @@
 import { expectTypeOf } from "expect-type";
+
 import { MutablePrimitives } from "../src";
 import { Course } from "./Course";
 import { DeliveryInfo } from "./DeliveryInfo";
@@ -12,7 +13,7 @@ describe("MutablePrimitives", () => {
     type actualPrimitives = MutablePrimitives<Course>;
 
     type expectedPrimitives = {
-       courseId: string;
+      courseId: string;
     };
 
     expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
@@ -22,7 +23,7 @@ describe("MutablePrimitives", () => {
     type actualPrimitives = MutablePrimitives<Learner>;
 
     type expectedPrimitives = {
-       enrolledCourses: string[];
+      enrolledCourses: string[];
     };
 
     expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
@@ -32,10 +33,10 @@ describe("MutablePrimitives", () => {
     type actualPrimitives = MutablePrimitives<User>;
 
     type expectedPrimitives = {
-       address: {
-         city: string;
-         street: string;
-         number: number;
+      address: {
+        city: string;
+        street: string;
+        number: number;
       };
     };
 
@@ -46,10 +47,10 @@ describe("MutablePrimitives", () => {
     type actualPrimitives = MutablePrimitives<DeliveryInfo>;
 
     type expectedPrimitives = {
-       addresses: {
-         city: string;
-         street: string;
-         number: number;
+      addresses: {
+        city: string;
+        street: string;
+        number: number;
       }[];
     };
 
@@ -60,8 +61,8 @@ describe("MutablePrimitives", () => {
     type actualPrimitives = MutablePrimitives<Product>;
 
     type expectedPrimitives = {
-       active: boolean;
-       createdAt: Date;
+      active: boolean;
+      createdAt: Date;
     };
 
     expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
@@ -71,9 +72,9 @@ describe("MutablePrimitives", () => {
     type actualPrimitives = MutablePrimitives<Video>;
 
     type expectedPrimitives = {
-       id: string;
-       name: string | undefined;
-       duration: number | undefined;
+      id: string;
+      name: string | undefined;
+      duration: number | undefined;
     };
 
     expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();