@allgemein/schema-api 1.7.1 → 1.8.1

package/lib/registry/DefaultNamespacedRegistry.js

@@ -1,22 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultNamespacedRegistry = void 0;
 /**
  * Handler for metadata
  */
-const lodash_1 = require("lodash");
-const Constants_1 = require("./../Constants");
-const IEntityRef_1 = require("../../api/IEntityRef");
-const IClassRef_1 = require("../../api/IClassRef");
-const MetadataRegistry_1 = require("./MetadataRegistry");
-const DefaultPropertyRef_1 = require("./DefaultPropertyRef");
-const ClassRef_1 = require("../ClassRef");
-const DefaultEntityRef_1 = require("./DefaultEntityRef");
-const JsonSchema7_1 = require("../json-schema/JsonSchema7");
-const base_1 = require("@allgemein/base");
-const JsonSchema_1 = require("../json-schema/JsonSchema");
-const SchemaRef_1 = require("../SchemaRef");
-const AbstractRegistry_1 = require("./AbstractRegistry");
+import { assign, clone, cloneDeep, defaults, get, isArray, isEmpty, isFunction, isObjectLike, isString, keys, merge, remove, snakeCase, uniq } from '@allgemein/base';
+import { C_EVENT_ADD, C_EVENT_DRAIN_FINISHED, C_EVENT_REMOVE, C_EVENT_UPDATE, DEFAULT_NAMESPACE, K_TRIGGERED, METATYPE_CLASS_REF, METATYPE_EMBEDDABLE, METATYPE_ENTITY, METATYPE_NAMESPACE, METATYPE_PROPERTY, METATYPE_SCHEMA } from './../Constants.js';
+import { isEntityRef } from '../../api/IEntityRef.js';
+import { isClassRef } from '../../api/IClassRef.js';
+import { MetadataRegistry } from './MetadataRegistry.js';
+import { DefaultPropertyRef } from './DefaultPropertyRef.js';
+import { ClassRef } from '../ClassRef.js';
+import { DefaultEntityRef } from './DefaultEntityRef.js';
+import { hasClassPropertiesInDefinition } from '../json-schema/JsonSchema7.js';
+import { C_DEFAULT, ClassUtils, NotSupportedError } from '@allgemein/base';
+import { JsonSchema } from '../json-schema/JsonSchema.js';
+import { SchemaRef } from '../SchemaRef.js';
+import { AbstractRegistry } from './AbstractRegistry.js';
 /**
  * Registry which handles by default class, schema, embeddalbes and properties, which are not handled by a specialized registry.
  *
@@ -31,9 +28,9 @@ const AbstractRegistry_1 = require("./AbstractRegistry");
  * 4. append through reload method
  *
  */
