@syncbridge/common 0.4.7 → 0.5.1

package/registry/extension-registry.js

@@ -0,0 +1,234 @@
+import { deepClone } from '@jsopen/objects';
+import semver from 'semver';
+import { COMPONENT_OPTIONS } from '../constants.js';
+import { resolvePromisesDeep } from '../utils/resolve-promises.js';
+import { ExtensionPackage, ExtensionPackageComponent, ExtensionPackageProcessor, } from './extension-package.js';
+export var ExtensionRegistry;
+(function (ExtensionRegistry) {
+    let _resolver = import.meta.resolve;
+    ExtensionRegistry.packages = new Map();
+    ExtensionRegistry.components = new Map();
+    ExtensionRegistry.processors = new Map();
+    /**
+     *
+     */
+    function findComponent(className, version = '*') {
+        return ExtensionRegistry.components
+            .get(className)
+            ?.find(v => semver.satisfies(v.version, version || '*'));
+    }
+    ExtensionRegistry.findComponent = findComponent;
+    /**
+     *
+     */
+    function getComponent(className, version = '*') {
+        const cmp = findComponent(className, version);
+        if (cmp)
+            return cmp;
+        throw new Error(`Component "${className}" version "${version}" not found in registry`);
+    }
+    ExtensionRegistry.getComponent = getComponent;
+    /**
+     *
+     */
+    function findProcessor(className, version = '*') {
+        return ExtensionRegistry.processors
+            .get(className)
+            ?.find(v => semver.satisfies(v.version, version || '*'));
+    }
+    ExtensionRegistry.findProcessor = findProcessor;
+    /**
+     *
+     */
+    function getProcessor(className, version = '*') {
+        const cmp = findProcessor(className, version);
+        if (!cmp) {
+            throw new Error(`Processor "${className}" version "${version}" not found in registry`);
+        }
+        return cmp;
+    }
+    ExtensionRegistry.getProcessor = getProcessor;
+    /**
+     *
+     * @param resolver
+     */
+    function setResolver(resolver) {
+        _resolver = resolver;
+    }
+    ExtensionRegistry.setResolver = setResolver;
+    /**
+     *
+     */
+    async function registerExtensionPackage(directory) {
+        const pkg = await ExtensionPackage.fromDirectory(directory);
+        storePackage(pkg);
+        return pkg;
+    }
+    ExtensionRegistry.registerExtensionPackage = registerExtensionPackage;
+    /**
+     *
+     */
+    async function registerNodePackage(specifier) {
+        const pkg = await ExtensionPackage.fromNodePackage(specifier, _resolver);
+        storePackage(pkg);
+        return pkg;
+    }
+    ExtensionRegistry.registerNodePackage = registerNodePackage;
+    async function registerComponent(ctor) {
+        const _metadata = Reflect.getMetadata(COMPONENT_OPTIONS, ctor);
+        if (!_metadata)
+            throw new TypeError(`Class "${ctor.name}" has no component metadata.`);
+        if (_metadata.abstract)
+            return;
+        let metadata = await resolvePromisesDeep(_metadata);
+        metadata = deepClone({
+            className: metadata.className,
+            displayName: metadata.displayName,
+            description: metadata.description,
+            iconUrl: metadata.iconUrl,
+            author: metadata.author,
+            interfaces: metadata.interfaces,
+            tags: metadata.tags,
+            abstract: metadata.abstract,
+            variables: metadata.variables,
+            components: metadata.components,
+            ...metadata,
+        });
+        if (metadata.variables) {
+            /** Convert object enumValues to arrays */
+            for (const v of Object.values(metadata.variables)) {
+                if (v.enumValues &&
+                    typeof v.enumValues === 'object' &&
+                    !Array.isArray(v.enumValues)) {
+                    let values = v.enumValues;
+                    const keys = Object.keys(values).filter(k => !/^\d+$/.test(k));
+                    values = keys.reduce((a, k) => {
+                        if (values[k] != null)
+                            a.push(values[k]);
+                        return a;
+                        // v => !(typeof v === 'number' && !keys.includes(String(v))),
+                    }, []);
+                    v.enumValues = values;
+                }
+            }
+        }
+        let versions = ExtensionRegistry.packages.get('internal');
+        if (!versions) {
+            versions = [];
+            ExtensionRegistry.packages.set('internal', versions);
+        }
+        let pkg = versions[0];
+        if (!pkg) {
+            pkg = new ExtensionPackage();
+            pkg.name = 'internal';
+            pkg.version = '0.0.0';
+            pkg.description = 'Internal extensions';
+        }
+        const cmp = new ExtensionPackageComponent(pkg, ctor.name, metadata, ctor);
+        pkg.components.push(cmp);
+        storePackage(pkg);
+        return cmp;
+    }
+    ExtensionRegistry.registerComponent = registerComponent;
+    async function registerProcessor(ctor) {
+        const _metadata = Reflect.getMetadata(COMPONENT_OPTIONS, ctor);
+        if (!_metadata)
+            throw new TypeError(`Class "${ctor.name}" has no processor metadata.`);
+        if (_metadata.abstract)
+            return;
+        let metadata = await resolvePromisesDeep(_metadata);
+        metadata = deepClone({
+            className: metadata.className,
+            displayName: metadata.displayName,
+            description: metadata.description,
+            iconUrl: metadata.iconUrl,
+            author: metadata.author,
+            tags: metadata.tags,
+            abstract: metadata.abstract,
+            variables: metadata.variables,
+            components: metadata.components,
+            ...metadata,
+        });
+        if (metadata.variables) {
+            /** Convert object enumValues to arrays */
+            for (const v of Object.values(metadata.variables)) {
+                if (v.enumValues &&
+                    typeof v.enumValues === 'object' &&
+                    !Array.isArray(v.enumValues)) {
+                    let values = v.enumValues;
+                    const keys = Object.keys(values).filter(k => !/^\d+$/.test(k));
+                    values = keys.reduce((a, k) => {
+                        if (values[k] != null)
+                            a.push(values[k]);
+                        return a;
+                        // v => !(typeof v === 'number' && !keys.includes(String(v))),
+                    }, []);
+                    v.enumValues = values;
+                }
+            }
+        }
+        let versions = ExtensionRegistry.packages.get('internal');
+        if (!versions) {
+            versions = [];
+            ExtensionRegistry.packages.set('internal', versions);
+        }
+        let pkg = versions[0];
+        if (!pkg) {
+            pkg = new ExtensionPackage();
+            pkg.name = 'internal';
+            pkg.version = '0.0.0';
+            pkg.description = 'Internal extensions';
+        }
+        const prc = new ExtensionPackageProcessor(pkg, ctor.name, metadata, ctor);
+        pkg.processors.push(prc);
+        storePackage(pkg);
+        return prc;
+    }
+    ExtensionRegistry.registerProcessor = registerProcessor;
+    /**
+     *
+     * @private
+     */
+    function storePackage(pkg) {
+        pkg.sortVersions();
+        let pkgVersions = ExtensionRegistry.packages.get(pkg.name);
+        if (!pkgVersions) {
+            pkgVersions = [];
+            ExtensionRegistry.packages.set(pkg.name, pkgVersions);
+        }
+        let i = pkgVersions.findIndex(v => v.version === pkg.version);
+        if (i >= 0)
+            pkgVersions[i] = pkg;
+        else
+            pkgVersions.push(pkg);
+        pkgVersions.sort((a, b) => a.version.localeCompare(b.version));
+        if (pkg.components?.length) {
+            for (const cmp of pkg.components) {
+                let versions = ExtensionRegistry.components.get(cmp.className);
+                if (!versions) {
+                    versions = [];
+                    ExtensionRegistry.components.set(cmp.className, versions);
+                }
+                i = versions.findIndex(v => v.version === cmp.version);
+                if (i >= 0)
+                    versions[i] = cmp;
+                else
+                    versions.push(cmp);
+            }
+        }
+        if (pkg.processors?.length) {
+            for (const prc of pkg.processors) {
+                let versions = ExtensionRegistry.processors.get(prc.className);
+                if (!versions) {
+                    versions = [];
+                    ExtensionRegistry.processors.set(prc.className, versions);
+                }
+                i = versions.findIndex(v => v.version === prc.version);
+                if (i >= 0)
+                    versions[i] = prc;
+                else
+                    versions.push(prc);
+            }
+        }
+    }
+})(ExtensionRegistry || (ExtensionRegistry = {}));

