From 39b7555a4406173ff04697288c1024045e902975 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Mon, 8 Jan 2024 06:36:24 +0100 Subject: [PATCH 01/47] extendWithZodSchema tests --- package.json | 2 +- src/extendWithZodSchema.ts | 102 +++++++++++++++++++++++++++++++++++++ 2 files changed, 103 insertions(+), 1 deletion(-) create mode 100644 src/extendWithZodSchema.ts diff --git a/package.json b/package.json index 547eb5f..1fa0eb4 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@thilawyn/schemable-class", - "version": "0.1.0", + "version": "0.1.1", "type": "module", "publishConfig": { "registry": "https://git.jvalver.de/api/packages/thilawyn/npm/" diff --git a/src/extendWithZodSchema.ts b/src/extendWithZodSchema.ts new file mode 100644 index 0000000..3323a94 --- /dev/null +++ b/src/extendWithZodSchema.ts @@ -0,0 +1,102 @@ +import { AbstractClass, Class } from "type-fest" +import { z } from "zod" +import { StaticMembers } from "./util" + + +type SchemableClass< + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + SchemaValues extends {}, +> = ( + AbstractClass< + { + readonly schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + SchemaValues, + SchemaValues + > + } & SchemaValues, + + any[] + > & { + readonly schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + SchemaValues, + SchemaValues + > + } +) + + +export function extendWithZodSchema< + C extends SchemableClass< + ExtendSchemaT, + ExtendSchemaUnknownKeys, + ExtendSchemaCatchall, + ExtendSchemaValues + >, + + ExtendSchemaT extends z.ZodRawShape, + ExtendSchemaUnknownKeys extends z.UnknownKeysParam, + ExtendSchemaCatchall extends z.ZodTypeAny, + ExtendSchemaValues extends {}, + + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + SchemaValues extends ExtendSchemaValues, +>( + extend: C | SchemableClass< + ExtendSchemaT, + ExtendSchemaUnknownKeys, + ExtendSchemaCatchall, + ExtendSchemaValues + >, + + schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + SchemaValues, + SchemaValues + >, +) { + + const class_ = class extends extend { + static readonly schema = schema + readonly schema = schema + } + + return class_ as unknown as ( + Class< + Omit & + { readonly schema: typeof schema } & + SchemaValues, + + ConstructorParameters + > & + Omit, "schema"> & + { readonly schema: typeof schema } + ) + +} + + +const Test1Schema = z.object({ prout: z.string() }) +class Test1 { + static readonly schema = Test1Schema + readonly schema = Test1Schema + + prout: string = "heugneu" +} + +const Test2Schema = Test1.schema.extend({ prout: z.literal("ruquier"), ruquier: z.number() }) +const Test2 = extendWithZodSchema(Test1, Test2Schema) + +Test2.schema +new Test2().schema -- 2.49.1 From d28f95af8263741a6e70332516a96118b1a49a6f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Mon, 8 Jan 2024 06:40:35 +0100 Subject: [PATCH 02/47] extendWithZodSchema work --- src/extendWithZodSchema.ts | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/src/extendWithZodSchema.ts b/src/extendWithZodSchema.ts index 3323a94..7dd3f1f 100644 --- a/src/extendWithZodSchema.ts +++ b/src/extendWithZodSchema.ts @@ -66,13 +66,10 @@ export function extendWithZodSchema< SchemaValues >, ) { - - const class_ = class extends extend { + return class extends extend { static readonly schema = schema - readonly schema = schema - } - - return class_ as unknown as ( + readonly schema = schema + } as unknown as ( Class< Omit & { readonly schema: typeof schema } & @@ -83,7 +80,6 @@ export function extendWithZodSchema< Omit, "schema"> & { readonly schema: typeof schema } ) - } @@ -99,4 +95,4 @@ const Test2Schema = Test1.schema.extend({ prout: z.literal("ruquier"), ruquier: const Test2 = extendWithZodSchema(Test1, Test2Schema) Test2.schema -new Test2().schema +new Test2().prout -- 2.49.1 From 94674530421dc0ae8274db8b92d171569234f168 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Mon, 8 Jan 2024 07:17:05 +0100 Subject: [PATCH 03/47] extendSchemable work --- src/{extendWithZodSchema.ts => extendSchemable.ts} | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) rename src/{extendWithZodSchema.ts => extendSchemable.ts} (92%) diff --git a/src/extendWithZodSchema.ts b/src/extendSchemable.ts similarity index 92% rename from src/extendWithZodSchema.ts rename to src/extendSchemable.ts index 7dd3f1f..17f4fc4 100644 --- a/src/extendWithZodSchema.ts +++ b/src/extendSchemable.ts @@ -33,7 +33,7 @@ type SchemableClass< ) -export function extendWithZodSchema< +export function extendSchemable< C extends SchemableClass< ExtendSchemaT, ExtendSchemaUnknownKeys, @@ -71,12 +71,16 @@ export function extendWithZodSchema< readonly schema = schema } as unknown as ( Class< - Omit & + Omit< + Omit, + keyof ExtendSchemaValues + > & { readonly schema: typeof schema } & SchemaValues, ConstructorParameters > & + Omit, "schema"> & { readonly schema: typeof schema } ) @@ -92,7 +96,7 @@ class Test1 { } const Test2Schema = Test1.schema.extend({ prout: z.literal("ruquier"), ruquier: z.number() }) -const Test2 = extendWithZodSchema(Test1, Test2Schema) +const Test2 = extendSchemable(Test1, Test2Schema) Test2.schema new Test2().prout -- 2.49.1 From 1bdfc079b9f02ecd2d712e526460dad4b5002d32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 00:10:56 +0100 Subject: [PATCH 04/47] Moved everything to legacy --- src/{ => legacy}/SchemableClass.ts | 0 src/{ => legacy}/index.ts | 0 .../jsonifiable/JsonifiableSchemableClass.ts | 0 .../jsonifiable/dejsonifySchemable.ts | 0 src/{ => legacy}/jsonifiable/index.ts | 0 .../makeJsonifiableSchemableClass.ts | 0 src/{ => legacy}/jsonifiable/schema/bigint.ts | 0 src/{ => legacy}/jsonifiable/schema/date.ts | 0 .../jsonifiable/schema/decimal.ts | 0 src/{ => legacy}/jsonifiable/schema/index.ts | 0 .../jsonifiable/schema/schemable.ts | 0 src/{ => legacy}/makeSchemableClass.ts | 0 src/{ => legacy}/newSchemable.ts | 0 src/legacy/tests.ts | 64 +++++++++++++++ src/legacy/util.ts | 82 +++++++++++++++++++ src/tests.ts | 64 --------------- src/util.ts | 47 ----------- 17 files changed, 146 insertions(+), 111 deletions(-) rename src/{ => legacy}/SchemableClass.ts (100%) rename src/{ => legacy}/index.ts (100%) rename src/{ => legacy}/jsonifiable/JsonifiableSchemableClass.ts (100%) rename src/{ => legacy}/jsonifiable/dejsonifySchemable.ts (100%) rename src/{ => legacy}/jsonifiable/index.ts (100%) rename src/{ => legacy}/jsonifiable/makeJsonifiableSchemableClass.ts (100%) rename src/{ => legacy}/jsonifiable/schema/bigint.ts (100%) rename src/{ => legacy}/jsonifiable/schema/date.ts (100%) rename src/{ => legacy}/jsonifiable/schema/decimal.ts (100%) rename src/{ => legacy}/jsonifiable/schema/index.ts (100%) rename src/{ => legacy}/jsonifiable/schema/schemable.ts (100%) rename src/{ => legacy}/makeSchemableClass.ts (100%) rename src/{ => legacy}/newSchemable.ts (100%) create mode 100644 src/legacy/tests.ts create mode 100644 src/legacy/util.ts diff --git a/src/SchemableClass.ts b/src/legacy/SchemableClass.ts similarity index 100% rename from src/SchemableClass.ts rename to src/legacy/SchemableClass.ts diff --git a/src/index.ts b/src/legacy/index.ts similarity index 100% rename from src/index.ts rename to src/legacy/index.ts diff --git a/src/jsonifiable/JsonifiableSchemableClass.ts b/src/legacy/jsonifiable/JsonifiableSchemableClass.ts similarity index 100% rename from src/jsonifiable/JsonifiableSchemableClass.ts rename to src/legacy/jsonifiable/JsonifiableSchemableClass.ts diff --git a/src/jsonifiable/dejsonifySchemable.ts b/src/legacy/jsonifiable/dejsonifySchemable.ts similarity index 100% rename from src/jsonifiable/dejsonifySchemable.ts rename to src/legacy/jsonifiable/dejsonifySchemable.ts diff --git a/src/jsonifiable/index.ts b/src/legacy/jsonifiable/index.ts similarity index 100% rename from src/jsonifiable/index.ts rename to src/legacy/jsonifiable/index.ts diff --git a/src/jsonifiable/makeJsonifiableSchemableClass.ts b/src/legacy/jsonifiable/makeJsonifiableSchemableClass.ts similarity index 100% rename from src/jsonifiable/makeJsonifiableSchemableClass.ts rename to src/legacy/jsonifiable/makeJsonifiableSchemableClass.ts diff --git a/src/jsonifiable/schema/bigint.ts b/src/legacy/jsonifiable/schema/bigint.ts similarity index 100% rename from src/jsonifiable/schema/bigint.ts rename to src/legacy/jsonifiable/schema/bigint.ts diff --git a/src/jsonifiable/schema/date.ts b/src/legacy/jsonifiable/schema/date.ts similarity index 100% rename from src/jsonifiable/schema/date.ts rename to src/legacy/jsonifiable/schema/date.ts diff --git a/src/jsonifiable/schema/decimal.ts b/src/legacy/jsonifiable/schema/decimal.ts similarity index 100% rename from src/jsonifiable/schema/decimal.ts rename to src/legacy/jsonifiable/schema/decimal.ts diff --git a/src/jsonifiable/schema/index.ts b/src/legacy/jsonifiable/schema/index.ts similarity index 100% rename from src/jsonifiable/schema/index.ts rename to src/legacy/jsonifiable/schema/index.ts diff --git a/src/jsonifiable/schema/schemable.ts b/src/legacy/jsonifiable/schema/schemable.ts similarity index 100% rename from src/jsonifiable/schema/schemable.ts rename to src/legacy/jsonifiable/schema/schemable.ts diff --git a/src/makeSchemableClass.ts b/src/legacy/makeSchemableClass.ts similarity index 100% rename from src/makeSchemableClass.ts rename to src/legacy/makeSchemableClass.ts diff --git a/src/newSchemable.ts b/src/legacy/newSchemable.ts similarity index 100% rename from src/newSchemable.ts rename to src/legacy/newSchemable.ts diff --git a/src/legacy/tests.ts b/src/legacy/tests.ts new file mode 100644 index 0000000..c19daf7 --- /dev/null +++ b/src/legacy/tests.ts @@ -0,0 +1,64 @@ +import { z } from "zod" +import { makeSchemableClass, newSchemable } from "." +import { dejsonifyBigIntSchema, dejsonifySchemable, dejsonifySchemableSchema, jsonifyBigIntSchema, jsonifySchemableSchema, makeJsonifiableSchemableClass } from "./jsonifiable" + + +const GroupSchema = z.object({ + /** Group ID */ + id: z.bigint(), + + /** Group name */ + name: z.string(), +}) + +const GroupSchemableObject = makeSchemableClass({ schema: GroupSchema }) + +const GroupJsonifiableSchemableObject = makeJsonifiableSchemableClass(GroupSchemableObject, { + jsonifySchema: ({ schema, s }) => schema.extend({ + id: jsonifyBigIntSchema(s.id) + }), + + dejsonifySchema: ({ schema, s }) => schema.extend({ + id: dejsonifyBigIntSchema(s.id) + }), +}) + +class Group extends GroupJsonifiableSchemableObject {} + + +const UserSchema = z.object({ + /** User ID */ + id: z.bigint(), + + /** Name string */ + name: z.string(), + + /** User group */ + group: z.instanceof(Group), +}) + +const UserSchemableObject = makeSchemableClass({ schema: UserSchema }) + +const UserJsonifiableSchemableObject = makeJsonifiableSchemableClass(UserSchemableObject, { + jsonifySchema: ({ schema, s }) => schema.extend({ + id: jsonifyBigIntSchema(s.id), + group: jsonifySchemableSchema(Group, s.group), + }), + + dejsonifySchema: ({ schema, s }) => schema.extend({ + id: dejsonifyBigIntSchema(s.id), + group: dejsonifySchemableSchema(Group, s.group), + }), +}) + +class User extends UserJsonifiableSchemableObject {} + + +const group1 = new Group({ id: 1n, name: "Group 1" }) + +const user1 = new User({ id: 1n, name: "User 1", group: group1 }) +const user2 = newSchemable(User, { id: 2n, name: "User 2", group: group1 }) + +const jsonifiedUser2 = user2.jsonify() +const dejsonifiedUser2 = dejsonifySchemable(User, jsonifiedUser2) +console.log(dejsonifiedUser2) diff --git a/src/legacy/util.ts b/src/legacy/util.ts new file mode 100644 index 0000000..2cf7b08 --- /dev/null +++ b/src/legacy/util.ts @@ -0,0 +1,82 @@ +import { Effect, pipe } from "effect" +import { mapValues } from "lodash-es" +import { z } from "zod" + + +/** + * Represents the static members of a class. + * @template C - The class type. + */ +export type StaticMembers = { + [Key in keyof C as Key extends "prototype" ? never : Key]: C[Key] +} + + +/** + * 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 + ? 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, + ...args: Parameters +) => pipe( + Effect.promise(() => schema.safeParseAsync(...args)), + + Effect.flatMap(response => + response.success + ? Effect.succeed(response.data) + : Effect.fail(response.error) + ), +) diff --git a/src/tests.ts b/src/tests.ts index c19daf7..e69de29 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,64 +0,0 @@ -import { z } from "zod" -import { makeSchemableClass, newSchemable } from "." -import { dejsonifyBigIntSchema, dejsonifySchemable, dejsonifySchemableSchema, jsonifyBigIntSchema, jsonifySchemableSchema, makeJsonifiableSchemableClass } from "./jsonifiable" - - -const GroupSchema = z.object({ - /** Group ID */ - id: z.bigint(), - - /** Group name */ - name: z.string(), -}) - -const GroupSchemableObject = makeSchemableClass({ schema: GroupSchema }) - -const GroupJsonifiableSchemableObject = makeJsonifiableSchemableClass(GroupSchemableObject, { - jsonifySchema: ({ schema, s }) => schema.extend({ - id: jsonifyBigIntSchema(s.id) - }), - - dejsonifySchema: ({ schema, s }) => schema.extend({ - id: dejsonifyBigIntSchema(s.id) - }), -}) - -class Group extends GroupJsonifiableSchemableObject {} - - -const UserSchema = z.object({ - /** User ID */ - id: z.bigint(), - - /** Name string */ - name: z.string(), - - /** User group */ - group: z.instanceof(Group), -}) - -const UserSchemableObject = makeSchemableClass({ schema: UserSchema }) - -const UserJsonifiableSchemableObject = makeJsonifiableSchemableClass(UserSchemableObject, { - jsonifySchema: ({ schema, s }) => schema.extend({ - id: jsonifyBigIntSchema(s.id), - group: jsonifySchemableSchema(Group, s.group), - }), - - dejsonifySchema: ({ schema, s }) => schema.extend({ - id: dejsonifyBigIntSchema(s.id), - group: dejsonifySchemableSchema(Group, s.group), - }), -}) - -class User extends UserJsonifiableSchemableObject {} - - -const group1 = new Group({ id: 1n, name: "Group 1" }) - -const user1 = new User({ id: 1n, name: "User 1", group: group1 }) -const user2 = newSchemable(User, { id: 2n, name: "User 2", group: group1 }) - -const jsonifiedUser2 = user2.jsonify() -const dejsonifiedUser2 = dejsonifySchemable(User, jsonifiedUser2) -console.log(dejsonifiedUser2) diff --git a/src/util.ts b/src/util.ts index 2cf7b08..276cbdd 100644 --- a/src/util.ts +++ b/src/util.ts @@ -1,5 +1,4 @@ import { Effect, pipe } from "effect" -import { mapValues } from "lodash-es" import { z } from "zod" @@ -12,52 +11,6 @@ export type StaticMembers = { } -/** - * 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 - ? 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. * -- 2.49.1 From 6fe782208df7258fe15a7d20379cc9c15276c469 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 03:06:52 +0100 Subject: [PATCH 05/47] extendSchemable work --- src/SchemableClass.ts | 38 +++++++++++++++++++ src/extendSchemable.ts | 85 ++++++++++++++---------------------------- src/index.ts | 2 + src/tests.ts | 23 ++++++++++++ 4 files changed, 91 insertions(+), 57 deletions(-) create mode 100644 src/SchemableClass.ts create mode 100644 src/index.ts diff --git a/src/SchemableClass.ts b/src/SchemableClass.ts new file mode 100644 index 0000000..02a75b9 --- /dev/null +++ b/src/SchemableClass.ts @@ -0,0 +1,38 @@ +import { AbstractClass } from "type-fest" +import { z } from "zod" + + +export type SchemableClass< + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + SchemaValues extends {}, + + DefaultValues extends Partial, +> = ( + AbstractClass< + { + readonly schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + SchemaValues, + SchemaValues + > + + readonly defaultValues: DefaultValues + } & SchemaValues, + + any[] + > & { + readonly schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + SchemaValues, + SchemaValues + > + + readonly defaultValues: DefaultValues + } +) diff --git a/src/extendSchemable.ts b/src/extendSchemable.ts index 17f4fc4..eee5111 100644 --- a/src/extendSchemable.ts +++ b/src/extendSchemable.ts @@ -1,102 +1,73 @@ -import { AbstractClass, Class } from "type-fest" +import { AbstractClass } from "type-fest" import { z } from "zod" +import { SchemableClass } from "." import { StaticMembers } from "./util" -type SchemableClass< - SchemaT extends z.ZodRawShape, - SchemaUnknownKeys extends z.UnknownKeysParam, - SchemaCatchall extends z.ZodTypeAny, - SchemaValues extends {}, -> = ( - AbstractClass< - { - readonly schema: z.ZodObject< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - SchemaValues, - SchemaValues - > - } & SchemaValues, - - any[] - > & { - readonly schema: z.ZodObject< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - SchemaValues, - SchemaValues - > - } -) - - export function extendSchemable< C extends SchemableClass< ExtendSchemaT, ExtendSchemaUnknownKeys, ExtendSchemaCatchall, - ExtendSchemaValues + ExtendSchemaValues, + ExtendDefaultValues >, ExtendSchemaT extends z.ZodRawShape, ExtendSchemaUnknownKeys extends z.UnknownKeysParam, ExtendSchemaCatchall extends z.ZodTypeAny, ExtendSchemaValues extends {}, + ExtendDefaultValues extends Partial, SchemaT extends z.ZodRawShape, SchemaUnknownKeys extends z.UnknownKeysParam, SchemaCatchall extends z.ZodTypeAny, SchemaValues extends ExtendSchemaValues, + DefaultValues extends Partial, >( extend: C | SchemableClass< ExtendSchemaT, ExtendSchemaUnknownKeys, ExtendSchemaCatchall, - ExtendSchemaValues + ExtendSchemaValues, + ExtendDefaultValues >, - schema: z.ZodObject< + schemaApplier: (schema: C["schema"]) => z.ZodObject< SchemaT, SchemaUnknownKeys, SchemaCatchall, SchemaValues, SchemaValues >, + + defaultValuesApplier: (defaultValues: ExtendDefaultValues) => DefaultValues, ) { + const schema = schemaApplier(extend.schema) + const defaultValues = defaultValuesApplier(extend.defaultValues) + return class extends extend { static readonly schema = schema readonly schema = schema + + static readonly defaultValues = defaultValues + readonly defaultValues = defaultValues } as unknown as ( - Class< - Omit< - Omit, - keyof ExtendSchemaValues - > & - { readonly schema: typeof schema } & + AbstractClass< + Omit & + { + readonly schema: typeof schema, + readonly defaultValues: typeof defaultValues, + } & SchemaValues, ConstructorParameters > & - Omit, "schema"> & - { readonly schema: typeof schema } + Omit, "schema" | "defaultValues"> & + { + readonly schema: typeof schema, + readonly defaultValues: typeof defaultValues, + } ) } - - -const Test1Schema = z.object({ prout: z.string() }) -class Test1 { - static readonly schema = Test1Schema - readonly schema = Test1Schema - - prout: string = "heugneu" -} - -const Test2Schema = Test1.schema.extend({ prout: z.literal("ruquier"), ruquier: z.number() }) -const Test2 = extendSchemable(Test1, Test2Schema) - -Test2.schema -new Test2().prout diff --git a/src/index.ts b/src/index.ts new file mode 100644 index 0000000..755e573 --- /dev/null +++ b/src/index.ts @@ -0,0 +1,2 @@ +export * from "./SchemableClass" +export * from "./extendSchemable" diff --git a/src/tests.ts b/src/tests.ts index e69de29..f17f90b 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -0,0 +1,23 @@ +import { z } from "zod" +import { extendSchemable } from "." + + +const Test1Schema = z.object({ prout: z.string() }) +class Test1 { + static readonly schema = Test1Schema + readonly schema = Test1Schema + + static readonly defaultValues = { prout: "heugneu" } + readonly defaultValues = { prout: "heugneu" } + + prout: string = "heugneu" +} + +const Test2 = extendSchemable( + Test1, + schema => schema.extend({ prout: z.literal("ruquier"), ruquier: z.number() }), + defaultValues => ({ prout: "ruquier" as const }), +) + +Test2.defaultValues +new Test2().prout -- 2.49.1 From 2d25c95a0abc9553f131d31dd2513c0e17f04145 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 03:13:53 +0100 Subject: [PATCH 06/47] extendSchemable work --- src/extendSchemable.ts | 10 ++++++++-- src/tests.ts | 2 +- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/src/extendSchemable.ts b/src/extendSchemable.ts index eee5111..6c68b2e 100644 --- a/src/extendSchemable.ts +++ b/src/extendSchemable.ts @@ -1,4 +1,4 @@ -import { AbstractClass } from "type-fest" +import { AbstractClass, Class } from "type-fest" import { z } from "zod" import { SchemableClass } from "." import { StaticMembers } from "./util" @@ -43,6 +43,12 @@ export function extendSchemable< defaultValuesApplier: (defaultValues: ExtendDefaultValues) => DefaultValues, ) { + type ClassKind = ( + C extends Class + ? Class + : AbstractClass + ) + const schema = schemaApplier(extend.schema) const defaultValues = defaultValuesApplier(extend.defaultValues) @@ -53,7 +59,7 @@ export function extendSchemable< static readonly defaultValues = defaultValues readonly defaultValues = defaultValues } as unknown as ( - AbstractClass< + ClassKind< Omit & { readonly schema: typeof schema, diff --git a/src/tests.ts b/src/tests.ts index f17f90b..3e1b408 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -16,7 +16,7 @@ class Test1 { const Test2 = extendSchemable( Test1, schema => schema.extend({ prout: z.literal("ruquier"), ruquier: z.number() }), - defaultValues => ({ prout: "ruquier" as const }), + () => ({ prout: "ruquier" as const }), ) Test2.defaultValues -- 2.49.1 From 712057fa1e7e7fa99cbbb220d40c758664287e27 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 04:31:20 +0100 Subject: [PATCH 07/47] extendSchemableClass work --- src/{extendSchemable.ts => extendSchemableClass.ts} | 2 +- src/index.ts | 2 +- src/tests.ts | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) rename src/{extendSchemable.ts => extendSchemableClass.ts} (98%) diff --git a/src/extendSchemable.ts b/src/extendSchemableClass.ts similarity index 98% rename from src/extendSchemable.ts rename to src/extendSchemableClass.ts index 6c68b2e..b1d6480 100644 --- a/src/extendSchemable.ts +++ b/src/extendSchemableClass.ts @@ -4,7 +4,7 @@ import { SchemableClass } from "." import { StaticMembers } from "./util" -export function extendSchemable< +export function extendSchemableClass< C extends SchemableClass< ExtendSchemaT, ExtendSchemaUnknownKeys, diff --git a/src/index.ts b/src/index.ts index 755e573..086aabb 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,2 +1,2 @@ export * from "./SchemableClass" -export * from "./extendSchemable" +export * from "./extendSchemableClass" diff --git a/src/tests.ts b/src/tests.ts index 3e1b408..f1763fa 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,5 +1,5 @@ import { z } from "zod" -import { extendSchemable } from "." +import { extendSchemableClass } from "." const Test1Schema = z.object({ prout: z.string() }) @@ -13,7 +13,7 @@ class Test1 { prout: string = "heugneu" } -const Test2 = extendSchemable( +const Test2 = extendSchemableClass( Test1, schema => schema.extend({ prout: z.literal("ruquier"), ruquier: z.number() }), () => ({ prout: "ruquier" as const }), -- 2.49.1 From 2dad6e08738d88c9f1343c4b6321ff56537ba312 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 05:32:27 +0100 Subject: [PATCH 08/47] makeSchemableClassFrom work --- src/extendSchemableClass.ts | 4 +-- src/index.ts | 1 + src/makeSchemableClass.ts | 62 +++++++++++++++++++++++++++++++++++++ 3 files changed, 65 insertions(+), 2 deletions(-) create mode 100644 src/makeSchemableClass.ts diff --git a/src/extendSchemableClass.ts b/src/extendSchemableClass.ts index b1d6480..2d06f72 100644 --- a/src/extendSchemableClass.ts +++ b/src/extendSchemableClass.ts @@ -60,14 +60,14 @@ export function extendSchemableClass< readonly defaultValues = defaultValues } as unknown as ( ClassKind< - Omit & + Omit, "schema" | "defaultValues" | keyof ExtendSchemaValues> & { readonly schema: typeof schema, readonly defaultValues: typeof defaultValues, } & SchemaValues, - ConstructorParameters + Parameters<(values: SchemaValues) => void> > & Omit, "schema" | "defaultValues"> & diff --git a/src/index.ts b/src/index.ts index 086aabb..9e51df9 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,2 +1,3 @@ export * from "./SchemableClass" export * from "./extendSchemableClass" +export * from "./makeSchemableClass" diff --git a/src/makeSchemableClass.ts b/src/makeSchemableClass.ts new file mode 100644 index 0000000..5352bd2 --- /dev/null +++ b/src/makeSchemableClass.ts @@ -0,0 +1,62 @@ +import { AbstractClass, Class } from "type-fest" +import { z } from "zod" +import { StaticMembers } from "./util" + + +export function makeSchemableClassFrom< + C extends AbstractClass, + + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + SchemaValues extends {}, + DefaultValues extends Partial, +>( + extend: C, + + schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + SchemaValues, + SchemaValues + >, + + defaultValues: DefaultValues, +) { + type ClassKind = ( + C extends Class + ? Class + : AbstractClass + ) + + return class extends (extend as unknown as Class) { + static readonly schema = schema + readonly schema = schema + + static readonly defaultValues = defaultValues + readonly defaultValues = defaultValues + + constructor(values: SchemaValues) { + super() + Object.assign(this, values) + } + } as unknown as ( + ClassKind< + Omit, "schema" | "defaultValues"> & + { + readonly schema: typeof schema, + readonly defaultValues: typeof defaultValues, + } & + SchemaValues, + + Parameters<(values: SchemaValues) => void> + > & + + Omit, "schema" | "defaultValues"> & + { + readonly schema: typeof schema, + readonly defaultValues: typeof defaultValues, + } + ) +} -- 2.49.1 From d9376214a0729c60c9d42ca296eb024d0b92f1b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 05:53:11 +0100 Subject: [PATCH 09/47] Tests --- src/tests.ts | 36 ++++++++++++++++++++++++++---------- 1 file changed, 26 insertions(+), 10 deletions(-) diff --git a/src/tests.ts b/src/tests.ts index f1763fa..b2c37a9 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,17 +1,27 @@ import { z } from "zod" -import { extendSchemableClass } from "." +import { extendSchemableClass, makeSchemableClassFrom } from "." -const Test1Schema = z.object({ prout: z.string() }) -class Test1 { - static readonly schema = Test1Schema - readonly schema = Test1Schema +// class Test1 { +// static readonly schema = Test1Schema +// readonly schema = Test1Schema - static readonly defaultValues = { prout: "heugneu" } - readonly defaultValues = { prout: "heugneu" } +// static readonly defaultValues = { prout: "heugneu" } +// readonly defaultValues = { prout: "heugneu" } + +// prout: string = "heugneu" +// } + +const Test1 = makeSchemableClassFrom( + class { + randomProperty: string = "" + }, + z.object({ prout: z.string() }), + {}, +) + +new Test1({ prout: "adfd" }).prout - prout: string = "heugneu" -} const Test2 = extendSchemableClass( Test1, @@ -20,4 +30,10 @@ const Test2 = extendSchemableClass( ) Test2.defaultValues -new Test2().prout +new Test2({ prout: "ruquier", ruquier: 69 }).randomProperty + + +class Test3 extends Test2 { +} + +console.log(new Test3({ prout: "ruquier", ruquier: 69 })) -- 2.49.1 From 0e71b79243c64d75e363e879180952e86c082e25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 05:54:02 +0100 Subject: [PATCH 10/47] Cleanup --- src/makeSchemableClass.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/makeSchemableClass.ts b/src/makeSchemableClass.ts index 5352bd2..1de1a62 100644 --- a/src/makeSchemableClass.ts +++ b/src/makeSchemableClass.ts @@ -4,13 +4,13 @@ import { StaticMembers } from "./util" export function makeSchemableClassFrom< - C extends AbstractClass, + C extends AbstractClass, - SchemaT extends z.ZodRawShape, - SchemaUnknownKeys extends z.UnknownKeysParam, - SchemaCatchall extends z.ZodTypeAny, - SchemaValues extends {}, - DefaultValues extends Partial, + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + SchemaValues extends {}, + DefaultValues extends Partial, >( extend: C, -- 2.49.1 From 66e2f5059e2ff9ff16f82c2973e42ed4614ff946 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 05:55:35 +0100 Subject: [PATCH 11/47] SchemableClass fix --- src/SchemableClass.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/SchemableClass.ts b/src/SchemableClass.ts index 02a75b9..6758472 100644 --- a/src/SchemableClass.ts +++ b/src/SchemableClass.ts @@ -23,7 +23,7 @@ export type SchemableClass< readonly defaultValues: DefaultValues } & SchemaValues, - any[] + Parameters<(values: SchemaValues) => void> > & { readonly schema: z.ZodObject< SchemaT, -- 2.49.1 From e147b61f89a511b0cde2ebf4bc79bd50dcf599d5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 17:21:39 +0100 Subject: [PATCH 12/47] makeSchemableClass --- src/makeSchemableClass.ts | 21 +++++++++++++++++++++ src/tests.ts | 9 +++------ 2 files changed, 24 insertions(+), 6 deletions(-) diff --git a/src/makeSchemableClass.ts b/src/makeSchemableClass.ts index 1de1a62..759c80c 100644 --- a/src/makeSchemableClass.ts +++ b/src/makeSchemableClass.ts @@ -60,3 +60,24 @@ export function makeSchemableClassFrom< } ) } + + +export function makeSchemableClass< + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + SchemaValues extends {}, + DefaultValues extends Partial, +>( + schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + SchemaValues, + SchemaValues + >, + + defaultValues: DefaultValues, +) { + return makeSchemableClassFrom(Object, schema, defaultValues) +} diff --git a/src/tests.ts b/src/tests.ts index b2c37a9..09d8037 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,5 +1,5 @@ import { z } from "zod" -import { extendSchemableClass, makeSchemableClassFrom } from "." +import { extendSchemableClass, makeSchemableClass, makeSchemableClassFrom } from "." // class Test1 { @@ -12,10 +12,7 @@ import { extendSchemableClass, makeSchemableClassFrom } from "." // prout: string = "heugneu" // } -const Test1 = makeSchemableClassFrom( - class { - randomProperty: string = "" - }, +const Test1 = makeSchemableClass( z.object({ prout: z.string() }), {}, ) @@ -30,7 +27,7 @@ const Test2 = extendSchemableClass( ) Test2.defaultValues -new Test2({ prout: "ruquier", ruquier: 69 }).randomProperty +new Test2({ prout: "ruquier", ruquier: 69 }) class Test3 extends Test2 { -- 2.49.1 From 674f96ab5259e9e7242dde18ac0e835315417117 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 22:04:17 +0100 Subject: [PATCH 13/47] SchemableClassInput --- src/SchemableClass.ts | 12 +++++++ src/newSchemable.ts | 73 +++++++++++++++++++++++++++++++++++++++++++ src/tests.ts | 5 ++- 3 files changed, 89 insertions(+), 1 deletion(-) create mode 100644 src/newSchemable.ts diff --git a/src/SchemableClass.ts b/src/SchemableClass.ts index 6758472..fb2144b 100644 --- a/src/SchemableClass.ts +++ b/src/SchemableClass.ts @@ -36,3 +36,15 @@ export type SchemableClass< readonly defaultValues: DefaultValues } ) + + +export type SchemableClassInput< + SchemaValues extends {}, + DefaultValues extends Partial, +> = { + [Key in Exclude]: SchemaValues[Key] +} & { + [Key in keyof DefaultValues]?: Key extends keyof SchemaValues + ? SchemaValues[Key] + : never +} diff --git a/src/newSchemable.ts b/src/newSchemable.ts new file mode 100644 index 0000000..183f995 --- /dev/null +++ b/src/newSchemable.ts @@ -0,0 +1,73 @@ +import { Effect, pipe } from "effect" +import { HasRequiredKeys } from "type-fest" +import { z } from "zod" +import { SchemableClass, SchemableClassInput } from "." +import { parseZodTypeEffect } from "./util" + + +type ParamsArgs = [] | [Partial] + +type NewSchemableArgs = + HasRequiredKeys extends true + ? [Input, ...ParamsArgs] + : [] | [Input, ...ParamsArgs] + + +export const newSchemable = < + C extends SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + SchemaValues, + DefaultValues + >, + + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + SchemaValues extends {}, + DefaultValues extends Partial, +>( + class_: C | SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + SchemaValues, + DefaultValues + >, + + ...[values, params]: NewSchemableArgs< + SchemableClassInput + > +) => + new class_() + + +// export const newSchemablePromise = async < +// C extends SchemableClass<$Config>, +// $Config extends SchemableConfig, +// >( +// class_: C | SchemableClass<$Config>, +// ...[values, params]: NewSchemableArgs<$Config["input"]> +// ) => +// new class_(await class_.schemaWithDefaultValues.parseAsync(values || {}, params)) as InstanceType + + +// export const newSchemableEffect = < +// C extends SchemableClass<$Config>, +// $Config extends SchemableConfig, +// >( +// class_: C | SchemableClass<$Config>, +// ...[values, params]: NewSchemableArgs<$Config["input"]> +// ) => pipe( +// parseZodTypeEffect< +// z.output, +// z.input +// >( +// class_.schemaWithDefaultValues, +// values || {}, +// params, +// ), + +// Effect.map(values => new class_(values) as InstanceType), +// ) diff --git a/src/tests.ts b/src/tests.ts index 09d8037..3399d68 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,5 +1,5 @@ import { z } from "zod" -import { extendSchemableClass, makeSchemableClass, makeSchemableClassFrom } from "." +import { SchemableClassInput, extendSchemableClass, makeSchemableClass, makeSchemableClassFrom } from "." // class Test1 { @@ -34,3 +34,6 @@ class Test3 extends Test2 { } console.log(new Test3({ prout: "ruquier", ruquier: 69 })) + + +type Test = SchemableClassInput, typeof Test3.defaultValues> -- 2.49.1 From a68376485ba19fdc19f58a8f030aea8c37cefcb3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 23:21:33 +0100 Subject: [PATCH 14/47] Working newSchemable --- src/SchemableClass.ts | 49 ++++++++++++++++++++++++++++++------------- src/index.ts | 1 + src/newSchemable.ts | 21 ++++++++++++------- src/tests.ts | 7 ++++--- 4 files changed, 52 insertions(+), 26 deletions(-) diff --git a/src/SchemableClass.ts b/src/SchemableClass.ts index fb2144b..ece592b 100644 --- a/src/SchemableClass.ts +++ b/src/SchemableClass.ts @@ -1,36 +1,55 @@ -import { AbstractClass } from "type-fest" +import { AbstractClass, Class as ConcreteClass } from "type-fest" import { z } from "zod" +export type ClassType = "AbstractClass" | "Class" + +type Class< + Type extends ClassType, + T, + Arguments extends unknown[] = any[], +> = ( + Type extends "AbstractClass" + ? AbstractClass + : Type extends "Class" + ? ConcreteClass + : never +) + + export type SchemableClass< SchemaT extends z.ZodRawShape, SchemaUnknownKeys extends z.UnknownKeysParam, SchemaCatchall extends z.ZodTypeAny, - SchemaValues extends {}, - DefaultValues extends Partial, + Values extends {}, + DefaultValues extends Partial, + + Type extends ClassType = "AbstractClass" > = ( - AbstractClass< + Class< + Type, + { readonly schema: z.ZodObject< SchemaT, SchemaUnknownKeys, SchemaCatchall, - SchemaValues, - SchemaValues + Values, + Values > readonly defaultValues: DefaultValues - } & SchemaValues, + } & Values, - Parameters<(values: SchemaValues) => void> + Parameters<(values: Values) => never> > & { readonly schema: z.ZodObject< SchemaT, SchemaUnknownKeys, SchemaCatchall, - SchemaValues, - SchemaValues + Values, + Values > readonly defaultValues: DefaultValues @@ -39,12 +58,12 @@ export type SchemableClass< export type SchemableClassInput< - SchemaValues extends {}, - DefaultValues extends Partial, + Values extends {}, + DefaultValues extends Partial, > = { - [Key in Exclude]: SchemaValues[Key] + [Key in Exclude]: Values[Key] } & { - [Key in keyof DefaultValues]?: Key extends keyof SchemaValues - ? SchemaValues[Key] + [Key in keyof DefaultValues]?: Key extends keyof Values + ? Values[Key] : never } diff --git a/src/index.ts b/src/index.ts index 9e51df9..7df42bc 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,3 +1,4 @@ export * from "./SchemableClass" export * from "./extendSchemableClass" export * from "./makeSchemableClass" +export * from "./newSchemable" diff --git a/src/newSchemable.ts b/src/newSchemable.ts index 183f995..7764693 100644 --- a/src/newSchemable.ts +++ b/src/newSchemable.ts @@ -18,29 +18,34 @@ export const newSchemable = < SchemaT, SchemaUnknownKeys, SchemaCatchall, - SchemaValues, - DefaultValues + Values, + DefaultValues, + "Class" >, SchemaT extends z.ZodRawShape, SchemaUnknownKeys extends z.UnknownKeysParam, SchemaCatchall extends z.ZodTypeAny, - SchemaValues extends {}, - DefaultValues extends Partial, + + Values extends {}, + DefaultValues extends Partial, >( class_: C | SchemableClass< SchemaT, SchemaUnknownKeys, SchemaCatchall, - SchemaValues, - DefaultValues + Values, + DefaultValues, + "Class" >, ...[values, params]: NewSchemableArgs< - SchemableClassInput + SchemableClassInput > ) => - new class_() + new class_( + class_.schema.parse({ ...class_.defaultValues, ...values }, params) + ) as InstanceType // export const newSchemablePromise = async < diff --git a/src/tests.ts b/src/tests.ts index 3399d68..a88318b 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,5 +1,5 @@ import { z } from "zod" -import { SchemableClassInput, extendSchemableClass, makeSchemableClass, makeSchemableClassFrom } from "." +import { SchemableClassInput, extendSchemableClass, makeSchemableClass, makeSchemableClassFrom, newSchemable } from "." // class Test1 { @@ -33,7 +33,8 @@ new Test2({ prout: "ruquier", ruquier: 69 }) class Test3 extends Test2 { } -console.log(new Test3({ prout: "ruquier", ruquier: 69 })) - type Test = SchemableClassInput, typeof Test3.defaultValues> + +const test3inst = newSchemable(Test3, { ruquier: 48 }) +console.log(test3inst) -- 2.49.1 From abcc3e88e8eb7f662402440c8df49c6372b0cf25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 9 Jan 2024 23:38:45 +0100 Subject: [PATCH 15/47] Working newSchemable --- src/newSchemable.ts | 95 +++++++++++++++++++++++++++++++++------------ src/tests.ts | 5 +-- 2 files changed, 72 insertions(+), 28 deletions(-) diff --git a/src/newSchemable.ts b/src/newSchemable.ts index 7764693..69e0996 100644 --- a/src/newSchemable.ts +++ b/src/newSchemable.ts @@ -48,31 +48,76 @@ export const newSchemable = < ) as InstanceType -// export const newSchemablePromise = async < -// C extends SchemableClass<$Config>, -// $Config extends SchemableConfig, -// >( -// class_: C | SchemableClass<$Config>, -// ...[values, params]: NewSchemableArgs<$Config["input"]> -// ) => -// new class_(await class_.schemaWithDefaultValues.parseAsync(values || {}, params)) as InstanceType +export const newSchemablePromise = async < + C extends SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + DefaultValues, + "Class" + >, + + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, +>( + class_: C | SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + DefaultValues, + "Class" + >, + + ...[values, params]: NewSchemableArgs< + SchemableClassInput + > +) => + new class_( + await class_.schema.parseAsync({ ...class_.defaultValues, ...values }, params) + ) as InstanceType -// export const newSchemableEffect = < -// C extends SchemableClass<$Config>, -// $Config extends SchemableConfig, -// >( -// class_: C | SchemableClass<$Config>, -// ...[values, params]: NewSchemableArgs<$Config["input"]> -// ) => pipe( -// parseZodTypeEffect< -// z.output, -// z.input -// >( -// class_.schemaWithDefaultValues, -// values || {}, -// params, -// ), +export const newSchemableEffect = < + C extends SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + DefaultValues, + "Class" + >, -// Effect.map(values => new class_(values) as InstanceType), -// ) + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, +>( + class_: C | SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + DefaultValues, + "Class" + >, + + ...[values, params]: NewSchemableArgs< + SchemableClassInput + > +) => pipe( + parseZodTypeEffect( + class_.schema, + { ...class_.defaultValues, ...values }, + params, + ), + + Effect.map(values => new class_(values) as InstanceType), +) diff --git a/src/tests.ts b/src/tests.ts index a88318b..905a71a 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,5 +1,5 @@ import { z } from "zod" -import { SchemableClassInput, extendSchemableClass, makeSchemableClass, makeSchemableClassFrom, newSchemable } from "." +import { SchemableClassInput, extendSchemableClass, makeSchemableClass, newSchemableEffect } from "." // class Test1 { @@ -36,5 +36,4 @@ class Test3 extends Test2 { type Test = SchemableClassInput, typeof Test3.defaultValues> -const test3inst = newSchemable(Test3, { ruquier: 48 }) -console.log(test3inst) +const test3inst = newSchemableEffect(Test3, { ruquier: 48 }) -- 2.49.1 From 6ae87887db6376ee019dc52c9a1fc9baa57ffc8f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 10 Jan 2024 00:00:58 +0100 Subject: [PATCH 16/47] Fixed makeSchemableClassFrom --- src/makeSchemableClass.ts | 36 +++++++++++++++++++----------------- 1 file changed, 19 insertions(+), 17 deletions(-) diff --git a/src/makeSchemableClass.ts b/src/makeSchemableClass.ts index 759c80c..e14700d 100644 --- a/src/makeSchemableClass.ts +++ b/src/makeSchemableClass.ts @@ -1,4 +1,4 @@ -import { AbstractClass, Class } from "type-fest" +import { AbstractClass, Class as ConcreteClass } from "type-fest" import { z } from "zod" import { StaticMembers } from "./util" @@ -9,8 +9,9 @@ export function makeSchemableClassFrom< SchemaT extends z.ZodRawShape, SchemaUnknownKeys extends z.UnknownKeysParam, SchemaCatchall extends z.ZodTypeAny, - SchemaValues extends {}, - DefaultValues extends Partial, + + Values extends {}, + DefaultValues extends Partial, >( extend: C, @@ -18,39 +19,39 @@ export function makeSchemableClassFrom< SchemaT, SchemaUnknownKeys, SchemaCatchall, - SchemaValues, - SchemaValues + Values, + Values >, defaultValues: DefaultValues, ) { - type ClassKind = ( - C extends Class - ? Class + type Class = ( + C extends ConcreteClass + ? ConcreteClass : AbstractClass ) - return class extends (extend as unknown as Class) { + return class extends (extend as unknown as ConcreteClass) { static readonly schema = schema readonly schema = schema static readonly defaultValues = defaultValues readonly defaultValues = defaultValues - constructor(values: SchemaValues) { + constructor(values: Values) { super() Object.assign(this, values) } } as unknown as ( - ClassKind< + Class< Omit, "schema" | "defaultValues"> & { readonly schema: typeof schema, readonly defaultValues: typeof defaultValues, } & - SchemaValues, + Values, - Parameters<(values: SchemaValues) => void> + Parameters<(values: Values) => void> > & Omit, "schema" | "defaultValues"> & @@ -66,15 +67,16 @@ export function makeSchemableClass< SchemaT extends z.ZodRawShape, SchemaUnknownKeys extends z.UnknownKeysParam, SchemaCatchall extends z.ZodTypeAny, - SchemaValues extends {}, - DefaultValues extends Partial, + + Values extends {}, + DefaultValues extends Partial, >( schema: z.ZodObject< SchemaT, SchemaUnknownKeys, SchemaCatchall, - SchemaValues, - SchemaValues + Values, + Values >, defaultValues: DefaultValues, -- 2.49.1 From c423e998bf290d0162690ce29e8bc603c99a2f9f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 10 Jan 2024 00:05:28 +0100 Subject: [PATCH 17/47] Fixed extendSchemableClass --- src/extendSchemableClass.ts | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/extendSchemableClass.ts b/src/extendSchemableClass.ts index 2d06f72..5d30d2b 100644 --- a/src/extendSchemableClass.ts +++ b/src/extendSchemableClass.ts @@ -1,4 +1,4 @@ -import { AbstractClass, Class } from "type-fest" +import { AbstractClass, Class as ConcreteClass } from "type-fest" import { z } from "zod" import { SchemableClass } from "." import { StaticMembers } from "./util" @@ -23,6 +23,7 @@ export function extendSchemableClass< SchemaUnknownKeys extends z.UnknownKeysParam, SchemaCatchall extends z.ZodTypeAny, SchemaValues extends ExtendSchemaValues, + DefaultValues extends Partial, >( extend: C | SchemableClass< @@ -43,9 +44,9 @@ export function extendSchemableClass< defaultValuesApplier: (defaultValues: ExtendDefaultValues) => DefaultValues, ) { - type ClassKind = ( - C extends Class - ? Class + type Class = ( + C extends ConcreteClass + ? ConcreteClass : AbstractClass ) @@ -59,7 +60,7 @@ export function extendSchemableClass< static readonly defaultValues = defaultValues readonly defaultValues = defaultValues } as unknown as ( - ClassKind< + Class< Omit, "schema" | "defaultValues" | keyof ExtendSchemaValues> & { readonly schema: typeof schema, -- 2.49.1 From 9525cba0ebe17d02ec106d2c54532cc856bb0699 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 10 Jan 2024 00:27:47 +0100 Subject: [PATCH 18/47] newSchemable types fix --- src/newSchemable.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/newSchemable.ts b/src/newSchemable.ts index 69e0996..0166eb5 100644 --- a/src/newSchemable.ts +++ b/src/newSchemable.ts @@ -5,12 +5,12 @@ import { SchemableClass, SchemableClassInput } from "." import { parseZodTypeEffect } from "./util" -type ParamsArgs = [] | [Partial] +type ParamsArgs = [] | [params: Partial] type NewSchemableArgs = HasRequiredKeys extends true - ? [Input, ...ParamsArgs] - : [] | [Input, ...ParamsArgs] + ? [values: Input, ...args: ParamsArgs] + : [] | [values: Input, ...args: ParamsArgs] export const newSchemable = < -- 2.49.1 From c3e1bffe0d793844688f8dce9edee8ab388311fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 10 Jan 2024 00:55:46 +0100 Subject: [PATCH 19/47] JsonifiableSchemable attempt as a trait --- bun.lockb | Bin 154055 -> 159977 bytes package.json | 5 ++- src/jsonifiable/JsonifiableSchemable.ts | 52 ++++++++++++++++++++++++ src/jsonifiable/index.ts | 1 + src/tests.ts | 49 +++++++++------------- 5 files changed, 76 insertions(+), 31 deletions(-) create mode 100644 src/jsonifiable/JsonifiableSchemable.ts create mode 100644 src/jsonifiable/index.ts diff --git a/bun.lockb b/bun.lockb index 4e23eb8b4364adf2258b86fdc025f2982746ab68..dc2bf927cab3aee136b3fe7dbe87262a7a246c20 100755 GIT binary patch delta 31264 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 F{|Cl_-wXf% delta 28420 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 A1ONa4 diff --git a/package.json b/package.json index 1fa0eb4..04f6667 100644 --- a/package.json +++ b/package.json @@ -38,8 +38,9 @@ "clean:node": "rm -rf node_modules" }, "dependencies": { + "@thilawyn/thilatrait": "^0.1.1", "decimal.js": "^10.4.3", - "effect": "^2.0.0-next.62", + "effect": "^2.0.2", "lodash-es": "^4.17.21", "type-fest": "^4.9.0", "zod": "^3.22.4" @@ -50,7 +51,7 @@ "bun-types": "latest", "npm-check-updates": "^16.14.12", "npm-sort": "^0.0.4", - "rollup": "^4.9.1", + "rollup": "^4.9.4", "rollup-plugin-cleanup": "^3.2.1", "rollup-plugin-ts": "^3.4.5", "tsx": "^4.7.0", diff --git a/src/jsonifiable/JsonifiableSchemable.ts b/src/jsonifiable/JsonifiableSchemable.ts new file mode 100644 index 0000000..914b7f5 --- /dev/null +++ b/src/jsonifiable/JsonifiableSchemable.ts @@ -0,0 +1,52 @@ +import { trait } from "@thilawyn/thilatrait" +import { JsonifiableObject } from "type-fest/source/jsonifiable" +import { z } from "zod" + + +export const JsonifiableSchemable = < + JsonifySchemaT extends z.ZodRawShape, + JsonifySchemaUnknownKeys extends z.UnknownKeysParam, + JsonifySchemaCatchall extends z.ZodTypeAny, + + DejsonifySchemaT extends z.ZodRawShape, + DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, + DejsonifySchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + JsonifiedValues extends JsonifiableObject, +>( + jsonifySchema: z.ZodObject< + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + JsonifiedValues, + Values + >, + + dejsonifySchema: z.ZodObject< + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + Values, + JsonifiedValues + >, +) => + trait(Parent => { + abstract class JsonifiableSchemable extends Parent { + abstract readonly schema: z.ZodObject< + z.ZodRawShape, + z.UnknownKeysParam, + z.ZodTypeAny, + Values, + Values + > + + static readonly jsonifySchema = jsonifySchema + readonly jsonifySchema = jsonifySchema + + static readonly dejsonifySchema = dejsonifySchema + readonly dejsonifySchema = dejsonifySchema + } + + return JsonifiableSchemable + }) diff --git a/src/jsonifiable/index.ts b/src/jsonifiable/index.ts new file mode 100644 index 0000000..2662891 --- /dev/null +++ b/src/jsonifiable/index.ts @@ -0,0 +1 @@ +export * from "./JsonifiableSchemable" diff --git a/src/tests.ts b/src/tests.ts index 905a71a..33cca5c 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,39 +1,30 @@ +import { extendsAndExpresses } from "@thilawyn/thilatrait" import { z } from "zod" -import { SchemableClassInput, extendSchemableClass, makeSchemableClass, newSchemableEffect } from "." +import { makeSchemableClass, newSchemable } from "." +import { JsonifiableSchemable } from "./jsonifiable" +import { dejsonifyBigIntSchema, jsonifyBigIntSchema } from "./legacy/jsonifiable" -// class Test1 { -// static readonly schema = Test1Schema -// readonly schema = Test1Schema - -// static readonly defaultValues = { prout: "heugneu" } -// readonly defaultValues = { prout: "heugneu" } - -// prout: string = "heugneu" -// } - -const Test1 = makeSchemableClass( - z.object({ prout: z.string() }), - {}, -) - -new Test1({ prout: "adfd" }).prout +const UserLevel = z.enum(["User", "Admin"]) -const Test2 = extendSchemableClass( - Test1, - schema => schema.extend({ prout: z.literal("ruquier"), ruquier: z.number() }), - () => ({ prout: "ruquier" as const }), -) +const UserProto = makeSchemableClass(z.object({ + id: z.bigint(), + name: z.string(), + level: UserLevel, +}), { + level: "User" +} as const) -Test2.defaultValues -new Test2({ prout: "ruquier", ruquier: 69 }) +UserProto.defaultValues -class Test3 extends Test2 { -} +class User extends extendsAndExpresses(UserProto, + JsonifiableSchemable( + UserProto.schema.extend({ id: jsonifyBigIntSchema(z.bigint()) }), + UserProto.schema.extend({ id: dejsonifyBigIntSchema(z.bigint()) }), + ) +) {} -type Test = SchemableClassInput, typeof Test3.defaultValues> - -const test3inst = newSchemableEffect(Test3, { ruquier: 48 }) +const user1 = newSchemable(User, { id: 1n, name: "User" }) -- 2.49.1 From f60ffba2a14fb72cff30e12d9f9e726a830e0789 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 10 Jan 2024 05:07:12 +0100 Subject: [PATCH 20/47] JsonifiableSchemableClass --- src/SchemableClass.ts | 17 +------- src/jsonifiable/JsonifiableSchemableClass.ts | 43 ++++++++++++++++++++ src/jsonifiable/index.ts | 1 + src/util.ts | 16 ++++++++ 4 files changed, 61 insertions(+), 16 deletions(-) create mode 100644 src/jsonifiable/JsonifiableSchemableClass.ts diff --git a/src/SchemableClass.ts b/src/SchemableClass.ts index ece592b..f54a32f 100644 --- a/src/SchemableClass.ts +++ b/src/SchemableClass.ts @@ -1,20 +1,5 @@ -import { AbstractClass, Class as ConcreteClass } from "type-fest" import { z } from "zod" - - -export type ClassType = "AbstractClass" | "Class" - -type Class< - Type extends ClassType, - T, - Arguments extends unknown[] = any[], -> = ( - Type extends "AbstractClass" - ? AbstractClass - : Type extends "Class" - ? ConcreteClass - : never -) +import { Class, ClassType } from "./util" export type SchemableClass< diff --git a/src/jsonifiable/JsonifiableSchemableClass.ts b/src/jsonifiable/JsonifiableSchemableClass.ts new file mode 100644 index 0000000..ea880c6 --- /dev/null +++ b/src/jsonifiable/JsonifiableSchemableClass.ts @@ -0,0 +1,43 @@ +import { JsonifiableObject } from "type-fest/source/jsonifiable" +import { z } from "zod" +import { SchemableClass } from ".." +import { Class, ClassType } from "../util" + + +export type JsonifiableSchemableClass< + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, + + JsonifySchemaT extends z.ZodRawShape, + JsonifySchemaUnknownKeys extends z.UnknownKeysParam, + JsonifySchemaCatchall extends z.ZodTypeAny, + + DejsonifySchemaT extends z.ZodRawShape, + DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, + DejsonifySchemaCatchall extends z.ZodTypeAny, + + JsonifiedValues extends JsonifiableObject, + + Type extends ClassType = "AbstractClass" +> = ( + SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + DefaultValues, + Type + > & + + Class< + Type, + + {}, + + any[] + > +) diff --git a/src/jsonifiable/index.ts b/src/jsonifiable/index.ts index 2662891..4269365 100644 --- a/src/jsonifiable/index.ts +++ b/src/jsonifiable/index.ts @@ -1 +1,2 @@ export * from "./JsonifiableSchemable" +export * from "./JsonifiableSchemableClass" diff --git a/src/util.ts b/src/util.ts index 276cbdd..1f2ea6b 100644 --- a/src/util.ts +++ b/src/util.ts @@ -1,7 +1,23 @@ import { Effect, pipe } from "effect" +import { AbstractClass, Class as ConcreteClass } from "type-fest" import { z } from "zod" +export type ClassType = "AbstractClass" | "Class" + +export type Class< + Type extends ClassType, + T, + Arguments extends unknown[] = any[], +> = ( + Type extends "AbstractClass" + ? AbstractClass + : Type extends "Class" + ? ConcreteClass + : never +) + + /** * Represents the static members of a class. * @template C - The class type. -- 2.49.1 From a9e53be4407be586f28a91c9f9c9ff3ab4487e55 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Thu, 11 Jan 2024 01:59:44 +0100 Subject: [PATCH 21/47] JsonifiableSchemableClass work --- src/jsonifiable/JsonifiableSchemableClass.ts | 36 ++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/src/jsonifiable/JsonifiableSchemableClass.ts b/src/jsonifiable/JsonifiableSchemableClass.ts index ea880c6..606622c 100644 --- a/src/jsonifiable/JsonifiableSchemableClass.ts +++ b/src/jsonifiable/JsonifiableSchemableClass.ts @@ -36,8 +36,40 @@ export type JsonifiableSchemableClass< Class< Type, - {}, + { + readonly jsonifySchema: z.ZodObject< + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + JsonifiedValues, + Values + > + + readonly dejsonifySchema: z.ZodObject< + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + Values, + JsonifiedValues + > + }, any[] - > + > & { + readonly jsonifySchema: z.ZodObject< + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + JsonifiedValues, + Values + > + + readonly dejsonifySchema: z.ZodObject< + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + Values, + JsonifiedValues + > + } ) -- 2.49.1 From b6bbda124675fe94ebfc785081c916a9ca78254c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Thu, 11 Jan 2024 03:39:41 +0100 Subject: [PATCH 22/47] Prevent makeSchemableClassFrom from being used with schemables --- src/makeSchemableClass.ts | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/makeSchemableClass.ts b/src/makeSchemableClass.ts index e14700d..8268b52 100644 --- a/src/makeSchemableClass.ts +++ b/src/makeSchemableClass.ts @@ -4,7 +4,13 @@ import { StaticMembers } from "./util" export function makeSchemableClassFrom< - C extends AbstractClass, + C extends AbstractClass<{ + schema?: never + defaultValues?: never + }, []> & { + schema?: never + defaultValues?: never + }, SchemaT extends z.ZodRawShape, SchemaUnknownKeys extends z.UnknownKeysParam, @@ -44,7 +50,7 @@ export function makeSchemableClassFrom< } } as unknown as ( Class< - Omit, "schema" | "defaultValues"> & + InstanceType & { readonly schema: typeof schema, readonly defaultValues: typeof defaultValues, @@ -54,7 +60,7 @@ export function makeSchemableClassFrom< Parameters<(values: Values) => void> > & - Omit, "schema" | "defaultValues"> & + StaticMembers & { readonly schema: typeof schema, readonly defaultValues: typeof defaultValues, -- 2.49.1 From b78ce499da3ca93c2d1ab9f94c8459fd6be2b6eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Sat, 13 Jan 2024 13:11:48 +0100 Subject: [PATCH 23/47] createMakeSchemableClassFromUnary --- src/makeSchemableClass.ts | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/src/makeSchemableClass.ts b/src/makeSchemableClass.ts index 8268b52..fbe30da 100644 --- a/src/makeSchemableClass.ts +++ b/src/makeSchemableClass.ts @@ -68,6 +68,36 @@ export function makeSchemableClassFrom< ) } +export function createMakeSchemableClassFromUnary< + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, +>( + schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + Values + >, + + defaultValues: DefaultValues, +) { + return < + C extends AbstractClass<{ + schema?: never + defaultValues?: never + }, []> & { + schema?: never + defaultValues?: never + } + >(extend: C) => + makeSchemableClassFrom(extend, schema, defaultValues) +} + export function makeSchemableClass< SchemaT extends z.ZodRawShape, -- 2.49.1 From 354454f76c0fee34f238f18bc5542eb9e20cadc7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Mon, 15 Jan 2024 11:05:44 +0100 Subject: [PATCH 24/47] makeJsonifiableSchemableClass --- src/jsonifiable/index.ts | 1 + .../makeJsonifiableSchemableClass.ts | 118 ++++++++++++++++++ src/makeSchemableClass.ts | 24 ++-- 3 files changed, 129 insertions(+), 14 deletions(-) create mode 100644 src/jsonifiable/makeJsonifiableSchemableClass.ts diff --git a/src/jsonifiable/index.ts b/src/jsonifiable/index.ts index 4269365..5d4869f 100644 --- a/src/jsonifiable/index.ts +++ b/src/jsonifiable/index.ts @@ -1,2 +1,3 @@ export * from "./JsonifiableSchemable" export * from "./JsonifiableSchemableClass" +export * from "./makeJsonifiableSchemableClass" diff --git a/src/jsonifiable/makeJsonifiableSchemableClass.ts b/src/jsonifiable/makeJsonifiableSchemableClass.ts new file mode 100644 index 0000000..36f0ad5 --- /dev/null +++ b/src/jsonifiable/makeJsonifiableSchemableClass.ts @@ -0,0 +1,118 @@ +import { Effect } from "effect" +import { JsonifiableObject } from "type-fest/source/jsonifiable" +import { z } from "zod" +import { SchemableClass } from ".." +import { Class, ClassType, StaticMembers, parseZodTypeEffect } from "../util" + + +export function makeJsonifiableSchemableClass< + C extends SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + DefaultValues + >, + + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, + + JsonifySchemaT extends z.ZodRawShape, + JsonifySchemaUnknownKeys extends z.UnknownKeysParam, + JsonifySchemaCatchall extends z.ZodTypeAny, + + DejsonifySchemaT extends z.ZodRawShape, + DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, + DejsonifySchemaCatchall extends z.ZodTypeAny, + + JsonifiedValues extends JsonifiableObject, + + Type extends ClassType = "AbstractClass" +>( + props: { + extend: C | SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + DefaultValues, + Type + > + + jsonifySchema: (props: { + schema: C["schema"] + shape: C["schema"]["shape"] + }) => z.ZodObject< + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + JsonifiedValues, + Values + > + + dejsonifySchema: (props: { + schema: C["schema"] + shape: C["schema"]["shape"] + }) => z.ZodObject< + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + Values, + JsonifiedValues + > + } +) { + const jsonifySchema = props.jsonifySchema({ + schema: props.extend.schema, + shape: props.extend.schema.shape, + }) + + const dejsonifySchema = props.dejsonifySchema({ + schema: props.extend.schema, + shape: props.extend.schema.shape, + }) + + return class extends props.extend { + static readonly jsonifySchema = jsonifySchema + readonly jsonifySchema = jsonifySchema + + static readonly dejsonifySchema = dejsonifySchema + readonly dejsonifySchema = dejsonifySchema + + jsonify() { + return this.jsonifySchema.parse(this) + } + + jsonifyPromise() { + return this.jsonifySchema.parseAsync(this) + } + + jsonifyEffect() { + return parseZodTypeEffect(this.jsonifySchema, this) + } + } as unknown as ( + Class< + Type, + + InstanceType & { + readonly jsonifySchema: typeof jsonifySchema, + readonly dejsonifySchema: typeof dejsonifySchema, + + jsonify(): JsonifiedValues + jsonifyPromise(): Promise + jsonifyEffect(): Effect.Effect, JsonifiedValues> + }, + + ConstructorParameters + > & + + StaticMembers & { + readonly jsonifySchema: typeof jsonifySchema, + readonly dejsonifySchema: typeof dejsonifySchema, + } + ) +} diff --git a/src/makeSchemableClass.ts b/src/makeSchemableClass.ts index fbe30da..7c334eb 100644 --- a/src/makeSchemableClass.ts +++ b/src/makeSchemableClass.ts @@ -3,14 +3,16 @@ import { z } from "zod" import { StaticMembers } from "./util" +type MakeSchemableClassFromInputClass = AbstractClass<{ + schema?: never + defaultValues?: never +}, []> & { + schema?: never + defaultValues?: never +} + export function makeSchemableClassFrom< - C extends AbstractClass<{ - schema?: never - defaultValues?: never - }, []> & { - schema?: never - defaultValues?: never - }, + C extends MakeSchemableClassFromInputClass, SchemaT extends z.ZodRawShape, SchemaUnknownKeys extends z.UnknownKeysParam, @@ -87,13 +89,7 @@ export function createMakeSchemableClassFromUnary< defaultValues: DefaultValues, ) { return < - C extends AbstractClass<{ - schema?: never - defaultValues?: never - }, []> & { - schema?: never - defaultValues?: never - } + C extends MakeSchemableClassFromInputClass >(extend: C) => makeSchemableClassFrom(extend, schema, defaultValues) } -- 2.49.1 From af84a7ef2a3f83060e46e5e233c15251631317b2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Mon, 15 Jan 2024 11:17:59 +0100 Subject: [PATCH 25/47] Jsonifiable tests --- src/tests.ts | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/src/tests.ts b/src/tests.ts index 33cca5c..bd17337 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,7 +1,6 @@ -import { extendsAndExpresses } from "@thilawyn/thilatrait" import { z } from "zod" import { makeSchemableClass, newSchemable } from "." -import { JsonifiableSchemable } from "./jsonifiable" +import { makeJsonifiableSchemableClass } from "./jsonifiable" import { dejsonifyBigIntSchema, jsonifyBigIntSchema } from "./legacy/jsonifiable" @@ -19,12 +18,21 @@ const UserProto = makeSchemableClass(z.object({ UserProto.defaultValues -class User extends extendsAndExpresses(UserProto, - JsonifiableSchemable( - UserProto.schema.extend({ id: jsonifyBigIntSchema(z.bigint()) }), - UserProto.schema.extend({ id: dejsonifyBigIntSchema(z.bigint()) }), - ) -) {} +const JsonifiableUserProto = makeJsonifiableSchemableClass({ + extend: UserProto, + + jsonifySchema: ({ schema, shape }) => schema.extend({ + id: jsonifyBigIntSchema(shape.id) + }), + + dejsonifySchema: ({ schema, shape }) => schema.extend({ + id: dejsonifyBigIntSchema(shape.id) + }), +}) + + +class User extends JsonifiableUserProto {} const user1 = newSchemable(User, { id: 1n, name: "User" }) +user1.jsonify() -- 2.49.1 From 5723829257fbaaf64918664571df8532f6a0c56e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Mon, 15 Jan 2024 11:24:46 +0100 Subject: [PATCH 26/47] makeJsonifiableSchemableClass fix --- .../makeJsonifiableSchemableClass.ts | 30 +++++++++---------- src/tests.ts | 4 +-- 2 files changed, 16 insertions(+), 18 deletions(-) diff --git a/src/jsonifiable/makeJsonifiableSchemableClass.ts b/src/jsonifiable/makeJsonifiableSchemableClass.ts index 36f0ad5..6d7843f 100644 --- a/src/jsonifiable/makeJsonifiableSchemableClass.ts +++ b/src/jsonifiable/makeJsonifiableSchemableClass.ts @@ -33,16 +33,16 @@ export function makeJsonifiableSchemableClass< Type extends ClassType = "AbstractClass" >( - props: { - extend: C | SchemableClass< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - Values, - DefaultValues, - Type - > + extend: C | SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + DefaultValues, + Type + >, + props: { jsonifySchema: (props: { schema: C["schema"] shape: C["schema"]["shape"] @@ -64,19 +64,19 @@ export function makeJsonifiableSchemableClass< Values, JsonifiedValues > - } + }, ) { const jsonifySchema = props.jsonifySchema({ - schema: props.extend.schema, - shape: props.extend.schema.shape, + schema: extend.schema, + shape: extend.schema.shape, }) const dejsonifySchema = props.dejsonifySchema({ - schema: props.extend.schema, - shape: props.extend.schema.shape, + schema: extend.schema, + shape: extend.schema.shape, }) - return class extends props.extend { + return class extends extend { static readonly jsonifySchema = jsonifySchema readonly jsonifySchema = jsonifySchema diff --git a/src/tests.ts b/src/tests.ts index bd17337..5e8740f 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -18,9 +18,7 @@ const UserProto = makeSchemableClass(z.object({ UserProto.defaultValues -const JsonifiableUserProto = makeJsonifiableSchemableClass({ - extend: UserProto, - +const JsonifiableUserProto = makeJsonifiableSchemableClass(UserProto, { jsonifySchema: ({ schema, shape }) => schema.extend({ id: jsonifyBigIntSchema(shape.id) }), -- 2.49.1 From 629b61c545e79cdc70bffcc97fd82cffd04adc22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Mon, 15 Jan 2024 15:35:27 +0100 Subject: [PATCH 27/47] makeJsonifiableSchemableClass refactoring --- .../makeJsonifiableSchemableClass.ts | 158 +++++++++++++++--- 1 file changed, 134 insertions(+), 24 deletions(-) diff --git a/src/jsonifiable/makeJsonifiableSchemableClass.ts b/src/jsonifiable/makeJsonifiableSchemableClass.ts index 6d7843f..943f744 100644 --- a/src/jsonifiable/makeJsonifiableSchemableClass.ts +++ b/src/jsonifiable/makeJsonifiableSchemableClass.ts @@ -5,13 +5,69 @@ import { SchemableClass } from ".." import { Class, ClassType, StaticMembers, parseZodTypeEffect } from "../util" +export type MakeJsonifiableSchemableClassProps< + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + + JsonifySchemaT extends z.ZodRawShape, + JsonifySchemaUnknownKeys extends z.UnknownKeysParam, + JsonifySchemaCatchall extends z.ZodTypeAny, + + DejsonifySchemaT extends z.ZodRawShape, + DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, + DejsonifySchemaCatchall extends z.ZodTypeAny, + + JsonifiedValues extends JsonifiableObject, +> = { + 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 + > +} + + export function makeJsonifiableSchemableClass< C extends SchemableClass< SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, - DefaultValues + DefaultValues, + Type >, SchemaT extends z.ZodRawShape, @@ -31,7 +87,7 @@ export function makeJsonifiableSchemableClass< JsonifiedValues extends JsonifiableObject, - Type extends ClassType = "AbstractClass" + Type extends ClassType = "AbstractClass", >( extend: C | SchemableClass< SchemaT, @@ -42,29 +98,23 @@ export function makeJsonifiableSchemableClass< Type >, - props: { - jsonifySchema: (props: { - schema: C["schema"] - shape: C["schema"]["shape"] - }) => z.ZodObject< - JsonifySchemaT, - JsonifySchemaUnknownKeys, - JsonifySchemaCatchall, - JsonifiedValues, - Values - > + props: MakeJsonifiableSchemableClassProps< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, - dejsonifySchema: (props: { - schema: C["schema"] - shape: C["schema"]["shape"] - }) => z.ZodObject< - DejsonifySchemaT, - DejsonifySchemaUnknownKeys, - DejsonifySchemaCatchall, - Values, - JsonifiedValues - > - }, + Values, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues + >, ) { const jsonifySchema = props.jsonifySchema({ schema: extend.schema, @@ -116,3 +166,63 @@ export function makeJsonifiableSchemableClass< } ) } + + +export function pipeMakeJsonifiableSchemableClass< + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, + + JsonifySchemaT extends z.ZodRawShape, + JsonifySchemaUnknownKeys extends z.UnknownKeysParam, + JsonifySchemaCatchall extends z.ZodTypeAny, + + DejsonifySchemaT extends z.ZodRawShape, + DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, + DejsonifySchemaCatchall extends z.ZodTypeAny, + + JsonifiedValues extends JsonifiableObject, +>( + props: MakeJsonifiableSchemableClassProps< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + + Values, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues + > +) { + return < + C extends SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + DefaultValues, + Type + >, + + Type extends ClassType = "AbstractClass", + >( + extend: C | SchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + DefaultValues, + Type + > + ) => makeJsonifiableSchemableClass(extend, props) +} -- 2.49.1 From 42d5d7a92e6b44a3a669629cbb6ee71f00f68e77 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Mon, 15 Jan 2024 19:28:06 +0100 Subject: [PATCH 28/47] makeJsonifiableSchemableClass fix --- .../makeJsonifiableSchemableClass.ts | 29 +++++++++---------- 1 file changed, 13 insertions(+), 16 deletions(-) diff --git a/src/jsonifiable/makeJsonifiableSchemableClass.ts b/src/jsonifiable/makeJsonifiableSchemableClass.ts index 943f744..d3e0478 100644 --- a/src/jsonifiable/makeJsonifiableSchemableClass.ts +++ b/src/jsonifiable/makeJsonifiableSchemableClass.ts @@ -1,8 +1,9 @@ import { Effect } from "effect" +import { AbstractClass, Class as ConcreteClass } from "type-fest" import { JsonifiableObject } from "type-fest/source/jsonifiable" import { z } from "zod" import { SchemableClass } from ".." -import { Class, ClassType, StaticMembers, parseZodTypeEffect } from "../util" +import { StaticMembers, parseZodTypeEffect } from "../util" export type MakeJsonifiableSchemableClassProps< @@ -66,8 +67,7 @@ export function makeJsonifiableSchemableClass< SchemaUnknownKeys, SchemaCatchall, Values, - DefaultValues, - Type + DefaultValues >, SchemaT extends z.ZodRawShape, @@ -86,16 +86,13 @@ export function makeJsonifiableSchemableClass< DejsonifySchemaCatchall extends z.ZodTypeAny, JsonifiedValues extends JsonifiableObject, - - Type extends ClassType = "AbstractClass", >( extend: C | SchemableClass< SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, - DefaultValues, - Type + DefaultValues >, props: MakeJsonifiableSchemableClassProps< @@ -116,6 +113,12 @@ export function makeJsonifiableSchemableClass< JsonifiedValues >, ) { + type Class = ( + C extends ConcreteClass + ? ConcreteClass + : AbstractClass + ) + const jsonifySchema = props.jsonifySchema({ schema: extend.schema, shape: extend.schema.shape, @@ -146,8 +149,6 @@ export function makeJsonifiableSchemableClass< } } as unknown as ( Class< - Type, - InstanceType & { readonly jsonifySchema: typeof jsonifySchema, readonly dejsonifySchema: typeof dejsonifySchema, @@ -210,19 +211,15 @@ export function pipeMakeJsonifiableSchemableClass< SchemaUnknownKeys, SchemaCatchall, Values, - DefaultValues, - Type - >, - - Type extends ClassType = "AbstractClass", + DefaultValues + > >( extend: C | SchemableClass< SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, - DefaultValues, - Type + DefaultValues > ) => makeJsonifiableSchemableClass(extend, props) } -- 2.49.1 From d32a3a6d1e7a3320ac59452e7f9645af074d050d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Mon, 15 Jan 2024 20:57:45 +0100 Subject: [PATCH 29/47] JsonifiableSchemableClass fix --- src/jsonifiable/JsonifiableSchemableClass.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/jsonifiable/JsonifiableSchemableClass.ts b/src/jsonifiable/JsonifiableSchemableClass.ts index 606622c..da145d6 100644 --- a/src/jsonifiable/JsonifiableSchemableClass.ts +++ b/src/jsonifiable/JsonifiableSchemableClass.ts @@ -1,3 +1,4 @@ +import { Effect } from "effect" import { JsonifiableObject } from "type-fest/source/jsonifiable" import { z } from "zod" import { SchemableClass } from ".." @@ -52,6 +53,10 @@ export type JsonifiableSchemableClass< Values, JsonifiedValues > + + jsonify(): JsonifiedValues + jsonifyPromise(): Promise + jsonifyEffect(): Effect.Effect, JsonifiedValues> }, any[] -- 2.49.1 From b848e43974001cfc99537f7757c5f3bb930dcb6e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 16 Jan 2024 10:41:49 +0100 Subject: [PATCH 30/47] Cleanup --- src/jsonifiable/JsonifiableSchemable.ts | 52 ------------------------- src/jsonifiable/index.ts | 1 - 2 files changed, 53 deletions(-) delete mode 100644 src/jsonifiable/JsonifiableSchemable.ts diff --git a/src/jsonifiable/JsonifiableSchemable.ts b/src/jsonifiable/JsonifiableSchemable.ts deleted file mode 100644 index 914b7f5..0000000 --- a/src/jsonifiable/JsonifiableSchemable.ts +++ /dev/null @@ -1,52 +0,0 @@ -import { trait } from "@thilawyn/thilatrait" -import { JsonifiableObject } from "type-fest/source/jsonifiable" -import { z } from "zod" - - -export const JsonifiableSchemable = < - JsonifySchemaT extends z.ZodRawShape, - JsonifySchemaUnknownKeys extends z.UnknownKeysParam, - JsonifySchemaCatchall extends z.ZodTypeAny, - - DejsonifySchemaT extends z.ZodRawShape, - DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, - DejsonifySchemaCatchall extends z.ZodTypeAny, - - Values extends {}, - JsonifiedValues extends JsonifiableObject, ->( - jsonifySchema: z.ZodObject< - JsonifySchemaT, - JsonifySchemaUnknownKeys, - JsonifySchemaCatchall, - JsonifiedValues, - Values - >, - - dejsonifySchema: z.ZodObject< - DejsonifySchemaT, - DejsonifySchemaUnknownKeys, - DejsonifySchemaCatchall, - Values, - JsonifiedValues - >, -) => - trait(Parent => { - abstract class JsonifiableSchemable extends Parent { - abstract readonly schema: z.ZodObject< - z.ZodRawShape, - z.UnknownKeysParam, - z.ZodTypeAny, - Values, - Values - > - - static readonly jsonifySchema = jsonifySchema - readonly jsonifySchema = jsonifySchema - - static readonly dejsonifySchema = dejsonifySchema - readonly dejsonifySchema = dejsonifySchema - } - - return JsonifiableSchemable - }) diff --git a/src/jsonifiable/index.ts b/src/jsonifiable/index.ts index 5d4869f..3f08be2 100644 --- a/src/jsonifiable/index.ts +++ b/src/jsonifiable/index.ts @@ -1,3 +1,2 @@ -export * from "./JsonifiableSchemable" export * from "./JsonifiableSchemableClass" export * from "./makeJsonifiableSchemableClass" -- 2.49.1 From e83c3a77be81457b6740631dd19eed2fc12393e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 16 Jan 2024 10:58:21 +0100 Subject: [PATCH 31/47] Cleanup --- .../makeJsonifiableSchemableClass.ts | 159 ++++-------------- src/makeSchemableClass.ts | 40 +---- 2 files changed, 41 insertions(+), 158 deletions(-) diff --git a/src/jsonifiable/makeJsonifiableSchemableClass.ts b/src/jsonifiable/makeJsonifiableSchemableClass.ts index d3e0478..020d658 100644 --- a/src/jsonifiable/makeJsonifiableSchemableClass.ts +++ b/src/jsonifiable/makeJsonifiableSchemableClass.ts @@ -6,61 +6,6 @@ import { SchemableClass } from ".." import { StaticMembers, parseZodTypeEffect } from "../util" -export type MakeJsonifiableSchemableClassProps< - SchemaT extends z.ZodRawShape, - SchemaUnknownKeys extends z.UnknownKeysParam, - SchemaCatchall extends z.ZodTypeAny, - - Values extends {}, - - JsonifySchemaT extends z.ZodRawShape, - JsonifySchemaUnknownKeys extends z.UnknownKeysParam, - JsonifySchemaCatchall extends z.ZodTypeAny, - - DejsonifySchemaT extends z.ZodRawShape, - DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, - DejsonifySchemaCatchall extends z.ZodTypeAny, - - JsonifiedValues extends JsonifiableObject, -> = { - 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 - > -} - - export function makeJsonifiableSchemableClass< C extends SchemableClass< SchemaT, @@ -95,23 +40,43 @@ export function makeJsonifiableSchemableClass< DefaultValues >, - props: MakeJsonifiableSchemableClassProps< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, + props: { + jsonifySchema: (props: { + schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + Values + > - Values, + shape: SchemaT + }) => z.ZodObject< + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + JsonifiedValues, + Values + > - JsonifySchemaT, - JsonifySchemaUnknownKeys, - JsonifySchemaCatchall, + dejsonifySchema: (props: { + schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + Values + > - DejsonifySchemaT, - DejsonifySchemaUnknownKeys, - DejsonifySchemaCatchall, - - JsonifiedValues - >, + shape: SchemaT + }) => z.ZodObject< + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + Values, + JsonifiedValues + > + }, ) { type Class = ( C extends ConcreteClass @@ -167,59 +132,3 @@ export function makeJsonifiableSchemableClass< } ) } - - -export function pipeMakeJsonifiableSchemableClass< - SchemaT extends z.ZodRawShape, - SchemaUnknownKeys extends z.UnknownKeysParam, - SchemaCatchall extends z.ZodTypeAny, - - Values extends {}, - DefaultValues extends Partial, - - JsonifySchemaT extends z.ZodRawShape, - JsonifySchemaUnknownKeys extends z.UnknownKeysParam, - JsonifySchemaCatchall extends z.ZodTypeAny, - - DejsonifySchemaT extends z.ZodRawShape, - DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, - DejsonifySchemaCatchall extends z.ZodTypeAny, - - JsonifiedValues extends JsonifiableObject, ->( - props: MakeJsonifiableSchemableClassProps< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - - Values, - - JsonifySchemaT, - JsonifySchemaUnknownKeys, - JsonifySchemaCatchall, - - DejsonifySchemaT, - DejsonifySchemaUnknownKeys, - DejsonifySchemaCatchall, - - JsonifiedValues - > -) { - return < - C extends SchemableClass< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - Values, - DefaultValues - > - >( - extend: C | SchemableClass< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - Values, - DefaultValues - > - ) => makeJsonifiableSchemableClass(extend, props) -} diff --git a/src/makeSchemableClass.ts b/src/makeSchemableClass.ts index 7c334eb..8268b52 100644 --- a/src/makeSchemableClass.ts +++ b/src/makeSchemableClass.ts @@ -3,16 +3,14 @@ import { z } from "zod" import { StaticMembers } from "./util" -type MakeSchemableClassFromInputClass = AbstractClass<{ - schema?: never - defaultValues?: never -}, []> & { - schema?: never - defaultValues?: never -} - export function makeSchemableClassFrom< - C extends MakeSchemableClassFromInputClass, + C extends AbstractClass<{ + schema?: never + defaultValues?: never + }, []> & { + schema?: never + defaultValues?: never + }, SchemaT extends z.ZodRawShape, SchemaUnknownKeys extends z.UnknownKeysParam, @@ -70,30 +68,6 @@ export function makeSchemableClassFrom< ) } -export function createMakeSchemableClassFromUnary< - SchemaT extends z.ZodRawShape, - SchemaUnknownKeys extends z.UnknownKeysParam, - SchemaCatchall extends z.ZodTypeAny, - - Values extends {}, - DefaultValues extends Partial, ->( - schema: z.ZodObject< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - Values, - Values - >, - - defaultValues: DefaultValues, -) { - return < - C extends MakeSchemableClassFromInputClass - >(extend: C) => - makeSchemableClassFrom(extend, schema, defaultValues) -} - export function makeSchemableClass< SchemaT extends z.ZodRawShape, -- 2.49.1 From 892ee29060534eec1bcf5ca768a86db9a21d8ec0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 16 Jan 2024 11:47:48 +0100 Subject: [PATCH 32/47] Refactoring --- bun.lockb | Bin 159977 -> 160399 bytes package.json | 1 + src/extendSchemableClass.ts | 30 ++++++++++++++-------- src/makeSchemableClass.ts | 38 +++++++++++++++------------- src/tests.ts | 48 ++++++++++++++++++++++++------------ 5 files changed, 74 insertions(+), 43 deletions(-) diff --git a/bun.lockb b/bun.lockb index dc2bf927cab3aee136b3fe7dbe87262a7a246c20..6e480f417ea87a3ec7eb6f758ea54b36b9ff880c 100755 GIT binary patch delta 28858 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