-class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
+export class DefaultNamespacedRegistry extends AbstractRegistry {
     constructor(namespace, options) {
-        super(namespace, (0, lodash_1.defaults)(options || {}, { detectUnannotatedProperties: true }));
+        super(namespace, defaults(options || {}, { detectUnannotatedProperties: true }));
         this.drained = false;
     }
     /**
@@ -42,9 +39,9 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
     prepare() {
         // apply listener
         this.drainAlreadyAdded();
-        MetadataRegistry_1.MetadataRegistry.$().on(Constants_1.C_EVENT_ADD, this.onMetadataAdd.bind(this));
-        MetadataRegistry_1.MetadataRegistry.$().on(Constants_1.C_EVENT_REMOVE, this.onMetadataRemove.bind(this));
-        MetadataRegistry_1.MetadataRegistry.$().on(Constants_1.C_EVENT_UPDATE, this.onMetadataUpdate.bind(this));
+        MetadataRegistry.$().on(C_EVENT_ADD, this.onMetadataAdd.bind(this));
+        MetadataRegistry.$().on(C_EVENT_REMOVE, this.onMetadataRemove.bind(this));
+        MetadataRegistry.$().on(C_EVENT_UPDATE, this.onMetadataUpdate.bind(this));
     }
     ready(timeout) {
         return super.ready(timeout).then(() => {
@@ -56,7 +53,7 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
                     const t = setTimeout(() => {
                         reject();
                     }, timeout ? timeout : 10000);
-                    MetadataRegistry_1.MetadataRegistry.$().once(Constants_1.C_EVENT_DRAIN_FINISHED + this.namespace, () => {
+                    MetadataRegistry.$().once(C_EVENT_DRAIN_FINISHED + this.namespace, () => {
                         resolve(true);
                     });
                 });
@@ -68,14 +65,14 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      */
     drainAlreadyAdded() {
         this.drained = false;
-        const alreadyFired = MetadataRegistry_1.MetadataRegistry.$()
+        const alreadyFired = MetadataRegistry.$()
             .getMetadata()
             .filter(x => {
-            const v = Object.getOwnPropertyDescriptor(x, Constants_1.K_TRIGGERED);
+            const v = Object.getOwnPropertyDescriptor(x, K_TRIGGERED);
             return v && v.value;
         });
         for (const event of alreadyFired) {
-            const cloneEvent = (0, lodash_1.cloneDeep)(event);
+            const cloneEvent = cloneDeep(event);
             try {
                 this.onAdd(cloneEvent.metaType, cloneEvent);
             }
@@ -83,7 +80,7 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
             }
         }
         this.drained = true;
-        MetadataRegistry_1.MetadataRegistry.$().emit([Constants_1.C_EVENT_DRAIN_FINISHED, this.namespace].join('_'), true);
+        MetadataRegistry.$().emit([C_EVENT_DRAIN_FINISHED, this.namespace].join('_'), true);
     }
     async onMetadataAdd(context, options) {
         await this.lock.acquire();
@@ -120,13 +117,13 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
         }
         else {
             // if namespace not present skipping
-            if (options.metaType !== Constants_1.METATYPE_PROPERTY) {
+            if (options.metaType !== METATYPE_PROPERTY) {
                 // only properties should be pass and check if entity already exists
-                const namespace = MetadataRegistry_1.MetadataRegistry.$().find(Constants_1.METATYPE_NAMESPACE, (x) => x.target === options.target);
+                const namespace = MetadataRegistry.$().find(METATYPE_NAMESPACE, (x) => x.target === options.target);
                 if (namespace && namespace.attributes.namespace === this.namespace) {
                     options.namespace = namespace.attributes.namespace;
                 }
-                else if (this.namespace !== Constants_1.DEFAULT_NAMESPACE) {
+                else if (this.namespace !== DEFAULT_NAMESPACE) {
                     // passing to default namespace if nothing
                     return false;
                 }
@@ -144,8 +141,8 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
         if (!this.validNamespace(options)) {
             return;
         }
-        if (context === Constants_1.METATYPE_PROPERTY) {
-            const sourceEntry = this.find(Constants_1.METATYPE_CLASS_REF, (ref) => ref.getClass() === options.target);
+        if (context === METATYPE_PROPERTY) {
+            const sourceEntry = this.find(METATYPE_CLASS_REF, (ref) => ref.getClass() === options.target);
             if (sourceEntry) {
                 const find = this.find(context, (c) => c.getClassRef().getClass() === options.target &&
                     c.name === options.propertyName);
@@ -155,31 +152,31 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
                 }
             }
         }
-        else if (context === Constants_1.METATYPE_ENTITY) {
+        else if (context === METATYPE_ENTITY) {
             const find = this.find(context, (c) => c.getClassRef().getClass() === options.target);
             if (!find) {
                 const entityRef = this.create(context, options);
-                const properties = this.find(Constants_1.METATYPE_PROPERTY, (c) => c.getClassRef().getClass() === options.target);
-                if ((0, lodash_1.isEmpty)(properties)) {
+                const properties = this.find(METATYPE_PROPERTY, (c) => c.getClassRef().getClass() === options.target);
+                if (isEmpty(properties)) {
                     // create properties only when non exists
                     this.createPropertiesForRef(entityRef.getClassRef());
                 }
             }
         }
-        else if (context === Constants_1.METATYPE_EMBEDDABLE) {
-            const find = this.find(Constants_1.METATYPE_CLASS_REF, (c) => c.getClass() === options.target);
+        else if (context === METATYPE_EMBEDDABLE) {
+            const find = this.find(METATYPE_CLASS_REF, (c) => c.getClass() === options.target);
             if (!find) {
                 this.create(context, options);
             }
             else {
                 const refOptions = find.getOptions();
-                (0, lodash_1.defaults)(refOptions, options);
+                defaults(refOptions, options);
             }
         }
-        else if (context === Constants_1.METATYPE_SCHEMA) {
-            let find = this.getOrCreateSchemaRefByName(options);
+        else if (context === METATYPE_SCHEMA) {
+            const find = this.getOrCreateSchemaRefByName(options);
             if (options.target) {
-                let entityRef = this.find(Constants_1.METATYPE_ENTITY, (c) => c.getClass() === options.target);
+                const entityRef = this.find(METATYPE_ENTITY, (c) => c.getClass() === options.target);
                 if (find && entityRef) {
                     this.addSchemaToEntityRef(find, entityRef);
                 }
@@ -187,26 +184,26 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
         }
     }
     getOrCreateSchemaRefByName(options) {
-        let find = this.find(Constants_1.METATYPE_SCHEMA, (c) => c.name === options.name);
+        let find = this.find(METATYPE_SCHEMA, (c) => c.name === options.name);
         if (!find) {
             find = this.createSchemaForOptions(options);
         }
         return find;
     }
     addSchemaToEntityRef(schemaRef, entityRef, options = {}) {
-        if ((0, lodash_1.isString)(schemaRef)) {
+        if (isString(schemaRef)) {
             schemaRef = this.getOrCreateSchemaRefByName({
-                metaType: Constants_1.METATYPE_SCHEMA,
+                metaType: METATYPE_SCHEMA,
                 name: schemaRef,
                 namespace: this.namespace,
                 target: entityRef.getClass()
             });
         }
         const name = schemaRef.name;
-        let entry = entityRef.getOptions(Constants_1.METATYPE_SCHEMA, []);
+        let entry = entityRef.getOptions(METATYPE_SCHEMA, []);
         if (!entry.includes(name)) {
             if (entry) {
-                if ((0, lodash_1.isArray)(entry)) {
+                if (isArray(entry)) {
                     entry.push(name);
                 }
                 else {
@@ -216,15 +213,15 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
             else {
                 entry = [name];
             }
-            if ((0, lodash_1.get)(options, 'override', false)) {
-                if ((0, lodash_1.get)(options, 'onlyDefault', false)) {
-                    (0, lodash_1.remove)(entry, x => x === base_1.C_DEFAULT);
+            if (get(options, 'override', false)) {
+                if (get(options, 'onlyDefault', false)) {
+                    remove(entry, x => x === C_DEFAULT);
                 }
                 else {
                     entry = [name];
                 }
             }
-            entityRef.setOption(Constants_1.METATYPE_SCHEMA, (0, lodash_1.uniq)(entry));
+            entityRef.setOption(METATYPE_SCHEMA, uniq(entry));
         }
     }
     /**
@@ -234,17 +231,17 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      * @param entries
      */
     onRemove(context, entries) {
-        if (context === Constants_1.METATYPE_ENTITY || context === Constants_1.METATYPE_CLASS_REF) {
+        if (context === METATYPE_ENTITY || context === METATYPE_CLASS_REF) {
             const targets = entries.map(x => x.target);
-            this.getLookupRegistry().remove(Constants_1.METATYPE_CLASS_REF, (x) => targets.includes(x.target));
-            this.getLookupRegistry().remove(Constants_1.METATYPE_ENTITY, (x) => targets.includes(x.target));
-            this.getLookupRegistry().remove(Constants_1.METATYPE_PROPERTY, (x) => targets.includes(x.target));
+            this.getLookupRegistry().remove(METATYPE_CLASS_REF, (x) => targets.includes(x.target));
+            this.getLookupRegistry().remove(METATYPE_ENTITY, (x) => targets.includes(x.target));
+            this.getLookupRegistry().remove(METATYPE_PROPERTY, (x) => targets.includes(x.target));
         }
-        else if (context === Constants_1.METATYPE_PROPERTY) {
+        else if (context === METATYPE_PROPERTY) {
             const targets = entries.map(x => [x.target, x.propertyName]);
             this.getLookupRegistry().remove(context, (x) => targets.includes([x.target, x.name]));
         }
-        else if (context === Constants_1.METATYPE_SCHEMA) {
+        else if (context === METATYPE_SCHEMA) {
             // TODO remove schema ref
             // TODO remove schema options entries
         }
@@ -264,32 +261,32 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      * @return ISchemaRef[]
      */
     getSchemaRefs(filter) {
-        return this.filter(Constants_1.METATYPE_SCHEMA, filter);
+        return this.filter(METATYPE_SCHEMA, filter);
     }
     getSchemaRefsFor(ref) {
         let lookup = [];
-        if ((0, IEntityRef_1.isEntityRef)(ref) || (0, IClassRef_1.isClassRef)(ref)) {
-            const schemas = ref.getOptions(Constants_1.METATYPE_SCHEMA, []);
+        if (isEntityRef(ref) || isClassRef(ref)) {
+            const schemas = ref.getOptions(METATYPE_SCHEMA, []);
             for (const schema of schemas) {
-                let schemaRef = this.find(Constants_1.METATYPE_SCHEMA, (x) => x.name === schema);
+                let schemaRef = this.find(METATYPE_SCHEMA, (x) => x.name === schema);
                 if (!schemaRef) {
-                    schemaRef = this.create(Constants_1.METATYPE_SCHEMA, { name: schema, target: ref.getClass() });
+                    schemaRef = this.create(METATYPE_SCHEMA, { name: schema, target: ref.getClass() });
                 }
                 lookup.push(schemaRef);
             }
             lookup = this.getSchemaRefs((x) => schemas.includes(x.name));
         }
-        else if ((0, lodash_1.isString)(ref)) {
-            let schemaRef = this.find(Constants_1.METATYPE_SCHEMA, (x) => x.name === ref);
+        else if (isString(ref)) {
+            let schemaRef = this.find(METATYPE_SCHEMA, (x) => x.name === ref);
             if (!schemaRef) {
-                schemaRef = this.create(Constants_1.METATYPE_SCHEMA, { name: ref });
+                schemaRef = this.create(METATYPE_SCHEMA, { name: ref });
             }
             return schemaRef;
         }
         else {
-            throw new base_1.NotSupportedError('passed value is not supported');
+            throw new NotSupportedError('passed value is not supported');
         }
-        return lookup ? (0, lodash_1.uniq)(lookup) : null;
+        return lookup ? uniq(lookup) : null;
     }
     /**
      * TODO
@@ -297,7 +294,7 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      * @param filter
      */
     getEntities(filter) {
-        return this.getLookupRegistry().filter(Constants_1.METATYPE_ENTITY, filter);
+        return this.getLookupRegistry().filter(METATYPE_ENTITY, filter);
     }
     /**
      * Can get get entity ref for function.
@@ -306,18 +303,18 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      */
     getEntityRefFor(fn, skipNsCheck = true) {
         let lookup = fn;
-        if (!(0, lodash_1.isFunction)(fn) && !(0, lodash_1.isString)(fn) && (0, lodash_1.isObjectLike)(fn)) {
-            lookup = base_1.ClassUtils.getFunction(fn);
+        if (!isFunction(fn) && !isString(fn) && isObjectLike(fn)) {
+            lookup = ClassUtils.getFunction(fn);
         }
         let lookupFn = (x) => x.getClassRef().getClass() === lookup;
-        if ((0, lodash_1.isString)(fn)) {
+        if (isString(fn)) {
             lookupFn = (x) => x.getClassRef().name === lookup || x.name === lookup;
         }
-        const entityRefExists = this.find(Constants_1.METATYPE_ENTITY, lookupFn);
+        const entityRefExists = this.find(METATYPE_ENTITY, lookupFn);
         if (entityRefExists) {
             return entityRefExists;
         }
-        return this.create(Constants_1.METATYPE_ENTITY, {
+        return this.create(METATYPE_ENTITY, {
             target: lookup,
             namespace: this.namespace,
             skipNsCheck: skipNsCheck
@@ -329,7 +326,7 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      * @param filter
      */
     getPropertyRef(ref, name) {
-        return this.getPropertyRefs(ref).find(x => (0, lodash_1.snakeCase)(x.name) === (0, lodash_1.snakeCase)(name));
+        return this.getPropertyRefs(ref).find(x => snakeCase(x.name) === snakeCase(name));
     }
     /**
      * Returns all properties for given class or entity ref
@@ -337,12 +334,12 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      * @param ref
      */
     getPropertyRefs(ref) {
-        const clsRef = (0, IEntityRef_1.isEntityRef)(ref) ? ref.getClassRef() : ref;
+        const clsRef = isEntityRef(ref) ? ref.getClassRef() : ref;
         // Return existing
-        const clsRefExists = this.find(Constants_1.METATYPE_CLASS_REF, (x) => x === clsRef);
+        const clsRefExists = this.find(METATYPE_CLASS_REF, (x) => x === clsRef);
         let properties = [];
         if (clsRefExists) {
-            properties = this.filter(Constants_1.METATYPE_PROPERTY, (x) => x.getClassRef() === clsRefExists);
+            properties = this.filter(METATYPE_PROPERTY, (x) => x.getClassRef() === clsRefExists);
         }
         else {
             properties = this.createPropertiesForRef(clsRef);
@@ -355,15 +352,15 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
     createPropertiesForRef(clsRef) {
         const cls = clsRef.getClass(true);
         const propOptions = [];
-        const metaPropOptions = MetadataRegistry_1.MetadataRegistry.$().getByContextAndTarget(Constants_1.METATYPE_PROPERTY, cls);
+        const metaPropOptions = MetadataRegistry.$().getByContextAndTarget(METATYPE_PROPERTY, cls);
         if (this.getOptions().detectUnannotatedProperties) {
-            const jsonSchema = JsonSchema_1.JsonSchema.serialize(cls, { appendTarget: true });
-            if ((0, JsonSchema7_1.hasClassPropertiesInDefinition)(clsRef.name, jsonSchema)) {
+            const jsonSchema = JsonSchema.serialize(cls, { appendTarget: true });
+            if (hasClassPropertiesInDefinition(clsRef.name, jsonSchema)) {
                 const properties = jsonSchema.definitions[clsRef.name].properties;
-                for (const k of (0, lodash_1.keys)(properties)) {
+                for (const k of keys(properties)) {
                     const property = properties[k];
                     const opts = {
-                        metaType: Constants_1.METATYPE_PROPERTY,
+                        metaType: METATYPE_PROPERTY,
                         namespace: clsRef.getNamespace(),
                         type: property.$target ? property.$target : property.type,
                         propertyName: k,
@@ -372,13 +369,13 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
                     if (property.default) {
                         opts.default = property.default;
                     }
-                    const propMetadata = (0, lodash_1.remove)(metaPropOptions, x => x.propertyName === k);
-                    if (!(0, lodash_1.isEmpty)(propMetadata)) {
+                    const propMetadata = remove(metaPropOptions, x => x.propertyName === k);
+                    if (!isEmpty(propMetadata)) {
                         for (const p of propMetadata) {
                             // clean namespace
-                            const copy = (0, lodash_1.clone)(p);
+                            const copy = clone(p);
                             delete copy.namespace;
-                            (0, lodash_1.assign)(opts, copy);
+                            assign(opts, copy);
                         }
                     }
                     propOptions.push(opts);
@@ -392,12 +389,12 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
             // .filter(x => !this.processing.find((z: IPropertyOptions) => z.propertyName === x.propertyName && z.target === x.target))
             .map(p => {
             // change namespace of properties namespace
-            const copy = (0, lodash_1.clone)(p);
+            const copy = clone(p);
             copy.namespace = clsRef.getNamespace();
             copy.skipNsCheck = true;
             return copy;
         });
-        return propertyOptions.map(opts => clsRef.getRegistry().create(Constants_1.METATYPE_PROPERTY, opts));
+        return propertyOptions.map(opts => clsRef.getRegistry().create(METATYPE_PROPERTY, opts));
     }
     /**
      * Create default property reference
@@ -405,11 +402,11 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      * @param options
      */
     createPropertyForOptions(options) {
-        if ((0, lodash_1.keys)(options).length === 0) {
+        if (keys(options).length === 0) {
             throw new Error('can\'t create property for empty options');
         }
         options.namespace = this.namespace;
-        const prop = new DefaultPropertyRef_1.DefaultPropertyRef(options);
+        const prop = new DefaultPropertyRef(options);
         return this.add(prop.metaType, prop);
     }
     /**
@@ -420,12 +417,12 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
     createEntityForOptions(options) {
         options.namespace = this.namespace;
         if (!options.name) {
-            options.name = ClassRef_1.ClassRef.getClassName(options.target);
+            options.name = ClassRef.getClassName(options.target);
         }
-        const entityRef = new DefaultEntityRef_1.DefaultEntityRef(options);
+        const entityRef = new DefaultEntityRef(options);
         const retRef = this.add(entityRef.metaType, entityRef);
-        const metaSchemaOptionsForEntity = MetadataRegistry_1.MetadataRegistry.$()
-            .getByContextAndTarget(Constants_1.METATYPE_SCHEMA, entityRef.getClass());
+        const metaSchemaOptionsForEntity = MetadataRegistry.$()
+            .getByContextAndTarget(METATYPE_SCHEMA, entityRef.getClass());
         if (metaSchemaOptionsForEntity.length > 0) {
             for (const schemaOptions of metaSchemaOptionsForEntity) {
                 this.addSchemaToEntityRef(schemaOptions.name, entityRef);
@@ -443,8 +440,8 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
         // if (!options.name) {
         //   options.name = ClassRef.getClassName(options.target);
         // }
-        options = (0, lodash_1.defaults)(options || {}, {});
-        const classRef = this.getClassRefFor(options.target, Constants_1.METATYPE_CLASS_REF);
+        options = defaults(options || {}, {});
+        const classRef = this.getClassRefFor(options.target, METATYPE_CLASS_REF);
         classRef.setOptions(options);
         return classRef;
     }
@@ -455,7 +452,7 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      */
     createSchemaForOptions(options) {
         options.namespace = this.namespace;
-        const schemaRef = new SchemaRef_1.SchemaRef(options);
+        const schemaRef = new SchemaRef(options);
         return this.add(schemaRef.metaType, schemaRef);
     }
     /**
@@ -466,14 +463,14 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      * @return IAbstractOptions
      */
     getMetadata(context, target, propertyName) {
-        let metadataOptionList = MetadataRegistry_1.MetadataRegistry.$()
+        const metadataOptionList = MetadataRegistry.$()
             .getByContextAndTarget(context, target, 'merge', propertyName);
         let metadataOptions = {};
         if (metadataOptionList.length > 1) {
-            metadataOptions = (0, lodash_1.assign)(metadataOptions, ...metadataOptionList.map(x => (0, lodash_1.cloneDeep)(x)));
+            metadataOptions = assign(metadataOptions, ...metadataOptionList.map(x => cloneDeep(x)));
         }
         else if (metadataOptionList.length === 1) {
-            metadataOptions = (0, lodash_1.cloneDeep)(metadataOptionList.shift());
+            metadataOptions = cloneDeep(metadataOptionList.shift());
         }
         if (propertyName) {
             // remove namespace for properties
@@ -482,44 +479,44 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
         return metadataOptions;
     }
     getPropertyRefsFor(fn) {
-        const clsName = ClassRef_1.ClassRef.getClassName(fn);
-        const clsRef = ClassRef_1.ClassRef.get(clsName, this.namespace);
+        const clsName = ClassRef.getClassName(fn);
+        const clsRef = ClassRef.get(clsName, this.namespace);
         return this.getPropertyRefs(clsRef);
     }
     create(context, options) {
-        const skipNsCheck = (0, lodash_1.get)(options, 'skipNsCheck', false);
-        const failedNsCheck = (0, lodash_1.get)(options, 'failedNsCheckMode', 'throw');
+        const skipNsCheck = get(options, 'skipNsCheck', false);
+        const failedNsCheck = get(options, 'failedNsCheckMode', 'throw');
         delete options.skipNsCheck;
         const metadata = this.getMetadata(context, options.target, options.propertyName ? options.propertyName : null);
         if (metadata) {
             if (metadata.namespace && metadata.namespace !== this.namespace) {
                 if (!skipNsCheck) {
-                    if (context !== Constants_1.METATYPE_PROPERTY) {
+                    if (context !== METATYPE_PROPERTY) {
                         if (failedNsCheck === 'ignore') {
                             return null;
                         }
                         else {
-                            throw new base_1.NotSupportedError('namespace for ' + context + ' is ' + metadata.namespace +
+                            throw new NotSupportedError('namespace for ' + context + ' is ' + metadata.namespace +
                                 ' the namespace of this registry is ' + this.namespace);
                         }
                     }
                 }
             }
-            if (!(0, lodash_1.isEmpty)(metadata) && (0, lodash_1.keys)(metadata).length > 0) {
-                (0, lodash_1.merge)(options, (0, lodash_1.assign)(metadata, { namespace: this.namespace }));
+            if (!isEmpty(metadata) && keys(metadata).length > 0) {
+                merge(options, assign(metadata, { namespace: this.namespace }));
             }
         }
         options.metaType = context;
         switch (context) {
-            case Constants_1.METATYPE_CLASS_REF:
+            case METATYPE_CLASS_REF:
                 break;
-            case Constants_1.METATYPE_EMBEDDABLE:
+            case METATYPE_EMBEDDABLE:
                 return this.createEmbeddableForOptions(options);
-            case Constants_1.METATYPE_ENTITY:
+            case METATYPE_ENTITY:
                 return this.createEntityForOptions(options);
-            case Constants_1.METATYPE_PROPERTY:
+            case METATYPE_PROPERTY:
                 return this.createPropertyForOptions(options);
-            case Constants_1.METATYPE_SCHEMA:
+            case METATYPE_SCHEMA:
                 return this.createSchemaForOptions(options);
         }
         return null;
@@ -528,7 +525,7 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      * TODO
      */
     add(context, entry) {
-        if (context === Constants_1.METATYPE_CLASS_REF) {
+        if (context === METATYPE_CLASS_REF) {
             return this.addClassRef(entry);
         }
         return this.getLookupRegistry().add(context, entry);
@@ -539,30 +536,30 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
      * @param options
      */
     addClassRef(ref) {
-        const addedClassRef = this.getLookupRegistry().add(Constants_1.METATYPE_CLASS_REF, ref);
+        const addedClassRef = this.getLookupRegistry().add(METATYPE_CLASS_REF, ref);
         this.createPropertiesForRef(addedClassRef);
         return addedClassRef;
     }
     getClassRefFor(object, type) {
         let ref = null;
-        if ((0, lodash_1.isString)(object)) {
-            ref = this.find(Constants_1.METATYPE_CLASS_REF, (x) => x.name === object);
+        if (isString(object)) {
+            ref = this.find(METATYPE_CLASS_REF, (x) => x.name === object);
         }
-        else if ((0, lodash_1.isFunction)(object)) {
-            ref = this.find(Constants_1.METATYPE_CLASS_REF, (x) => x.getClass(true) === object);
+        else if (isFunction(object)) {
+            ref = this.find(METATYPE_CLASS_REF, (x) => x.getClass(true) === object);
         }
         else {
-            ref = this.find(Constants_1.METATYPE_CLASS_REF, (x) => x === object);
+            ref = this.find(METATYPE_CLASS_REF, (x) => x === object);
         }
         if (!ref) {
-            ref = ClassRef_1.ClassRef.get(object, this.namespace, {
-                resolve: type === Constants_1.METATYPE_PROPERTY,
+            ref = ClassRef.get(object, this.namespace, {
+                resolve: type === METATYPE_PROPERTY,
                 checkNamespace: true
             });
-            const metadata = this.getMetadata(Constants_1.METATYPE_EMBEDDABLE, object);
-            if (!(0, lodash_1.isEmpty)(metadata) && (0, lodash_1.keys)(metadata).length > 0) {
+            const metadata = this.getMetadata(METATYPE_EMBEDDABLE, object);
+            if (!isEmpty(metadata) && keys(metadata).length > 0) {
                 const refOptions = ref.getOptions();
-                (0, lodash_1.merge)(refOptions, metadata);
+                merge(refOptions, metadata);
             }
             // this.createPropertiesForRef(ref);
         }
@@ -570,10 +567,9 @@ class DefaultNamespacedRegistry extends AbstractRegistry_1.AbstractRegistry {
     }
     reset() {
         super.reset();
-        MetadataRegistry_1.MetadataRegistry.$().off(Constants_1.C_EVENT_ADD, this.onAdd.bind(this));
-        MetadataRegistry_1.MetadataRegistry.$().off(Constants_1.C_EVENT_REMOVE, this.onRemove.bind(this));
-        MetadataRegistry_1.MetadataRegistry.$().off(Constants_1.C_EVENT_UPDATE, this.onUpdate.bind(this));
+        MetadataRegistry.$().off(C_EVENT_ADD, this.onAdd.bind(this));
+        MetadataRegistry.$().off(C_EVENT_REMOVE, this.onRemove.bind(this));
+        MetadataRegistry.$().off(C_EVENT_UPDATE, this.onUpdate.bind(this));
     }
 }
-exports.DefaultNamespacedRegistry = DefaultNamespacedRegistry;
 //# sourceMappingURL=DefaultNamespacedRegistry.js.map