Merge branch 'roypeled-type-metadata-storage_with_maps'

Author: kamilmysliwiec

packages/graphql/lib/schema-builder/collections/array-with-global-cache.collection.ts

@@ -0,0 +1,35 @@
+export class ArrayWithGlobalCacheCollection<T> {
+  private readonly internalArray: T[] = [];
+
+  constructor(private globalArray: Array<T>) {}
+
+  getAll() {
+    return this.internalArray;
+  }
+
+  push(...items: T[]): number {
+    this.globalArray.push(...items);
+    return this.internalArray.push(...items);
+  }
+
+  unshift(...items: T[]): number {
+    this.globalArray.unshift(...items);
+    return this.internalArray.unshift(...items);
+  }
+
+  reverse() {
+    return this.internalArray.reverse();
+  }
+
+  reduce<U>(
+    callbackfn: (
+      previousValue: U,
+      currentValue: T,
+      currentIndex: number,
+      array: T[],
+    ) => U,
+    initialValue: U,
+  ): U {
+    return this.internalArray.reduce(callbackfn, initialValue);
+  }
+}

packages/graphql/lib/schema-builder/collections/field-directive.collection.ts

@@ -0,0 +1,19 @@
+import { PropertyDirectiveMetadata } from '../metadata';
+import { MetadataListByNameCollection } from './metadata-list-by-name.collection';
+
+export class FieldDirectiveCollection extends MetadataListByNameCollection<PropertyDirectiveMetadata> {
+  sdls = new Set<string>();
+  fieldNames = new Set<string>();
+
+  add(value: PropertyDirectiveMetadata) {
+    if (this.sdls.has(value.sdl) && this.fieldNames.has(value.fieldName)) {
+      return;
+    }
+
+    super.add(value, value.fieldName);
+
+    this.sdls.add(value.sdl);
+    this.fieldNames.add(value.fieldName);
+    this.globalArray?.push(value);
+  }
+}

packages/graphql/lib/schema-builder/collections/index.ts

@@ -0,0 +1,7 @@
+export * from './array-with-global-cache.collection';
+export * from './field-directive.collection';
+export * from './metada-collection-model.interface';
+export * from './metadata-by-name.collection';
+export * from './metadata-by-target.collection';
+export * from './metadata-list-by-name.collection';
+export * from './target-metadata.collection';

packages/graphql/lib/schema-builder/collections/metada-collection-model.interface.ts

@@ -0,0 +1,21 @@
+import {
+  ClassDirectiveMetadata,
+  ClassExtensionsMetadata,
+  ClassMetadata,
+  PropertyDirectiveMetadata,
+  PropertyExtensionsMetadata,
+  ResolverClassMetadata,
+} from '../metadata';
+import { ObjectTypeMetadata } from '../metadata/object-type.metadata';
+
+export interface MetadataCollectionModel {
+  argumentType: ClassMetadata[];
+  interface: ClassMetadata[];
+  inputType: ClassMetadata[];
+  objectType: ObjectTypeMetadata[];
+  resolver: ResolverClassMetadata[];
+  classDirectives: ClassDirectiveMetadata[];
+  classExtensions: ClassExtensionsMetadata[];
+  fieldDirectives: PropertyDirectiveMetadata[];
+  fieldExtensions: PropertyExtensionsMetadata[];
+}

packages/graphql/lib/schema-builder/collections/metadata-by-name.collection.ts

@@ -0,0 +1,29 @@
+export class MetadataByNameCollection<T> {
+  protected internalCollection = new Map<string, T>();
+  protected all: (T extends any[] ? T[number] : T)[] = [];
+
+  getAll() {
+    return this.all;
+  }
+
+  getByName(name: string) {
+    return this.internalCollection.get(name);
+  }
+
+  add(value: T extends any[] ? T[number] : T, name: string) {
+    if (this.internalCollection.has(name)) {
+      return;
+    }
+
+    this.internalCollection.set(name, value);
+    this.all.push(value);
+  }
+
+  unshift(value: T extends any[] ? T[number] : T, name: string) {
+    if (this.internalCollection.has(name)) {
+      return;
+    }
+    this.internalCollection.set(name, value);
+    this.all.unshift(value);
+  }
+}

packages/graphql/lib/schema-builder/collections/metadata-by-target.collection.ts

