@rsdk/metadata 3.1.0-next.0 → 3.1.0

package/dist/index.d.ts

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

package/dist/metadata.d.ts

@@ -1,6 +1,11 @@
 /**
  * Абстракция для изоляции значений метаданных...
  * От метаданных rsdk...
+ * Важное понятие - сигнатура/signature(подпись)
+ * Представляет собой композит значений полей `key` и `scope`
+ * Значения со значением поля `key="x"` будет считаться идентичным любому другому ресурсу с таким же значением, при условии равенства поля `scope`.
+ * Если поле `scope` не указано, ресурс будет равен только ресурсу с таким же ключом и без `scope` соответственно
+ * TODO: Стоит добавить хелпер `ResourceSignature` для упрощения взаимодействия и прозрачности работы с ним
  */
 export type Resource<T> = {
     /**
@@ -15,7 +20,7 @@ export type Resource<T> = {
      * В чём собственно дело
      * У нас есть ряд вещей которые необходимо объявить по принципу at-most-once.
      * Но так как они все переиспользуемые они декларируются везде где они нужны.
-     * Для того чтобы высекать такие вещи в ряде случаев сделано это поле, работает просто по сравнению `===`
+     * Для того чтобы высекать такие вещи в ряде случаев сделано это поле, работает просто по сравнению через `===`
      * Если значение с таким же скоупом уже есть, все последующие будут отброшены
      */
     key?: unknown;

package/dist/resource-aggregator.d.ts

@@ -0,0 +1,32 @@
+import type { Resource } from './metadata';
+/**
+ * Хелпер для работы с массивами ресурсов
+ */
+export declare class ResourceAggregator {
+    readonly resources: Resource<unknown>[];
+    private readonly map;
+    private readonly keys;
+    /**
+     * Проверка есть ли уже такой ресурс в агрегаторе
+     * @param resource
+     */
+    isDuplicate(resource: Resource<unknown>): boolean;
+    /**
+     * Добавить новый ресурс
+     * Если ресурс с такой же сигнатурой уже будет найден, он будет пропущен
+     * @param resources
+     */
+    add(...resources: Resource<unknown>[]): void;
+    /**
+     * Внутренний метод добавления, не делает никаких проверок на существование с такой же сигнатурой
+     * @param resource
+     * @private
+     */
+    private handle;
+    /**
+     * Добавляет сигнатуру в "существующие" в списке
+     * @param resource
+     * @private
+     */
+    private handleSignature;
+}

package/dist/resource-aggregator.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceAggregator = void 0;
+/**
+ * Хелпер для работы с массивами ресурсов
+ */
+class ResourceAggregator {
+    resources = [];
+    map = new Map();
+    keys = new Set();
+    /**
+     * Проверка есть ли уже такой ресурс в агрегаторе
+     * @param resource
+     */
+    isDuplicate(resource) {
+        const hasKey = Object.hasOwn(resource, 'key');
+        if (!hasKey) {
+            return false;
+        }
+        const hasScope = Object.hasOwn(resource, 'scope');
+        if (hasScope) {
+            const keys = this.map.get(resource.scope);
+            return Boolean(keys?.some((key) => key === resource.key));
+        }
+        return this.keys.has(resource.key);
+    }
+    /**
+     * Добавить новый ресурс
+     * Если ресурс с такой же сигнатурой уже будет найден, он будет пропущен
+     * @param resources
+     */
+    add(...resources) {
+        for (const resource of resources) {
+            const isDuplicate = this.isDuplicate(resource);
+            if (isDuplicate) {
+                continue;
+            }
+            this.handle(resource);
+        }
+    }
+    /**
+     * Внутренний метод добавления, не делает никаких проверок на существование с такой же сигнатурой
+     * @param resource
+     * @private
+     */
+    handle(resource) {
+        this.handleSignature(resource);
+        this.resources.push(resource);
+    }
+    /**
+     * Добавляет сигнатуру в "существующие" в списке
+     * @param resource
+     * @private
+     */
+    handleSignature(resource) {
+        const hasKey = Object.hasOwn(resource, 'key');
+        if (!hasKey) {
+            return;
+        }
+        const hasScope = Object.hasOwn(resource, 'scope');
+        if (hasScope) {
+            const keys = this.map.get(resource.scope) ?? [];
+            this.map.set(resource.scope, [...keys, resource.key]);
+            return;
+        }
+        this.keys.add(resource.key);
+    }
+}
+exports.ResourceAggregator = ResourceAggregator;

package/dist/resource-extractor.d.ts

@@ -0,0 +1,5 @@
+import type { ClassProvider, DynamicModule, ExistingProvider, FactoryProvider, InjectionToken, ValueProvider } from '@nestjs/common';
+import type { Resource } from './metadata';
+export interface ResourceExtractor {
+    extract(value: DynamicModule | ClassProvider<any> | ValueProvider<any> | FactoryProvider<any> | ExistingProvider<any> | InjectionToken): Resource<unknown>[];
+}

package/dist/resource-extractor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -2,6 +2,7 @@ import type { ClassProvider, DynamicModule, ExistingProvider, FactoryProvider, I
 import type { NestModuleDefinition } from '@rsdk/common.nestjs';
 import type { Promisable } from 'type-fest';
 import type { Resource } from './metadata';
+import type { ResourceExtractor } from './resource-extractor';
 /**
  * Провайдер агрегирующий в себе ресурсы из метаданных
  * По задумке должен выступать лишь в роли фасада/агрегатора который знает о структуре ресурсов и её значении
@@ -10,17 +11,16 @@ import type { Resource } from './metadata';
 export declare class RsdkMetadataProvider {
     private readonly resources;
     protected constructor(resources: Resource<any>[]);
-    static create(...rootModule: Promisable<NestModuleDefinition>[]): Promise<RsdkMetadataProvider>;
+    static create(modules: Promisable<NestModuleDefinition>[], extractors?: ResourceExtractor[]): 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;
+    static isDuplicate(resources: Resource<any>[], definitionResource: Resource<unknown>): boolean;
+    private static extractResources;
     get<T>(scope?: string): Resource<T>[];
     add(...moduleDef: Promisable<NestModuleDefinition>[]): Promise<void>;
 }

package/dist/rsdk-metadata-provider.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RsdkMetadataProvider = void 0;
 const nest_tools_1 = require("@rsdk/nest-tools");
 const metadata_1 = require("./metadata");
+const resource_aggregator_1 = require("./resource-aggregator");
 /**
  * Провайдер агрегирующий в себе ресурсы из метаданных
  * По задумке должен выступать лишь в роли фасада/агрегатора который знает о структуре ресурсов и её значении
@@ -13,9 +14,9 @@ class RsdkMetadataProvider {
     constructor(resources) {
         this.resources = resources;
     }
-    static async create(...rootModule) {
+    static async create(modules, extractors) {
         const resources = [];
-        await this.extractResources(rootModule, resources);
+        await this.extractResources(modules, resources, extractors);
         return new RsdkMetadataProvider(resources);
     }
     static *getMetadataSource(nestDefinition) {
@@ -30,7 +31,17 @@ class RsdkMetadataProvider {
         }
         yield nestDefinition;
     }
-    static async extractResources(rootModule, resources) {
+    /**
+     * Есть ли уже этот ресурс в массиве
+     * Проверка осуществляется на основе `key` и `scope` у `Resource`
+     * @param resources
+     * @param definitionResource
+     */
+    static isDuplicate(resources, definitionResource) {
+        return resources.some((resource) => metadata_1.RsdkMetadata.isEqual(resource, definitionResource));
+    }
+    static async extractResources(rootModule, resources, extractors) {
+        const agg = new resource_aggregator_1.ResourceAggregator();
         for await (const rootModuleElement of rootModule) {
             const nestDefinitionIterator = new nest_tools_1.NestDefinitionIterator(rootModuleElement);
             for await (const _nestDefinition of nestDefinitionIterator.iterate()) {
@@ -39,29 +50,23 @@ class RsdkMetadataProvider {
                         continue;
                     }
                     const definitionResources = metadata_1.RsdkMetadata.get(value);
-                    if (!definitionResources) {
+                    const extractedResources = extractors?.reduce((acc, extractor) => {
+                        const resources = extractor.extract(value);
+                        acc.push(...resources);
+                        return acc;
+                    }, []);
+                    const foundedResources = [
+                        ...(definitionResources ?? []),
+                        ...(extractedResources ?? []),
+                    ];
+                    if (!foundedResources?.length) {
                         continue;
                     }
-                    for (const definitionResource of definitionResources) {
-                        const isDuplicate = this.isDuplicate(resources, definitionResource);
-                        if (isDuplicate) {
-                            continue;
-                        }
-                        resources.push(definitionResource);
-                    }
+                    agg.add(...foundedResources);
                 }
             }
         }
-    }
-    /**
-     * Есть ли уже этот ресурс в массиве
-     * Проверка осуществляется на основе `key` и `scope` у `Resource`
-     * @param resources
-     * @param definitionResource
-     * @private
-     */
-    static isDuplicate(resources, definitionResource) {
-        return resources.some((resource) => metadata_1.RsdkMetadata.isEqual(resource, definitionResource));
+        resources.push(...agg.resources);
     }
     get(scope) {
         if (scope === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsdk/metadata",
-  "version": "3.1.0-next.0",
+  "version": "3.1.0",
   "license": "Apache License 2.0",
   "description": "Rsdk stack metadata management",
   "main": "dist/index.js",
@@ -13,10 +13,10 @@
   "peerDependencies": {
     "@nestjs/common": "^10.1.3",
     "@nestjs/core": "^10.1.3",
-    "@rsdk/common": "^3.1.0-next.0",
-    "@rsdk/logging": "^3.1.0-next.0",
-    "@rsdk/nest-tools": "^3.1.0-next.0",
+    "@rsdk/common": "^3.1.0",
+    "@rsdk/logging": "^3.1.0",
+    "@rsdk/nest-tools": "^3.1.0",
     "reflect-metadata": "^0.1.13"
   },
-  "gitHead": "55598931db264fb6d5b5c4787c48298ed86bbc0d"
+  "gitHead": "428640441ec53822ea1c1be7b085bb9dad04689d"
 }