package/registry/registry.js

@@ -0,0 +1,273 @@
+"use strict";
+// import * as fs from 'node:fs';
+// import path from 'node:path';
+// import process from 'node:process';
+// import { fileURLToPath, pathToFileURL } from 'node:url';
+// import { deepClone, isPlainObject } from '@jsopen/objects';
+// import { Type } from 'ts-gems';
+// import type { ComponentBase } from '../classes/component-base.js';
+// import type { ProcessorBase } from '../classes/processor-base.js';
+// import { COMPONENT_OPTIONS, PROCESSOR_OPTIONS } from '../constants.js';
+// import { ComponentMetadata, ProcessorMetadata } from '../models/index.js';
+// import { isExtensionPackage } from '../utils/make-extension-package.js';
+//
+// export namespace ExtensionRegistry {
+//   let _resolver = import.meta.resolve;
+//
+//   export const packages = new Map<
+//     string,
+//     ExtensionRegistry.ExtensionPackageRecord
+//   >();
+//   export const components = new Map<
+//     string,
+//     ExtensionRegistry.ComponentRecord
+//   >();
+//   export const processors = new Map<
+//     string,
+//     ExtensionRegistry.ProcessorRecord
+//   >();
+//
+//   export function setResolver(resolver: (name: string) => string) {
+//     _resolver = resolver;
+//   }
+//
+//   export function getProcessor(
+//     className: string,
+//   ): ExtensionRegistry.ProcessorRecord {
+//     const rec = ExtensionRegistry.processors.get(className);
+//     if (!rec) {
+//       throw new Error(`Processor "${className}" not found in registry`);
+//     }
+//     return rec;
+//   }
+//
+//   export function getComponent(
+//     className: string,
+//   ): ExtensionRegistry.ComponentRecord {
+//     const rec = ExtensionRegistry.components.get(className);
+//     if (!rec) {
+//       throw new Error(`Component "${className}" not found in registry`);
+//     }
+//     return rec;
+//   }
+//
+//   export async function registerPackage(
+//     ...specifiers: string[]
+//   ): Promise<void> {
+//     const errors: string[] = [];
+//     await Promise.all(
+//       specifiers.map(specifier =>
+//         _registerPackage(specifier).catch(err => {
+//           errors.push(`\n    ${specifier}: ${err.message}`);
+//         }),
+//       ),
+//     );
+//     if (errors.length) {
+//       console.error(`Failed to register extensions:${errors}`);
+//     }
+//   }
+//
+//   async function _registerPackage(
+//     specifier: string,
+//     options?: {
+//       ignoreInvalid?: boolean;
+//     },
+//   ): Promise<void> {
+//     let packagePath = fileURLToPath(_resolver(specifier));
+//     const json = locatePkgJson(path.dirname(packagePath));
+//     if (!json) {
+//       if (options?.ignoreInvalid) return;
+//       throw new TypeError(`Can't locate package.json file for "${specifier}"`);
+//     }
+//
+//     if (path.isAbsolute(packagePath) && process.platform === 'win32') {
+//       packagePath = pathToFileURL(packagePath).href;
+//     }
+//
+//     const pkg = (await import(packagePath)).default;
+//     if (!isExtensionPackage(pkg)) {
+//       if (options?.ignoreInvalid) return;
+//       throw new TypeError(
+//         `"${specifier}" do not export ExtensionPackage interface`,
+//       );
+//     }
+//     // ignore if already registered
+//     if (packages.get(json.name)) return;
+//
+//     // Register dependencies
+//     if (pkg.dependencies) {
+//       for (const dep of pkg.dependencies)
+//         await _registerPackage(dep, { ignoreInvalid: true });
+//     }
+//
+//     const packageRec: ExtensionRegistry.ExtensionPackageRecord = Object.freeze({
+//       name: json.name,
+//       version: json.version,
+//       description: json.description,
+//     });
+//     packages.set(packageRec.name, packageRec);
+//
+//     if (Array.isArray(pkg.components)) {
+//       for (const ctor of pkg.components) {
+//         await registerComponent(ctor, packageRec.name);
+//       }
+//     }
+//
+//     if (Array.isArray(pkg.processors)) {
+//       for (const ctor of pkg.processors) {
+//         await registerProcessor(ctor, packageRec.name);
+//       }
+//     }
+//   }
+//
+//   export async function registerComponent(ctor: Type, packageName: string) {
+//     const _metadata: ComponentMetadata = Reflect.getMetadata(
+//       COMPONENT_OPTIONS,
+//       ctor,
+//     );
+//     if (!_metadata)
+//       throw new TypeError(`Class "${ctor.name}" has no component metadata.`);
+//     if (_metadata.abstract) return;
+//     let componentRec = components.get(_metadata.className);
+//     if (componentRec)
+//       throw new TypeError(
+//         `Component "${_metadata.className}" already registered by "${componentRec.package}" package`,
+//       );
+//
+//     let metadata: ComponentMetadata = await resolvePromisesDeep(_metadata);
+//     metadata = deepClone({
+//       className: metadata.className,
+//       displayName: metadata.displayName,
+//       description: metadata.description,
+//       iconUrl: metadata.iconUrl,
+//       author: metadata.author,
+//       interfaces: metadata.interfaces,
+//       tags: metadata.tags,
+//       abstract: metadata.abstract,
+//       variables: metadata.variables,
+//       components: metadata.components,
+//       ...(metadata as any),
+//     });
+//     if (metadata.variables) {
+//       /** Convert object enumValues to arrays */
+//       for (const v of Object.values(metadata.variables)) {
+//         if (
+//           v.enumValues &&
+//           typeof v.enumValues === 'object' &&
+//           !Array.isArray(v.enumValues)
+//         ) {
+//           let values: any = v.enumValues;
+//           const keys = Object.keys(values).filter(k => !/^\d+$/.test(k));
+//           values = keys.reduce((a, k) => {
+//             if (values[k] != null) a.push(values[k]);
+//             return a;
+//             // v => !(typeof v === 'number' && !keys.includes(String(v))),
+//           }, [] as any[]);
+//           v.enumValues = values;
+//         }
+//       }
+//     }
+//
+//     componentRec = {
+//       package: packageName,
+//       ctor,
+//       metadata,
+//     };
+//     components.set(metadata.className, componentRec);
+//   }
+//
+//   export async function registerProcessor(ctor: Type, packageName: string) {
+//     const _metadata: ProcessorMetadata = Reflect.getMetadata(
+//       PROCESSOR_OPTIONS,
+//       ctor,
+//     );
+//     if (!_metadata)
+//       throw new TypeError(`Class "${ctor.name}" has no processor metadata.`);
+//     if (_metadata.abstract) return;
+//     let processorRec = processors.get(_metadata.className);
+//     if (processorRec)
+//       throw new TypeError(
+//         `Processor "${_metadata.className}" already registered by "${processorRec.package}" package`,
+//       );
+//     let metadata: ComponentMetadata = await resolvePromisesDeep(_metadata);
+//     metadata = deepClone({
+//       className: metadata.className,
+//       displayName: metadata.displayName,
+//       description: metadata.description,
+//       iconUrl: metadata.iconUrl,
+//       author: metadata.author,
+//       tags: metadata.tags,
+//       abstract: metadata.abstract,
+//       variables: metadata.variables,
+//       components: metadata.components,
+//       ...(metadata as any),
+//     });
+//     if (metadata.variables) {
+//       /** Convert object enumValues to arrays */
+//       for (const v of Object.values(metadata.variables)) {
+//         if (
+//           v.enumValues &&
+//           typeof v.enumValues === 'object' &&
+//           !Array.isArray(v.enumValues)
+//         ) {
+//           let values: any = v.enumValues;
+//           const keys = Object.keys(values).filter(k => !/^\d+$/.test(k));
+//           values = keys.reduce((a, k) => {
+//             if (values[k] != null) a.push(values[k]);
+//             return a;
+//             // v => !(typeof v === 'number' && !keys.includes(String(v))),
+//           }, [] as any[]);
+//           v.enumValues = values;
+//         }
+//       }
+//     }
+//     processorRec = {
+//       package: packageName,
+//       ctor,
+//       metadata,
+//     };
+//     processors.set(metadata.className, processorRec);
+//   }
+// }
+//
+// function locatePkgJson(directory: string): Record<string, any> | undefined {
+//   if (directory.startsWith('file:')) directory = fileURLToPath(directory);
+//   for (let i = 0; i < 3; i++) {
+//     const f = path.resolve(directory, 'package.json');
+//     if (fs.existsSync(f)) {
+//       const json = JSON.parse(fs.readFileSync(f, 'utf8'));
+//       if (json.name && json.version) return json;
+//     }
+//     directory = path.dirname(directory);
+//   }
+// }
+//
+// async function resolvePromisesDeep(obj: any) {
+//   obj = await obj;
+//   if (obj && isPlainObject(obj)) {
+//     for (const k of Object.keys(obj)) {
+//       obj[k] = await resolvePromisesDeep(obj[k]);
+//     }
+//   }
+//   return obj;
+// }
+//
+// export namespace ExtensionRegistry {
+//   export interface ExtensionPackageRecord {
+//     name: string;
+//     description?: string;
+//     version: string;
+//   }
+//
+//   export interface ComponentRecord {
+//     package: string;
+//     ctor: Type<ComponentBase>;
+//     metadata: ComponentMetadata;
+//   }
+//
+//   export interface ProcessorRecord {
+//     package: string;
+//     ctor: Type<ProcessorBase>;
+//     metadata: ProcessorMetadata;
+//   }
+// }

