@rsdk/metadata 1.0.12 → 2.0.0

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 import 'reflect-metadata';
+export { RsdkMetadataProvider } from './rsdk-metadata-provider';
 export { RsdkMetadata, Resource } from './metadata';

package/dist/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RsdkMetadata = void 0;
+exports.RsdkMetadata = exports.RsdkMetadataProvider = void 0;
 require("reflect-metadata");
+var rsdk_metadata_provider_1 = require("./rsdk-metadata-provider");
+Object.defineProperty(exports, "RsdkMetadataProvider", { enumerable: true, get: function () { return rsdk_metadata_provider_1.RsdkMetadataProvider; } });
 var metadata_1 = require("./metadata");
 Object.defineProperty(exports, "RsdkMetadata", { enumerable: true, get: function () { return metadata_1.RsdkMetadata; } });

package/dist/metadata.d.ts

@@ -8,25 +8,42 @@ export type Resource<T> = {
      * Чтобы получать только значения по-определенному скоупу.
      * Никаких дополнительных проверок не происходит, используется обычный массив
      */
-    scope: string;
+    scope?: string;
     value: T;
+    /**
+     * Ну, это было неизбежно...
+     * В чём собственно дело
+     * У нас есть ряд вещей которые необходимо объявить по принципу at-most-once.
+     * Но так как они все переиспользуемые они декларируются везде где они нужны.
+     * Для того чтобы высекать такие вещи в ряде случаев сделано это поле, работает просто по сравнению `===`
+     * Если значение с таким же скоупом уже есть, все последующие будут отброшены
+     */
+    key?: unknown;
 };
 /**
  * RSDK metadata for object
  */
 export declare class RsdkMetadata<T = unknown> {
-    readonly target: any;
+    readonly target: object;
     readonly scope?: string | undefined;
+    private static logger;
     /**
      * @param target Target object (could be anything)
      * @param scope Just tag for organizing metadata into groups
      */
-    constructor(target: any, scope?: string | undefined);
+    constructor(target: object, scope?: string | undefined);
+    static add<T>(target: object, value: T, scope?: string): void;
+    static get<T>(target: object, scope?: string): Resource<T>[] | null;
+    static set<T>(target: object, key: unknown, value: T, ifNotExist?: boolean): void;
+    static isEqual(resource: Resource<any>, definitionResource: Pick<Resource<unknown>, 'scope' | 'key'>): boolean;
+    static setWithScope<T>(target: object, scope: string, key: unknown, value: T, ifNotExist?: boolean): void;
     /**
      * Sets metadata for object itself
      * @param value Metadata value (could be anything)
      */
     add(value: T): void;
+    set(key: unknown, value: T, ifNotExist?: boolean): boolean;
+    getResourceByKey(key: any): Resource<T> | null;
     /**
      * Sets metadata for property
      * @param {string|symbol} propKey Property name
@@ -44,4 +61,5 @@ export declare class RsdkMetadata<T = unknown> {
      * @returns {Resource<T>} Array of resources
      */
     getForProperty(propKey: string | symbol): Resource<T>[] | null;
+    private getResourceByKeyFromList;
 }

