@tsed/json-mapper 8.11.1 → 8.11.2-rc.1

package/src/domain/JsonDeserializer.ts

@@ -1,402 +0,0 @@
-import {classOf, isArray, isBoolean, isClass, isEmpty, isNil, nameOf, objectKeys, Type} from "@tsed/core";
-import {getPropertiesStores, JsonClassStore, JsonEntityStore, JsonParameterStore, JsonPropertyStore} from "@tsed/schema";
-
-import {alterAfterDeserialize} from "../hooks/alterAfterDeserialize.js";
-import {alterBeforeDeserialize} from "../hooks/alterBeforeDeserialize.js";
-import {alterOnDeserialize} from "../hooks/alterOnDeserialize.js";
-import {JsonDeserializerOptions} from "./JsonDeserializerOptions.js";
-import {CachedJsonMapper, JsonMapperCompiler} from "./JsonMapperCompiler.js";
-import {JsonMapperSettings} from "./JsonMapperSettings.js";
-import {getJsonMapperTypes} from "./JsonMapperTypesContainer.js";
-import {Writer} from "./Writer.js";
-
-function isDeserializable(obj: any, options: JsonDeserializerOptions) {
-  if ((!!options.collectionType && isNil(obj)) || obj === undefined) {
-    return false;
-  }
-
-  return !(isEmpty(options.type) || (options.type === Object && !options.collectionType));
-}
-
-function varKey(k: string) {
-  return `__${k}`;
-}
-
-function mapParamStoreOptions(store: JsonParameterStore, options: JsonDeserializerOptions) {
-  return {
-    ...options,
-    store: undefined,
-    type: store.getBestType(),
-    collectionType: store.collectionType,
-    groups: store.parameter.groups,
-    // genericTypes: store.nestedGenerics[0],
-    generics: store.nestedGenerics
-  };
-}
-
-function getGenericIndex(propertyStore: JsonPropertyStore) {
-  return propertyStore.parent.schema.genericLabels.indexOf(propertyStore.itemSchema.genericType);
-}
-
-export class JsonDeserializer extends JsonMapperCompiler<JsonDeserializerOptions> {
-  /**
-   * Cached classes by his id
-   * @protected
-   */
-  protected constructors: Record<string, Type<any>> = {};
-
-  constructor() {
-    super();
-
-    this.addGlobal("newInstanceOf", this.newInstanceOf.bind(this));
-    this.addGlobal("alterBeforeDeserialize", this.alterBeforeDeserialize.bind(this));
-    this.addGlobal("alterAfterDeserialize", this.alterAfterDeserialize.bind(this));
-
-    this.addTypeMapper(Object, this.mapObject.bind(this));
-    this.addTypeMapper(Array, this.mapArray.bind(this));
-    this.addTypeMapper(Map, this.mapMap.bind(this));
-    this.addTypeMapper(Set, this.mapSet.bind(this));
-    this.addTypeMapper("ObjectId", (value: any) => String(value));
-  }
-
-  map<Model = any>(input: any, options: JsonDeserializerOptions = {}): Model {
-    options = this.mapOptions(options);
-
-    if (!isDeserializable(input, options)) {
-      return input;
-    }
-
-    if (!options.collectionType && isArray(input)) {
-      options.collectionType = Array;
-    }
-
-    const model = options.type || classOf(input);
-
-    const mapper = this.compile(model, options.groups!);
-
-    if (options.collectionType) {
-      const collectionMapper = this.compile(options.collectionType, options.groups!);
-      return collectionMapper.fn(input, {...options, id: mapper.id});
-    }
-
-    return mapper.fn(input, this.createContext(options));
-  }
-
-  compile(model: Type<any>, groups: false | string[]): CachedJsonMapper<JsonDeserializerOptions> {
-    if ([WeakMap, WeakSet].includes(model)) {
-      throw new Error(`${nameOf(model)} is not supported by JsonMapper.`);
-    }
-
-    return super.compile(model, groups);
-  }
-
-  eval(
-    mapper: string,
-    {
-      id,
-      groupsId,
-      model
-    }: {
-      id: string;
-      model: Type<any>;
-      groupsId: string;
-    }
-  ): CachedJsonMapper<JsonDeserializerOptions> {
-    this.constructors[id] = model;
-
-    return super.eval(mapper, {id, groupsId, model});
-  }
-
-  protected newInstanceOf(id: string, obj: any, options: any) {
-    try {
-      return new this.constructors[id](options.disableUnsecureConstructor ? {} : obj);
-    } catch (er) {
-      return obj;
-    }
-  }
-
-  protected createMapper(model: Type<any>, id: string, groups: false | string[]): string {
-    const entity = JsonEntityStore.from(model);
-    const properties = new Set<string>();
-    const schemaProperties = [...getPropertiesStores(entity).values()];
-
-    const writer = new Writer().arrow("input", "options");
-
-    writer.if("isNil(input)").return("input");
-
-    if (entity.schema.hasDiscriminator) {
-      writer.add(this.mapDiscriminator(entity, groups));
-    }
-
-    // pre hook
-    if (entity.schema.$hooks?.has("beforeDeserialize")) {
-      this.schemes[id] = entity.schema;
-      writer.set("input", `alterBeforeDeserialize('${id}', input, options)`);
-    }
-
-    // generics and options
-    writer.const("generics", "options.generics[0]");
-
-    if (entity.schema.genericLabels?.length) {
-      writer.set("options", "{...options, self: input, generics: [...options.generics].slice(1)}");
-    } else {
-      writer.set("options", "{...options, self: input}");
-    }
-
-    writer.const("obj", `newInstanceOf('${id}', input, options)`);
-
-    // properties
-    writer.add(
-      ...schemaProperties.flatMap((propertyStore) => {
-        const key = propertyStore.propertyName;
-
-        // TODO V8 add this line: properties.add(key as string);
-        properties.add(String(propertyStore.parent.schema.getAliasOf(key) || key));
-
-        if (
-          (propertyStore.schema?.$ignore && isBoolean(propertyStore.schema?.$ignore)) ||
-          propertyStore.isGetterOnly() ||
-          (propertyStore.schema?.$hooks?.has("groups") && this.alterGroups(propertyStore.schema, groups))
-        ) {
-          return;
-        }
-
-        return this.mapProperty(propertyStore, id, groups);
-      })
-    );
-
-    // additional properties
-    writer.add(this.mapAdditionalProperties(entity, properties, groups));
-
-    // post hook
-    if (entity.schema.$hooks?.has("afterDeserialize")) {
-      this.schemes[id] = entity.schema;
-
-      return writer.return(`alterAfterDeserialize('${id}', obj, options)`).root().toString();
-    }
-
-    return writer.return("obj").root().toString();
-  }
-
-  protected alterValue(schemaId: string, value: any, options: JsonDeserializerOptions): any {
-    return alterOnDeserialize(this.schemes[schemaId], value, options as any);
-  }
-
-  private mapDiscriminator(entity: JsonClassStore, groups: false | string[]) {
-    const writer = new Writer();
-    const discriminator = entity.schema.discriminator();
-
-    const sw = writer.switch(`input['${discriminator.propertyName}']`);
-
-    discriminator.values.forEach((value, kind) => {
-      const nestedMapper = this.compile(value, groups);
-
-      sw.case(`'${kind}'`).returnCallMapper(nestedMapper.id, "input");
-    });
-
-    return writer;
-  }
-
-  private mapProperty(propertyStore: JsonPropertyStore, id: string, groups: false | string[]) {
-    const key = String(propertyStore.propertyKey);
-    const aliasKey: string = String(propertyStore.parent.schema.getAliasOf(key) || key);
-    const schemaId = this.getSchemaId(id, key);
-    const format = propertyStore.itemSchema.get("format");
-    const formatOpts = format && `options: {format: '${format}'}`;
-
-    let writer = new Writer().add(`// Map ${key} ${id} ${groups || ""}`);
-    const pick = key !== aliasKey ? `options.useAlias ? '${aliasKey}' : '${key}'` : `'${key}'`;
-
-    // ignore hook (deprecated)
-    if (propertyStore.schema?.$hooks?.has("ignore")) {
-      this.schemes[schemaId] = propertyStore.schema;
-
-      writer = writer.if(`!alterIgnore('${schemaId}', {...options, self: input})`);
-    }
-
-    // pre hook
-    const hasDeserializer = propertyStore.schema?.$hooks?.has("onDeserialize");
-    let getter = `input[${pick}]`;
-
-    if (hasDeserializer) {
-      this.schemes[schemaId] = propertyStore.schema;
-      const opts = Writer.options(formatOpts);
-
-      getter = `alterValue('${schemaId}', input[${pick}], ${opts})`;
-    }
-
-    const ifWriter = writer.set(`let ${varKey(key)}`, getter).if(`${varKey(key)} !== undefined`);
-
-    const fill = this.getPropertyFiller(propertyStore, id, groups, formatOpts);
-
-    if (hasDeserializer) {
-      fill(ifWriter.if(`${varKey(key)} === input.${key}`));
-    } else {
-      fill(ifWriter);
-    }
-
-    ifWriter.set(`obj.${key}`, varKey(key));
-
-    if (groups && groups.includes("partial")) {
-      ifWriter.else().add(`delete obj.${key}`);
-    }
-
-    return writer.root();
-  }
-
-  private getPropertyFiller(propertyStore: JsonPropertyStore, id: string, groups: false | string[], formatOpts: any) {
-    const key = String(propertyStore.propertyKey);
-    const schemaId = this.getSchemaId(id, key);
-    const generics = propertyStore.itemSchema.nestedGenerics;
-    const isGeneric = propertyStore.itemSchema.isGeneric && !generics?.length;
-
-    if (isGeneric) {
-      const index = getGenericIndex(propertyStore);
-      const opts = Writer.options(formatOpts, `type: generics[${index}]`);
-
-      return (writer: Writer) => writer.set(varKey(key), `compileAndMap(${varKey(key)}, ${opts})`);
-    }
-
-    const type = propertyStore.itemSchema.hasDiscriminator ? propertyStore.itemSchema.discriminator().base : propertyStore.getBestType();
-    const nestedMapper = this.compile(type, groups);
-
-    if (propertyStore.isCollection) {
-      return (writer: Writer) =>
-        writer.callMapper(nameOf(propertyStore.collectionType), varKey(key), `id: '${nestedMapper.id}'`, formatOpts);
-    }
-
-    if (generics?.length) {
-      this.schemes[schemaId] = propertyStore.schema;
-
-      return (writer: Writer) =>
-        writer.callMapper(nestedMapper.id, varKey(key), formatOpts, `generics: schemes['${schemaId}'].nestedGenerics`);
-    }
-
-    return (writer: Writer) => writer.callMapper(nestedMapper.id, varKey(key), formatOpts);
-  }
-
-  private mapOptions({groups, useAlias = true, types, ...options}: JsonDeserializerOptions<any, any>): JsonDeserializerOptions {
-    if (options.store instanceof JsonParameterStore) {
-      return this.mapOptions(mapParamStoreOptions(options.store, options));
-    }
-
-    const customMappers: Record<string, any> = {};
-    types = types || getJsonMapperTypes();
-
-    types.forEach((mapper, model) => {
-      if (![Array, Set, Map].includes(model as any)) {
-        const typeName = nameOf(model);
-
-        if (nameOf(model) in mapper) {
-          this.addTypeMapper(model as any, (mapper as any)[typeName].bind(mapper));
-        } else {
-          this.addTypeMapper(model as any, (value: any, options: any) =>
-            mapper.deserialize(value, {
-              ...options,
-              type: model
-            })
-          );
-        }
-      }
-    });
-
-    const strictGroups = options.strictGroups ?? JsonMapperSettings.strictGroups;
-
-    return {
-      ...options,
-      additionalProperties: options.additionalProperties ?? JsonMapperSettings.additionalProperties,
-      disableUnsecureConstructor: options.disableUnsecureConstructor ?? JsonMapperSettings.disableUnsecureConstructor,
-      groups: groups === undefined ? (strictGroups ? [] : false) : groups || false,
-      useAlias,
-      customMappers,
-      generics: options.generics || []
-    };
-  }
-
-  private mapAdditionalProperties(entity: JsonClassStore, properties: Set<string>, groups: string[] | false) {
-    const additionalProperties = entity.schema.get("additionalProperties");
-
-    const exclude = [...properties.values()].map((key) => `'${key}'`).join(", ");
-    const writer = new Writer();
-
-    writer.add("// add additional properties");
-    let each = writer.each("objectKeys(input)", ["key"]);
-
-    if (exclude.length) {
-      each = each.if(`![${exclude}].includes(key)`);
-    }
-
-    if (isClass(additionalProperties)) {
-      const nestedMapper = this.compile(additionalProperties.getComputedType(), groups);
-
-      each.set("obj[key]", Writer.mapper(nestedMapper.id, "input[key]", "options"));
-
-      return writer;
-    }
-
-    if (additionalProperties) {
-      each.set("obj[key]", "input[key]");
-
-      return writer;
-    }
-
-    // dynamic additional properties options
-    each.if(`options.additionalProperties && obj[key] === undefined`).set("obj[key]", "input[key]");
-
-    return writer;
-  }
-
-  private mapObject(input: any, options: JsonDeserializerOptions) {
-    return input;
-  }
-
-  private mapSet(input: any, options: JsonDeserializerOptions): Set<any> {
-    if (isNil(input)) {
-      return input;
-    }
-
-    const obj = new Set<any>();
-
-    objectKeys(input).forEach((key) => {
-      obj.add(this.mapItem(input[key], options));
-    });
-
-    return obj;
-  }
-
-  private mapArray(input: any, options: JsonDeserializerOptions) {
-    if (isNil(input)) {
-      return input;
-    }
-
-    return [].concat(input).map((item: any) => {
-      return this.mapItem(item, options);
-    });
-  }
-
-  private mapMap(input: any, options: JsonDeserializerOptions): Map<string, any> {
-    if (isNil(input)) {
-      return input;
-    }
-
-    const obj = new Map<string, any>();
-
-    objectKeys(input).forEach((key) => {
-      obj.set(key, this.mapItem(input[key], options));
-    });
-
-    return obj;
-  }
-
-  private mapItem(input: any, {id, ...options}: JsonDeserializerOptions) {
-    return this.execMapper(id, input, options);
-  }
-
-  private alterBeforeDeserialize(schemaId: string, value: any, options: JsonDeserializerOptions): any {
-    return alterBeforeDeserialize(value, this.schemes[schemaId], options);
-  }
-
-  private alterAfterDeserialize(schemaId: string, value: any, options: JsonDeserializerOptions): any {
-    return alterAfterDeserialize(value, this.schemes[schemaId], options);
-  }
-}

