zod-schema-class/src/ZodSchemaClass.ts

import { Trait, TraitExpressionBuilder } from "@thilawyn/traitify-ts"
import { AbstractClass, Simplify } from "type-fest"
import { JsonifiableObject } from "type-fest/source/jsonifiable"
import { z } from "zod"
import { ZodSchemaAbstractClass } from "./shapes/ZodSchemaClass"
import { DejsonifiableZodSchemaObject } from "./traits/DejsonifiableZodSchemaObject"
import { ExtendableZodSchemaObject } from "./traits/ExtendableZodSchemaObject"
import { InstantiableZodSchemaObject } from "./traits/InstantiableZodSchemaObject"
import { JsonifiableZodSchemaObject } from "./traits/JsonifiableZodSchemaObject"
import { Extend, StaticMembers } from "./util"


export class ZodSchemaClassBuilder<
    Superclass   extends AbstractClass<object>,
    const Traits extends Trait<any, any, any, any>[],
>
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<
        Superclass        extends AbstractClass<object, []> & { schema?: never, defaultValues?: never },

        SchemaT           extends z.ZodRawShape,
        SchemaUnknownKeys extends z.UnknownKeysParam,
        SchemaCatchall    extends z.ZodTypeAny,

        Values            extends object,
        DefaultValues     extends Partial<Values>,
    >(
        this: ZodSchemaClassBuilder<Superclass, Traits>,

        { schema, defaultValues }: {
            schema:         z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
            defaultValues:  DefaultValues
        },
    ) {
        class Schemas extends (this.expressionSuperclass as AbstractClass<object, []>) {
            static readonly schema        = schema
            static readonly defaultValues = defaultValues

            constructor(values: Values) {
                super()
                Object.assign(this, values)
            }
        }

        return new ZodSchemaClassBuilder(
            Schemas as unknown as (
                AbstractClass<
                    InstanceType<Superclass> & Values,
                    ConstructorParameters<typeof Schemas>
                > &
                StaticMembers<Superclass> &
                StaticMembers<typeof Schemas>
            ),

            [
                ...this.expressionTraits,
                InstantiableZodSchemaObject,
                ExtendableZodSchemaObject,
            ],
        )
    }

    jsonifiable<
        Superclass                 extends ZodSchemaAbstractClass<Instance, SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, DefaultValues>
                                         & { jsonifySchema?: never, dejsonifySchema?: never },
        Instance                   extends Values,

        SchemaT                    extends z.ZodRawShape,
        SchemaUnknownKeys          extends z.UnknownKeysParam,
        SchemaCatchall             extends z.ZodTypeAny,

        Values                     extends object,
        DefaultValues              extends Partial<Values>,

        JsonifiedValues            extends JsonifiableObject,

        JsonifySchemaT             extends z.ZodRawShape,
        JsonifySchemaUnknownKeys   extends z.UnknownKeysParam,
        JsonifySchemaCatchall      extends z.ZodTypeAny,

        DejsonifySchemaT           extends z.ZodRawShape,
        DejsonifySchemaUnknownKeys extends z.UnknownKeysParam,
        DejsonifySchemaCatchall    extends z.ZodTypeAny,
    >(
        this: ZodSchemaClassBuilder<
            Superclass | ZodSchemaAbstractClass<Instance, SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, DefaultValues>,
            Traits
        >,

        props: {
            jsonifySchema: (props: {
                schema:  z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
                shape:   SchemaT
            }) => z.ZodObject<JsonifySchemaT, JsonifySchemaUnknownKeys, JsonifySchemaCatchall, JsonifiedValues, Values>

            dejsonifySchema: (props: {
                schema:  z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
                shape:   SchemaT
            }) => z.ZodObject<DejsonifySchemaT, DejsonifySchemaUnknownKeys, DejsonifySchemaCatchall, Values, JsonifiedValues>
        },
    ) {
        const jsonifySchema = props.jsonifySchema({
            schema:  this.expressionSuperclass.schema,
            shape:   this.expressionSuperclass.schema.shape,
        })
        const dejsonifySchema = props.dejsonifySchema({
            schema:  this.expressionSuperclass.schema,
            shape:   this.expressionSuperclass.schema.shape,
        })

        class JsonifiableSchemas extends (this.expressionSuperclass as AbstractClass<object>) {
            static readonly jsonifySchema   = jsonifySchema
                   readonly jsonifySchema   = jsonifySchema
            static readonly dejsonifySchema = dejsonifySchema
                   readonly dejsonifySchema = dejsonifySchema
        }

        return new ZodSchemaClassBuilder(
            JsonifiableSchemas as unknown as (
                AbstractClass<
                    InstanceType<Superclass> & JsonifiableSchemas,
                    ConstructorParameters<Superclass>
                > &
                StaticMembers<Superclass> &
                StaticMembers<typeof JsonifiableSchemas>
            ),

            [
                ...this.expressionTraits,
                JsonifiableZodSchemaObject,
                DejsonifiableZodSchemaObject,
            ],
        )
    }
}