From 718a32052d798678f99588536d0c51106b6079df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Julien=20Valverd=C3=A9?= <julien.valverde@mailo.com>
Date: Thu, 22 Feb 2024 04:44:24 +0100
Subject: [PATCH] ZodSchemaClassBuilder work

---
 src/ZodSchemaClass.ts | 85 +++++++++++++++++++------------------------
 src/tests.ts          |  5 +--
 2 files changed, 40 insertions(+), 50 deletions(-)

diff --git a/src/ZodSchemaClass.ts b/src/ZodSchemaClass.ts
index 971167f..5145db6 100644
--- a/src/ZodSchemaClass.ts
+++ b/src/ZodSchemaClass.ts
@@ -1,4 +1,4 @@
-import { Trait, TraitExpression, TraitExpressionBuilder, expression } from "@thilawyn/traitify-ts"
+import { Trait, TraitExpressionBuilder, expression } from "@thilawyn/traitify-ts"
 import { AbstractClass, Simplify } from "type-fest"
 import { z } from "zod"
 import { ExtendableZodSchemaObject } from "./traits/ExtendableZodSchemaObject"
@@ -9,25 +9,22 @@ import { Extend, StaticMembers } from "./util"
 export class ZodSchemaClassBuilder<
     Superclass   extends AbstractClass<object>,
     const Traits extends Trait<any, any, any, any>[],
-> {
-    constructor(
-        private readonly expressionBuilder: TraitExpressionBuilder<Superclass, Traits>
-    ) {}
-
-    extends<
-        This  extends ZodSchemaClassBuilder<
-            typeof TraitExpression.NullSuperclass,  // Ensures `extends` can only be called when the expression does not have a superclass
-            Traits
-        >,
-        Super extends AbstractClass<object, []>,
-    >(
-        this:        This,
-        superclass:  Super,
-    ) {
-        return new ZodSchemaClassBuilder(
-            this.expressionBuilder.extends(superclass)
-        )
-    }
+>
+extends TraitExpressionBuilder<Superclass, Traits> {
+    // extends<
+    //     This  extends ZodSchemaClassBuilder<
+    //         typeof TraitExpression.NullSuperclass,  // Ensures `extends` can only be called when the expression does not have a superclass
+    //         Traits
+    //     >,
+    //     Super extends AbstractClass<object, []>,
+    // >(
+    //     this:        This,
+    //     superclass:  Super,
+    // ) {
+    //     return new ZodSchemaClassBuilder(
+    //         this.expressionBuilder.extends(superclass)
+    //     )
+    // }
 
     schema<
         SchemaT           extends z.ZodRawShape,
@@ -41,7 +38,7 @@ export class ZodSchemaClassBuilder<
         schema:         z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>,
         defaultValues:  DefaultValues,
     ) {
-        class Schemas extends (this.expressionBuilder.expressionSuperclass as AbstractClass<object, []>) {
+        class Schemas extends (this.expressionSuperclass as AbstractClass<object, []>) {
             static readonly schema        = schema
             static readonly defaultValues = defaultValues
 
@@ -51,38 +48,32 @@ export class ZodSchemaClassBuilder<
             }
         }
 
-        return new ZodSchemaClassBuilder(
-            this.expressionBuilder
-                .extends(Schemas as unknown as (
-                    AbstractClass<
-                        InstanceType<Superclass> &
-                        Simplify<
-                            Extend<[Schemas, Values]>
-                        >,
-
-                        ConstructorParameters<typeof Schemas>
-                    > &
+        return this
+            .extends(Schemas as unknown as (
+                AbstractClass<
+                    InstanceType<Superclass> &
                     Simplify<
-                        Extend<[
-                            StaticMembers<Superclass>,
-                            StaticMembers<typeof Schemas>,
-                        ]>
-                    >
-                ))
-                .expresses(
-                    InstantiableZodSchemaObject,
-                    ExtendableZodSchemaObject,
-                )
-        )
+                        Extend<[Schemas, Values]>
+                    >,
+
+                    ConstructorParameters<typeof Schemas>
+                > &
+                Simplify<
+                    Extend<[
+                        StaticMembers<Superclass>,
+                        StaticMembers<typeof Schemas>,
+                    ]>
+                >
+            ))
+            .expresses(
+                InstantiableZodSchemaObject,
+                ExtendableZodSchemaObject,
+            )
     }
 
     jsonifiable() {
 
     }
-
-    toBuilder() {
-        return this.expressionBuilder
-    }
 }
 
 
diff --git a/src/tests.ts b/src/tests.ts
index 228c13c..4ed7404 100644
--- a/src/tests.ts
+++ b/src/tests.ts
@@ -1,10 +1,10 @@
-import { Implements, expression } from "@thilawyn/traitify-ts"
+import { Implements, TraitExpression } from "@thilawyn/traitify-ts"
 import { z } from "zod"
 import { ZodSchemaClass, ZodSchemaClassBuilder } from "./ZodSchemaClass"
 import { ObservableZodSchemaObject } from "./traits/ObservableZodSchemaObject"
 
 
-const newTestExp = new ZodSchemaClassBuilder(expression)
+const newTestExp = new ZodSchemaClassBuilder(TraitExpression.NullSuperclass, [])
     .schema(
         z.object({
             id: z.bigint()
@@ -12,7 +12,6 @@ const newTestExp = new ZodSchemaClassBuilder(expression)
 
         { id: -1n },
     )
-    .toBuilder()
     .expressionSuperclass