package/dist/metadata.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RsdkMetadata = void 0;
+const logging_1 = require("@rsdk/logging");
 const constants_1 = require("./constants");
 /**
  * RSDK metadata for object
@@ -8,6 +9,7 @@ const constants_1 = require("./constants");
 class RsdkMetadata {
     target;
     scope;
+    static logger = logging_1.LoggerFactory.create('RsdkMetadata');
     /**
      * @param target Target object (could be anything)
      * @param scope Just tag for organizing metadata into groups
@@ -15,6 +17,33 @@ class RsdkMetadata {
     constructor(target, scope) {
         this.target = target;
         this.scope = scope;
+        if (!['object', 'function'].includes(typeof target)) {
+            // TODO InternalException
+            throw new Error('target must be object or function, received: ' +
+                target +
+                'typeof target - ' +
+                typeof target);
+        }
+    }
+    static add(target, value, scope) {
+        const metadata = new RsdkMetadata(target, scope);
+        metadata.add(value);
+    }
+    static get(target, scope) {
+        const metadata = new RsdkMetadata(target, scope);
+        return metadata.get();
+    }
+    static set(target, key, value, ifNotExist) {
+        new RsdkMetadata(target).set(key, value, ifNotExist);
+    }
+    static isEqual(resource, definitionResource) {
+        return (Object.hasOwn(resource, 'key') &&
+            Object.hasOwn(definitionResource, 'key') &&
+            resource.scope === definitionResource.scope &&
+            definitionResource.key === resource.key);
+    }
+    static setWithScope(target, scope, key, value, ifNotExist) {
+        new RsdkMetadata(target, scope).set(key, value, ifNotExist);
     }
     /**
      * Sets metadata for object itself
@@ -22,8 +51,41 @@ class RsdkMetadata {
      */
     add(value) {
         const metadata = Reflect.getMetadata(constants_1.RSDK_METADATA_KEY, this.target) ?? [];
-        metadata.push({ scope: this.scope, value: value });
+        metadata.push({
+            ...(this.scope && { scope: this.scope }),
+            value: value,
+        });
+        Reflect.defineMetadata(constants_1.RSDK_METADATA_KEY, metadata, this.target);
+    }
+    set(key, value, ifNotExist) {
+        const metadata = Reflect.getMetadata(constants_1.RSDK_METADATA_KEY, this.target) ?? [];
+        const valueWithKey = this.getResourceByKeyFromList(metadata, key);
+        if (valueWithKey) {
+            if (!ifNotExist) {
+                // TODO InternalException
+                throw new Error('Value with key ' + key + ' already existed', {
+                    cause: {
+                        existed: valueWithKey,
+                        received: valueWithKey,
+                    },
+                });
+            }
+            return false;
+        }
+        metadata.push({
+            ...(this.scope && { scope: this.scope }),
+            value: value,
+            key,
+        });
         Reflect.defineMetadata(constants_1.RSDK_METADATA_KEY, metadata, this.target);
+        return true;
+    }
+    getResourceByKey(key) {
+        const metadata = this.get();
+        if (!metadata) {
+            return null;
+        }
+        return metadata.find((resource) => resource.key === key) ?? null;
     }
     /**
      * Sets metadata for property
@@ -64,5 +126,11 @@ class RsdkMetadata {
         }
         return resources.filter((resource) => resource.scope === this.scope);
     }
+    getResourceByKeyFromList(metadata, key) {
+        return (metadata.find((resource) => RsdkMetadata.isEqual(resource, {
+            key,
+            ...(this.scope && { scope: this.scope }),
+        })) ?? null);
+    }
 }
 exports.RsdkMetadata = RsdkMetadata;

package/dist/rsdk-metadata-provider.d.ts

@@ -0,0 +1,26 @@
+import type { ClassProvider, DynamicModule, ExistingProvider, FactoryProvider, InjectionToken, Type, ValueProvider } from '@nestjs/common';
+import type { NestModuleDefinition } from '@rsdk/common';
+import type { Promisable } from 'type-fest';
+import type { Resource } from './metadata';
+/**
+ * Провайдер агрегирующий в себе ресурсы из метаданных
+ * По задумке должен выступать лишь в роли фасада/агрегатора который знает о структуре ресурсов и её значении
+ * Также он знает о том где могут быть записаны rsdk метаданные
+ */
+export declare class RsdkMetadataProvider {
+    private readonly resources;
+    protected constructor(resources: Resource<any>[]);
+    static create(...rootModule: Promisable<NestModuleDefinition>[]): Promise<RsdkMetadataProvider>;
+    static getMetadataSource(nestDefinition: DynamicModule | Type | ClassProvider | ValueProvider | FactoryProvider | ExistingProvider): IterableIterator<InjectionToken | DynamicModule | Type | ClassProvider | ValueProvider | FactoryProvider | ExistingProvider>;
+    private static extractResources;
+    /**
+     * Есть ли уже этот ресурс в массиве
+     * Проверка осуществляется на основе `key` и `scope` у `Resource`
+     * @param resources
+     * @param definitionResource
+     * @private
+     */
+    private static isDuplicate;
+    get<T>(scope?: string): Resource<T>[];
+    add(...moduleDef: Promisable<NestModuleDefinition>[]): Promise<void>;
+}