uLu!e3F3+n*``S)i1R|s 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 delta 28516 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, - schemaApplier: (schema: C["schema"]) => z.ZodObject< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - SchemaValues, - SchemaValues - >, + props: { + schema: ( + schema: z.ZodObject< + ExtendSchemaT, + ExtendSchemaUnknownKeys, + ExtendSchemaCatchall, + ExtendSchemaValues, + ExtendSchemaValues + > + ) => z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + SchemaValues, + SchemaValues + > - defaultValuesApplier: (defaultValues: ExtendDefaultValues) => DefaultValues, + defaultValues: (defaultValues: ExtendDefaultValues) => DefaultValues + }, ) { type Class = ( C extends ConcreteClass @@ -50,8 +60,8 @@ export function extendSchemableClass< : AbstractClass ) - const schema = schemaApplier(extend.schema) - const defaultValues = defaultValuesApplier(extend.defaultValues) + const schema = props.schema(extend.schema) + const defaultValues = props.defaultValues(extend.defaultValues) return class extends extend { static readonly schema = schema diff --git a/src/makeSchemableClass.ts b/src/makeSchemableClass.ts index 8268b52..544dade 100644 --- a/src/makeSchemableClass.ts +++ b/src/makeSchemableClass.ts @@ -21,15 +21,17 @@ export function makeSchemableClassFrom< >( extend: C, - schema: z.ZodObject< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - Values, - Values - >, + { schema, defaultValues }: { + schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + Values + > - defaultValues: DefaultValues, + defaultValues: DefaultValues + }, ) { type Class = ( C extends ConcreteClass @@ -77,15 +79,17 @@ export function makeSchemableClass< Values extends {}, DefaultValues extends Partial, >( - schema: z.ZodObject< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - Values, - Values - >, + props: { + schema: z.ZodObject< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + Values, + Values + > - defaultValues: DefaultValues, + defaultValues: DefaultValues + } ) { - return makeSchemableClassFrom(Object, schema, defaultValues) + return makeSchemableClassFrom(Object, props) } diff --git a/src/tests.ts b/src/tests.ts index 5e8740f..ce37480 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,3 +1,4 @@ +import { pipeInto } from "ts-functional-pipe" import { z } from "zod" import { makeSchemableClass, newSchemable } from "." import { makeJsonifiableSchemableClass } from "./jsonifiable" @@ -7,29 +8,44 @@ import { dejsonifyBigIntSchema, jsonifyBigIntSchema } from "./legacy/jsonifiable const UserLevel = z.enum(["User", "Admin"]) -const UserProto = makeSchemableClass(z.object({ - id: z.bigint(), - name: z.string(), - level: UserLevel, -}), { - level: "User" -} as const) +const UserProto = makeSchemableClass({ + schema: z.object({ + id: z.bigint(), + name: z.string(), + level: UserLevel, + }), + + defaultValues: { + level: "User" + } as const, +}) UserProto.defaultValues -const JsonifiableUserProto = makeJsonifiableSchemableClass(UserProto, { - jsonifySchema: ({ schema, shape }) => schema.extend({ - id: jsonifyBigIntSchema(shape.id) +class User extends pipeInto( + makeSchemableClass({ + schema: z.object({ + id: z.bigint(), + name: z.string(), + level: UserLevel, + }), + + defaultValues: { + level: "User" + } as const, }), - dejsonifySchema: ({ schema, shape }) => schema.extend({ - id: dejsonifyBigIntSchema(shape.id) - }), -}) + v => makeJsonifiableSchemableClass(v, { + jsonifySchema: ({ schema, shape }) => schema.extend({ + id: jsonifyBigIntSchema(shape.id) + }), - -class User extends JsonifiableUserProto {} + dejsonifySchema: ({ schema, shape }) => schema.extend({ + id: dejsonifyBigIntSchema(shape.id) + }), + }) +) {} const user1 = newSchemable(User, { id: 1n, name: "User" }) -- 2.49.1 From adc24574ec1edb317f5c1d7d5bba7f8e4ab28cce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 16 Jan 2024 12:43:00 +0100 Subject: [PATCH 33/47] extendSchemableClass tests --- src/tests.ts | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/src/tests.ts b/src/tests.ts index ce37480..b76de19 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,6 +1,6 @@ import { pipeInto } from "ts-functional-pipe" import { z } from "zod" -import { makeSchemableClass, newSchemable } from "." +import { extendSchemableClass, makeSchemableClass, newSchemable } from "." import { makeJsonifiableSchemableClass } from "./jsonifiable" import { dejsonifyBigIntSchema, jsonifyBigIntSchema } from "./legacy/jsonifiable" @@ -49,4 +49,22 @@ class User extends pipeInto( const user1 = newSchemable(User, { id: 1n, name: "User" }) -user1.jsonify() +console.log(user1.jsonify()) + + +const UserWithPhone = extendSchemableClass(User, { + schema: schema => schema.extend({ + phone: z.string() + }), + + defaultValues: defaultValues => ({ + ...defaultValues, + phone: "+33600000000", + }), +}) + +UserWithPhone.schema + + +const user2 = newSchemable(UserWithPhone, { id: 1n, name: "User" }) +console.log(user2.jsonify()) -- 2.49.1 From bfa359449ec4c94c3112dae2dd67ad9558edf2c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 16 Jan 2024 14:44:54 +0100 Subject: [PATCH 34/47] dejsonifySchemable --- src/extendSchemableClass.ts | 11 +- src/jsonifiable/dejsonifySchemable.ts | 213 ++++++++++++++++++++++++++ src/jsonifiable/index.ts | 1 + src/tests.ts | 12 +- 4 files changed, 229 insertions(+), 8 deletions(-) create mode 100644 src/jsonifiable/dejsonifySchemable.ts diff --git a/src/extendSchemableClass.ts b/src/extendSchemableClass.ts index 9074869..4c92aac 100644 --- a/src/extendSchemableClass.ts +++ b/src/extendSchemableClass.ts @@ -35,7 +35,7 @@ export function extendSchemableClass< >, props: { - schema: ( + schema: (props: { schema: z.ZodObject< ExtendSchemaT, ExtendSchemaUnknownKeys, @@ -43,7 +43,9 @@ export function extendSchemableClass< ExtendSchemaValues, ExtendSchemaValues > - ) => z.ZodObject< + + shape: ExtendSchemaT + }) => z.ZodObject< SchemaT, SchemaUnknownKeys, SchemaCatchall, @@ -60,7 +62,10 @@ export function extendSchemableClass< : AbstractClass ) - const schema = props.schema(extend.schema) + const schema = props.schema({ + schema: extend.schema, + shape: extend.schema.shape, + }) const defaultValues = props.defaultValues(extend.defaultValues) return class extends extend { diff --git a/src/jsonifiable/dejsonifySchemable.ts b/src/jsonifiable/dejsonifySchemable.ts new file mode 100644 index 0000000..b8e7f80 --- /dev/null +++ b/src/jsonifiable/dejsonifySchemable.ts @@ -0,0 +1,213 @@ +import { Effect, pipe } from "effect" +import { JsonifiableObject } from "type-fest/source/jsonifiable" +import { z } from "zod" +import { JsonifiableSchemableClass } from "." +import { parseZodTypeEffect } from "../util" + + +export function dejsonifySchemable< + C extends JsonifiableSchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + + Values, + DefaultValues, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues, + + "Class" + >, + + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, + + JsonifySchemaT extends z.ZodRawShape, + JsonifySchemaUnknownKeys extends z.UnknownKeysParam, + JsonifySchemaCatchall extends z.ZodTypeAny, + + DejsonifySchemaT extends z.ZodRawShape, + DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, + DejsonifySchemaCatchall extends z.ZodTypeAny, + + JsonifiedValues extends JsonifiableObject, +>( + class_: C | JsonifiableSchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + + Values, + DefaultValues, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues, + + "Class" + >, + + values: JsonifiedValues, + params?: Partial, +) { + return new class_( + class_.dejsonifySchema.parse(values, params) + ) as InstanceType +} + + +export async function dejsonifySchemablePromise< + C extends JsonifiableSchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + + Values, + DefaultValues, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues, + + "Class" + >, + + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, + + JsonifySchemaT extends z.ZodRawShape, + JsonifySchemaUnknownKeys extends z.UnknownKeysParam, + JsonifySchemaCatchall extends z.ZodTypeAny, + + DejsonifySchemaT extends z.ZodRawShape, + DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, + DejsonifySchemaCatchall extends z.ZodTypeAny, + + JsonifiedValues extends JsonifiableObject, +>( + class_: C | JsonifiableSchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + + Values, + DefaultValues, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues, + + "Class" + >, + + values: JsonifiedValues, + params?: Partial, +) { + return new class_( + await class_.dejsonifySchema.parseAsync(values, params) + ) as InstanceType +} + + +export function dejsonifySchemableEffect< + C extends JsonifiableSchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + + Values, + DefaultValues, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues, + + "Class" + >, + + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, + + JsonifySchemaT extends z.ZodRawShape, + JsonifySchemaUnknownKeys extends z.UnknownKeysParam, + JsonifySchemaCatchall extends z.ZodTypeAny, + + DejsonifySchemaT extends z.ZodRawShape, + DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, + DejsonifySchemaCatchall extends z.ZodTypeAny, + + JsonifiedValues extends JsonifiableObject, +>( + class_: C | JsonifiableSchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + + Values, + DefaultValues, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues, + + "Class" + >, + + values: JsonifiedValues, + params?: Partial, +) { + return pipe( + parseZodTypeEffect(class_.dejsonifySchema, values, params), + Effect.map(values => new class_(values) as InstanceType), + ) +} diff --git a/src/jsonifiable/index.ts b/src/jsonifiable/index.ts index 3f08be2..26a26be 100644 --- a/src/jsonifiable/index.ts +++ b/src/jsonifiable/index.ts @@ -1,2 +1,3 @@ export * from "./JsonifiableSchemableClass" +export * from "./dejsonifySchemable" export * from "./makeJsonifiableSchemableClass" diff --git a/src/tests.ts b/src/tests.ts index b76de19..00be534 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,7 +1,7 @@ import { pipeInto } from "ts-functional-pipe" import { z } from "zod" import { extendSchemableClass, makeSchemableClass, newSchemable } from "." -import { makeJsonifiableSchemableClass } from "./jsonifiable" +import { dejsonifySchemable, makeJsonifiableSchemableClass } from "./jsonifiable" import { dejsonifyBigIntSchema, jsonifyBigIntSchema } from "./legacy/jsonifiable" @@ -49,11 +49,13 @@ class User extends pipeInto( const user1 = newSchemable(User, { id: 1n, name: "User" }) -console.log(user1.jsonify()) +const jsonifiedUser1 = user1.jsonify() +console.log(jsonifiedUser1) +console.log(dejsonifySchemable(User, jsonifiedUser1)) const UserWithPhone = extendSchemableClass(User, { - schema: schema => schema.extend({ + schema: ({ schema }) => schema.extend({ phone: z.string() }), @@ -66,5 +68,5 @@ const UserWithPhone = extendSchemableClass(User, { UserWithPhone.schema -const user2 = newSchemable(UserWithPhone, { id: 1n, name: "User" }) -console.log(user2.jsonify()) +// const user2 = newSchemable(UserWithPhone, { id: 1n, name: "User" }) +// console.log(user2.jsonify()) -- 2.49.1 From 56597350cd6a24b0588af09144ccc16f7fc5ada0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 16 Jan 2024 14:59:33 +0100 Subject: [PATCH 35/47] newSchemable refactoring --- src/newSchemable.ts | 34 +++++++++++++++++++--------------- 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/src/newSchemable.ts b/src/newSchemable.ts index 0166eb5..98a5498 100644 --- a/src/newSchemable.ts +++ b/src/newSchemable.ts @@ -13,7 +13,7 @@ type NewSchemableArgs = : [] | [values: Input, ...args: ParamsArgs] -export const newSchemable = < +export function newSchemable< C extends SchemableClass< SchemaT, SchemaUnknownKeys, @@ -42,13 +42,14 @@ export const newSchemable = < ...[values, params]: NewSchemableArgs< SchemableClassInput > -) => - new class_( +) { + return new class_( class_.schema.parse({ ...class_.defaultValues, ...values }, params) ) as InstanceType +} -export const newSchemablePromise = async < +export async function newSchemablePromise< C extends SchemableClass< SchemaT, SchemaUnknownKeys, @@ -77,13 +78,14 @@ export const newSchemablePromise = async < ...[values, params]: NewSchemableArgs< SchemableClassInput > -) => - new class_( +) { + return new class_( await class_.schema.parseAsync({ ...class_.defaultValues, ...values }, params) ) as InstanceType +} -export const newSchemableEffect = < +export function newSchemableEffect< C extends SchemableClass< SchemaT, SchemaUnknownKeys, @@ -112,12 +114,14 @@ export const newSchemableEffect = < ...[values, params]: NewSchemableArgs< SchemableClassInput > -) => pipe( - parseZodTypeEffect( - class_.schema, - { ...class_.defaultValues, ...values }, - params, - ), +) { + return pipe( + parseZodTypeEffect( + class_.schema, + { ...class_.defaultValues, ...values }, + params, + ), - Effect.map(values => new class_(values) as InstanceType), -) + Effect.map(values => new class_(values) as InstanceType), + ) +} -- 2.49.1 From 822149e9309b4ac1227c321f185a88503673830e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 16 Jan 2024 15:08:24 +0100 Subject: [PATCH 36/47] Jsonifiable schema helpers --- src/jsonifiable/index.ts | 1 + src/jsonifiable/schema/bigint.ts | 18 ++++++++++++++++++ src/jsonifiable/schema/date.ts | 18 ++++++++++++++++++ src/jsonifiable/schema/decimal.ts | 19 +++++++++++++++++++ src/jsonifiable/schema/index.ts | 4 ++++ src/jsonifiable/schema/schemable.ts | 25 +++++++++++++++++++++++++ 6 files changed, 85 insertions(+) create mode 100644 src/jsonifiable/schema/bigint.ts create mode 100644 src/jsonifiable/schema/date.ts create mode 100644 src/jsonifiable/schema/decimal.ts create mode 100644 src/jsonifiable/schema/index.ts create mode 100644 src/jsonifiable/schema/schemable.ts diff --git a/src/jsonifiable/index.ts b/src/jsonifiable/index.ts index 26a26be..74e7d23 100644 --- a/src/jsonifiable/index.ts +++ b/src/jsonifiable/index.ts @@ -1,3 +1,4 @@ export * from "./JsonifiableSchemableClass" export * from "./dejsonifySchemable" export * from "./makeJsonifiableSchemableClass" +export * from "./schema" diff --git a/src/jsonifiable/schema/bigint.ts b/src/jsonifiable/schema/bigint.ts new file mode 100644 index 0000000..b0f0093 --- /dev/null +++ b/src/jsonifiable/schema/bigint.ts @@ -0,0 +1,18 @@ +import { z } from "zod" + + +export const jsonifyBigIntSchema = (schema: S) => + schema.transform(v => v.toString()) + +export const dejsonifyBigIntSchema = (schema: S) => + z + .string() + .transform(v => { + try { + return BigInt(v) + } + catch (e) { + return v + } + }) + .pipe(schema) diff --git a/src/jsonifiable/schema/date.ts b/src/jsonifiable/schema/date.ts new file mode 100644 index 0000000..b5ac677 --- /dev/null +++ b/src/jsonifiable/schema/date.ts @@ -0,0 +1,18 @@ +import { z } from "zod" + + +export const jsonifyDateSchema = (schema: S) => + schema.transform(v => v.toString()) + +export const dejsonifyDateSchema = (schema: S) => + z + .string() + .transform(v => { + try { + return new Date(v) + } + catch (e) { + return v + } + }) + .pipe(schema) diff --git a/src/jsonifiable/schema/decimal.ts b/src/jsonifiable/schema/decimal.ts new file mode 100644 index 0000000..58c492d --- /dev/null +++ b/src/jsonifiable/schema/decimal.ts @@ -0,0 +1,19 @@ +import { Decimal } from "decimal.js" +import { z } from "zod" + + +export const jsonifyDecimalSchema = >(schema: S) => + schema.transform(v => v.toJSON()) + +export const dejsonifyDecimalSchema = >(schema: S) => + z + .string() + .transform(v => { + try { + return new Decimal(v) + } + catch (e) { + return v + } + }) + .pipe(schema) diff --git a/src/jsonifiable/schema/index.ts b/src/jsonifiable/schema/index.ts new file mode 100644 index 0000000..08ecef8 --- /dev/null +++ b/src/jsonifiable/schema/index.ts @@ -0,0 +1,4 @@ +export * from "./bigint" +export * from "./date" +export * from "./decimal" +export * from "./schemable" diff --git a/src/jsonifiable/schema/schemable.ts b/src/jsonifiable/schema/schemable.ts new file mode 100644 index 0000000..c6e2a2d --- /dev/null +++ b/src/jsonifiable/schema/schemable.ts @@ -0,0 +1,25 @@ +import { z } from "zod" +import { JsonifiableSchemableClass, JsonifiableSchemableConfig } from ".." + + +// TODO: try to find a way to get rid of the 'class_' arg +export const jsonifySchemableSchema = < + C extends JsonifiableSchemableClass<$Config>, + $Config extends JsonifiableSchemableConfig, + S extends z.ZodType, z.ZodTypeDef, InstanceType>, +>( + class_: C | JsonifiableSchemableClass<$Config>, + schema: S, +) => + schema.pipe(class_.jsonifySchema) + +// TODO: try to find a way to get rid of the 'class_' arg +export const dejsonifySchemableSchema = < + C extends JsonifiableSchemableClass<$Config>, + $Config extends JsonifiableSchemableConfig, + S extends z.ZodType, z.ZodTypeDef, InstanceType>, +>( + class_: C | JsonifiableSchemableClass<$Config>, + schema: S, +) => + class_.dejsonifySchema.transform(v => new class_(v)).pipe(schema) -- 2.49.1 From c980148c0acfe90382490f41b0bc4be539b30de6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Tue, 16 Jan 2024 15:30:50 +0100 Subject: [PATCH 37/47] Jsonifiable schema refactoring --- src/jsonifiable/schema/bigint.ts | 10 ++++++---- src/jsonifiable/schema/date.ts | 10 ++++++---- src/jsonifiable/schema/decimal.ts | 14 ++++++++++---- 3 files changed, 22 insertions(+), 12 deletions(-) diff --git a/src/jsonifiable/schema/bigint.ts b/src/jsonifiable/schema/bigint.ts index b0f0093..099d309 100644 --- a/src/jsonifiable/schema/bigint.ts +++ b/src/jsonifiable/schema/bigint.ts @@ -1,11 +1,12 @@ import { z } from "zod" -export const jsonifyBigIntSchema = (schema: S) => - schema.transform(v => v.toString()) +export function jsonifyBigIntSchema(schema: S) { + return schema.transform(v => v.toString()) +} -export const dejsonifyBigIntSchema = (schema: S) => - z +export function dejsonifyBigIntSchema(schema: S) { + return z .string() .transform(v => { try { @@ -16,3 +17,4 @@ export const dejsonifyBigIntSchema = (schema: S) => } }) .pipe(schema) +} diff --git a/src/jsonifiable/schema/date.ts b/src/jsonifiable/schema/date.ts index b5ac677..ea0ee6f 100644 --- a/src/jsonifiable/schema/date.ts +++ b/src/jsonifiable/schema/date.ts @@ -1,11 +1,12 @@ import { z } from "zod" -export const jsonifyDateSchema = (schema: S) => - schema.transform(v => v.toString()) +export function jsonifyDateSchema(schema: S) { + return schema.transform(v => v.toString()) +} -export const dejsonifyDateSchema = (schema: S) => - z +export function dejsonifyDateSchema(schema: S) { + return z .string() .transform(v => { try { @@ -16,3 +17,4 @@ export const dejsonifyDateSchema = (schema: S) => } }) .pipe(schema) +} diff --git a/src/jsonifiable/schema/decimal.ts b/src/jsonifiable/schema/decimal.ts index 58c492d..ca01261 100644 --- a/src/jsonifiable/schema/decimal.ts +++ b/src/jsonifiable/schema/decimal.ts @@ -2,11 +2,16 @@ import { Decimal } from "decimal.js" import { z } from "zod" -export const jsonifyDecimalSchema = >(schema: S) => - schema.transform(v => v.toJSON()) +export function jsonifyDecimalSchema< + S extends z.ZodType +>(schema: S) { + return schema.transform(v => v.toJSON()) +} -export const dejsonifyDecimalSchema = >(schema: S) => - z +export function dejsonifyDecimalSchema< + S extends z.ZodType +>(schema: S) { + return z .string() .transform(v => { try { @@ -17,3 +22,4 @@ export const dejsonifyDecimalSchema = Date: Tue, 16 Jan 2024 15:46:44 +0100 Subject: [PATCH 38/47] jsonifySchemableSchema refactoring --- src/jsonifiable/schema/schemable.ts | 152 ++++++++++++++++++++++++---- 1 file changed, 133 insertions(+), 19 deletions(-) diff --git a/src/jsonifiable/schema/schemable.ts b/src/jsonifiable/schema/schemable.ts index c6e2a2d..b0a72bc 100644 --- a/src/jsonifiable/schema/schemable.ts +++ b/src/jsonifiable/schema/schemable.ts @@ -1,25 +1,139 @@ +import { JsonifiableObject } from "type-fest/source/jsonifiable" import { z } from "zod" -import { JsonifiableSchemableClass, JsonifiableSchemableConfig } from ".." +import { JsonifiableSchemableClass } from ".." -// TODO: try to find a way to get rid of the 'class_' arg -export const jsonifySchemableSchema = < - C extends JsonifiableSchemableClass<$Config>, - $Config extends JsonifiableSchemableConfig, - S extends z.ZodType, z.ZodTypeDef, InstanceType>, +export function jsonifySchemableSchema< + C extends JsonifiableSchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + + Values, + DefaultValues, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues, + + "Class" + >, + + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, + + JsonifySchemaT extends z.ZodRawShape, + JsonifySchemaUnknownKeys extends z.UnknownKeysParam, + JsonifySchemaCatchall extends z.ZodTypeAny, + + DejsonifySchemaT extends z.ZodRawShape, + DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, + DejsonifySchemaCatchall extends z.ZodTypeAny, + + JsonifiedValues extends JsonifiableObject, + + S extends z.ZodType, z.ZodTypeDef, InstanceType>, >( - class_: C | JsonifiableSchemableClass<$Config>, - schema: S, -) => - schema.pipe(class_.jsonifySchema) + class_: C | JsonifiableSchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, -// TODO: try to find a way to get rid of the 'class_' arg -export const dejsonifySchemableSchema = < - C extends JsonifiableSchemableClass<$Config>, - $Config extends JsonifiableSchemableConfig, - S extends z.ZodType, z.ZodTypeDef, InstanceType>, + Values, + DefaultValues, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues, + + "Class" + >, + + schema: S, +) { + return schema.pipe(class_.jsonifySchema) +} + + +export function dejsonifySchemableSchema< + C extends JsonifiableSchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + + Values, + DefaultValues, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues, + + "Class" + >, + + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, + + JsonifySchemaT extends z.ZodRawShape, + JsonifySchemaUnknownKeys extends z.UnknownKeysParam, + JsonifySchemaCatchall extends z.ZodTypeAny, + + DejsonifySchemaT extends z.ZodRawShape, + DejsonifySchemaUnknownKeys extends z.UnknownKeysParam, + DejsonifySchemaCatchall extends z.ZodTypeAny, + + JsonifiedValues extends JsonifiableObject, + + S extends z.ZodType, z.ZodTypeDef, InstanceType>, >( - class_: C | JsonifiableSchemableClass<$Config>, - schema: S, -) => - class_.dejsonifySchema.transform(v => new class_(v)).pipe(schema) + class_: C | JsonifiableSchemableClass< + SchemaT, + SchemaUnknownKeys, + SchemaCatchall, + + Values, + DefaultValues, + + JsonifySchemaT, + JsonifySchemaUnknownKeys, + JsonifySchemaCatchall, + + DejsonifySchemaT, + DejsonifySchemaUnknownKeys, + DejsonifySchemaCatchall, + + JsonifiedValues, + + "Class" + >, + + schema: S, +) { + return class_.dejsonifySchema.transform(v => new class_(v)).pipe(schema) +} -- 2.49.1 From 222676dfafdf9fb4f848ee59ab9091bae7d7065b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 17 Jan 2024 16:23:53 +0100 Subject: [PATCH 39/47] Jsonifiable schemas work --- src/jsonifiable/schema/bigint.ts | 30 +++++++++++++++++++----------- src/jsonifiable/schema/date.ts | 30 +++++++++++++++++++----------- src/jsonifiable/schema/decimal.ts | 30 +++++++++++++++++++----------- src/tests.ts | 11 +++++------ src/util.ts | 5 +++++ 5 files changed, 67 insertions(+), 39 deletions(-) diff --git a/src/jsonifiable/schema/bigint.ts b/src/jsonifiable/schema/bigint.ts index 099d309..76a605d 100644 --- a/src/jsonifiable/schema/bigint.ts +++ b/src/jsonifiable/schema/bigint.ts @@ -1,20 +1,28 @@ +import { Opaque } from "type-fest" import { z } from "zod" +import { identity } from "../../util" + + +export type JsonifiedBigInt = Opaque export function jsonifyBigIntSchema(schema: S) { - return schema.transform(v => v.toString()) + return schema.transform(v => v.toString() as JsonifiedBigInt) } export function dejsonifyBigIntSchema(schema: S) { return z - .string() - .transform(v => { - try { - return BigInt(v) - } - catch (e) { - return v - } - }) - .pipe(schema) + .custom(identity) + .pipe(z + .string() + .transform(v => { + try { + return BigInt(v) + } + catch (e) { + return v + } + }) + .pipe(schema) + ) } diff --git a/src/jsonifiable/schema/date.ts b/src/jsonifiable/schema/date.ts index ea0ee6f..c70b2ed 100644 --- a/src/jsonifiable/schema/date.ts +++ b/src/jsonifiable/schema/date.ts @@ -1,20 +1,28 @@ +import { Opaque } from "type-fest" import { z } from "zod" +import { identity } from "../../util" + + +export type JsonifiedDate = Opaque export function jsonifyDateSchema(schema: S) { - return schema.transform(v => v.toString()) + return schema.transform(v => v.toString() as JsonifiedDate) } export function dejsonifyDateSchema(schema: S) { return z - .string() - .transform(v => { - try { - return new Date(v) - } - catch (e) { - return v - } - }) - .pipe(schema) + .custom(identity) + .pipe(z + .string() + .transform(v => { + try { + return new Date(v) + } + catch (e) { + return v + } + }) + .pipe(schema) + ) } diff --git a/src/jsonifiable/schema/decimal.ts b/src/jsonifiable/schema/decimal.ts index ca01261..be387ee 100644 --- a/src/jsonifiable/schema/decimal.ts +++ b/src/jsonifiable/schema/decimal.ts @@ -1,25 +1,33 @@ import { Decimal } from "decimal.js" +import { Opaque } from "type-fest" import { z } from "zod" +import { identity } from "../../util" + + +export type JsonifiedDecimal = Opaque export function jsonifyDecimalSchema< S extends z.ZodType >(schema: S) { - return schema.transform(v => v.toJSON()) + return schema.transform(v => v.toJSON() as JsonifiedDecimal) } export function dejsonifyDecimalSchema< S extends z.ZodType >(schema: S) { return z - .string() - .transform(v => { - try { - return new Decimal(v) - } - catch (e) { - return v - } - }) - .pipe(schema) + .custom(identity) + .pipe(z + .string() + .transform(v => { + try { + return new Decimal(v) + } + catch (e) { + return v + } + }) + .pipe(schema) + ) } diff --git a/src/tests.ts b/src/tests.ts index 00be534..8cbcee3 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,8 +1,7 @@ import { pipeInto } from "ts-functional-pipe" import { z } from "zod" import { extendSchemableClass, makeSchemableClass, newSchemable } from "." -import { dejsonifySchemable, makeJsonifiableSchemableClass } from "./jsonifiable" -import { dejsonifyBigIntSchema, jsonifyBigIntSchema } from "./legacy/jsonifiable" +import { dejsonifyBigIntSchema, dejsonifySchemable, jsonifyBigIntSchema, makeJsonifiableSchemableClass } from "./jsonifiable" const UserLevel = z.enum(["User", "Admin"]) @@ -10,9 +9,9 @@ const UserLevel = z.enum(["User", "Admin"]) const UserProto = makeSchemableClass({ schema: z.object({ - id: z.bigint(), - name: z.string(), - level: UserLevel, + id: z.bigint(), + name: z.string(), + level: UserLevel, }), defaultValues: { @@ -44,7 +43,7 @@ class User extends pipeInto( dejsonifySchema: ({ schema, shape }) => schema.extend({ id: dejsonifyBigIntSchema(shape.id) }), - }) + }), ) {} diff --git a/src/util.ts b/src/util.ts index 1f2ea6b..a1c11d4 100644 --- a/src/util.ts +++ b/src/util.ts @@ -3,6 +3,11 @@ import { AbstractClass, Class as ConcreteClass } from "type-fest" import { z } from "zod" +export function identity(value: T) { + return value +} + + export type ClassType = "AbstractClass" | "Class" export type Class< -- 2.49.1 From 4a27f5c7652a4e8d133d17310b5259fd771545e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 17 Jan 2024 17:39:34 +0100 Subject: [PATCH 40/47] defineDefaultValues --- src/defineDefaultValues.ts | 8 ++++++++ src/extendSchemableClass.ts | 4 ++-- src/index.ts | 1 + src/makeSchemableClass.ts | 5 +++-- src/tests.ts | 25 ++++++------------------- 5 files changed, 20 insertions(+), 23 deletions(-) create mode 100644 src/defineDefaultValues.ts diff --git a/src/defineDefaultValues.ts b/src/defineDefaultValues.ts new file mode 100644 index 0000000..4c860ed --- /dev/null +++ b/src/defineDefaultValues.ts @@ -0,0 +1,8 @@ +import { Opaque } from "type-fest" + + +export type DefinedDefaultValues = Opaque + +export function defineDefaultValues(values: T) { + return values as DefinedDefaultValues +} diff --git a/src/extendSchemableClass.ts b/src/extendSchemableClass.ts index 4c92aac..1b1180b 100644 --- a/src/extendSchemableClass.ts +++ b/src/extendSchemableClass.ts @@ -1,6 +1,6 @@ import { AbstractClass, Class as ConcreteClass } from "type-fest" import { z } from "zod" -import { SchemableClass } from "." +import { DefinedDefaultValues, SchemableClass } from "." import { StaticMembers } from "./util" @@ -53,7 +53,7 @@ export function extendSchemableClass< SchemaValues > - defaultValues: (defaultValues: ExtendDefaultValues) => DefaultValues + defaultValues: (defaultValues: ExtendDefaultValues) => DefinedDefaultValues }, ) { type Class = ( diff --git a/src/index.ts b/src/index.ts index 7df42bc..4b4c248 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,4 +1,5 @@ export * from "./SchemableClass" +export * from "./defineDefaultValues" export * from "./extendSchemableClass" export * from "./makeSchemableClass" export * from "./newSchemable" diff --git a/src/makeSchemableClass.ts b/src/makeSchemableClass.ts index 544dade..0f0c2cf 100644 --- a/src/makeSchemableClass.ts +++ b/src/makeSchemableClass.ts @@ -1,5 +1,6 @@ import { AbstractClass, Class as ConcreteClass } from "type-fest" import { z } from "zod" +import { DefinedDefaultValues } from "." import { StaticMembers } from "./util" @@ -30,7 +31,7 @@ export function makeSchemableClassFrom< Values > - defaultValues: DefaultValues + defaultValues: DefinedDefaultValues }, ) { type Class = ( @@ -88,7 +89,7 @@ export function makeSchemableClass< Values > - defaultValues: DefaultValues + defaultValues: DefinedDefaultValues } ) { return makeSchemableClassFrom(Object, props) diff --git a/src/tests.ts b/src/tests.ts index 8cbcee3..e022514 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -1,27 +1,12 @@ import { pipeInto } from "ts-functional-pipe" import { z } from "zod" -import { extendSchemableClass, makeSchemableClass, newSchemable } from "." +import { defineDefaultValues, extendSchemableClass, makeSchemableClass, newSchemable } from "." import { dejsonifyBigIntSchema, dejsonifySchemable, jsonifyBigIntSchema, makeJsonifiableSchemableClass } from "./jsonifiable" const UserLevel = z.enum(["User", "Admin"]) -const UserProto = makeSchemableClass({ - schema: z.object({ - id: z.bigint(), - name: z.string(), - level: UserLevel, - }), - - defaultValues: { - level: "User" - } as const, -}) - -UserProto.defaultValues - - class User extends pipeInto( makeSchemableClass({ schema: z.object({ @@ -30,9 +15,9 @@ class User extends pipeInto( level: UserLevel, }), - defaultValues: { - level: "User" - } as const, + defaultValues: defineDefaultValues({ + level: "User" as const + }), }), v => makeJsonifiableSchemableClass(v, { @@ -46,6 +31,8 @@ class User extends pipeInto( }), ) {} +User.defaultValues + const user1 = newSchemable(User, { id: 1n, name: "User" }) const jsonifiedUser1 = user1.jsonify() -- 2.49.1 From aef4d23b92905fb7979d2097264b9c9ecdb916c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 17 Jan 2024 18:45:00 +0100 Subject: [PATCH 41/47] Fixed default values --- src/defineDefaultValues.ts | 4 ++-- src/extendSchemableClass.ts | 14 +++++++------- src/makeSchemableClass.ts | 34 ++++++++++------------------------ src/tests.ts | 4 ++-- 4 files changed, 21 insertions(+), 35 deletions(-) diff --git a/src/defineDefaultValues.ts b/src/defineDefaultValues.ts index 4c860ed..634d83a 100644 --- a/src/defineDefaultValues.ts +++ b/src/defineDefaultValues.ts @@ -1,8 +1,8 @@ import { Opaque } from "type-fest" -export type DefinedDefaultValues = Opaque +export type DefinedDefaultValuesTag = "@thilawyn/schemable-class/DefinedDefaultValues" export function defineDefaultValues(values: T) { - return values as DefinedDefaultValues + return values as Opaque } diff --git a/src/extendSchemableClass.ts b/src/extendSchemableClass.ts index 1b1180b..bb392e1 100644 --- a/src/extendSchemableClass.ts +++ b/src/extendSchemableClass.ts @@ -1,6 +1,6 @@ -import { AbstractClass, Class as ConcreteClass } from "type-fest" +import { AbstractClass, Class as ConcreteClass, Opaque } from "type-fest" import { z } from "zod" -import { DefinedDefaultValues, SchemableClass } from "." +import { DefinedDefaultValuesTag, SchemableClass } from "." import { StaticMembers } from "./util" @@ -53,7 +53,7 @@ export function extendSchemableClass< SchemaValues > - defaultValues: (defaultValues: ExtendDefaultValues) => DefinedDefaultValues + defaultValues: (defaultValues: ExtendDefaultValues) => Opaque }, ) { type Class = ( @@ -78,8 +78,8 @@ export function extendSchemableClass< Class< Omit, "schema" | "defaultValues" | keyof ExtendSchemaValues> & { - readonly schema: typeof schema, - readonly defaultValues: typeof defaultValues, + readonly schema: z.ZodObject, + readonly defaultValues: DefaultValues, } & SchemaValues, @@ -88,8 +88,8 @@ export function extendSchemableClass< Omit, "schema" | "defaultValues"> & { - readonly schema: typeof schema, - readonly defaultValues: typeof defaultValues, + readonly schema: z.ZodObject, + readonly defaultValues: DefaultValues, } ) } diff --git a/src/makeSchemableClass.ts b/src/makeSchemableClass.ts index 0f0c2cf..0345eb7 100644 --- a/src/makeSchemableClass.ts +++ b/src/makeSchemableClass.ts @@ -1,6 +1,6 @@ -import { AbstractClass, Class as ConcreteClass } from "type-fest" +import { AbstractClass, Class as ConcreteClass, Opaque } from "type-fest" import { z } from "zod" -import { DefinedDefaultValues } from "." +import { DefinedDefaultValuesTag } from "." import { StaticMembers } from "./util" @@ -23,15 +23,8 @@ export function makeSchemableClassFrom< extend: C, { schema, defaultValues }: { - schema: z.ZodObject< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - Values, - Values - > - - defaultValues: DefinedDefaultValues + schema: z.ZodObject + defaultValues: Opaque }, ) { type Class = ( @@ -55,8 +48,8 @@ export function makeSchemableClassFrom< Class< InstanceType & { - readonly schema: typeof schema, - readonly defaultValues: typeof defaultValues, + readonly schema: z.ZodObject, + readonly defaultValues: DefaultValues, } & Values, @@ -65,8 +58,8 @@ export function makeSchemableClassFrom< StaticMembers & { - readonly schema: typeof schema, - readonly defaultValues: typeof defaultValues, + readonly schema: z.ZodObject, + readonly defaultValues: DefaultValues, } ) } @@ -81,15 +74,8 @@ export function makeSchemableClass< DefaultValues extends Partial, >( props: { - schema: z.ZodObject< - SchemaT, - SchemaUnknownKeys, - SchemaCatchall, - Values, - Values - > - - defaultValues: DefinedDefaultValues + schema: z.ZodObject + defaultValues: Opaque } ) { return makeSchemableClassFrom(Object, props) diff --git a/src/tests.ts b/src/tests.ts index e022514..5d8ee9f 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -45,13 +45,13 @@ const UserWithPhone = extendSchemableClass(User, { phone: z.string() }), - defaultValues: defaultValues => ({ + defaultValues: defaultValues => defineDefaultValues({ ...defaultValues, phone: "+33600000000", }), }) -UserWithPhone.schema +UserWithPhone.defaultValues // const user2 = newSchemable(UserWithPhone, { id: 1n, name: "User" }) -- 2.49.1 From e1f7446b6d1ca0dcadb162eaf7de4d98bf953245 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 17 Jan 2024 18:48:37 +0100 Subject: [PATCH 42/47] Fix --- src/jsonifiable/makeJsonifiableSchemableClass.ts | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/jsonifiable/makeJsonifiableSchemableClass.ts b/src/jsonifiable/makeJsonifiableSchemableClass.ts index 020d658..691a3f2 100644 --- a/src/jsonifiable/makeJsonifiableSchemableClass.ts +++ b/src/jsonifiable/makeJsonifiableSchemableClass.ts @@ -115,8 +115,8 @@ export function makeJsonifiableSchemableClass< } as unknown as ( Class< InstanceType & { - readonly jsonifySchema: typeof jsonifySchema, - readonly dejsonifySchema: typeof dejsonifySchema, + readonly jsonifySchema: z.ZodObject, + readonly dejsonifySchema: z.ZodObject, jsonify(): JsonifiedValues jsonifyPromise(): Promise @@ -127,8 +127,8 @@ export function makeJsonifiableSchemableClass< > & StaticMembers & { - readonly jsonifySchema: typeof jsonifySchema, - readonly dejsonifySchema: typeof dejsonifySchema, + readonly jsonifySchema: z.ZodObject, + readonly dejsonifySchema: z.ZodObject, } ) } -- 2.49.1 From 6d1eddae5579786c71fd74be3138da7a48fdb703 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 17 Jan 2024 19:42:18 +0100 Subject: [PATCH 43/47] ObservableSchemable --- bun.lockb | Bin 160399 -> 160736 bytes package.json | 1 + src/observable/ObservableSchemable.ts | 27 ++++++++++++++++++++++++++ src/observable/index.ts | 1 + src/tests.ts | 8 +++++++- 5 files changed, 36 insertions(+), 1 deletion(-) create mode 100644 src/observable/ObservableSchemable.ts create mode 100644 src/observable/index.ts diff --git a/bun.lockb b/bun.lockb index 6e480f417ea87a3ec7eb6f758ea54b36b9ff880c..ab7c9a9ec429c424afa7003cbaaa1125192f08a5 100755 GIT binary patch delta 27675 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 delta 27202 zcmeI4d3;XS_Wz$9LLM435fSqgBt*y{l834xeHv4>G0!Qfn1T{T;`a8I>$zq92 zIH%8hXP@&v9~BYvSkY0-x_sPcj&p5^iMtZdt756sNW7(33hg?zEk7&~axIHqr%W1rx(Q;1hm&yXq} zPYF+s%;4aGnFEKUUnT>a+#^VtxfdxY1Nj_M`0+>?@V-de%&iM4cIA*_*OpjU! zKEjb1bV4R#D#Ih?-TZOrC2}C1U>r*zdm+U$cSIr?cSbokYgA_D_|YEEe`2bFWe)Go zmEK<@BRS?SY)<$kF3R55yHu-v%~63!cf%{T5xiof2WotifXC@tma|8J7_m zBQr)YGYE?>z)mJ87Ag4;G_vb?7D+uhxd%wdc#KBMzzu0^7wCa513%Q7SC3~`q}|{e zq;%v%M_-BzMn4y2=bu1&(dWWTz0;9pk>iol0bf(Q{1A(0MLZB~SKww0PtSfzy1o~_ zBn56#KxY0VQkHCY3YL+Ikka8!F}B{s;d7jk$`~6ta`Xs~=Sg(2Ti@Jn_)VnLYmJaj z4=mrazcc2;29Ax)9+)+RO8mdJgcgk+S}(~38#`7D}r?voU|*znBs@x(FD z=&Vsgv(m?o9k2Hnk5gT>H>i3}Z*0qAyR(xm$Br62d@QyDI@<%4F&c%V4!U&VRlnV( ztn_hN+3@LES&@TB4N2cjdC7mvsb>+g6#5H}Odp9=#>kW{V zGGh~w(y?Jkaji&qTOT}-|AwV|mY~Z_-9U=7qa#NQl)h#?X7dM-GN#*+lK%pBQcqVL z5Pdqj6`gxIJ?xuiXN(Z{IRfCNf^p-YhS37l&H)w)58^tL6yN$FA@lq*SmJDV{Y&%358Hp)|l&9W`Mjz3yjs zq_I8wxlHTe$jnhgr_+F}(LP8ipVQy&fZRS18^_i`uK+)3fIY$!unU(S6({OS!Ql|n z;4<`*NS|&~qJBg-qOEjm)X2fILp&3*296%h)c?=LJzLKy5t7pZYbi?@qDvmnDauHl zLkEr@D#ic&ggyV+NU_@v8G_72m(d=GH-l(D4_;br$?g9v@y`Dr*ZbQF4oy{P`gCO);$SR}kif=t^%gj+j29Blo-Izx4AW@$w z8KN5N!jkoK+KjQelq`F+24xK#oX#5D=ICD1G8(;+QZ^Z0I!*ky`dyB(klh#sFMW7o z;Mj3g>B&kTKQ`luY>y#dI^AQuJv;wE$|zT}?Q?R6WMo-2jbjccQ*uo6s$i8Yo&5@VVF<7s}rjF0-;0t*5?o_6|Hcw%6&VjfQi zE0szr#Y(+Q%FaE0m#b6UwHr>#&Rs*wE>TD-)hgRQ$mM2}>TGeRNZGlKaNBMziQj&C!rDIdicYBGQ@eCF z=SOsY9bceg8TQhf>LdpCCe_1Ay?d7nW=gtQTz^sntkh;weXLYiIge+EmC7O2&q|%V zn@VIM+jfSOo%<6hyNy&L-s4ijyOh*}%t;ZM6K~=Dn(D9f8~D^~y0C#S;FpTJWkj+! zl^EXAnpT;@7j%AvPkpKjBYa*j@v6I(qo&5I5Iw13vZ|}|8~VJ1D%)j>NfUwd(PH(K z*u;PXmGz`X$*Qc*Z{$;Lbs^`!>V(EVRa$2^_IW2%@pxLftHt{+nye@KSv4-;QWf1Y zGFe6G>`0%=)%l!v=t9m#bV8I*rReM^pLc#$Cd{g!ph2AXELwZCK;5QcoEokZn)m{j zaRqu%-wI0%I3KRxZ<4HP>B1&H^}J4K>I*ngO;2i?tg7k!ratfJ>TYLL)j01ewAOab zed1MhJt;a_wbJ>~KJ_PE80`yuuZB$Pt?0zSGBst$B{htc&21&s&EhH$0S8#AaiscK zsePn|SgGcUU>FijacR3t)V7bMumGLv0xEv(o?|m%7){5zZ ziSfEH&gb0?(~0~5-6lFNuu4N_OW%r1RNZubyi8GHywCd~tk?ufM^qJ^o#0b*bbbP3 z-AMnEknFA8*yDKw17#VE(%CJ2-nZboSse4`^+b9+P0$|D)0)P4zd(~t*^9SQl-*%l z>xFhN?^U!1u?*0Pa@U+Z+Cht^LRr&+mTSY&WZ4xHN7U=Ou$9ky4X%^L$tFo`=t-@Uy>*&M$f9vhg7zU~mpT?rmuG6z+Xk1D}3yTXl-ojcVp)k%4q(E0RamC)$tI;0T zNo^8kOSbiSr^eaCVMqEcx)AO*oRsirl@#Y~MO88()?@{~fY!wtu&+poPfSglIIbHB z?R?(e33kiYlz26oIB0cTZP$fZ6v9dO88cSrP%4l*f@C#&SCNznEpBN)I2tQAD?TXE zUL!2XI&t3T(4>Q2JuM;5`!Sl#vPT!NM!eKuyDKZEgQFF-*2uFuyQ9y$1x^~ZSKlv= zR$LdP#0T;B7dlz$;dq^$;`45I7~7*F)GYb-9Q)87zgy8uXwtB~unv-JX^m5`&)rMY z9*r-G(put}cR49B$JsV<-e5L>3=2c`WPH#)h4~wUCgISY{*Tb^&W5*Go4Yg3K26qz zkN5%?!L`y;nkITrkdh{tAqK4q#V9Nqv-%{O%uS#!XcEVjBcYQ|mD1UreBOR-?K+vE z7IEH}(HP&{64spTN0XuRTAi-KsM|f06+aS9rh)qD%R9QTvrn-Ey7;{QcJ3^bikE2-aaWF58(_>hHg5Vv}SLC zeQ2%prY4Er2OhR-Evl!rjq@g>IrT83PoYtpvmOem#PXxM|<96 zB|MHsz+*#BqrDkucZWq4=!9Orz*}$+>stwlfgQR^0G7d=DJe=Z$PB|tG(v@JY9eNh zZn|Z!Wbedoc8Bn|Lwpd5z24YB0l#6}-}!;Fo9*T6|3cfjt>AR{hcL zPJZC)k|#0OdybS$wS7Sf)rI|i-eGBWNtQV!m!sLEtXP@{(43hg#+J~91K3SH>>X(@ zmw9M1n^yexeuE~LKO#4EHScNfJ3DVAn)HxWAh8w=Pw9#5$=F`p@>p8I)c7D$gDj;@ zS4)v$?YkQmH{DK0YfYXV5Z9n3quB%U z9hxjcdmD6O*d)r}pf5fMMH=QJ)tZ}HG<)V{yh8@tHycz*I2wdzua<(Rz9H->j>e)rNERJrRjo(6JDY(Q z(K_l)$*qEh-Q6@y>q@kT>>>=s_xCi$Iyu8`iR(NIcruzjN7DNOw5F7^Ze+aI(Cm?s z#ZmW3dmEIn%8f=7ODfF0@mfjdkf7T0a?Mm5gw0^JbQGeqRH;GFJZgU#5wy$ zx7bK~0oqg31x=>LzTmuv#vdBoG}Iks_r~4>gVAEKB0k5)7ZpWs3QG*!ONv{Ms)=6j z=(|(ZHa-X?3Tt~|&2ls@T@2qwG}&qPu&Xil#j2z(=pP@1Vy|hLgUM*lsJD&_TqByk z)h;pM>oNNM3CZ3^v+QLB3x}_noKt z+l3ZNi|eY7&YtG;elXeNVS~$X(4$&Y?$-Sff5xEQ-GPCxpmEveVttL23?Wm?u8o^& zTX8?d&Ey!J@JwP(S&#KY73Y6XD(uQx*0wA{x}u|tl>ADLE;0l}I{NR(94qU0GX9Tv zyZt}vq2&=9(mF(z2W>zp&>6__|1Al4*75ID5P)S@Ao5YGlr5Exe73sf$YZc2Kz}D! zq)f;FM-D{F@kg>K`CM^4GO@&b>-aaMJ&=E7C>0ZRt>gEkG)PFaI!v6i4w1qWTdd=L zDUK0GtYaL%<;pM1o@X55|5DbV&86bMtcbNh4w2HscO3aHQVx;AuLCk78yr2~(KjLG z_#-LhKLj!|1wa-=&NfbRh!lg5MB%t!mPFqRB!3@}<9;a>9kAFxmQwzpV<)n>?D=C3 zalcgh%8McTw-?MkWjID#>u^3Dt&8aeQW-wlPgw#MM_<> z9DTM^>V7HtFThKdcI;kq?CzK1!d!Tf3mm(Jj$G{6BWscE@dzOuSc;Uqe>ifPD0wa)=bWe9705uZBd+ycLLs+{#H}&>lzs3@Nk!xnw$0 z=@GAn%zd;Ih-r@g9N_`ixlcBxr*dt3=6=3!d@c2YSwsvG2G2sv? z$+iyvki(0VWP6A2;P95zv*uUVf14d7ur2}*JGmm2J~=-mMe0s<*!!hWogH4J%u_c< z7b$&w)REnV*Wu5HM97NmgC^Gfh5Z*&>D1@LtZi5p3xOQ}j+Ay~^5qaIE&YGq2Iu_Y z-KRA0pS?ZC|9__e@%TS-8{CnKJBynf|BjUTlr<{yQ6PuN|K0|3JIrLt1@ajg6psH( zS%dcedmH@U+h7S49QWTQ3sr=ZM9Kf&1~Ulv-xkZ|Ykiy>9w3|Yww$B{G>jRGcV1(i63v`$4bAduQOJr zsRp`$bA%3EmByma`J2^MjHCLypNS)0&O7G{~L`S@prkd($oTK$o&dqf6+i5CB z&*0o#pW)m>C#*@+@oR$hf;D~>r!S&iKucZgR|$IV+BE&j+F*SPEm5bulcqbq6RcOi z<5x+#5bY*f-*^4Wr&qk2rr&rsSO>53t2Vmlx-{KmU9jGS)>eDhr|F>e%*=YfYNzwj zHlT&S=T{wc#(T`nd&~@4iVn?7)0Ojr^^`on^6Q;wJJ2FG_*JUT-jJpzZYZTsZFpF9 z))Dz>xGIK8ZF;M|^}=yi_~uBR>y0j-nkwOZwQa#_Aa#;MFI7H9=oQ zyMUIu-Ouxzx!dt-J6@qZty6a3)egMc;a5|1A=*u}zB~QAw!2~{v$m62+vVq3W6xd8 z+Ad}d?HTR;lv(?fS^Lzlp4Iti8_>dc`_*$gV>h$5n^{Afp+omDYkQcrJ$^M)??l^y z7WtW9&C=PQ;ooQYhc;VB?8U#m__x>3)A^%lN6?b?`IXi)_Tk??{6l+5C+x?+{rI=v zuZ+Hkb^$H*fM3nka}VI(0sKRor&A8%-$DF4=vNDLA=*u}zMuQmLcQX1{QDgL4*At$ z-SZIs9l}4frP})i{(XUeU-;EBosYHwE&Q;b7yU90va z9cYn9{c5$&K8k-w@el279dQi*j^W=izgnx0q8&j?I_~G?=o!cH?>PRUt=9=B@b3iv zo$#wXeG%;fTIxx^%GYyG;@?U9L))lRPT}7v{5$1Wn{*-CO|-sW`gv=5#h3W^CH|fE z^WIC()A)B9|IoH+?-~3%gMVlI>SLXcwgD~tD?jhaWqgHyU*R9xP91s{|IXsySwAoE z?nK*x7WuVb?a|p^zpU_p8JDBH9JC)C+!fRL{MDe;4o%?YK_4h<_LH@1kFw)P-m_(fWStS6}KC-{Rl5 z_;<;#&gh<(@b41-p`F#<%lLO0|1SI0Ih~KT0WJKBU!B((SMcu&{-Iseq2J-(clh_6 zUtQ8W(RQFke(zUTboTf7_dWiheXk>~;@?&LyXsfh^ii}UXi3-n>bjnB4gap;AKFhk z;RpQt0snsRs~h?v+6A=K>wZ-dNEt4{e5|9-^3AN}fdUS{JmNICv8W(Y!je5C;o! zu+T4;G_)OPk-u1%v|n)W7aT+@ts{QL!C!IkSHE1=(2k%b{pObo+iy7d8xEpX)Csq6 z@D>i<^2@~y?E+frZR_H88wYRWAX=DCxr2juaPW>_E^uf!?*zZpSNT=-msY5>m)=mp zCRm}?G(D9{Gd&c<}U{5F*lK2SQ8?gg7Zg6BAJkqCqi;S;Zit%~2ta2$57ABF4-p4l%tr z#1$c0n1mpR_#lV{K@f4~q7WB^NcBP_n7LkvSG*9ngh(_gB_KMMfLL7uBFPjAaZ`xC zB_VufMM;P^Nv<`F|iE9Ng+C$h_Vn3%0kR43(?ga72=2x zN#!6OH8aXVOfLsHkL!_CDLR=6cwE{#>Gq(c7D-|Ga3DMi6RD|eQ z5n^>kh`y#!h?_$6tpw5Etf&O>MkR>g5Qu@MX9z@(5Qt4e3^v}%5J8n8MpTAKH~B(r z5F$JjVyMXog%}nJu}6pu6IunLautXvRUn3&okHvoA~FnOgvkzrm>33eQixF|qAEm# zst~iPLX0s-g*YNaQaHp|Gb0>gdN{-tA;z18Y7p_&AQn`Em|!jnaY2aG>JZsxZgq%P zszclo;%Spo1EOOMh}AV9rkFw@ZVJ)2CPa=|Q4`{gnh?RYAf}m~wIF)bg4iU)GsasR zBB(aRh}sa(ntUNP2oYWf;yII12Vz(qh&@8gFrjrJD%XXWQWs*T*(t;hAtLKR%re>a zASTv>I4Q(z6Hy^&#e%qe2`JBB=p{HZvMPOm6^jMTnP7LIgy71jK>}2xBe^ zaY2aGh7fbj+=dXZG=#V%#5|MI2%=*nh}DfC7MMaIZVJ)2F~mZ%qA|o9jUj>~Ar_mS zk?OeV7^P|izQ&&v519Q)+rb$9^7zc_C={hR?gMt_^%)gG3dWH&D$^94VgEKRtycMBR$VGq;=0fNmsGcW=CdTV+-hV^k_xKW>p}aUVo7c8znbfnwE!Bm9*BK0}$Kh@d9~@-=+cBweB>y%wa%lGG+`Odrs=rd1WAq{mZ*KE9b(kfKT#RbBJ;r>d8_lsGMq=s12{Viv!qT8H1hV;{ot;L-Zy zS03cZk!jRIRX%5gL(A`Jk4f_!BOOj2O}S4@^>iXF$9#ulwRs+MI2j^I%5U3`D}Lmb<28qrhjVF;p*-f4q&&mv?Qn}6PJU=> z>TvSZQ`Y%#|V}--9Iy@5`?oEdagB$8_D;+MUD&#PST;-7Aa34CH`?R(ioK!A{ z`{cGdY2$G2Q`{PG$#CMiJkgcxnxM2KIMyM>ky_xI%)fZ~9;D>g2G@Zcc@9^H^p6(9 z8!ir47yYcmS&xTFvo}2_9PWL`u0Hxlq{X3)4%dM6Cl2?4%)hL1c@{6PH^{LCDO^J! zuW?AHq!P()1bzn6sgE75F=_W@5~*11BEfzV(t+&`7e)Ge($aw)NNJ;qC?`)+wHe7!Cu^UR6$2OMaMETGblFflfE?COfXEg=UJ;Vx5O&g3 zEGQ}oj>ArUaiojGNq^;eIseN`#-0iRo_-d2)FBffzb4%TDG$)auqBX0G~&3!C6ca2 zS~@De^1r;x=-CY9IO%XnX3kPozI`%OHQJZHed%QRNXwIc$vf?Etx1c&l6S`8YRD$z zc;iiTd#QS&p+vODK^o`*dV*d+p6^Oz>jLB@lV?2U@BdI!)i@KpOeK0Hm`U(zV!AF< zwMWQqm)%VS_B;vXIj}qv?hE<>2|=AeN00)VfTkcCGy^f9Ifw%F>0l%>6)9n=Gw1@k zf^ML@IkQYv&nZVT7s#*sjX@-c0upp2$i#r=paqBp@gM=T1QKu}KtoU))CKi`1f3w@ z1rlp+;>uF63@it)gEznmc6H8jRkq#RC~LqNkOc;UL0~W#0v-d8gEY_s^ag!EKhPCC z3M!dH%T@0j33@U&w~=>%Jg%1q`tmA4EQkXMK;l>ykk~Z^$Yp0VkhmpbDgz7xgF!z~ z9>^8qPauNwjR8OJdTN6Y;3SN#QG^)@3GzmX#ITov#I24X1w0J=APKYq4}u1uBzOQw z>?#6^f-7|XJ8%_T2NIf2gEQbOa29+CBov(l?}B&aS?X94+$YF;x7Ld>etIacKs*TK z6$yEHVk!+h3HpNppa5(I+kk|T9bhexz&any0JVUGu8N>IkT=nO0+)e=rE}n$ft)UY zbznVs4?IGH?SQ<0(Hh8G8^ftULe5^W4;%mo!4)7|T(-1qVcD_^z-!>I;3JPIwL&$_ zkyi~R#>l%HNkBq{#Frp&p7aH93dp{eJ$nu;0Smz_aGbIS!582#I0E*8{oq5e8EgUh zU?WJTUWr@Pk>4sp#wAgJyg66^E|abSMw0dcxr30GJo+O?gHhl?b7h5!3G9A1sca_4 zL&2xO6CfQ70Uf}f!D^5UN`XLdjnY2=Mfy4L49Em+!AIZ|uoLVC>%d&l9+UxP!7r4R ztIf~gJUAuSMhS1Dw&yFjuN^yaNIF;* zgoA3}0Oj5X9{>rvRX|0c6xSv(7HlJPE7(I?IwcJqd6N@Ik987j>(vyGWLLcaWSAvV zN;Hshm5Xy7b8DrlA1rq+C4d){G%Z%C-c99}O)lwOKxfbnB!N~S7PJKMpal>+Q?N>f zn0>2MpjR%i#evtHTcu)h=(1HpDC;_gl*^P{f;xdz@Cfh&Y2_i%7CZ=Kc_f3@pbe0` zhd~Nx4?2PlK*~J|x&euD(glftk1>9h@;FK_&=a^}Q3`m?`qlKYFUeKldB$lr_&b;m zWYzoyi~=LU2yg~F*^?3!GJr%I*$cs>WpiHyvainpR*V&Kb|b}?Pr(jQ03?!c0h?u2 zWs+D8q!Ww4Lhu@x4_*NVybQ(w*&kAw?4J=%TK0`x4st;@kjN%BHh@n{)X3jP6>IO*4sZ-A8`A8Y_JT6thCcn_=xZ-I3{I2qzK z;9c;JqYM8&_z-LY60&k+qiqG-!N)-M)<@tIunX)2d%$tOg3rJ{Cw%~U5PSg+ z0k40!Y!7-T)Y5W8@3(kPk;7jlo_!^uC-+*Dt4t+zAai9b!2fimS z3fTh4eMlr|41R&HiIk{vo%9dj61WDg0x5Sz=KnH@HsCu)x@qxJ!jgnF2~iT}euR_D zn=~$S9fT|niUEncQmKTsJBZuh7Lbno1f&CnKpg!U+ypmd{)PAr{0gKK0%^P`6+$ z-d6?^;H9H70#!)MI&eovII*h%sSkaR6aZ-i_Bq~6-d`k)S|C$~a%9YtgWXb8ju zsni|LXml9~nP-_>sZgX;*aX?sNjF1^6LK#q9T9u65yX;~PNySf4JCkT@)wuftjdZX zj2r|K!3y-pkdK0PKyGBE5?MgofY>|)N0~sNyR7R*LvKNpAcK;~#gOkyacp+se!}q2j zWN2j?h60&4fy|LKDtlVyS{jk9$W%-LQ-KuD1=GNv!C%1)FcbU@%mOk!bC55A7lC%tFC$+8UC3XITm)VN z3&5*Degu=uGu6lJ$y1?W zH;Py<=H{L{wRyqHW}6anU}T?f+{ zgBI>*NSi+RYX7`qr33C6xF0GF4teO}Yi~WZ{a((qW`Wf0e%Ul5zttPfi;ei^p2149 zU;41wTtZZJKaIMweMa9bU;X*_>@E~FHS$&E7I%uWjv4EQ7OnP(T@vv5DRnmJ&} zoiFC(x4D-SVMgTB3HSS~=U*Q8!(!jh8}Au(Hj6P(gUm*;bHDFeaBj{U2VsNCCO6ukUfg}p;B8a;eH9btem`{E;fF3yJO6Z@0M)NWRMV(t-2a&|@6%F( znTZH?WJw zjo3{$^*5>*emC!p7PctZ{iZ!A!b3Y{8_0{jbYrSay?V_rA6bq4@FG`uW zKA`d+OPMlTRfRy|%9}G%zM1(I5$1lZ_M0|!gMMoJ&`0;mW|=08k$S<**{Uj5my+%W zZ^I{bR_7)k%Drd1!%V?8;Oo-nwA+j|#Erb?SX8pE63w|ys!>w=iuR}c+)vmRmQ5di zyZN5EjC^!d^Qh<+p64p@2LJ`;H0d>~-uk2j$%$iZ`4(Ubu7x;gV9Iu!Y@bolYF{t{#EBG|j`jMK?-6`-s7AFP3AdM)^^sf#uK1za{?RSxZnD~-9|TgfX$z}3)?A}P zHQAIbpkDVAx_x%O_gs<4oei8WG0#sJpBO~euzn5CeZIom8|JF=R zK5HRX3~bKIuoh#e$}`6)S=If(aj|g+hGc$roq#6mQS9t>SXo(Xuwr$g+^;0hoPBG4 zUhT5q-ZSoQ`fjDa);hGCvDRX!T4`32QPuqpbLp@4M>qcM)8FouwAW#?F!!T;Cx^^= zchJm)URBTiX7c3LGjk-&j4%_ggig{YJ+U6zE8k?QlRBBjaJ$oZ&t+@0~NY0-o zI0HoCZYKI8R*w5&#`hu;Q_BC+YL^(W3|WYoCg&rS%Hzj9*zxpFeN64on=lcJOpA}H z{cUQ0fZ2MnZoB@!g%-66Q>we(1rf+8U*x--GP`fND=H2~PYy4K$;7V)Gx zga~s#zB{`v-?)-*x{9B5?P@06X?*bWcz5AXV}*}N(f16W(ccI@3x2oG(U-0AbNzjdUh z7G#m*Gpng0%>DN8w0Wn^4-HTKih%?c42GC9($skKtJt|8Jswc*xw>z?FzL_O$<>3A zpKF@z!odA%@*|Dwy}Ptt&1Q}PomgYmVxT@WQ^d~w>T=ADZ~MHh-YAY;jNPDZ7jPoV z?B1m+hq<3$t}ya}W-*IzN=TzUyX$wPCinBn&vfzDn)up;l^Do`-tAJr&8DW)r%Zy+ zO#74$JYeP_s{ZQ^?2R`2KIO9Set)@Xky+#BWDYczD}*loDrPB49RAANIB!H|qwDuN zzutuJRzuYgv-&Je%{B{nvs~TJEeF@#-0GqIO~eK9mEGcg9J|fI}U zQ}Q#k4yNvBEN=IU%z?*#Z8u`go;5TgLr6FJna&5WTWn@wUbRC@dt=_pRBJ}pdg$1_ z?jEgYsvh8CdZDE`@fqEAzxmwrlh|(GK3sSiOQuA+J=v7r%bIlxg#GI(JD9#0hPhvn zzC5JYV<%f}d5D_g?EzS0<~TL2+Dnt}=cjwA`N!MeSUCD#=jNF&_o|qHuYIP%KK6H> z8MqIhW}2r(ylh_Dr(#;TUtJC@S1z-A?b4r9I>z2>rysPhIa{jKEw-`$fYanOi;9VA zAq(B34|Sa*LSg{VKG)`=R5jA59rO|M2dE0ldS~myEl1B~1=$?0|>t z+orUxpQrZyVdohtcc$0XQ+eOYdFiEEb{ zwy#h$K<$O80ONkQx>J*_OG0;Tt3bz`0P4)x@5JC(d&Y*D{j!?!%q0=lv{Wi;E#>M5 z*)?U&b0R)5-yh`G-~EK{i4CteepL-zaIYQrW4noM&YpjM(Q6W{oWR-8Bz;cJK9lx2 zi@d9uDWZ>Q^A!up{qXU3Pv3r29~@AEQcj4QU>0AY)N~Vk2=iA>n?q=?o8BTen6m6- z^Y=q)81D?+IHZawwcA9WVhNu}HMytc1~Sz&Jxsg^=wuJs5B=wN`Ek=OS@SZNZ1dm0 z8p;OiWu_cvY1$#GvKnSSJxrq$jqd_thPfkJPc!SdY8)hifw6kQq#l7>WR4$4yk(|| zw%L@vh;X{T)9gKhBXvxXqYUQ&GyJGpAF#KpS#^=sU&)L*rb0uUPjlxM2G?3&vGt;> z0jf_o7L6ImVm7yrsvwGQIz}x;%r)#?ZMyMEv)0Ilnyllhiru{!?u82^=b!pzN}W)h z)DqM81i{1ohIjYnlisQ}xxqi~&8HLVxSLrihVI9_gJ!fX{^imoNzU}*`+>*I=@aS+ zuC5(UGHT8Qm={mdjb!sS+#lR{{KeclNeAssE359Gr?Kk4o+PK8F!v+hiGN*kqFK$t z0y^egv-orNOIFG5Q>w}zShX?=EBV`3L}Qb52C>|9{*r!M9|~u8&AVED<+c-Z<&IM7 z=0eldEWkX>{eXDOw;$$d_L_Ny3(F*P^b7{YO)$I6b+f9GAUBJFUX3|+M-Oly2 zx7mJH?d7VaF4J(PIrlXsx|z^(h>|At9Pa_uBL;C#^&j7sooA>|J3k5wP-3`Qq6fg)qhD1t-7SU{fAZG zeh-(7+&<;6&S0~0Zge-FT_W1L!Q$>B=zN*B?8~W{f0?SH&3;)PRZMk>>dtO+gtf{- z!~XZ>nQK9F*=^RfAja;F8&FNqcZ4x#cf^`8-_c+jv+O&9Yc&)6J@e##f_-!2dB+kT ztNgGvPuBb=n>OELo?^y}u>LF!4cnGw|9+8leaqTiWm*iwTrNf2Z+Xp0>SGJu5c6`T z(N#2K+Fj-E1?Ri%xig2nxb}l%JHHH2vJSZq@$@jOu?zdhczf^?t9R@->4k^=PA}Nm zqs*~A*Qn3^Ub{YcsmO-~cUBiw z(NSE5Xz)3+76Vnod@6SC=i0raT7B|u*H<@E5r198GMu(ui~nsf)iH3t>|VFa_6zkk z{y-lZQoS7IOzIER?S8U7=DnIPtqEAhwVqIA-3Eo2X&BIlc_O0C`X5xg+ASyB_c_aZ z+Z$);lTVG$zTG>VF7bB?5!Itj_;nSU?0!1_w=HpnpQd*mVvUt`fptF`zwKz}=(44< z_L39B{T^<=@`L^RXXWeiu3!Z-{km#u-n&kGdfZ&RuBvnW_5P@;S9!IreW!Hx`|^{I b#2@x_yl$7fF(&W9AJv~#-i@Es#VP*}FjyJA diff --git a/package.json b/package.json index 7800bca..e70368d 100644 --- a/package.json +++ b/package.json @@ -42,6 +42,7 @@ "decimal.js": "^10.4.3", "effect": "^2.0.2", "lodash-es": "^4.17.21", + "mobx": "^6.12.0", "type-fest": "^4.9.0", "zod": "^3.22.4" }, diff --git a/src/observable/ObservableSchemable.ts b/src/observable/ObservableSchemable.ts new file mode 100644 index 0000000..56be1f5 --- /dev/null +++ b/src/observable/ObservableSchemable.ts @@ -0,0 +1,27 @@ +import { trait } from "@thilawyn/thilatrait" +import { mapValues } from "lodash-es" +import { makeObservable } from "mobx" +import { z } from "zod" + + +export const ObservableSchemable = trait(Parent => { + abstract class ObservableSchemable extends Parent { + abstract readonly schema: z.ZodObject< + z.ZodRawShape, + z.UnknownKeysParam, + z.ZodTypeAny, + z.objectOutputType, + z.objectInputType + > + + // constructor(...args: any[]) { + // super(...args) + + // makeObservable(this, + // mapValues(this.schema.shape, () => observable) as AnnotationsMap<$Config["values"], never> + // ) + // } + } + + return ObservableSchemable +}) diff --git a/src/observable/index.ts b/src/observable/index.ts new file mode 100644 index 0000000..9ccfcad --- /dev/null +++ b/src/observable/index.ts @@ -0,0 +1 @@ +export * from "./ObservableSchemable" diff --git a/src/tests.ts b/src/tests.ts index 5d8ee9f..db106b1 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -2,6 +2,8 @@ import { pipeInto } from "ts-functional-pipe" import { z } from "zod" import { defineDefaultValues, extendSchemableClass, makeSchemableClass, newSchemable } from "." import { dejsonifyBigIntSchema, dejsonifySchemable, jsonifyBigIntSchema, makeJsonifiableSchemableClass } from "./jsonifiable" +import { extendsAndExpresses } from "@thilawyn/thilatrait" +import { ObservableSchemable } from "./observable" const UserLevel = z.enum(["User", "Admin"]) @@ -29,12 +31,16 @@ class User extends pipeInto( id: dejsonifyBigIntSchema(shape.id) }), }), + + v => extendsAndExpresses(v, ObservableSchemable), ) {} -User.defaultValues +User.schema const user1 = newSchemable(User, { id: 1n, name: "User" }) +user1.schema + const jsonifiedUser1 = user1.jsonify() console.log(jsonifiedUser1) console.log(dejsonifySchemable(User, jsonifiedUser1)) -- 2.49.1 From 24a0e7098acdb0c89332ebdd0eebcbefd63b6653 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 17 Jan 2024 20:00:51 +0100 Subject: [PATCH 44/47] Cleanup --- src/observable/ObservableSchemable.ts | 27 --------------------------- src/observable/index.ts | 1 - src/tests.ts | 4 ---- 3 files changed, 32 deletions(-) delete mode 100644 src/observable/ObservableSchemable.ts diff --git a/src/observable/ObservableSchemable.ts b/src/observable/ObservableSchemable.ts deleted file mode 100644 index 56be1f5..0000000 --- a/src/observable/ObservableSchemable.ts +++ /dev/null @@ -1,27 +0,0 @@ -import { trait } from "@thilawyn/thilatrait" -import { mapValues } from "lodash-es" -import { makeObservable } from "mobx" -import { z } from "zod" - - -export const ObservableSchemable = trait(Parent => { - abstract class ObservableSchemable extends Parent { - abstract readonly schema: z.ZodObject< - z.ZodRawShape, - z.UnknownKeysParam, - z.ZodTypeAny, - z.objectOutputType, - z.objectInputType - > - - // constructor(...args: any[]) { - // super(...args) - - // makeObservable(this, - // mapValues(this.schema.shape, () => observable) as AnnotationsMap<$Config["values"], never> - // ) - // } - } - - return ObservableSchemable -}) diff --git a/src/observable/index.ts b/src/observable/index.ts index 9ccfcad..e69de29 100644 --- a/src/observable/index.ts +++ b/src/observable/index.ts @@ -1 +0,0 @@ -export * from "./ObservableSchemable" diff --git a/src/tests.ts b/src/tests.ts index db106b1..1ddf878 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -2,8 +2,6 @@ import { pipeInto } from "ts-functional-pipe" import { z } from "zod" import { defineDefaultValues, extendSchemableClass, makeSchemableClass, newSchemable } from "." import { dejsonifyBigIntSchema, dejsonifySchemable, jsonifyBigIntSchema, makeJsonifiableSchemableClass } from "./jsonifiable" -import { extendsAndExpresses } from "@thilawyn/thilatrait" -import { ObservableSchemable } from "./observable" const UserLevel = z.enum(["User", "Admin"]) @@ -31,8 +29,6 @@ class User extends pipeInto( id: dejsonifyBigIntSchema(shape.id) }), }), - - v => extendsAndExpresses(v, ObservableSchemable), ) {} User.schema -- 2.49.1 From a2a92f483a098fabe2c0454410482e380ce8ba88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 17 Jan 2024 20:23:25 +0100 Subject: [PATCH 45/47] makeSchemableClassObservable --- src/observable/index.ts | 1 + .../makeSchemableClassObservable.ts | 29 +++++++++++++++++++ src/tests.ts | 3 ++ 3 files changed, 33 insertions(+) create mode 100644 src/observable/makeSchemableClassObservable.ts diff --git a/src/observable/index.ts b/src/observable/index.ts index e69de29..6f219a5 100644 --- a/src/observable/index.ts +++ b/src/observable/index.ts @@ -0,0 +1 @@ +export * from "./makeSchemableClassObservable" diff --git a/src/observable/makeSchemableClassObservable.ts b/src/observable/makeSchemableClassObservable.ts new file mode 100644 index 0000000..7b5fcb7 --- /dev/null +++ b/src/observable/makeSchemableClassObservable.ts @@ -0,0 +1,29 @@ +import { mapValues } from "lodash-es" +import { makeObservable, observable } from "mobx" +import { AbstractConstructor } from "type-fest" +import { z } from "zod" +import { SchemableClass } from ".." + + +export function makeSchemableClassObservable< + C extends SchemableClass, + + SchemaT extends z.ZodRawShape, + SchemaUnknownKeys extends z.UnknownKeysParam, + SchemaCatchall extends z.ZodTypeAny, + + Values extends {}, + DefaultValues extends Partial, +>( + extend: C | SchemableClass +) { + return class extends (extend as AbstractConstructor) { + constructor(...args: any[]) { + super(...args) + + makeObservable(this, + mapValues(this.schema.shape, () => observable) + ) + } + } as unknown as C +} diff --git a/src/tests.ts b/src/tests.ts index 1ddf878..6015710 100644 --- a/src/tests.ts +++ b/src/tests.ts @@ -2,6 +2,7 @@ import { pipeInto } from "ts-functional-pipe" import { z } from "zod" import { defineDefaultValues, extendSchemableClass, makeSchemableClass, newSchemable } from "." import { dejsonifyBigIntSchema, dejsonifySchemable, jsonifyBigIntSchema, makeJsonifiableSchemableClass } from "./jsonifiable" +import { makeSchemableClassObservable } from "./observable" const UserLevel = z.enum(["User", "Admin"]) @@ -20,6 +21,8 @@ class User extends pipeInto( }), }), + v => makeSchemableClassObservable(v), + v => makeJsonifiableSchemableClass(v, { jsonifySchema: ({ schema, shape }) => schema.extend({ id: jsonifyBigIntSchema(shape.id) -- 2.49.1 From 35e699f0df94b344b91515fd1ad366931d2bc37e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 17 Jan 2024 20:39:14 +0100 Subject: [PATCH 46/47] Added observable build --- package.json | 10 ++++++++++ rollup.config.ts | 1 + 2 files changed, 11 insertions(+) diff --git a/package.json b/package.json index e70368d..4b4fc48 100644 --- a/package.json +++ b/package.json @@ -28,6 +28,16 @@ "types": "./dist/jsonifiable.d.cts", "default": "./dist/jsonifiable.cjs" } + }, + "./observable": { + "import": { + "types": "./dist/observable.d.mts", + "default": "./dist/observable.mjs" + }, + "require": { + "types": "./dist/observable.d.cts", + "default": "./dist/observable.cjs" + } } }, "scripts": { diff --git a/rollup.config.ts b/rollup.config.ts index 8625946..292a90c 100644 --- a/rollup.config.ts +++ b/rollup.config.ts @@ -40,4 +40,5 @@ export const createBundleConfig = ( export default [ createBundleConfig("src/index.ts", "."), createBundleConfig("src/jsonifiable/index.ts", "./jsonifiable"), + createBundleConfig("src/observable/index.ts", "./observable"), ] -- 2.49.1 From 79f87fa4206dbb752f23c882b94e2e243d9bc24e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Julien=20Valverd=C3=A9?= Date: Wed, 17 Jan 2024 20:44:56 +0100 Subject: [PATCH 47/47] Package upgrade --- bun.lockb | Bin 160736 -> 160294 bytes package.json | 5 ++--- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/bun.lockb b/bun.lockb index ab7c9a9ec429c424afa7003cbaaa1125192f08a5..a8be37ec9a258a1b8ffb32b87f1705fd70b7789f 100755 GIT binary patch delta 30080 zcmeHwd0b8T|NnhoT{;nxR4O5%R7%>_En~}-ePjzs6s43cTQOrWK4!+e@gCb)X6*Yg z5<+&ymSxDkEBi8rjQBlYXA$!;^Z0z1-}kRMGtc{azn<^cdwIQ=*Ey$q+;jDgwDhL* zjhEZt{ew3&>%Y~e>Vpb<=U$l8=Dt;&m(87(N&PII&9vaQhi47Z>*!cKJ=)ngXFih^ z<-zkht(P@Qfibc^Y^4w+x0x(YC~E~C>`hKx_| zJ1jA&pRT__r>g?J6Qnhy5wa?zr^?%_dRaC9H#5clDkRw*hO7p;S=ARn+CrbA^1~rf zuPLjqYS12%8f>EKbs?z&Ye?$A8+6bH@-8Gba2k^Gcd7c?GJG+sn>n|VPUi$V6Vef~ zuc}8v+Cz7PtO;2jvIb;PMV+oT$W^MG21)sYRlOr5)fWIs18ua_>F|G+lPaI0 zPvv#G%q(9JG@!H4Su%8oPBRgP&cYz83UrdMVMP6(fKeg)^!ViA@oAU@JHH4;%-SH;{xJ$sx%Kdh>T#%!8P#Rd493MK#rBK;0U2m3>uX3FFcS*W zK!!mQ?*T~zUKJ8;W?e*WWOoRX>|ViL>i7dlvcIazM0A2C!Vkkk<+c0<&@D1SIAI(u zAgv&&huVnTgpN_qN=r#f8kVZl{r{LMOSF;oZmxKK8QaXwb(Lmg>L~-+QI)B~Qe)wY zu4;XSZw4Ndo3#i!bzA4A$h0`J(&^@)9vYYA#KDQlm>CF}9|=2}pa&>N`Fq@zdYUwl z%V%ayL4wAk9wZH%gNIU}5_B5)0rI@+bmKjh1_wY=M~10-cSuX<^SqRN4kW@aka?_#J>E(MTE?LGjN#PvFMO1atV2G{{0vB1vgJ{*GF60*Qilz` zihdh9@&4*aC8m20PEFS7YC$Kvq{d3av5@7V%Ok|&4c6VNsbiiHo9>wrn>M(-s(12N zx}Fb7J;;Hygxn8FHLO)-3zhc^RP40y=D_m}^)hXOl>zw%GeiTj06NJxLCS#nhA6eU zLeju?MLyMTp-Qc`=dh=Ny|2paknh*?=lTbP$}w$Vme#-;bbu<*mdfYQX(@FyDh-ZE zNQ_Isz$d21kBo<$3!Zkw;Bdw5)Yzd3o|v69l%uT`6`^#XDI|5cKfhMiHgjuJMWcn7 z8k?T3MGP0U_1&K+wc0jQ+!e5=Uaf~t)As`;4YD?D+Hg3xQ24=+-{8xd3L)C3EM@DzK%s zn$=d3=_zr8(qU`cP8q4hR46zuAfNis!KCylEq-WP2Ke~2G|#w{e(}TA{CKsVXvm7N zk5py+U|1y%9&ogSQjbeVx&F+oFF=r?HfZ4}K!ei|k~-!LNxp6Er08+6_%9(|*R8WM zsB0m~*;LQuSn8|WrwTs>k_L4gB;`lKj_NUo1Ed?F%i-Ay4O9eCHCo9?CiijVL@5;v z9oFA-Ah_qqrwT*6Dw~TVpQ6PoNGkssBsGwN2C6}x?xvjJvLWdN*b6*4^sKv*Kd1*z zV3|Z9LAy1vr&2+8NLqwS1uHfd}Xi`EefoCOu!3{SycG^ThQ; z%m^jFqbgIeNaJFM#zW$KJyh3mq>{f6<*32!YWbfasiPgS#^f1CCndU&x(b2}&q7jz z+7+C}ZGgC1xOHlIy#Ilv1`n7KdUt3@L@%fs|YyE5nOjjI13G zs$*p1c?Leq@SHkE!xpT$?mV|nh@lErX;(Ql5GjS*i&RIMtA-itBd3NV)l*KLM5>>h z@<%-DC8uV*OFczOv1^NUuH>#pN@>Has!rF1N=V(2YKl22Lvtdne_vzOcusvI`;-^g zH|jUo@L;zv$qd0B*DaV=n!-q)<7Q+Nc(I#NzpEM#b`R5kWy?oFT(sp|-NPh%oHNM0 ztXz91XjrycW;`!EklFE34Z`#X?f6!RS9bhWgD@7sgFKA-{q}s6N0{VQU8idTb9uQ) z1EJB1LPxQp7FXxNo?-f1)%hsTFc!dbJdG@q7ke7@TOD|?R~Xar3@@Y9$q{oVSCLmg zK$-)s1vCSX7=tC-&}it1b5&Db;t-<$-idE*7^W|9;;$Npv6ei@+oq+w%iw`|pnBfbH_<#t<g#mPz?G9%*cxcz(9CI(NEO@^tt^l52{5#Q z=E27XHZez{EsU^+Qv=PQ1oD!A5GL`QKqHn?aiCEe=B}6+s5AO}cRng8jJ4u9L0A+G z_^Y5W>39R3t_><-WWnn4j9{Y_@1e{Sqy9F&`0w3=kAWidB`l9T!qtK|=ie}~Y zeqIM?P37(}lv}Rmp&e+2&}csyWdCZT`Xc<%Q2Nwev5jjM#O1wDS$VTy? z2&1$EbZHk}LxcB9jXyl?2G{^Dc=0<5fIC21^h7qlS8mJO;dF8|*N%LAx)>f#R zQr9hLw8F76>jX$)Axak|K0YWw8Uu}HTgUUTR(7d**ig{ksG1qg1Z%=GS{bDgXoOl- zR^bL!L#vp%d(fy4^8B-UJR{O5jSGEmy-8bDO_}N6q0t6c>S}{=qoGsQ*q2BK%Y(HS zDO#O!8ABD^fQD1_m12-0d$b)9VAu<-k<9;2De&^hN%i44#cxF$4UN{Z(qb+&b+)l% zpNI2TZNd!E5$G@<>m4F-q^JSR5{4}w8Vw>e%xo>xLepd5c?|<_x(jM+)bDG`N3{); zY(7zH#Vlc^M?u3dW?9JdG8r0;9_o%jmC%&F(dfBi8fYfa0HQ-8FK&kuWHTPzK1|X# z*QOd-(lS+3HqSL^)JrqYS_DWQsE-^}HqS_CG$Bf#H$kIK2j@}CYiLS23OvEse;|~B zF=Rn&#Y@~m3>T1UD-WwLimJmJ86c%Yquqn0fzm6W(LlaVrpTRVkG){%&vGD*W{ zghtKDBX5`ltqIR<7$WUKimF9i_#{Aj4o#_u^$av`t@M}iyaZXn=FF-juhWSpWn-6> zwOnX48Q6#z@h8yKI?%2g0HyaoZ1OFL!FAUt9_#X<9crLq*i zhDLLvoV$L3RyuE%h?@v;*p%bZUN|(xAuJj;k_UA+8a9Dz%}atp3~!KXCJ$xP4$1<; z5Mvl-KtsHsjg7#0wgV6D9ws&HsB{P(V{B5ODJu>Y>o<1f!9Bwa4?za=P@fQ~eka8< zWwWM1qt$~I9};K|1)EoO#k{jlhe(%YC2x%cXz!MiKBqGUR>KRBjpXed_^FnSm1CF% zt*OkPLrR$p8mnrE3)Gst84SIkg;D60<{?G1B%jXpC%W)gy~8BuXr(BOQ8WgcGRzE1 za|$$d>fmEuG=J3x`>Ct4DU}7&5gN^>a?Lm&8igA~a8z~=8f{o5&$XM@5Uu(+XmAUC zpliee86{Rbq${JL zoRdCNvk(@%V}PO3P>isAV-w4RMj53U(8*SruEWr9u|c+< z1Q;BKVN`i8u9N7mapW$naAmL_8qE^^ii18sf~Euv{pj=hCv?3YOHmXk2 z7VuE@kH}0p>mwQeN4(Ph-}O*O9(k%BkhBKEfr>y|fR6vRRNMcLD$t{$_5jI_039T$ zgPlmhL6Y>&q~Lg8T0rk5vx+3U%-;B*L?3{TKJw?sr5W=20W{}0gUHAKP-e;%QN@Vj z^6@cA4I;409Yw&D50bvxHI^BKxz(LX+_zj@J zeF2dDOMniN#Q#AGj*m&Qe=X;JTvC1sK=q*VfpPVGGzz^)1GsH07p(moPO z1h;~jwv z%Il}fct{$NL{%TC%0ZBHkfdais=qI(BZI+H$A+l+Br8B43rUpUI5j~XAtDPORB!?* zf09Ifh7ZO|raH?bH%Yag0!hvMOVz)Eq~m=_`P0Eu*0-wN4At&^N$!3Jo+N#-N4@!8 zl?zpSNM+`TAcMt_l=p)wemey?gDQW5r1~}ysY6=|$2?*le;Dg3Pk6LLbRfQzp zMwQj5H5~6t8XgBV-w~2bYN)a%DL6hRsoq+8b%)kc3%Ed1Mjc2R2@kb`_a)_fs{H$s zcrWlYAC1-gk4frq5c0_+gnCQ`o2W8Wm0^_2L+3fmXRoFz`w6i)NK&%7%C}JY_a)WZ zQsw_nl1Zd$N0Q35R;5Xg8&V?Ls0JUCl+{+vCrK-zgQ}CH@*PQX%WrJu@$L+bwn-02 zvhD>*$Hyd$2ghue)-37I8 z4TJ-9$=DX4NOXmOf?Ztob?gHaaw-t1dq{a9C zZ3Xe9lSlvA?ZtobE`o-C0zk)qB5T5KF+gjDZY$^@Nge#>_Tr!03oHX#!&ndh++JW$ z(8Wt#+8ck8ME!Gn@z3pryf7C2b9*75KmP8vf(DB6>6+o6+Y7qQpb+xU?S*o>`ODjj z=Cp49$F~<7XU{*)!aG+=ew}*%?B|#2RJ>8#y)fa`;r#=C>$5)4ac|=ckMP$ei+1L% z8h!6@^{A`+XNJNre^ z%z_WWXL){TQ8Yie$dY?5HZe<{u{fGl~W|jGPd|L4Wd{*H;KStv#nko3K z%CF(mh6gQ)#zU*q@oCG8mPGTyC6+vDsR_>+&R!bLs`DrKbl{Q8qM0LKgij}4jL#ap z!}4f6PPhV}H91=m&1&&(_^i!0;M0XmE2CK*9*a*`p0hHVZ&_){omQDxJ)XEK8eiw+ z;nR)Vua0K!d&3O*A zEzq1coAB6c;^t_cuo*K0Et1=3M{~PuOFlN+#7z7Uw1dz*x0qNI&)5>pM{cReFK=m$ z2b4XZZ)w^e9G2nK6$Gpe*g_nS8aoT+u+|e6N~0W&%k*);a{$0ruEblJtE%D-q>bO($vz7?9StCcZzWFkxO9GKO}7dYFxF zGO_)A*I{4A-7kA{k87@O{-(=fZOYN633{8{Lr%Qb>nbms)t<1?J|Qpi>xeBYCS+{1 z%v-v=`PyCcu9z~e4jZ$BKghMqthlDfa$8g4{1z$2!$&W8^F!*eXOFC1PFT*c>^Qx! zV0oZZr{CyZ?rdL zc}~EJW0$+$@=HIo{20Ehl`E!;uRdC>kY*iYU86gFcRuBL{RsEA9bKkeUl489Cx2ee zt52``m3Um1!ktp1UYwk|tYY}>?kD@y{n`Ed?DWP(UAhhTwwN0~q1-~$K~a~6GnQ^0 zwZqKm+RE8g1|RAgTr%!oKSr%xw_)z#KJ83<67w5A3h%II&Lrocs&D#Vezo$^*5A(5 z-#2FeicZg$`F~fWuYICp7Z1;4O;8cT-@tTpOG@KmEjA6edT=>N zn%=eR?dVtC4-Togw#mvfU3!hTsebcrLA^NLUhAY&vkG#i*;$+)XyyI%^uI<h>I2K&)8`H_{z@u1D3`Q z@yJ`28UAFN^~IVio1Wg7xiBfY{eh@&&;4|z-t;+inj*JpI1{Kw^)Soq<@B&HywL@H zb#J@8>FbJ`c$v}+3CHZ`#Z_G}d_q~t(Xp)ATAN|)%IF^6DW-vq6BjGoCFTxByiY-e|6IBFirx8aT0*`8JB*+N#GZp1b#8Gi983|7HCdKOl%TQJc5(J z5u5~|P2u)OaS}L+lfY3Eo5~MCI|$A5n2Al}8OPw?G581VYwmU&{vC&Z$4zWHFMxIq zTIdNA<9x~q_;&*SL7T~g^5I`T{L42n!Hb|3LW??SVzc?|lko2({DU@^N1lRzr{Lcy z6PwSAp}m9_bK1lf@D-=w-)Z=F#>5u!ZfD@%8Tbe72QK{z|9*vkzna(*o&#+QG^evB zwu~p9g@0$^AG8(R{v7-}2mj8Q*eZSq+CgZZ1tzwJXB5D{0{91Q9d|nq|IWj|^Cq@| z7eG4)E%btkZRArfz`qOd58BT>=py{P2>&jcST-+$RtPQXl8NQ;*_YtoCHMzz8;`sU z|1QJ7%O;k~i=n-Q7IVeKcJdWh;NKPach$u5c(<$Y?<)L*wuejC;NLa)cg@81@f>Jd zpgCPPu>(BuI{dp1|DYY>_BY_)4fuD%#D3w2pdEzfdDFy>@{F7C?2DO&x##prI%0T22;UXkG z2y;D%WIYI1kwe55BAm*As3#K3fJi6<;wTYr!rlyoof(L+W*{1fLqr@T!qWi4Q)C!G zj5L6_L_|a3Ru)A4vLL3F1>qwKh&V??XgLtRVoEs>lgoj4K!l$NG6xZ84r0DJhyYPU zL?IDT5{Mu%TLST&1fqn95D{qsqLl@RH5MR3MKKXCiHIo=!YEdh2eG_72+Il}B1E?e zAi7onkxRrULb3#5ZV4jU5=3*6L&O#$oGOB7DH1D!NT>+nC=rpuz7hz#N+8Bo0$~z| zh&V`uXJrskBBL^hk(EJQBBGsevjS1y3dA%k5FJDT5$A{qtpcKxm{JAA!9 zvIY@o4Pw4Eh-gtnL?IDTRY7zUv#Wymt}2KUB6^5O8xXB*K&-I=5hIF;cu7P|H4weU zifSO1R|8>b3nEr@vjx%B7DO%)aYC{KVQvQ^*$za!$RT125l;3X28cv^5DE4mjuMe5 z?5l&Ys}5ppbr6HZAtDYE;pqS(S!6hX80i4w5)moF%@IU>M-bB-K@1TEM4Tfc)Coko znBoLtvJ;30L<|!_H9!Q`05QJ?h!LWQh(aQwoIzxW+0G!oa|TgD#Ap#&6GW?;AlB3b zF;)~4@sfy`S|BpTidrC+*8*W#8^n0gtu~0RwL#<(@tKfZK$yFLNOl1+QREP@g$SoQ zASQ{#Iv^72fH+FT6k+cQ!p;@MSXU5J#UUaN65&}F#59pn7sSZAATAN{wQ#EkqJBLP z)9QhkE((Y^M?`3S5L`^D4`OnC5D$o$DT3TU1iFEk?*>AMA|eWjh;j!pTg-L`@tr$} z5+de`$Oa%%6+EtGQ}H%88HmUtqhG^d}Ov$_#-j^i;%OR8r8 zan-b6t%*xY^rBxmKr6cS_SwO{YzHf?r5qz;3IC?wGd(43Xr*i`e|E2|#Y&^{52-g9 z#j#MfRBmK_C^NUQYO4H8Y^qKBcl1`-M?=|YX5-dMDMWb#>DNb+lXUSS#>j+|M_r|u zS3{*cWRe;imogNW{KJG*IICyaXhLb~{%ETSyba-{9J|SfQ;0D?9djhH$zaK-;ymeB;!I@9?TRbwH&O|Rflq;gTo@oq<`T~|Jp`A zvQ$HQ{*vwis6XQsL-}!$fzYX=^uP=X%g^X&U**qL%Mu@jG#&I{3?=DXzs@R0Lqth> zAn8->$tHSohDf@9>p}?}3sjE2T<@-O3ssID>S(BPi&T!jj`mSG?Liy*LOw+0w1;l! zSzk%ze$*Z)ss@s&Bt3mYN$dpqJ4*=NQV=v6b^zVPV6o_yt9JHCPox4kR;V0ShijPFMtYXY(IY{WtO*sT?(i|K*)jUFGs2X}2^64ghp$4^sIdoefa?@1CmiN4gC400%u;MHL1BWx-MJ zD>($*?hpmIUrZXn$d^1R9gBmEYj&Xbe)pC10#IUzw?{vv&WL?rzoX$L^ZCDkw# z>76ozr(9KzVuBMIrjA}wIU~|Ea+G&f<-(Ds5uv_nA(7^&=Z)NJo08uw23dEGhO;tfMh%C^{@* z&hkGNpdgU|Bm(qE5IrW;6NmvQYDEF`L{lq(z7c5%cmqB_BfuA+Z%pcBOTY%reso3I!N{aj-JUIiv|*bUO;bP7mx?+1}H`y0M-K(wdVqpfm#5? zz^Xu5fF9lc4Y&tTe7gzUqDJok8-Y#0&j6mT(=`L=={_S60t`e2M*)go$ANs{Byb;~ zkU=4WLIOg7e3qUMIR)5*`u6HX#TEEz#_dQ`jH0Il>A6A*KNOzI0k@I916%?qI?&F) z2`mEWWd1MUJj$K~&H%pxXMy9u2_P5P0qg{}09yfiX7N{)s{vWW@Xw;|k^<19`?~;o z9@H5~Mw-G6U5?NbfxRG8fWbfn&{RBF!5T`PK2Qy%Ihk*fGYl2Q1O0$Fpat+5uo?&j zECDm%F>IdzI;6hOc^Mo~JAJqKC5HR#g%bYXIuR zLSO;#JunaW4iLaBU8%@GEcz z&>EsnP$Sf_v%ookIzU_jaGqv^8ovnK0ImU7fh)ju;3jYfxD6yQWCyK?-kbVl>1D*hn0V?-^=Knqt5x_%LYH9M4LXsAqY?1yA z9G&W@ahhv$$Z|kgzyMIC6rtWiya7r8>d13|I#3LdqrU?$ffqFYM7#$60H_lLYMcW3 z14ss`2g(4Hr&S_B*V1$jrqQ6OqK;5`x{}j6LR(ZDf$~UK0BEgcRz!j#K1F`5VIwlM zz)s#%aJL7jqcj2(=xH5jqeC3o)dc8NN1dQ_ZB=goSs$Q!T_EcLb%45bY2>OZB;5da zfIOf|wc(`eP8tcCXPR58kR(;u5Yk&sH-aQ58beY?$ewHn{zy}&;~{Ac1pzhaRxS{U zy~v1z>EcK+BS(nx+g$WqE)I@NIQoXRu6zih$^KK>IT^zpau5+DD?tIqe1b4 z%AyQ@+7bi}EltA!faZ-rb3~2Oo~F5`MrbQ(wn@+_ee5u8o zGNL^!{Is7+_ij3;cXruI`cez+$J8xtn-zV(cKCtPoF-!a7H03D{rY-hPLt)0%O>A0 zHRvnyVZerqdk~J=&$q8?krC3HcTfQi@ zGm1xKp#5sSxm8$$Eo{b-QiJ}&Wh?Xb*M8)D&)H`8$KM%UN6&isd3k#^!U?Z}G7+6N zn^)<$uJupI@j;GHknV8>@vp7urS{A1m!_Vw-@f?7FR*Cj1shDQ*tr$GbP^kK(FyIB z-;c~5*Kc8!)iJW2H`)0L%WbeTihA3aFKZ)uKy!$;l>e}qRqajf<~!G&`l>1m3k~q1 z>!f(`H4OZR!@v$p#AZO{%kAA;XO|j$g&b$(L~S~-^s41I150z(Sc=Qrn4NyJrFglG zxjXKLr7bKMqFM{c1+G~h4JO9-t;`B6Mc8&$6W_%3-j2R?6nS~frY4rRPWuV`4s#wp z3}2Z4#*8)g!kR_Sw2ETwcGSMAqNu!^Rh6x^AJPweJi1-Q%9HX-t&1v(*RXcbetQ3Q zgsb`UPnzv5wQv&+F>v_KZTfCz<4i4RKi}^(svWyE=1f+pZKfCtTm9Th;wqXpkg+`O z4J_tiAJJBNT2=zsO%~6+h@r!ru?$hf292!J9 z0hn}O|EeNt2j)imt^AyETkG}@b3zq~GOLtXQFKb>g5pV`*(rP0=Y#`sdd=^OiwGi!)JqG9&M4=K0`uRYkM`&>n< zJ*<&F-&Kqu{k*G~Mfwd_ad;1FM_MKKR?6n3nMVEeEqS_%ge(ZX*Zi*o2+SNTe8hHLZQukFp`!YJDq zmj+@!?EJMK%dcgenvrg~cL-{y1&t-A{qDX~?Q1T(q}q6dp;v$saOcz&_xEABYCpW6 z{aCWLE;H#1STsgi49n)aqUL_qhLsn|`_Z*(ViAd2;tYg?_9BD0x|2>m?t9e-#k{>x z5Z6Y+3o&Bq0hFpLc0$uHsxQtTz_>lAFDf2ncKGXTy@RkFDTYBfYQO#8 zZcYA(2WRd5^lY5GFL8D1E-u5~L3{6mf7Np%f;ud#fmUf0(P}+mbqLKh5e*>pQyPdC zhiD&r;13|!VS%j=KWsF&`ba$%D^57Dzm1&A$QckE*7kJz>sF}A4_V0h-9xNBM6uRW zu^2!1s(9*t`43o7V1tE&xJGSxh(914w0B7KsWQoR?YE;ohaH{MF!=37!^1GpUP95v zqwdBZ>egzc8lV>g#0D7PEBmozHy#b*44UQp;%?7%Y; zst&Hu$am383aMyM?t8;ozo6^d+bBM3FV!CT{fJdCpgDclCH*>Y(e@YC$WeQ(#kSY0 ztc;C+9H1Ja$vxg;9;$Nu>rQ>)BTm4=PkY6McbREJrzgb<)S=E=ELJFu{&mSCJ2|Pr zGvufaB?+e^Yyfi*Yi_{*7Gl8>tYYnr7M89%n>5RBNN$liHj(!Jk%&_lbas6PuR#u7 zav;pD^%oD1pqtv;FAC1LO}J6T?K4==r3W0@?=KeKW;O;mpYJc49L4bbwXvT_If@SD ziYZ5#ul{>NK@k!<%(UEz2VO)m%*7pY0@{Tto(`**zCy7)e7 z#C(!}zM|4`ta!D+-&FY~Nc1|6su@9dFNdS)hK@|nGbR&@6#A}b%))!N%UqC1?9ig|kInp}mvIJEb9 ze82MBd(~`CPDBok1=h;?X5tu?{pb|QbKR-A;^50yqZ4*_ov}pEnt-7zM0GA4MnbO$ zyqAB!jV+*?#N)3YzY&;^+GVv)8DcQ3X-yr(KU zrbcCL8b1=*{gr8S7WuTs28(+n?%KU`sI>5>NR&I)!bgz2xBHmSrAu zSnT}LrnJ`~ghbr9^UcEVDFUiH`&w%eb{fm`_tv88Xap(<*h};bu9ndCMA$P z9Q~#fKh?(q<cD^f(A0~swYT!4rd<4GGXDiuMfUC$E7&!N%_ZG~9@ zM$}deDquhBzvv)V7qK?_qa8%*d1hzp(oq?YV$0e;+k`KCtY_9>DvMaGbMdBtnNtNj z&LbXcuTJR`{72cj^M`(?XIP5zp;}<*jMN)>!0koa1y)_@wJ$FH^C;(o?uv>RSz9~+ z7jqHOMtlEC=cS|8))-U&$I^*bqbQzWTt$Z3i&)I3d{XYp4~s+9dB>1U`BYrJ2uG`m zmY3kSIxk|zCETw+j~44Mu||J$sS_$nE}@6YE;mDUA5O31Ur(OekfZj7mXI$OUu;yX zI1fEj&nTz63CAnUP8_++s{8-7nf6MTKRWfYFSz{WWmKTfwpsyQ(uG~arAdrvcZKdI zdMGb1oBP;$)t-y9=>nQs#F_0*5Ai)(bkJT36TGfX%$=x+p{0H5F7mIy-$dbj6}#fE z?PLRA2kmV!b7vo}J|uZdc~nFfH&_9cMKWq&Rm7yL*fz?#)L-Z&e!VLHeS|ihsCx!; zpme?s^A}UE;kpV>lU~C#?dT&aUdQ%PT~xMd6zeIzMnQEtoG~3mu}VaNPcgk(m-jp{_DgjN zu%y;@7RT;k>8TOsy~WY)zOpLl3@zr}M{R{k;^cjV&HTZl=7ZAZsx4c+vIy-Q{{6g< z(@SI8lJe=rSM8Ra8l;8!L&QL33+W%EinNEglzW*fmOjL}@XQcV@e!^cZw*nF)=rPP z=R-cVYb{TkyhNT45ltUqfOKNmBlK9ghqrUo-sKbeY}bavmHiS>fX;E4=Ur*yGOEOG zeL)2dr3;V8P}_>;k8v-jzN05=YQGs9wx2(A1rZ*_=%%%jSo0WRLVKA{h;yr6qrPoz zQhS0ZP)}Tg0Z!qqH~l_-?K>bG?2Et|buJ%OMHiZFre!L_^iD+Xiq^qAFGOK$C2ZUYft2ie5(Ad`sGu4V6>{3{0ujETb?m* zJmOpQj5%X9Nxw1Y>K$B_E3_MrtjC-SJgck!Oeyyj*2!<|M0VZhuoXU?^tHu+-&yVK zN58WkHAEE;ea%_+`br|zOm88MndxhNKv{~bHhM>mvJqnpdRI-WBu*IgE~Of3C@X53 z>C214YWkWQZzDo&_4PEZl2}+yFNt}!dXG{n*&b!0%IWKrQm|_HfmT86v@7jfSZN*# UyOnB{C4D{Sm;JzA|E$~p1IMkX1poj5 delta 30810 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 diff --git a/package.json b/package.json index 4b4fc48..2ab619a 100644 --- a/package.json +++ b/package.json @@ -48,9 +48,8 @@ "clean:node": "rm -rf node_modules" }, "dependencies": { - "@thilawyn/thilatrait": "^0.1.1", "decimal.js": "^10.4.3", - "effect": "^2.0.2", + "effect": "^2.1.1", "lodash-es": "^4.17.21", "mobx": "^6.12.0", "type-fest": "^4.9.0", @@ -62,7 +61,7 @@ "bun-types": "latest", "npm-check-updates": "^16.14.12", "npm-sort": "^0.0.4", - "rollup": "^4.9.4", + "rollup": "^4.9.5", "rollup-plugin-cleanup": "^3.2.1", "rollup-plugin-ts": "^3.4.5", "ts-functional-pipe": "^3.1.2", -- 2.49.1