src/tests.ts

@@ -2,85 +2,36 @@ import { Implements } from "@thilawyn/traitify-ts"
 import { z } from "zod"
 import { ZodSchemaClass } from "./ZodSchemaClass"
 import { MobXObservableZodSchemaObject } from "./traits/MobXObservableZodSchemaObject"
-import { stripZodObjectDefaults } from "./util"
 
 
-// const exp = zodSchemaClass
-//     .schema({
-//         schema: z.object({
-//             /** User ID */
-//             id: z.bigint(),
-
-//             /** Username */
-//             name: z.string(),
-//         }),
-
-//         schemaWithDefaultValues: s => s.extend({
-//             id: s.shape.id.default(-1n),
-//         }),
-//     })
-//     .jsonifiable({
-//         jsonifySchema: s => s.extend({
-//             id: jsonify.bigint(s.shape.id)
-//         }),
-
-//         dejsonifySchema: s => s.extend({
-//             id: dejsonify.bigint(s.shape.id)
-//         }),
-//     })
-//     .toExpression()
-//     .expresses(MobXObservableZodSchemaObject)
-//     .build()
-
-const exp = ZodSchemaClass(
+const userExp = ZodSchemaClass(
     z.object({
         /** User ID */
         id: z.bigint().default(-1n),
 
         /** Username */
         name: z.string(),
+
+        /** Role */
+        role: z.enum(["User", "Moderator", "Admin"]).default("User"),
     })
 )
     .expresses(MobXObservableZodSchemaObject)
     .build()
 
-const test = stripZodObjectDefaults(
-    z.object({
-        /** User ID */
-        id: z.bigint().default(-1n),
-
-        /** Username */
-        name: z.string(),
-    })
-)
-
-
-@exp.staticImplements
-class User extends exp.extends implements Implements<typeof exp> {}
+@userExp.staticImplements
+class User extends userExp.extends implements Implements<typeof userExp> {}
 
 const inst = User.create({ id: 1n, name: "User" })
 // console.log(inst.name)
 const instEffect = User.createEffect({ id: 1n, name: "User" })
 
-// const jsonifiedUser = await inst.jsonifyPromise()
-// const dejsonifiedInst = await User.dejsonifyPromise(jsonifiedUser)
 
+const adminUserExp = User.extend(s => s.extend({
+    role: z.literal("Admin").default("Admin")
+})).build()
 
-// const AdminUserProto = User.extend()
-//     .schema({
-//         schema: s => s.extend({
-//             name: z.literal("Admin"),
-//             prout: z.string(),
-//         }),
-//         defaultValues: v => ({ ...v, name: "Admin" as const }),
-//     })
-//     .jsonifiable({
-//         jsonifySchema: (s, json) => json.extend({
-//             prout: s.shape.prout
-//         })
-//     })
+@adminUserExp.staticImplements
+class AdminUser extends adminUserExp.extends implements Implements<typeof adminUserExp> {}
 
-
-// class AdminUser extends AdminUserProto.toClass() {}
-// const subInst = await AdminUser.createPromise({ id: 2n, prout: "" })
-// console.log(subInst)
+const admin = AdminUser.create({ id: 2n, name: "Admin" })

src/traits/ExtendableZodSchemaObject.ts

@@ -1,6 +1,7 @@
 import { ImplStatic, expression } from "@thilawyn/traitify-ts"
 import { AbstractClass } from "type-fest"
 import { z } from "zod"
+import { Extend, StaticMembers } from "../util"
 import { ZodSchemaObject } from "./ZodSchemaObject"
 
 
@@ -17,7 +18,8 @@ export const ExtendableZodSchemaObject = <
     .subtrait()
         .implement(Super => class ExtendableZodSchemaObjectImpl extends Super {
             static extend<
-                Self                  extends AbstractClass<ExtendableZodSchemaObjectImpl> & ImplStatic<typeof ExtendableZodSchemaObjectImpl>,
+                Self                  extends AbstractClass<ExtendableZodSchemaObjectImpl & Values, [values: Values]>
+                                            & ImplStatic<typeof ExtendableZodSchemaObjectImpl>,
 
                 ExtendedT             extends z.ZodRawShape,
                 ExtendedCatchall      extends z.ZodTypeAny,
@@ -31,7 +33,18 @@ export const ExtendableZodSchemaObject = <
                 ) => z.ZodObject<ExtendedT, "strip", ExtendedCatchall, ExtendedValues, ExtendedPartialValues>,
             ) {
                 return expression
-                    .extends(this)
+                    .extends(
+                        this as unknown as (
+                            AbstractClass<
+                                Omit<
+                                    Extend<[InstanceType<Self>, ExtendedValues]>,
+                                    keyof ExtendableZodSchemaObjectImpl
+                                >,
+                                [values: ExtendedValues]
+                            > &
+                            Omit<StaticMembers<Self>, keyof ImplStatic<typeof ExtendableZodSchemaObjectImpl>>
+                        )
+                    )
                     .expresses(ExtendableZodSchemaObject(schemaWithDefaults(this.schemaWithDefaults)))
             }
         })