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(
+extends TraitExpressionBuilder<Superclass, Traits> {
-        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
-    extends<
+    //         Traits
-        This  extends ZodSchemaClassBuilder<
+    //     >,
-            typeof TraitExpression.NullSuperclass,  // Ensures `extends` can only be called when the expression does not have a superclass
+    //     Super extends AbstractClass<object, []>,
-            Traits
+    // >(
-        >,
+    //     this:        This,
-        Super extends AbstractClass<object, []>,
+    //     superclass:  Super,
-    >(
+    // ) {
-        this:        This,
+    //     return new ZodSchemaClassBuilder(
-        superclass:  Super,
+    //         this.expressionBuilder.extends(superclass)
-    ) {
+    //     )
-        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(
+        return this
-            this.expressionBuilder
+            .extends(Schemas as unknown as (
-                .extends(Schemas as unknown as (
+                AbstractClass<
-                    AbstractClass<
+                    InstanceType<Superclass> &
-                        InstanceType<Superclass> &
-                        Simplify<
-                            Extend<[Schemas, Values]>
-                        >,
-
-                        ConstructorParameters<typeof Schemas>
-                    > &
                     Simplify<
-                        Extend<[
+                        Extend<[Schemas, Values]>
-                            StaticMembers<Superclass>,
+                    >,
-                            StaticMembers<typeof Schemas>,
+
-                        ]>
+                    ConstructorParameters<typeof Schemas>
-                    >
+                > &
-                ))
+                Simplify<
-                .expresses(
+                    Extend<[
-                    InstantiableZodSchemaObject,
+                        StaticMembers<Superclass>,
-                    ExtendableZodSchemaObject,
+                        StaticMembers<typeof Schemas>,
-                )
+                    ]>
-        )
+                >
+            ))
+            .expresses(
+                InstantiableZodSchemaObject,
+                ExtendableZodSchemaObject,
+            )
     }
 
     jsonifiable() {
 
     }
-
-    toBuilder() {
-        return this.expressionBuilder
-    }
 }
 
 

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