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

package/src/domain/JsonSerializer.ts

@@ -1,371 +0,0 @@
-import {
-  classOf,
-  hasJsonMethod,
-  isArray,
-  isBoolean,
-  isClassObject,
-  isCollection,
-  isDate,
-  isMomentObject,
-  isMongooseObject,
-  isNil,
-  isObject,
-  isPrimitive,
-  nameOf,
-  Type
-} from "@tsed/core";
-import {getPropertiesStores, JsonClassStore, JsonEntityStore, JsonPropertyStore} from "@tsed/schema";
-
-import {alterOnSerialize} from "../hooks/alterOnSerialize.js";
-import {getObjectProperties} from "../utils/getObjectProperties.js";
-import {JsonMapperCompiler} from "./JsonMapperCompiler.js";
-import {JsonMapperSettings} from "./JsonMapperSettings.js";
-import {getJsonMapperTypes} from "./JsonMapperTypesContainer.js";
-import {JsonSerializerOptions} from "./JsonSerializerOptions.js";
-import {Writer} from "./Writer.js";
-
-const getCollectionType = (input: any) => {
-  return isArray(input) ? "Array" : input instanceof Set ? "Set" : input instanceof Map ? "Map" : undefined;
-};
-
-function getBestType(type: Type<any>, obj: any) {
-  const dataType = classOf(obj);
-
-  if (dataType && !isClassObject(dataType) && !isCollection(obj)) {
-    return dataType;
-  }
-
-  return type || Object;
-}
-
-function varKey(k: string) {
-  return `__${k}`;
-}
-
-export class JsonSerializer extends JsonMapperCompiler<JsonSerializerOptions> {
-  constructor() {
-    super();
-
-    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.addGlobal("mapJSON", this.mapJSON.bind(this));
-    this.addTypeMapper("ObjectId", (value: any) => String(value));
-  }
-
-  map(input: any, options: JsonSerializerOptions = {}) {
-    if (isNil(input)) {
-      return input;
-    }
-
-    options = this.mapOptions(options);
-
-    const model = getBestType(options.type, input);
-
-    const mapper = this.compile(model, options.groups);
-
-    return mapper.fn(input, this.createContext(options));
-  }
-
-  protected alterValue(schemaId: string, value: any, options: JsonSerializerOptions): any {
-    return alterOnSerialize(this.schemes[schemaId], value, options as any);
-  }
-
-  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");
-
-    // prepare options
-    writer.const("obj", "{}");
-    writer.set("options", "{...options, self: input}");
-
-    // detect some special case
-    writer.add(this.mapPrecondition(id));
-
-    if (!schemaProperties.length) {
-      return writer.return("isObject(input) ? {...input} : input").root().toString();
-    }
-
-    // properties
-    writer.add(
-      ...schemaProperties.flatMap((propertyStore) => {
-        properties.add(propertyStore.propertyKey as string);
-
-        if (
-          (propertyStore.schema?.$ignore && isBoolean(propertyStore.schema?.$ignore)) ||
-          (propertyStore.schema?.$hooks?.has("groups") && this.alterGroups(propertyStore.schema, groups))
-        ) {
-          return;
-        }
-
-        return this.mapProperty(propertyStore, id, groups);
-      })
-    );
-
-    // discriminator
-    writer.add(this.mapDiscriminatorKeyValue(entity));
-
-    // additional properties
-    writer.add(this.mapAdditionalProperties(entity, properties));
-
-    return writer.return("obj").root().toString();
-  }
-
-  private mapOptions({groups, useAlias = true, types, ...options}: JsonSerializerOptions<any, any>): JsonSerializerOptions {
-    const customMappers: Record<string, any> = {};
-    types = types || getJsonMapperTypes();
-
-    types.forEach((mapper, model) => {
-      if (![Array, Set, Map].includes(model as any)) {
-        this.addTypeMapper(model as any, (value: any, options: any) =>
-          mapper.serialize(value, {
-            ...options,
-            type: model
-          })
-        );
-      }
-    });
-
-    const strictGroups = options.strictGroups ?? JsonMapperSettings.strictGroups;
-
-    return {
-      ...options,
-      groups: groups === undefined ? (strictGroups ? [] : false) : groups || false,
-      useAlias,
-      customMappers
-    };
-  }
-
-  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 || ""}`);
-
-    // 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 hasSerializer = propertyStore.schema?.$hooks?.has("onSerialize");
-    let getter = `input.${key}`;
-
-    if (hasSerializer) {
-      this.schemes[schemaId] = propertyStore.schema;
-      const opts = Writer.options(formatOpts);
-
-      getter = `alterValue('${schemaId}', input.${key}, ${opts})`;
-    }
-
-    writer = writer.set(`let ${varKey(key)}`, getter).if(`${varKey(key)} !== undefined`);
-
-    const fill = this.getPropertyFiller(propertyStore, key, groups, formatOpts);
-
-    if (hasSerializer) {
-      fill(writer.if(`${varKey(key)} === input.${key}`));
-    } else {
-      fill(writer);
-    }
-
-    if (aliasKey !== key) {
-      writer.set(`obj[options.useAlias ? '${aliasKey}' : '${key}']`, varKey(key));
-    } else {
-      writer.set(`obj.${key}`, varKey(key));
-    }
-
-    return writer.root();
-  }
-
-  private getPropertyFiller(propertyStore: JsonPropertyStore, key: string, groups: false | string[], formatOpts: any) {
-    const isGeneric = propertyStore.itemSchema.isGeneric;
-    const hasDiscriminator = propertyStore.itemSchema.hasDiscriminator;
-
-    if (propertyStore.isCollection) {
-      const type = propertyStore.getBestType();
-      let nestedMapper: any;
-
-      if (hasDiscriminator) {
-        const targetName = propertyStore.parent.targetName;
-
-        nestedMapper = this.compile(`Discriminator:${targetName}:${key}`, groups, {
-          mapper: () => this.createDiscriminatorMapper(propertyStore, groups)
-        });
-      } else {
-        nestedMapper = isGeneric ? {id: ""} : this.compile(type, groups);
-      }
-
-      return (writer: Writer) =>
-        writer.callMapper(nameOf(propertyStore.collectionType), varKey(key), `id: '${nestedMapper.id}'`, formatOpts);
-    }
-
-    if (isGeneric) {
-      return (writer: Writer) => writer.set(varKey(key), `compileAndMap(${varKey(key)}, options)`);
-    }
-
-    let nestedMapper: any;
-    if (hasDiscriminator) {
-      const targetName = propertyStore.parent.targetName;
-
-      nestedMapper = this.compile(`Discriminator:${targetName}:${key}`, groups, {
-        mapper: () => this.createDiscriminatorMapper(propertyStore, groups)
-      });
-    } else {
-      nestedMapper = this.compile(propertyStore.getBestType(), groups);
-    }
-
-    return (writer: Writer) => writer.callMapper(nestedMapper.id, varKey(key), formatOpts);
-  }
-
-  private createDiscriminatorMapper(propertyStore: JsonPropertyStore, groups: false | string[]) {
-    const discriminator = propertyStore.itemSchema.discriminator();
-    const writer = new Writer().arrow("input", "options");
-
-    const sw = writer.switch(`nameOf(classOf(input))`);
-
-    discriminator.values.forEach((value, kind) => {
-      const nestedMapper = this.compile(value, groups);
-
-      sw.case(`'${nameOf(value)}'`).returnCallMapper(nestedMapper.id, "input");
-    });
-
-    return writer.root().toString();
-  }
-
-  private mapPrecondition(id: string) {
-    const writer = new Writer();
-
-    writer.if("input && isCollection(input)").return(Writer.mapperFrom("input", `{...options, id: '${id}'}`));
-
-    writer.if("hasJsonMethod(input)").return(`mapJSON(input, {...options, id: '${id}'})`);
-
-    return writer;
-  }
-
-  private mapDiscriminatorKeyValue(entity: JsonClassStore) {
-    if (entity.discriminatorAncestor) {
-      const discriminator = entity.discriminatorAncestor.schema.discriminator();
-      const type = discriminator.getDefaultValue(entity.target);
-
-      if (type) {
-        const writer = new Writer();
-        writer.if(`!obj.${discriminator.propertyName}`).set(`obj.${discriminator.propertyName}`, `'${type}'`);
-
-        return writer;
-      }
-    }
-  }
-
-  private mapAdditionalProperties(entity: JsonClassStore, properties: Set<string>) {
-    const additionalProperties = !!entity.schema.get("additionalProperties");
-
-    if (additionalProperties) {
-      const exclude = [...properties.values()].map((key) => `'${key}'`).join(", ");
-      const writer = new Writer();
-      writer.add("// add additional properties");
-      writer.each("objectKeys(input)", ["key"]).if(`![${exclude}].includes(key)`).set("obj[key]", "input[key]");
-
-      return writer;
-    }
-  }
-
-  private mapObject(input: any, {type, ...options}: JsonSerializerOptions) {
-    if ((input && isPrimitive(input)) || !input) {
-      // prevent mongoose mapping error
-      return input;
-    }
-
-    if (input && isCollection(input)) {
-      return this.execMapper(getCollectionType(input)!, input, options);
-    }
-
-    if (hasJsonMethod(input)) {
-      return this.mapJSON(input, options);
-    }
-
-    return getObjectProperties(input)
-      .filter(([, value]) => value !== undefined)
-      .reduce((obj, [key, value]) => {
-        if (isNil(value)) {
-          return {
-            ...obj,
-            [key]: value
-          };
-        }
-
-        const mapper = this.compile(classOf(value), options.groups);
-
-        return {
-          ...obj,
-          [key]: mapper.fn(value, options)
-        };
-      }, {});
-  }
-
-  private mapSet(input: any, options: JsonSerializerOptions) {
-    if (isNil(input)) {
-      return input;
-    }
-    return [...input.values()].map((item) => {
-      return this.mapItem(item, options);
-    });
-  }
-
-  private mapArray(input: any, options: JsonSerializerOptions) {
-    if (isNil(input)) {
-      return input;
-    }
-
-    return [].concat(input).map((item: any) => {
-      return this.mapItem(item, options);
-    });
-  }
-
-  private mapMap(input: any, options: JsonSerializerOptions) {
-    if (isNil(input)) {
-      return input;
-    }
-
-    return [...input.entries()].reduce((obj, [key, item]) => {
-      return {
-        ...obj,
-        [key]: this.mapItem(item, options)
-      };
-    }, {});
-  }
-
-  private mapItem(input: any, {id, ...options}: JsonSerializerOptions) {
-    if (!id && input) {
-      return this.compile(classOf(input), options.groups).fn(input, options);
-    }
-
-    return id ? this.execMapper(id, input, options) : input;
-  }
-
-  private mapJSON(input: any, {id, ...options}: JsonSerializerOptions) {
-    if (isMongooseObject(input)) {
-      return input.toJSON({...options, self: undefined, id});
-    }
-
-    id = id || nameOf(classOf(input));
-
-    if (this.mappers[id] && (isDate(input) || isMomentObject(input))) {
-      return this.execMapper(id, input, options);
-    }
-
-    input = input.toJSON();
-
-    return isObject(input) ? this.execMapper(id, input, options) : input;
-  }
-}

package/src/domain/JsonSerializerOptions.ts

@@ -1,17 +0,0 @@
-import {MetadataTypes, Type} from "@tsed/core";
-
-import {JsonMapperMethods} from "../interfaces/JsonMapperMethods.js";
-import {JsonMapperGlobalOptions} from "./JsonMapperGlobalOptions.js";
-
-export interface JsonSerializerOptions<T = any, C = any> extends MetadataTypes<T, C>, Pick<JsonMapperGlobalOptions, "strictGroups"> {
-  /**
-   * Types used to map complex types (Symbol, Number, String, etc...)
-   */
-  types?: Map<Type<any> | Symbol | string, JsonMapperMethods>;
-  /**
-   * useAlias mapping
-   */
-  useAlias?: boolean;
-
-  [key: string]: any;
-}

package/src/domain/Writer.spec.ts

@@ -1,11 +0,0 @@
-import {Writer} from "./Writer.js";
-
-describe("Writer", () => {
-  it("should generate code for if/else condition", () => {
-    const writer = new Writer();
-
-    writer.if("condition").add("return true;").else().add("return false;");
-
-    expect(writer.toString()).toMatchSnapshot();
-  });
-});

package/src/domain/Writer.ts

@@ -1,181 +0,0 @@
-export class Writer {
-  static object = {
-    assign(...args: string[]) {
-      return `{ ${args.filter(Boolean).join(", ")} }`;
-    }
-  };
-
-  protected _root?: Writer;
-  protected body: (string | Writer)[] = [];
-  private _indent: boolean;
-
-  constructor(root?: Writer) {
-    this._root = root;
-  }
-
-  static indent(lines: string[]) {
-    return lines.map((p) => `\t${p}`);
-  }
-
-  static mapper(mapperId: string, key: string, options: string) {
-    return `execMapper('${mapperId}', ${key}, ${options})`;
-  }
-
-  static mapperFrom(key: string, options: string) {
-    return `execMapper(nameOf(classOf(${key})), ${key}, ${options})`;
-  }
-
-  static options(...args: string[]) {
-    args = args.filter(Boolean);
-    return !args.length ? "options" : Writer.object.assign("...options", ...args);
-  }
-
-  add(...lines: (undefined | string | Writer)[]) {
-    lines = lines.filter((line) => line !== undefined);
-
-    lines.length && this.body.push(...(lines as string | Writer[]));
-
-    return this;
-  }
-
-  arrow(...args: string[]) {
-    this.add(`(${args}) => {`);
-
-    const writer = this.new();
-
-    this.add("}");
-
-    return writer;
-  }
-
-  build(): string[] {
-    const result = this.body.flatMap((line) => {
-      return line instanceof Writer ? line.build() : line;
-    });
-
-    return this._indent ? result.map((item) => "\t" + item) : result;
-  }
-
-  callMapper(id: string, key: string, ...options: string[]) {
-    return this.set(key, Writer.mapper(id, key, Writer.options(...options)));
-  }
-
-  returnCallMapper(id: string, key: string, ...options: string[]) {
-    return this.return(Writer.mapper(id, key, Writer.options(...options)));
-  }
-
-  const(name: string, line: string) {
-    this.add(`const ${name} = ${line};`);
-    return this;
-  }
-
-  each(iterable: string, args: string[] = []) {
-    const writer = this.add(iterable + ".forEach((" + args.join(", ") + ") => {").new();
-
-    this.add("});");
-
-    return writer;
-  }
-
-  if(condition: string) {
-    const writer = new IfWriter(condition, this);
-
-    this.add(writer);
-
-    return writer;
-  }
-
-  switch(input: string) {
-    const sw = new SwitchWriter(input);
-
-    this.add(sw);
-
-    return sw;
-  }
-
-  indent(indent: boolean) {
-    this._indent = indent;
-    return this;
-  }
-
-  new(indent = true) {
-    const writer = new Writer(this.root());
-    writer.indent(indent);
-    this.add(writer);
-
-    return writer;
-  }
-
-  return(line: string) {
-    this.add(`return ${line};`);
-    return this.root();
-  }
-
-  root() {
-    return this._root || this;
-  }
-
-  set(left: string, right: string) {
-    this.add(`${left} = ${right};`);
-    return this;
-  }
-
-  toString() {
-    return this.build().join("\n");
-  }
-}
-
-class IfWriter extends Writer {
-  protected elseWriter?: Writer;
-
-  constructor(
-    protected condition: string,
-    root: Writer
-  ) {
-    super();
-    this._root = root;
-  }
-
-  else() {
-    const writer = new Writer(this._root);
-
-    this.elseWriter = writer;
-
-    return writer;
-  }
-
-  build() {
-    return [
-      `if (${this.condition}) {`,
-      ...Writer.indent(super.build()),
-      "}",
-      this.elseWriter ? [`else {`, ...Writer.indent(this.elseWriter.build()), "}"] : []
-    ].flat();
-  }
-}
-
-class SwitchWriter extends Writer {
-  #map = new Map<string, Writer>();
-
-  constructor(private input: string) {
-    super();
-  }
-
-  case(condition: string) {
-    const writer = new Writer();
-    this.#map.set(condition, writer);
-    return writer;
-  }
-
-  build() {
-    return [
-      `switch (${this.input}) {`,
-      ...Writer.indent(
-        Array.from(this.#map.entries()).flatMap(([condition, writer]) => {
-          return [condition === "default" ? `${condition}:` : `case ${condition}:`, ...Writer.indent(writer.build())];
-        })
-      ),
-      "}"
-    ].flat();
-  }
-}

package/src/domain/__snapshots__/Writer.spec.ts.snap

@@ -1,10 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`Writer > should generate code for if/else condition 1`] = `
-"if (condition) {
-	return true;
-}
-else {
-	return false;
-}"
-`;

package/src/hooks/alterAfterDeserialize.ts

@@ -1,5 +0,0 @@
-import type {Hooks} from "@tsed/hooks";
-
-export function alterAfterDeserialize(data: any, schema: {$hooks: Hooks}, options: any) {
-  return schema?.$hooks?.alter("afterDeserialize", data, [options]);
-}

package/src/hooks/alterBeforeDeserialize.ts

@@ -1,5 +0,0 @@
-import type {Hooks} from "@tsed/hooks";
-
-export function alterBeforeDeserialize(data: any, schema: {$hooks: Hooks}, options: any) {
-  return schema?.$hooks?.alter("beforeDeserialize", data, [options]);
-}

package/src/hooks/alterOnDeserialize.ts

@@ -1,5 +0,0 @@
-import {JsonHookContext, JsonSchema} from "@tsed/schema";
-
-export function alterOnDeserialize(schema: JsonSchema, value: any, options: JsonHookContext) {
-  return schema.$hooks.alter("onDeserialize", value, [options]);
-}

package/src/hooks/alterOnSerialize.ts

@@ -1,5 +0,0 @@
-import {JsonHookContext, JsonSchema} from "@tsed/schema";
-
-export function alterOnSerialize(schema: JsonSchema, value: any, options: JsonHookContext) {
-  return schema.$hooks.alter("onSerialize", value, [options]);
-}

package/src/index.ts

@@ -1,28 +0,0 @@
-/**
- * @file Automatically generated by @tsed/barrels.
- */
-export * from "./components/DateMapper.js";
-export * from "./components/PrimitiveMapper.js";
-export * from "./components/SymbolMapper.js";
-export * from "./decorators/afterDeserialize.js";
-export * from "./decorators/beforeDeserialize.js";
-export * from "./decorators/jsonMapper.js";
-export * from "./decorators/onDeserialize.js";
-export * from "./decorators/onSerialize.js";
-export * from "./domain/JsonDeserializer.js";
-export * from "./domain/JsonDeserializerOptions.js";
-export * from "./domain/JsonMapperCompiler.js";
-export * from "./domain/JsonMapperGlobalOptions.js";
-export * from "./domain/JsonMapperSettings.js";
-export * from "./domain/JsonMapperTypesContainer.js";
-export * from "./domain/JsonSerializer.js";
-export * from "./domain/JsonSerializerOptions.js";
-export * from "./domain/Writer.js";
-export * from "./hooks/alterAfterDeserialize.js";
-export * from "./hooks/alterBeforeDeserialize.js";
-export * from "./hooks/alterOnDeserialize.js";
-export * from "./hooks/alterOnSerialize.js";
-export * from "./interfaces/JsonMapperMethods.js";
-export * from "./utils/deserialize.js";
-export * from "./utils/getObjectProperties.js";
-export * from "./utils/serialize.js";

package/src/interfaces/JsonMapperMethods.ts

@@ -1,32 +0,0 @@
-import {Type} from "@tsed/core";
-
-export interface JsonMapperCtx<T = any, C = any> {
-  collectionType: Type<C> | undefined;
-  type: Type<T> | T;
-  next: JsonMapperNext;
-  options: {
-    format?: string;
-  };
-}
-
-export interface JsonMapperNext {
-  (obj: any): any;
-}
-
-export interface JsonMapperMethods {
-  /**
-   *
-   * @param obj
-   * @param {JsonMapperNext} ctx
-   * @returns {any}
-   */
-  deserialize<T = any, C = any>(obj: any, ctx: JsonMapperCtx<T, C>): any;
-
-  /**
-   *
-   * @param obj
-   * @param ctx
-   * @returns {any}
-   */
-  serialize(obj: any, ctx: JsonMapperCtx<any>): any;
-}