TZodSchemaClass work

src/TZodSchemaClass.ts

@@ -1,6 +1,8 @@
-import { Class as ConcreteClass, HasRequiredKeys } from "type-fest"
+import { Effect } from "effect"
+import { AbstractClass, Class as ConcreteClass, HasRequiredKeys, Opaque } from "type-fest"
 import { z } from "zod"
-import { Class, ClassType } from "./util"
+import { DefinedDefaultValuesTag } from "."
+import { Class, ClassType, StaticMembers } from "./util"
 
 
 export type NewZodSchemaInstanceInput<
@@ -22,8 +24,23 @@ export type NewZodSchemaInstanceArgs<Input extends object> =
         : [] | [values: Input, ...args: ParseParamsArgs]
 
 
+type ExtendZodSchemaClass<
+    Parent extends AbstractClass<any>,
+    Self   extends AbstractClass<any>,
+> = (
+    AbstractClass<
+        Omit<InstanceType<Parent>, keyof InstanceType<DefaultZodSchemaClass>> &
+        InstanceType<Self>,
+
+        ConstructorParameters<Self>
+    > &
+
+    Omit<Parent, keyof DefaultZodSchemaClass> &
+    StaticMembers<Self>
+)
+
+
 export type TZodSchemaClass<
-    Schema            extends z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>,
     SchemaT           extends z.ZodRawShape,
     SchemaUnknownKeys extends z.UnknownKeysParam,
     SchemaCatchall    extends z.ZodTypeAny,
@@ -38,7 +55,7 @@ export type TZodSchemaClass<
         Values,
         [values: Values]
     > & {
-        readonly schema:         Schema
+        readonly schema:         z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
         readonly defaultValues:  DefaultValues
 
         instantiate<Self extends ConcreteClass<any>>(
@@ -60,12 +77,48 @@ export type TZodSchemaClass<
             ...[values, params]: NewZodSchemaInstanceArgs<
                 NewZodSchemaInstanceInput<Values, DefaultValues>
             >
-        ): Promise<InstanceType<Self>>
+        ): Effect.Effect<never, z.ZodError<Values>, Values>
 
         extend<
-            Parent
+            Parent                    extends AbstractClass<any>,
+
+            ExtendedSchemaT           extends z.ZodRawShape,
+            ExtendedSchemaUnknownKeys extends z.UnknownKeysParam,
+            ExtendedSchemaCatchall    extends z.ZodTypeAny,
+
+            ExtendedValues            extends Values,
+            ExtendedDefaultValues     extends Partial<ExtendedValues>,
         >(
-            this: Parent
-        ): Parent
+            this: Parent,
+
+            props: {
+                schema: (props: {
+                    schema:  z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
+                    shape:   SchemaT
+                }) => z.ZodObject<ExtendedSchemaT, ExtendedSchemaUnknownKeys, ExtendedSchemaCatchall, ExtendedValues, ExtendedValues>
+
+                defaultValues: (defaultValues: DefaultValues) => Opaque<ExtendedDefaultValues, DefinedDefaultValuesTag>
+            },
+        ): ExtendZodSchemaClass<
+            Parent,
+
+            TZodSchemaClass<
+                ExtendedSchemaT,
+                ExtendedSchemaUnknownKeys,
+                ExtendedSchemaCatchall,
+
+                ExtendedValues,
+                ExtendedDefaultValues
+            >
+        >
     }
 )
+
+export type DefaultZodSchemaClass = TZodSchemaClass<
+    z.ZodRawShape,
+    z.UnknownKeysParam,
+    z.ZodTypeAny,
+
+    {},
+    {}
+>

src/ZodSchemaClass.ts

@@ -1,7 +1,8 @@
+import { Effect, pipe } from "effect"
 import { AbstractClass, Class as ConcreteClass, Opaque } from "type-fest"
 import { z } from "zod"
 import { DefinedDefaultValuesTag, NewZodSchemaInstanceArgs, NewZodSchemaInstanceInput, TZodSchemaClass } from "."
