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

0.1.0 #1

Merged
Thilawyn merged 24 commits from next into master 2024-01-05 00:39:33 +01:00
Conversation 0 Commits 24 Files Changed 24 +78 -575
8 changed files with 78 additions and 575 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 60daa8ec3a - Show all commits

BIN
bun.lockb Executable file
View File

Binary file not shown.

6
package.json
View File

@@ -28,9 +28,13 @@
"clean:node": "rm -rf node_modules"
},
"dependencies": {
"type-fest": "^4.9.0"
"effect": "^2.0.0-next.62",
"lodash-es": "^4.17.21",
"type-fest": "^4.9.0",
"zod": "^3.22.4"
},
"devDependencies": {
"@types/lodash-es": "^4.17.12",
"bun-types": "latest",
"npm-check-updates": "^16.14.12",
"npm-sort": "^0.0.4",

195
src/index.ts
View File

@@ -1,195 +0,0 @@
import { AbstractClass, AbstractConstructor, Opaque, UnionToIntersection } from "type-fest"
/**
* Represents the static members of a class.
* @template C - The class type.
*/
export type StaticMembers<C> = {
[Key in keyof C as Key extends "prototype" ? never : Key]: C[Key]
}
/**
* Represents a trait that can be applied to a class.
* @template C - The abstract class type.
*/
export type Trait<
C extends AbstractClass<any>
> = Opaque<
TraitApplier<C>,
"thilatrait/Trait"
>
/**
* Represents the function signature for applying a trait to a parent class.
* @template C - The abstract class type.
*/
export type TraitApplier<
C extends AbstractClass<any>
> =
(Parent: AbstractConstructor<any>) => C
/**
* Unwraps the type of the class from a given trait.
* @template T - The trait type.
*/
export type UnwrapTraitC<T> =
T extends Trait<infer C>
? C
: never
/**
* Creates a trait using the provided trait applier function.
* @template C - The abstract class type.
* @param applier - The trait applier function.
* @returns A trait.
* @example
* Creates a trait:
* ```ts
* const Permissible = trait(Parent => {
* abstract class Permissible extends Parent {
* static readonly defaultPermissions: string[] = []
* permissions: string[] = []
*
* // Constructor is optional
* // If you wish to use it, make sure it takes any[] as an args array and passes it to the super call. This is necessary for inheritance to work properly.
* // Trait constructors cannot have typed arguments of their own, they only serve to run logic during object instantiation.
* constructor(...args: any[]) {
* super(...args)
* }
* }
*
* return Permissible
* })
* ```
* Creates a generic trait:
* ```ts
* const Identifiable = <ID>() =>
* trait(Parent => {
* abstract class Identifiable extends Parent {
* abstract readonly id: ID
*
* equals(el: Identifiable) {
* return this.id === el.id
* }
*
* // Optional
* constructor(...args: any[]) {
* super(...args)
* }
* }
*
* return Identifiable
* })
* ```
* Creates a subtrait:
* ```ts
* const ImplementsIdentifiable = <ID>(defaultID: ID) =>
* trait(Parent => {
* abstract class ImplementsIdentifiable extends extendsAndExpresses(
* Parent,
* [Identifiable<ID>()],
* ) {
* id: ID = defaultID
*
* // Optional
* constructor(...args: any[]) {
* super(...args)
* }
* }
*
* return ImplementsIdentifiable
* })
* ```
*/
export function trait<
C extends AbstractClass<any>
>(
applier: TraitApplier<C>
) {
return applier as Trait<C>
}
/**
* Extends a class with the given traits and expresses their combined functionality.
* @template C - The abstract class type.
* @template Traits - An array of traits.
* @param extend - The class to extend.
* @param traits - An array of traits to apply.
* @returns A new class type expressing the combined functionality of the base class and traits.
* @example
* Extends a superclass and applies traits:
* ```ts
* class User extends extendsAndExpresses(Entity, [Identifiable<bigint>(), Permissible]) {
* readonly id: bigint
*
* constructor(id: bigint) {
* super()
* this.id = id
* }
* }
* ```
*/
export function extendsAndExpresses<
C extends AbstractClass<any>,
Traits extends readonly Trait<any>[],
>(
extend: C,
traits: Traits,
) {
return traits.reduce(
(previous, trait) => trait(previous),
extend,
) as (
AbstractClass<
InstanceType<C> &
UnionToIntersection<
InstanceType<
UnwrapTraitC<
Traits[number]
>
>
>,
ConstructorParameters<C>
> &
StaticMembers<C> &
StaticMembers<
UnionToIntersection<
UnwrapTraitC<
Traits[number]
>
>
>
)
}
/**
* Expresses the combined functionality of multiple traits.
* @template Traits - An array of trait.
* @param traits - An array of trait to apply.
* @returns A new class type expressing the combined functionality of the traits.
* @example
* Applies traits to a class:
* ```ts
* class User extends expresses(Identifiable<bigint>(), Permissible) {
* readonly id: bigint
*
* constructor(id: bigint) {
* super()
* this.id = id
* }
* }
* ```
*/
export function expresses<
Traits extends readonly Trait<any>[],
>(
...traits: Traits
) {
return extendsAndExpresses(Object, traits)
}

74
src/legacy/tests.ts
View File

@@ -1,74 +0,0 @@
import { AbstractClass } from "type-fest"
import { expresses } from "./trait"
function inspectClass(class_: AbstractClass<any, any>) {
Object.getOwnPropertyNames(class_).forEach(name => {
console.log(
"[static]",
name,
Object.getOwnPropertyDescriptor(class_, name)
)
})
Object.getOwnPropertyNames(class_.prototype).forEach(name => {
console.log(
"[prototype]",
name,
Object.getOwnPropertyDescriptor(class_.prototype, name)
)
})
}
abstract class Identified<ID> {
abstract id: ID
equals(el: Identified<ID>) {
return this.id === el.id
}
// initializer() {
// console.log("Identified initializer")
// }
}
class ImplementsIdentifiable<ID> extends Identified<ID> {
id!: ID
}
abstract class Permissible {
static readonly defaultPermissions: string[] = []
permissions: string[] = []
// permissions!: string[]
constructor() {
console.log("Permissible constructor")
}
initializer() {
console.log("Permissible initializer")
this.permissions = []
}
}
class User extends expresses(
Identified as typeof Identified<bigint>,
// Identified<string>,
Permissible,
) {
readonly id: bigint
constructor(id: bigint) {
super()
this.id = id
}
}
const user1 = new User(BigInt(1))
const user2 = new User(BigInt(2))
console.log(user1)
console.log(user1.equals(user2))

126
src/legacy/trait.ts
View File

@@ -1,126 +0,0 @@
import { AbstractClass, Class, UnionToIntersection } from "type-fest"
import { StaticMembers, copyProperties, getInheritanceHierarchy } from "./util/class"
/**
* Represents a trait that can be used to define common behavior
* for classes and abstract classes.
* @typeParam T - The type of the trait.
*/
export type Trait<T> =
AbstractClass<T, []>
/**
* Creates a link class that expresses the given traits.
* @param traits - An array of traits to be expressed by the link class.
* @returns A dynamically created class that expresses the given traits.
* @typeParam Traits - An array of traits that the link class expresses.
*/
export function expresses<
Traits extends readonly Trait<any>[]
>(
...traits: Traits
) {
return makeLinkClass(traits)
}
/**
* Creates a link class that extends a base class and expresses the given traits.
* @param extend - The base class or abstract class to extend.
* @param traits - An array of traits to be expressed by the link class.
* @returns A dynamically created class that extends the given base class and expresses the given traits.
* @typeParam C - The type of the base class to extend.
* @typeParam Traits - An array of traits that the link class expresses.
*/
export function extendsAndExpresses<
C extends Class<any, any>
| AbstractClass<any, any>,
Traits extends readonly Trait<any>[],
>(
extend: C,
...traits: Traits
) {
return makeLinkClass(traits, extend)
}
/**
* Creates a link class that expresses the given traits and optionally extends a base class.
* @param traits - An array of traits to be expressed by the link class.
* @param extend - The base class or abstract class to extend (optional).
* @returns A dynamically created class that expresses the given traits and extends the base class.
* @typeParam Traits - An array of traits that the link class expresses.
* @typeParam C - The type of the base class to extend (optional).
*/
export function makeLinkClass<
Traits extends readonly Trait<any>[],
C extends Class<any, any>
| AbstractClass<any, any>
| undefined = undefined,
>(
traits: Traits,
extend?: C,
) {
const class_ = extend
? class extends extend {
constructor(...args: any[]) {
super(...args)
traits.forEach(trait => {
trait.prototype.initializer?.call(this)
})
}
}
: class {
constructor() {
traits.forEach(trait => {
trait.prototype.initializer?.call(this)
})
}
}
traits.forEach(trait => {
getInheritanceHierarchy(trait).forEach(current => {
copyProperties(
current,
class_,
["name", "length"],
["constructor"],
)
})
})
return class_ as unknown as (
(C extends Class<any, any> | AbstractClass<any, any>
? (
AbstractClass<
InstanceType<C> &
UnionToIntersection<
InstanceType<
Traits[number]
>
>,
ConstructorParameters<C>
> &
StaticMembers<C>
)
: Trait<
UnionToIntersection<
InstanceType<
Traits[number]
>
>
>
) &
StaticMembers<
UnionToIntersection<
Traits[number]
>
>
)
}

109
src/legacy/util/class.ts
View File

@@ -1,109 +0,0 @@
import { AbstractClass } from "type-fest"
/**
* Represents the static members of a class.
*
* @template C - The type of the class for which static members are extracted.
* @typeparam The static members of the class.
*/
export type StaticMembers<C> = Pick<C, keyof C>
/**
* Flattens the inheritance hierarchy of a given class by copying all properties
* from its superclass chain into a single object.
*
* @template C - The type of the class to be flattened, extending AbstractClass<any, any>.
* @param C - The class to be flattened.
* @returns A new class with properties flattened from the entire inheritance hierarchy.
*/
export function flattenClass<
C extends AbstractClass<any, any>
>(class_: C) {
const flattenedClass = class {} as unknown as C
getInheritanceHierarchy(class_).forEach(current => {
copyProperties(current, flattenedClass)
})
copyProperty(class_, flattenedClass, "name")
copyProperty(class_.prototype, flattenedClass.prototype, "constructor")
return flattenedClass
}
/**
* Retrieves the inheritance hierarchy of a given class, including itself.
*
* @param class_ - The class for which the inheritance hierarchy is retrieved.
* @returns An array representing the inheritance hierarchy, ordered from the furthest in the hierarchy to `class_` itself.
*/
export function getInheritanceHierarchy(
class_: AbstractClass<any, any>
): AbstractClass<any, any>[] {
const parent = Object.getPrototypeOf(class_)
return isClass(parent)
? [...getInheritanceHierarchy(parent), class_]
: [class_]
}
/**
* Checks if a given element appears to be a class based on its string representation.
*
* @param el - The element to check for being a class.
* @returns `true` if the element is likely a class; otherwise, `false`.
*/
export function isClass(el: { toString: () => string }) {
return Boolean(el.toString().match(/^class(?: [.\S]+)?(?: extends [.\S]+)? {[\s\S]*}$/))
}
/**
* Copies properties from one class to another, including static and prototype properties.
*
* @param from - The source class to copy properties from.
* @param to - The destination class to copy properties to.
*/
export function copyProperties(
from: AbstractClass<any, any>,
to: AbstractClass<any, any>,
ignoreKeys: string[] = [],
ignorePrototypeKeys: string[] = [],
) {
Object.getOwnPropertyNames(from).forEach(name => {
if (name === "prototype"
|| ignoreKeys.find(v => v === name)
)
return
// console.log(from, to, name, Object.getOwnPropertyDescriptor(from, name))
copyProperty(from, to, name)
})
Object.getOwnPropertyNames(from.prototype).forEach(name => {
if (ignorePrototypeKeys.find(v => v === name))
return
// console.log(from, to, name, Object.getOwnPropertyDescriptor(from, name))
copyProperty(from.prototype, to.prototype, name)
})
}
export function copyProperty(
from: unknown,
to: unknown,
name: string,
) {
Object.defineProperty(
to,
name,
Object.getOwnPropertyDescriptor(from, name) || Object.create(null),
)
}

70
src/tests.ts
View File

@@ -1,70 +0,0 @@
import { expresses, extendsAndExpresses, trait } from "."
const Identifiable = <ID>() =>
trait(Parent => {
abstract class Identifiable extends Parent {
abstract readonly id: ID
equals(el: Identifiable) {
return this.id === el.id
}
constructor(...args: any[]) {
super(...args)
console.log("Identified constructor")
}
}
return Identifiable
})
const ImplementsIdentifiable = <ID>(defaultID: ID) =>
trait(Parent => {
abstract class ImplementsIdentifiable extends extendsAndExpresses(
Parent,
[Identifiable<ID>()],
) {
id: ID = defaultID
constructor(...args: any[]) {
super(...args)
console.log("ImplementsIdentifiable constructor")
}
}
return ImplementsIdentifiable
})
const Permissible = trait(Parent => {
abstract class Permissible extends Parent {
static readonly defaultPermissions: string[] = []
permissions: string[] = []
constructor(...args: any[]) {
super(...args)
console.log("Permissible constructor")
}
}
return Permissible
})
const UserProto = expresses(
// Identifiable<bigint>(),
ImplementsIdentifiable(0n),
Permissible,
)
class User extends UserProto {
constructor(id: bigint) {
super()
this.id = id
}
}
const user1 = new User(1n)
console.log(user1)
console.log(user1.equals(user1))

73
src/util.ts Normal file
View File

@@ -0,0 +1,73 @@
import { Effect, pipe } from "effect"
import { mapValues } from "lodash-es"
import { z } from "zod"
/**
* Removes default values from a ZodObject schema and returns a new schema.
*
* @param schema - The ZodObject schema to process.
* @returns A new ZodObject schema with default values removed.
*/
export const zodObjectRemoveDefaults = <
T extends z.ZodRawShape,
UnknownKeys extends z.UnknownKeysParam,
Catchall extends z.ZodTypeAny,
Output extends {},
Input extends {},
>(
schema: z.ZodObject<
T,
UnknownKeys,
Catchall,
Output,
Input
>
) =>
schema.extend(zodShapeRemoveDefaults(schema.shape))
/**
* Removes default values from a ZodObject shape and returns a new shape.
*
* @param shape - The ZodObject shape to process.
* @returns A new shape with default values removed.
*/
export const zodShapeRemoveDefaults = <
Shape extends z.ZodRawShape
>(
shape: Shape
): {
[K in keyof Shape]:
Shape[K] extends z.ZodDefault<infer T>
? T
: Shape[K]
} =>
mapValues(shape, el =>
el instanceof z.ZodDefault
? el.removeDefault()
: el
)
/**
* Parses a value using a ZodType schema wrapped in an Effect monad.
*
* @param schema - The ZodType schema to use for parsing.
* @param args - The arguments to pass to the `safeParseAsync` method of the schema.
* @returns An Effect monad representing the parsing result.
*/
export const parseZodTypeEffect = <
Output,
Input,
>(
schema: z.ZodType<Output, z.ZodTypeDef, Input>,
...args: Parameters<typeof schema.safeParseAsync>
) => pipe(
Effect.promise(() => schema.safeParseAsync(...args)),
Effect.flatMap(response =>
response.success
? Effect.succeed(response.data)
: Effect.fail(response.error)
),
)