Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

feat(type) add some options to the JIT compiler #546

Open
wants to merge 8 commits into
base: master
Choose a base branch
from
Open

feat(type) add some options to the JIT compiler #546

Show file tree
Hide file tree
Changes from 4 commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
28c6929
feat(type): ddd options to the JIT compiler to skip omitting errors a…
M-jerez Feb 1, 2024
6e07691
feat(type): fix few failing test for quick JIT compiler. run serializ…
M-jerez Feb 1, 2024
4d9340c
feat(type): change Serializer.options name to Serializer.jitOptions …
M-jerez Feb 1, 2024
0900239
feat(type): update unit test to use describe.each instead hand made f…
M-jerez Feb 1, 2024
4711e78
feat(type): add option to ignore grouping functionality on serialize …
M-jerez Feb 1, 2024
e5ba504
feat(type): optimise JIT nullable block
M-jerez Feb 1, 2024
69c8ce6
feat(type): fix JIT deserializer compilation for null and undefined v…
M-jerez Feb 2, 2024
088ca8e
feat(type): remove unnecessary names for unit test with describe.each
M-jerez Feb 2, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
26 changes: 13 additions & 13 deletions packages/type/src/serializer-facade.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,7 +24,7 @@ import { findMember, getTypeJitContainer, ReflectionKind, Type, TypeClass, TypeO
* @throws ValidationError if casting or validation fails
*/
export function cast<T>(data: JSONPartial<T> | unknown, options?: SerializationOptions, serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): T {
const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy);
const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy, undefined, undefined, serializerToUse.jitOptions.emitErrors);
const item = fn(data, options) as T;
assert(item, undefined, type);
return item;
Expand All @@ -34,7 +34,7 @@ export function cast<T>(data: JSONPartial<T> | unknown, options?: SerializationO
* Same as cast but returns a ready to use function. Used to improve performance.
*/
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);
const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy, undefined, undefined, serializerToUse.jitOptions.emitErrors);
return (data: JSONPartial<T> | unknown, options?: SerializationOptions) => {
const item = fn(data, options);
assert(item, undefined, type);
Expand All @@ -59,15 +59,15 @@ export function castFunction<T>(serializerToUse: Serializer = serializer, naming
* ```
*/
export function deserialize<T>(data: JSONPartial<T> | unknown, options?: SerializationOptions, serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): T {
const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy);
const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy, undefined, undefined, serializerToUse.jitOptions.emitErrors);
return fn(data, options) as T;
}

/**
* Same as deserialize but returns a ready to use function. Used to improve performance.
*/
export function deserializeFunction<T>(serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): SerializeFunction<any, T> {
return getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy);
return getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy, undefined, undefined, serializerToUse.jitOptions.emitErrors);
}

/**
Expand All @@ -77,21 +77,21 @@ export function deserializeFunction<T>(serializerToUse: Serializer = serializer,
export function patch<T>(data: DeepPartial<T>, options?: SerializationOptions, serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): (data: JSONPartial<T> | unknown) => T {
type = resolveReceiveType(type);
if (type.kind !== ReflectionKind.objectLiteral && type.kind !== ReflectionKind.class) throw new Error('patch() only works on object literals and classes');
return getPatchSerializeFunction(type, serializerToUse.deserializeRegistry, namingStrategy)(data, options);
return getPatchSerializeFunction(type, serializerToUse.deserializeRegistry, namingStrategy, serializerToUse.jitOptions.emitErrors)(data, options);
}

/**
* Create a serializer/deserializer function including validator for the given type for a patch structure.
* This is handy for deep patch structures like e.g '{user.address.street: "new street"}'.
*/
export function getPatchSerializeFunction(type: TypeClass | TypeObjectLiteral, registry: TemplateRegistry, namingStrategy: NamingStrategy = new NamingStrategy()):
export function getPatchSerializeFunction(type: TypeClass | TypeObjectLiteral, registry: TemplateRegistry, namingStrategy: NamingStrategy = new NamingStrategy(), emitErrors = true):
(data: any, state?: SerializationOptions, patch?: { normalizeArrayIndex: boolean }) => any {

const jitContainer = getTypeJitContainer(type);
const id = registry.id + '_' + namingStrategy.id + '_' + 'patch';
if (jitContainer[id]) return jitContainer[id];

const partialSerializer = getPartialSerializeFunction(type, registry, namingStrategy);
const partialSerializer = getPartialSerializeFunction(type, registry, namingStrategy, emitErrors);
// const partialValidator = getValidatorFunction(registry.serializer, getPartialType(type));

return jitContainer[id] = function (data: any, state?: SerializationOptions, patch?: { normalizeArrayIndex: boolean }) {
Expand Down Expand Up @@ -148,7 +148,7 @@ export function getPatchSerializeFunction(type: TypeClass | TypeObjectLiteral, r
}
}
if (newPath) {
result[newPath] = getSerializeFunction(currentType, registry, namingStrategy)(data[i], state);
result[newPath] = getSerializeFunction(currentType, registry, namingStrategy, undefined, undefined, emitErrors)(data[i], state);
// assert(result[newPath], undefined, currentType);
}
}
Expand Down Expand Up @@ -179,15 +179,15 @@ export function getPatchSerializeFunction(type: TypeClass | TypeObjectLiteral, r
* @throws ValidationError when serialization or validation fails.
*/
export function serialize<T>(data: T, options?: SerializationOptions, serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): JSONSingle<T> {
const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.serializeRegistry, namingStrategy);
const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.serializeRegistry, namingStrategy, undefined, undefined, serializerToUse.jitOptions.emitErrors);
return fn(data, options) as JSONSingle<T>;
}

/**
* Same as serialize but returns a ready to use function. Used to improve performance.
*/
export function serializeFunction<T>(serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): SerializeFunction<T> {
return getSerializeFunction(resolveReceiveType(type), serializerToUse.serializeRegistry, namingStrategy);
return getSerializeFunction(resolveReceiveType(type), serializerToUse.serializeRegistry, namingStrategy, undefined, undefined, serializerToUse.jitOptions.emitErrors);
}

/**
Expand All @@ -196,8 +196,8 @@ export function serializeFunction<T>(serializerToUse: Serializer = serializer, n
export function cloneClass<T>(target: T, options?: SerializationOptions): T {
const classType = getClassTypeFromInstance(target);
const type = typeInfer(classType);
const serialize = getSerializeFunction(type, serializer.serializeRegistry);
const deserialize = getSerializeFunction(type, serializer.deserializeRegistry);
const serialize = getSerializeFunction(type, serializer.serializeRegistry, undefined, undefined, undefined, serializer.jitOptions.emitErrors);
const deserialize = getSerializeFunction(type, serializer.deserializeRegistry, undefined, undefined, undefined, serializer.jitOptions.emitErrors);
return deserialize(serialize(target, options));
}

Expand All @@ -209,7 +209,7 @@ export function cloneClass<T>(target: T, options?: SerializationOptions): T {
* @throws ValidationError when serialization or validation fails.
*/
export function validatedDeserialize<T>(data: any, options?: SerializationOptions, serializerToUse: Serializer = serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>) {
const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy);
const fn = getSerializeFunction(resolveReceiveType(type), serializerToUse.deserializeRegistry, namingStrategy, undefined, undefined, serializerToUse.jitOptions.emitErrors);
const item = fn(data, options) as T;
assert(item, undefined, type);
return item;
Expand Down
Loading