Thilawyn/zod-schema-class
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleanup
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse Source
This commit is contained in:
Julien Valverdé
2024-02-08 18:28:39 +01:00
parent 5f7fd30459
commit 99f071147d
6 changed files with 1 additions and 288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
src/TZodSchemaClass.ts
View File

@@ -1,128 +0,0 @@
import { Effect } from "effect"
import { AbstractClass, Class as ConcreteClass, HasRequiredKeys, Opaque } from "type-fest"
import { z } from "zod"
import { DefinedDefaultValuesTag } from "."
import { Class, ClassType, ClassesInstances, ClassesStaticMembers, GetClassType, MergeInheritanceTree } from "./util"
export type NewZodSchemaInstanceInput<
Values extends {},
DefaultValues extends Partial<Values>,
> = {
[Key in Exclude<keyof Values, keyof DefaultValues>]: Values[Key]
} & {
[Key in keyof DefaultValues]?: Key extends keyof Values
? Values[Key]
: never
}
export type ParseParamsArgs = [] | [params: Partial<z.ParseParams>]
export type NewZodSchemaInstanceArgs<Input extends object> =
HasRequiredKeys<Input> extends true
? [values: Input, ...args: ParseParamsArgs]
: [] | [values: Input, ...args: ParseParamsArgs]
type ExtendZodSchemaClass<
Super extends AbstractClass<any>,
Self extends AbstractClass<any>,
> = (
Class<
GetClassType<Super>,
MergeInheritanceTree<
ClassesInstances<[Super, Self]>
>,
ConstructorParameters<Self>
> &
MergeInheritanceTree<
ClassesStaticMembers<[Super, Self]>
>
)
export type TZodSchemaClass<
SchemaT extends z.ZodRawShape,
SchemaUnknownKeys extends z.UnknownKeysParam,
SchemaCatchall extends z.ZodTypeAny,
Values extends {},
DefaultValues extends Partial<Values>,
Type extends ClassType = "AbstractClass"
> = (
Class<
Type,
Values,
[values: Values]
> & {
readonly schema: z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
readonly defaultValues: DefaultValues
create<Self extends ConcreteClass<any>>(
this: Self,
...[values, params]: NewZodSchemaInstanceArgs<
NewZodSchemaInstanceInput<Values, DefaultValues>
>
): InstanceType<Self>
createPromise<Self extends ConcreteClass<any>>(
this: Self,
...[values, params]: NewZodSchemaInstanceArgs<
NewZodSchemaInstanceInput<Values, DefaultValues>
>
): Promise<InstanceType<Self>>
createEffect<Self extends ConcreteClass<any>>(
this: Self,
...[values, params]: NewZodSchemaInstanceArgs<
NewZodSchemaInstanceInput<Values, DefaultValues>
>
): Effect.Effect<never, z.ZodError<Values>, Values>
extend<
Super extends AbstractClass<any>,
ExtendedSchemaT extends z.ZodRawShape,
ExtendedSchemaUnknownKeys extends z.UnknownKeysParam,
ExtendedSchemaCatchall extends z.ZodTypeAny,
ExtendedValues extends Values,
ExtendedDefaultValues extends Partial<ExtendedValues>,
>(
this: Super,
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<
Super,
TZodSchemaClass<
ExtendedSchemaT,
ExtendedSchemaUnknownKeys,
ExtendedSchemaCatchall,
ExtendedValues,
ExtendedDefaultValues
>
>
}
)
export type DefaultZodSchemaClass = TZodSchemaClass<
z.ZodRawShape,
z.UnknownKeysParam,
z.ZodTypeAny,
{},
{}
>

148
src/ZodSchemaClass.old.ts
View File

@@ -1,148 +0,0 @@
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 { Class, ClassesInstances, ClassesStaticMembers, GetClassType, MergeInheritanceTree, MergeInheritanceTreeWithoutOverriding, parseZodTypeEffect } from "./util"
export function ZodSchemaClassOf<
Super extends AbstractClass<any, []>,
SchemaT extends z.ZodRawShape,
SchemaUnknownKeys extends z.UnknownKeysParam,
SchemaCatchall extends z.ZodTypeAny,
Values extends {},
DefaultValues extends Partial<Values>,
>(
of: Super,
{ schema, defaultValues }: {
schema: z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
defaultValues: Opaque<DefaultValues, DefinedDefaultValuesTag>
},
) {
type TZodSchemaClassImpl = TZodSchemaClass<
SchemaT,
SchemaUnknownKeys,
SchemaCatchall,
Values,
DefaultValues
>
return class extends (of as unknown as ConcreteClass<any, []>) {
static readonly schema = schema
static readonly defaultValues = defaultValues
constructor(values: Values) {
super()
Object.assign(this, values)
}
static create(
...[values, params]: NewZodSchemaInstanceArgs<
NewZodSchemaInstanceInput<Values, DefaultValues>
>
) {
return new this(
this.schema.parse({ ...this.defaultValues, ...values }, params)
)
}
static async createPromise(
...[values, params]: NewZodSchemaInstanceArgs<
NewZodSchemaInstanceInput<Values, DefaultValues>
>
) {
return new this(
await this.schema.parseAsync({ ...this.defaultValues, ...values }, params)
)
}
static createEffect(
...[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<
GetClassType<Super>,
MergeInheritanceTreeWithoutOverriding<
ClassesInstances<[
Super,
TZodSchemaClassImpl,
]>
> &
ConstructorParameters<TZodSchemaClassImpl>
> &
MergeInheritanceTree<
ClassesStaticMembers<[
Super,
TZodSchemaClassImpl,
]>
>
)
}
class DefaultRoot {}
export function ZodSchemaClass<
SchemaT extends z.ZodRawShape,
SchemaUnknownKeys extends z.UnknownKeysParam,
SchemaCatchall extends z.ZodTypeAny,
Values extends {},
DefaultValues extends Partial<Values>,
>(
props: {
schema: z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
defaultValues: Opaque<DefaultValues, DefinedDefaultValuesTag>
},
) {
return ZodSchemaClassOf(DefaultRoot, props)
}

8
src/defineDefaultValues.ts
View File

@@ -1,8 +0,0 @@
import { Opaque } from "type-fest"
export type DefinedDefaultValuesTag = "@thilawyn/schemable-class/DefinedDefaultValues"
export function defineDefaultValues<T>(values: T) {
return values as Opaque<T, DefinedDefaultValuesTag>
}

3
src/index.ts
View File

@@ -1,3 +0,0 @@
export * from "./TZodSchemaClass"
export * from "./ZodSchemaClass"
export * from "./defineDefaultValues"

0
src/lib.ts Normal file
View File

2
src/tests.ts
View File

@@ -1,5 +1,5 @@
import { z } from "zod" import { z } from "zod"
import { ZodSchemaClass, defineDefaultValues } from "." import { ZodSchemaClass } from "./ZodSchemaClass"
class Test extends ZodSchemaClass({ class Test extends ZodSchemaClass({