package/src/domain/JsonDeserializerOptions.ts

@@ -1,31 +0,0 @@
-import {MetadataTypes, Type} from "@tsed/core";
-import {JsonEntityStore} from "@tsed/schema";
-
-import {JsonMapperMethods} from "../interfaces/JsonMapperMethods.js";
-import {JsonMapperGlobalOptions} from "./JsonMapperGlobalOptions.js";
-
-export interface JsonDeserializerOptions<T = any, C = any> extends MetadataTypes<T, C>, JsonMapperGlobalOptions {
-  /**
-   * Types used to map complex types (Symbol, Array, Set, Map)
-   */
-  types?: Map<Type | Symbol | string, JsonMapperMethods>;
-  /**
-   * useAlias mapping
-   */
-  useAlias?: boolean;
-  /**
-   * Use the store which have all metadata to deserialize correctly the model. This
-   * property is useful when you deal with metadata parameters.
-   */
-  store?: JsonEntityStore;
-  /**
-   *
-   */
-  groups?: string[] | false;
-  /**
-   * Add types to deserialize a module using generics feature.
-   */
-  generics?: Type[][];
-
-  [key: string]: any;
-}

package/src/domain/JsonMapperCompiler.ts

@@ -1,247 +0,0 @@
-import {
-  ancestorsOf,
-  classOf,
-  getRandomId,
-  hasJsonMethod,
-  isClass,
-  isCollection,
-  isDate,
-  isMomentObject,
-  isMongooseObject,
-  isNil,
-  isObject,
-  isObjectID,
-  isString,
-  nameOf,
-  objectKeys,
-  Type
-} from "@tsed/core";
-import {JsonSchema} from "@tsed/schema";
-
-export type JsonMapperCallback<Options> = (input: any, options?: Options) => any;
-export type CachedJsonMapper<Options> = {
-  id: string;
-  fn: JsonMapperCallback<Options>;
-};
-
-export type CachedGroupsJsonMapper<Options> = Map<string, CachedJsonMapper<Options>>;
-
-export abstract class JsonMapperCompiler<Options extends Record<string, any> = any> {
-  /**
-   * Cached mappers metadata
-   * @protected
-   */
-  protected cache = new Map<Type<any> | string, CachedGroupsJsonMapper<Options>>();
-  /**
-   * Cached executable mappers by his id
-   * @protected
-   */
-  protected mappers: Record<string, JsonMapperCallback<Options>> = {};
-  /**
-   * Cached schemas
-   * @protected
-   */
-  protected schemes: Record<string, any> = {};
-
-  /**
-   * Cached classes by his id
-   * @protected
-   */
-  protected constructors: Record<string, Type<any>> = {};
-  /**
-   * Global variables available in the mapper
-   * @protected
-   */
-  protected globals: Record<string, any> = {
-    isCollection,
-    isClass,
-    isObject,
-    classOf,
-    nameOf,
-    hasJsonMethod,
-    isMongooseObject,
-    isNil,
-    isDate,
-    objectKeys,
-    isMomentObject
-  };
-
-  constructor() {
-    this.addGlobal("alterIgnore", this.alterIgnore.bind(this));
-    this.addGlobal("alterValue", this.alterValue.bind(this));
-    this.addGlobal("execMapper", this.execMapper.bind(this));
-    this.addGlobal("compileAndMap", this.map.bind(this));
-  }
-
-  addTypeMapper(model: Type<any> | string, fn: any) {
-    const id = nameOf(model);
-
-    this.cache.set(
-      model,
-      new Map().set("typeMapper", {
-        id,
-        fn
-      })
-    );
-
-    this.mappers[id] = fn;
-
-    return this;
-  }
-
-  removeTypeMapper(model: Type<any> | string) {
-    const store = this.cache.get(model);
-
-    if (store) {
-      const {id} = store.get("typeMapper")!;
-
-      delete this.mappers[id];
-      this.cache.delete(model);
-    }
-  }
-
-  addGlobal(key: string, value: any) {
-    this.globals[key] = value;
-
-    return this;
-  }
-
-  eval(mapper: string, {id, groupsId, model}: {id: string; model: Type<any> | string; groupsId: string}) {
-    this.addGlobal("cache", this.cache);
-
-    const {globals, schemes} = this;
-
-    const injectGlobals = Object.keys(globals)
-      .map((name) => {
-        return `const ${name} = globals.${name};`;
-      })
-      .join("\n");
-
-    eval(`${injectGlobals};
-
-    cache.get(model).set(groupsId, { id: '${id}', fn: ${mapper} })`);
-
-    const store = this.cache.get(model)!.get(groupsId)!;
-
-    this.mappers[id] = store.fn;
-
-    return store;
-  }
-
-  createContext(options: Options) {
-    const {cache} = this;
-
-    return {
-      ...options,
-      cache
-    };
-  }
-
-  compile(
-    model: Type<any> | string,
-    groups: false | string[],
-    opts: {
-      mapper?: any;
-    } = {}
-  ): CachedJsonMapper<Options> {
-    const token = isString(model) ? model : this.getType(model);
-
-    const groupsId = this.getGroupsId(groups);
-    let storeGroups = this.cache.get(token) || this.cache.get(nameOf(token));
-
-    if (!storeGroups) {
-      storeGroups = new Map();
-      this.cache.set(token, storeGroups);
-    }
-
-    if (storeGroups.has("typeMapper")) {
-      return storeGroups.get("typeMapper")!;
-    }
-
-    // generate mapper for the given groups
-    if (!storeGroups.has(groupsId)) {
-      const id = this.getId(token, groupsId);
-
-      // prevent circular dependencies
-      storeGroups.set(groupsId, {
-        id
-      } as any);
-
-      const mapper = opts.mapper ? opts.mapper(id, groups) : this.createMapper(token as Type<any>, id, groups);
-
-      try {
-        return this.eval(mapper, {id, model: token, groupsId});
-      } catch (err) {
-        throw new Error(`Fail to compile mapper for ${nameOf(model)}. See the error above: ${err.message}.\n${mapper}`);
-      }
-    }
-
-    return storeGroups!.get(groupsId)!;
-  }
-
-  protected execMapper(id: string, value: any, options: Options) {
-    if (isObjectID(value)) {
-      return value.toString();
-    }
-
-    return this.mappers[id || nameOf(classOf(value))](value, options);
-  }
-
-  protected abstract map(input: any, options: Options): any;
-
-  protected abstract alterValue(schemaId: string, value: any, options: Options): any;
-
-  protected abstract createMapper(model: Type<any>, id: string, groups: false | string[]): string;
-
-  protected getType(model: Type<any>) {
-    if (!model) {
-      return Object;
-    }
-
-    if (isClass(model) && !isCollection(model)) {
-      const type = [Array, Map, Set].find((t) => ancestorsOf(model).includes(t));
-
-      if (type) {
-        return type;
-      }
-    }
-
-    return model;
-  }
-
-  protected alterIgnore(id: string, options: Options) {
-    let result = this.schemes[id]?.$hooks?.alter("ignore", false, [options]);
-
-    if (result) {
-      return result;
-    }
-  }
-
-  protected alterGroups(schema: JsonSchema, groups: false | string[]) {
-    if (groups !== false) {
-      return schema.$hooks.alter("groups", false, [groups]);
-    }
-
-    return false;
-  }
-
-  protected getGroupsId(groups: false | string[]) {
-    if (groups === false) {
-      return "default";
-    }
-
-    if (groups.length === 0) {
-      return "-";
-    }
-
-    return groups.join(",");
-  }
-
-  protected getId(model: Type<any> | string, groupsId: string) {
-    return `${isString(model) ? model : nameOf(model)}:${getRandomId()}:${groupsId}`;
-  }
-
-  protected getSchemaId(id: string, propertyKey: string) {
-    return `${id}:${propertyKey}`;
-  }
-}

package/src/domain/JsonMapperGlobalOptions.ts

@@ -1,14 +0,0 @@
-export interface JsonMapperGlobalOptions {
-  /**
-   * JsonMapper additional property policy. (see [JsonMapper](/docs/json-mapper.md))
-   */
-  additionalProperties?: boolean;
-  /**
-   * Disable the unsecure constructor injection when the deserialize function is used (by default: false)
-   */
-  disableUnsecureConstructor?: boolean;
-  /**
-   * Enable strict Groups configuration when the `options.groups` is undefined. (by default: false)
-   */
-  strictGroups?: boolean;
-}

package/src/domain/JsonMapperSettings.ts

@@ -1,7 +0,0 @@
-import type {JsonMapperGlobalOptions} from "./JsonMapperGlobalOptions.js";
-
-export const JsonMapperSettings: JsonMapperGlobalOptions = {
-  disableUnsecureConstructor: true,
-  additionalProperties: false,
-  strictGroups: false
-};