@@ -0,0 +1,44 @@
+import { MetadataCollectionModel } from './metada-collection-model.interface';
+import { TargetMetadataCollection } from './target-metadata.collection';
+
+export class MetadataByTargetCollection {
+  public readonly all: MetadataCollectionModel = {
+    argumentType: [],
+    interface: [],
+    inputType: [],
+    objectType: [],
+    resolver: [],
+    classDirectives: [],
+    classExtensions: [],
+    fieldDirectives: [],
+    fieldExtensions: [],
+  };
+
+  private readonly storageMap = new Map<Function, TargetMetadataCollection>();
+  private readonly storageList = new Array<TargetMetadataCollection>();
+
+  get(target: Function) {
+    let metadata = this.storageMap.get(target);
+
+    if (!metadata) {
+      metadata = new TargetMetadataCollection(this.all);
+      this.storageMap.set(target, metadata);
+      this.storageList.push(metadata);
+    }
+
+    return metadata;
+  }
+
+  compile() {
+    this.reversePredicate((t) => t.classDirectives.getAll());
+    this.reversePredicate((t) => t.classExtensions.getAll());
+    this.reversePredicate((t) => t.fieldDirectives.getAll());
+    this.reversePredicate((t) => t.fieldExtensions.getAll());
+  }
+
+  private reversePredicate<V>(
+    predicate: (t: TargetMetadataCollection) => Array<V>,
+  ) {
+    this.storageList.forEach((t) => predicate(t).reverse());
+  }
+}

packages/graphql/lib/schema-builder/collections/metadata-list-by-name.collection.ts

@@ -0,0 +1,37 @@
+import { MetadataByNameCollection } from './metadata-by-name.collection';
+
+export class MetadataListByNameCollection<T> extends MetadataByNameCollection<
+  T[]
+> {
+  constructor(protected globalArray: Array<T> = null) {
+    super();
+  }
+
+  getByName(name: string): T[] {
+    return super.getByName(name) || [];
+  }
+
+  add(value: T, name: string) {
+    let arrayResult = super.getByName(name);
+    if (!arrayResult) {
+      arrayResult = [];
+      this.internalCollection.set(name, arrayResult);
+    }
+
+    arrayResult.push(value);
+    this.all.push(value);
+    this.globalArray && this.globalArray.push(value);
+  }
+
+  unshift(value: T, name: string) {
+    let arrayResult = super.getByName(name);
+    if (!arrayResult) {
+      arrayResult = [];
+      this.internalCollection.set(name, arrayResult);
+    }
+
+    arrayResult.unshift(value);
+    this.all.push(value);
+    this.globalArray && this.globalArray.unshift(value);
+  }
+}

packages/graphql/lib/schema-builder/collections/target-metadata.collection.ts

@@ -0,0 +1,84 @@
+import {
+  ClassDirectiveMetadata,
+  ClassExtensionsMetadata,
+  ClassMetadata,
+  MethodArgsMetadata,
+  PropertyExtensionsMetadata,
+  PropertyMetadata,
+  ResolverClassMetadata,
+} from '../metadata';
+import { ObjectTypeMetadata } from '../metadata/object-type.metadata';
+import { ArrayWithGlobalCacheCollection } from './array-with-global-cache.collection';
+import { FieldDirectiveCollection } from './field-directive.collection';
+import { MetadataCollectionModel } from './metada-collection-model.interface';
+import { MetadataByNameCollection } from './metadata-by-name.collection';
+import { MetadataListByNameCollection } from './metadata-list-by-name.collection';
+
+export class TargetMetadataCollection {
+  constructor(private readonly all: MetadataCollectionModel) {}
+
+  fields = new MetadataByNameCollection<PropertyMetadata>();
+  params = new MetadataListByNameCollection<MethodArgsMetadata>();
+  fieldDirectives = new FieldDirectiveCollection(this.all.fieldDirectives);
+  fieldExtensions =
+    new MetadataListByNameCollection<PropertyExtensionsMetadata>(
+      this.all.fieldExtensions,
+    );
+  classDirectives = new ArrayWithGlobalCacheCollection<ClassDirectiveMetadata>(
+    this.all.classDirectives,
+  );
+  classExtensions = new ArrayWithGlobalCacheCollection<ClassExtensionsMetadata>(
+    this.all.classExtensions,
+  );
+
+  private _argumentType: ClassMetadata;
+  private _interface: ClassMetadata;
+  private _inputType: ClassMetadata;
+  private _objectType: ObjectTypeMetadata;
+  private _resolver: ResolverClassMetadata;
+
+  set argumentType(val: ClassMetadata) {
+    this._argumentType = val;
+    this.all.argumentType.push(val);
+  }
+
+  get argumentType() {
+    return this._argumentType;
+  }
+
+  set interface(val: ClassMetadata) {
+    this._interface = val;
+    this.all.interface.push(val);
+  }
+
+  get interface() {
+    return this._interface;
+  }
+
+  set inputType(val: ClassMetadata) {
+    this._inputType = val;
+    this.all.inputType.push(val);
+  }
+
+  get inputType() {
+    return this._inputType;
+  }
+
+  set objectType(val: ObjectTypeMetadata) {
+    this._objectType = val;
+    this.all.objectType.push(val);
+  }
+
+  get objectType() {
+    return this._objectType;
+  }
+
+  set resolver(val: ResolverClassMetadata) {
+    this._resolver = val;
+    this.all.resolver.push(val);
+  }
+
+  get resolver() {
+    return this._resolver;
+  }
+}