package/utils/metadata-utils.js

@@ -1,7 +1,7 @@
 import { clone, merge, omitUndefined } from '@jsopen/objects';
 import { SbError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
-import { ExtensionRegistry } from '../registry.js';
+import { ExtensionRegistry } from '../registry/extension-registry.js';
 export function materializeMetadata(profile) {
     const { metadata, issues } = materializeMetadataSilent(profile);
     if (issues?.length) {

package/utils/resolve-promises.d.ts

@@ -0,0 +1 @@
+export declare function resolvePromisesDeep(obj: any): Promise<any>;

package/utils/resolve-promises.js

@@ -0,0 +1,10 @@
+import { isPlainObject } from '@jsopen/objects';
+export async function resolvePromisesDeep(obj) {
+    obj = await obj;
+    if (obj && isPlainObject(obj)) {
+        for (const k of Object.keys(obj)) {
+            obj[k] = await resolvePromisesDeep(obj[k]);
+        }
+    }
+    return obj;
+}

package/interfaces/extension-package.interface.d.ts

@@ -1,6 +0,0 @@
-import type { Type } from 'ts-gems';
-export interface IExtensionPackage {
-    components: Type[];
-    processors: Type[];
-    dependencies?: string[];
-}

package/interfaces/extension-package.interface.js

@@ -1 +0,0 @@
-export {};

package/registry.d.ts

@@ -1,32 +0,0 @@
-import { Type } from 'ts-gems';
-import type { ComponentBase } from './classes/component-base.js';
-import type { ProcessorBase } from './classes/processor-base.js';
-import type { ComponentMetadata, ProcessorMetadata } from './models/index.js';
-export declare namespace ExtensionRegistry {
-    const packages: Map<string, ExtensionPackageRecord>;
-    const components: Map<string, ComponentRecord>;
-    const processors: Map<string, ProcessorRecord>;
-    function setResolver(resolver: (name: string) => string): void;
-    function getProcessor(className: string): ExtensionRegistry.ProcessorRecord;
-    function getComponent(className: string): ExtensionRegistry.ComponentRecord;
-    function registerPackage(...specifiers: string[]): Promise<void>;
-    function registerComponent(ctor: Type, packageName: string): Promise<void>;
-    function registerProcessor(ctor: Type, packageName: string): Promise<void>;
-}
-export declare namespace ExtensionRegistry {
-    interface ExtensionPackageRecord {
-        name: string;
-        description?: string;
-        version: string;
-    }
-    interface ComponentRecord {
-        package: string;
-        ctor: Type<ComponentBase>;
-        metadata: ComponentMetadata;
-    }
-    interface ProcessorRecord {
-        package: string;
-        ctor: Type<ProcessorBase>;
-        metadata: ProcessorMetadata;
-    }
-}