-import { StaticMembers } from "./util"
+import { StaticMembers, parseZodTypeEffect } from "./util"
 
 
 type ExtendableClass = AbstractClass<any, []> & {
@@ -12,7 +13,6 @@ type ExtendableClass = AbstractClass<any, []> & {
 export function ZodSchemaClassOf<
     Parent            extends ExtendableClass,
 
-    Schema            extends z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>,
     SchemaT           extends z.ZodRawShape,
     SchemaUnknownKeys extends z.UnknownKeysParam,
     SchemaCatchall    extends z.ZodTypeAny,
@@ -23,7 +23,7 @@ export function ZodSchemaClassOf<
     of: Parent,
 
     { schema, defaultValues }: {
-        schema:         Schema | z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
+        schema:         z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
         defaultValues:  Opaque<DefaultValues, DefinedDefaultValuesTag>
     },
 ) {
@@ -34,7 +34,6 @@ export function ZodSchemaClassOf<
     )
 
     type TZodSchemaClassImpl = TZodSchemaClass<
-        Schema,
         SchemaT,
         SchemaUnknownKeys,
         SchemaCatchall,
@@ -44,7 +43,7 @@ export function ZodSchemaClassOf<
     >
 
     return class extends (of as unknown as ConcreteClass<any, []>) {
-        static readonly schema = schema
+        static readonly schema        = schema
         static readonly defaultValues = defaultValues
 
         constructor(values: Values) {
@@ -52,7 +51,7 @@ export function ZodSchemaClassOf<
             Object.assign(this, values)
         }
 
-        static async instantiate(
+        static instantiate(
             ...[values, params]: NewZodSchemaInstanceArgs<
                 NewZodSchemaInstanceInput<Values, DefaultValues>
             >
@@ -71,6 +70,52 @@ export function ZodSchemaClassOf<
                 await this.schema.parseAsync({ ...this.defaultValues, ...values }, params)
             )
         }
+
+        static instantiateEffect(
+            ...[values, params]: NewZodSchemaInstanceArgs<
+                NewZodSchemaInstanceInput<Values, DefaultValues>
+            >
+        ) {
+            return pipe(
+                parseZodTypeEffect(
+                    this.schema,
+                    { ...this.defaultValues, ...values },
+                    params,
+                ),
+
+                Effect.map(values => new this(values)),
+            )
+        }
+
+        static extend<
+            ExtendedSchemaT           extends z.ZodRawShape,
+            ExtendedSchemaUnknownKeys extends z.UnknownKeysParam,
+            ExtendedSchemaCatchall    extends z.ZodTypeAny,
+
+            ExtendedValues            extends Values,
+            ExtendedDefaultValues     extends Partial<ExtendedValues>,
+        >(
+            props: {
+                schema: (props: {
+                    schema:  z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
+                    shape:   SchemaT
+                }) => z.ZodObject<ExtendedSchemaT, ExtendedSchemaUnknownKeys, ExtendedSchemaCatchall, ExtendedValues, ExtendedValues>
+
+                defaultValues: (defaultValues: DefaultValues) => Opaque<ExtendedDefaultValues, DefinedDefaultValuesTag>
+            },
+        ) {
+            const schema = props.schema({
+                schema:  this.schema,
+                shape:   this.schema.shape,
+            })
+
+            const defaultValues = props.defaultValues(this.defaultValues)
+
+            return class extends (this as unknown as ConcreteClass<any, []>) {
+                static readonly schema        = schema
+                static readonly defaultValues = defaultValues
+            }
+        }
     } as unknown as (
         Class<
             InstanceType<Parent> &

src/tests.ts

@@ -14,12 +14,24 @@ class Test extends ZodSchemaClassOf(Root, {
 
     defaultValues: defineDefaultValues({ id: -1n }),
 }) {}
+
 Test.defaultValues
 const inst = await Test.instantiatePromise({ id: 1n, name: "" })
-// Test.extend()
 
-console.log(inst)
+class SubTest extends Test.extend({
+    schema: ({ schema }) => schema.extend({
+        prout: z.string()
+    }),
 
-class ChildTest extends Test {}
+    defaultValues: defaultValues => defineDefaultValues({
+        ...defaultValues
+    }),
+}) {}
 
-ChildTest.instantiate({ name: "" })
+const subInst = await SubTest.instantiatePromise({ name: "", prout: "" })
+
+console.log(subInst)
+
+// class ChildTest extends Test {}
+
+// ChildTest.instantiate({ name: "" })