fix(type): make serializer API consistent

move options to callback away from the factory

Author: marcj

packages/sql/src/sql-adapter.ts

@@ -565,7 +565,7 @@ export class RawQuery<T> implements FindQuery<T> {
         const connection = await this.connectionPool.getConnection(this.session.logger, this.session.assignedTransaction, this.session.stopwatch);
 
         try {
-            const caster = castFunction(undefined, undefined, undefined, this.type);
+            const caster = castFunction(undefined, undefined, this.type);
             const res = await connection.execAndReturnAll(sql.sql, sql.params);
             return (isArray(res) ? [...res] : []).map(v => caster(v)) as T[];
         } finally {

packages/type/src/reflection/reflection.ts

@@ -496,6 +496,14 @@ export class ReflectionProperty {
 
     data: { [name: string]: any } = {};
 
+    /**
+     * The type of the property, not the property itself.
+     *
+     * Note: If the property is optional via `property?: T`, this information
+     * is not available here. It's on `property`.
+     * Use `isOptional()` instead, which handles this case plus the case
+     * where optionality is given via union of T and undefined.
+     */
     type: Type;
 
     symbol: symbol;
@@ -587,6 +595,10 @@ export class ReflectionProperty {
         return groupAnnotation.getAnnotations(this.getType());
     }
 
+    isInGroup(...group: string[]): boolean {
+        return this.getGroups().some(v => group.includes(v));
+    }
+
     getExcluded(): string[] {
         return excludedAnnotation.getAnnotations(this.getType());
     }
@@ -1265,6 +1277,10 @@ export class ReflectionClass<T> {
         return this.properties;
     }
 
+    getPropertiesInGroup(...group: string[]): ReflectionProperty[] {
+        return this.properties.filter(v => v.isInGroup(...group));
+    }
+
     getMethodNames(): (string | number | symbol)[] {
         return this.methodNames;
     }

packages/type/src/serializer-facade.ts

@@ -1,6 +1,15 @@
 import { getClassTypeFromInstance } from '@deepkit/core';
 import { ReceiveType, resolveReceiveType } from './reflection/reflection.js';
-import { getPartialSerializeFunction, getSerializeFunction, NamingStrategy, SerializationOptions, serializer, Serializer, TemplateRegistry } from './serializer.js';
+import {
+    getPartialSerializeFunction,
+    getSerializeFunction,
+    NamingStrategy,
+    SerializationOptions,
+    SerializeFunction,
+    serializer,
+    Serializer,
+    TemplateRegistry
+} from './serializer.js';
 import { JSONPartial, JSONSingle } from './utils.js';
 import { typeInfer } from './reflection/processor.js';
 import { assert } from './typeguard.js';
@@ -22,17 +31,19 @@ export function cast<T>(data: JSONPartial<T> | unknown, options?: SerializationO
 }
 
 /**
- * Casts/coerces a given data structure to the target data type.
- *
- * Same as deserialize().
+ * Same as cast but returns a ready to use function. Used to improve performance.
  */
-export function castFunction<T>(options?: SerializationOptions, serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): (data: JSONPartial<T> | unknown) => T {
+export function castFunction<T>(serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): (data: JSONPartial<T> | unknown, options?: SerializationOptions) => T {
     const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy);
-    return (data: JSONPartial<T> | unknown) => fn(data, options);
+    return (data: JSONPartial<T> | unknown, options?: SerializationOptions) => {
+        const item = fn(data, options);
+        assert(item, undefined, type);
+        return item;
+    }
 }
 
 /**
- * Deserialize given data structure from JSON data objects to JavaScript objects.
+ * Deserialize given data structure from JSON data objects to JavaScript objects, without running any validators.
  *
  * Types that are already correct will be used as-is.
  *
@@ -44,7 +55,7 @@ export function castFunction<T>(options?: SerializationOptions, serializerToUse:
  * const data = deserialize<Data>({created: '2009-02-13T23:31:30.123Z'});
  * //data is {created: Date(2009-02-13T23:31:30.123Z)}
  *
- * @throws ValidationError when serialization or validation fails.
+ * @throws ValidationError when deserialization fails.
  * ```
  */
 export function deserialize<T>(data: JSONPartial<T> | unknown, options?: SerializationOptions, serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): T {
@@ -55,7 +66,7 @@ export function deserialize<T>(data: JSONPartial<T> | unknown, options?: Seriali
 /**
  * Same as deserialize but returns a ready to use function. Used to improve performance.
  */
-export function deserializeFunction<T>(options?: SerializationOptions, serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): (data: JSONPartial<T> | unknown) => T {
+export function deserializeFunction<T>(serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): SerializeFunction<any, T> {
     return getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy);
 }
 
@@ -175,7 +186,7 @@ export function serialize<T>(data: T, options?: SerializationOptions, serializer
 /**
  * Same as serialize but returns a ready to use function. Used to improve performance.
  */
-export function serializeFunction<T>(options?: SerializationOptions, serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): (data: T) => any {
+export function serializeFunction<T>(serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): SerializeFunction<T> {
     return getSerializeFunction(resolveReceiveType(type), serializerToUse.serializeRegistry, namingStrategy);
 }
 
@@ -193,6 +204,8 @@ export function cloneClass<T>(target: T, options?: SerializationOptions): T {
 /**
  * Tries to deserialize given data as T, and throws an error if it's not possible or validation after conversion fails.
  *
+ * @deprecated use cast() instead
+ *
  * @throws ValidationError when serialization or validation fails.
  */
 export function validatedDeserialize<T>(data: any, options?: SerializationOptions, serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>) {

packages/type/src/serializer.ts

@@ -169,7 +169,7 @@ function isGroupAllowed(options: SerializationOptions, groupNames: string[]): bo
 }
 
 
-export type SerializeFunction = (data: any, state?: SerializationOptions) => any;
+export type SerializeFunction<T = any, R = any> = (data: T, state?: SerializationOptions) => R;
 
 export function getPartialType(type: TypeClass | TypeObjectLiteral) {
     const jitContainer = getTypeJitContainer(type);

packages/type/tests/reflection.spec.ts

@@ -1,6 +1,6 @@
 import { test, expect } from '@jest/globals';
-import { typeOf } from '../src/reflection/reflection.js';
-import { assertType, ReflectionKind } from '../src/reflection/type.js';
+import { ReflectionClass, typeOf } from '../src/reflection/reflection.js';
+import { assertType, Group, ReflectionKind, stringifyType } from '../src/reflection/type.js';
 
 test('union empty interfaces', () => {
     interface Dog {
@@ -18,3 +18,44 @@ test('union empty interfaces', () => {
     assertType(type.types[1], ReflectionKind.objectLiteral);
     expect(type.types).toHaveLength(2);
 });
+
+test('groups', () => {
+    class Model {
+        created!: Date & Group<'a'>;
+        modified!: Date & Group<'a'> & Group<'b'>;
+
+        field!: (string | number) & Group<'a'>;
+        field2!: (string | number) & Group<'a'> & Group<'b'>;
+    }
+
+    const schema = ReflectionClass.from(Model);
+
+    expect(schema.getPropertiesInGroup('a').map(v => v.name)).toEqual(['created', 'modified', 'field', 'field2']);
+    expect(schema.getPropertiesInGroup('b').map(v => v.name)).toEqual(['modified', 'field2']);
+
+    const created = schema.getProperty('created');
+    expect(created.getGroups()).toEqual(['a']);
+    expect(created.isInGroup('a')).toBe(true);
+    expect(created.isInGroup('b')).toBe(false);
+    expect(created.isInGroup('c')).toBe(false);
+
+    const modified = schema.getProperty('modified');
+    expect(modified.getGroups()).toEqual(['a', 'b']);
+    expect(modified.isInGroup('a')).toBe(true);
+    expect(modified.isInGroup('b')).toBe(true);
+    expect(modified.isInGroup('c')).toBe(false);
+
+    const field = schema.getProperty('field');
+    expect(field.getGroups()).toEqual(['a']);
+    expect(field.isInGroup('a')).toBe(true);
+    expect(field.isInGroup('b')).toBe(false);
+    expect(field.isInGroup('c')).toBe(false);
+    expect(stringifyType(field.type)).toBe(`string | number`);
+
+    const field2 = schema.getProperty('field2');
+    expect(field2.getGroups()).toEqual(['a', 'b']);
+    expect(field2.isInGroup('a')).toBe(true);
+    expect(field2.isInGroup('b')).toBe(true);
+    expect(field2.isInGroup('c')).toBe(false);
+    expect(stringifyType(field2.type)).toBe(`string | number`);
+});