package/dist/rsdk-metadata-provider.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RsdkMetadataProvider = void 0;
+const nest_tools_1 = require("@rsdk/nest-tools");
+const metadata_1 = require("./metadata");
+/**
+ * Провайдер агрегирующий в себе ресурсы из метаданных
+ * По задумке должен выступать лишь в роли фасада/агрегатора который знает о структуре ресурсов и её значении
+ * Также он знает о том где могут быть записаны rsdk метаданные
+ */
+class RsdkMetadataProvider {
+    resources;
+    constructor(resources) {
+        this.resources = resources;
+    }
+    static async create(...rootModule) {
+        const resources = [];
+        await this.extractResources(rootModule, resources);
+        return new RsdkMetadataProvider(resources);
+    }
+    static *getMetadataSource(nestDefinition) {
+        if ('useClass' in nestDefinition) {
+            yield nestDefinition.useClass;
+        }
+        if ('useValue' in nestDefinition) {
+            yield nestDefinition.useValue;
+        }
+        if ('provide' in nestDefinition) {
+            yield nestDefinition.provide;
+        }
+        yield nestDefinition;
+    }
+    static async extractResources(rootModule, resources) {
+        for await (const rootModuleElement of rootModule) {
+            const nestDefinitionIterator = new nest_tools_1.NestDefinitionIterator(rootModuleElement);
+            for await (const _nestDefinition of nestDefinitionIterator.iterate()) {
+                for (const value of this.getMetadataSource(_nestDefinition)) {
+                    if (!['object', 'function'].includes(typeof value)) {
+                        continue;
+                    }
+                    const definitionResources = metadata_1.RsdkMetadata.get(value);
+                    if (!definitionResources) {
+                        continue;
+                    }
+                    for (const definitionResource of definitionResources) {
+                        const isDuplicate = this.isDuplicate(resources, definitionResource);
+                        if (isDuplicate) {
+                            continue;
+                        }
+                        resources.push(definitionResource);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Есть ли уже этот ресурс в массиве
+     * Проверка осуществляется на основе `key` и `scope` у `Resource`
+     * @param resources
+     * @param definitionResource
+     * @private
+     */
+    static isDuplicate(resources, definitionResource) {
+        return resources.some((resource) => metadata_1.RsdkMetadata.isEqual(resource, definitionResource));
+    }
+    get(scope) {
+        if (scope === undefined) {
+            return this.resources;
+        }
+        return this.resources.filter((resource) => resource.scope === scope);
+    }
+    async add(...moduleDef) {
+        await RsdkMetadataProvider.extractResources(moduleDef, this.resources);
+    }
+}
+exports.RsdkMetadataProvider = RsdkMetadataProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdk/metadata",
-  "version": "1.0.12",
+  "version": "2.0.0",
   "license": "Apache License 2.0",
   "description": "Rsdk stack metadata management",
   "main": "dist/index.js",
@@ -13,7 +13,10 @@
   "peerDependencies": {
     "@nestjs/common": "^9.0.0",
     "@nestjs/core": "^9.0.0",
+    "@rsdk/common": "^2.0.0",
+    "@rsdk/logging": "",
+    "@rsdk/nest-tools": "^2.0.0",
     "reflect-metadata": "^0.1.13"
   },
-  "gitHead": "e2741fe798655b87946330f8db0705e0f7ba2fb2"
+  "gitHead": "9fe1395b8e38e1c7b9578dd5eed12e0c57a9087f"
 }