@xyo-network/module-abstract 2.51.10

package/src/Resolver/SimpleModuleResolver.ts

@@ -0,0 +1,118 @@
+import {
+  AddressModuleFilter,
+  Module,
+  ModuleFilter,
+  ModuleRepository,
+  ModuleResolver,
+  NameModuleFilter,
+  QueryModuleFilter,
+} from '@xyo-network/module-model'
+import { Promisable } from '@xyo-network/promise'
+import compact from 'lodash/compact'
+import flatten from 'lodash/flatten'
+
+//This class is now package private (not exported from index.ts)
+export class SimpleModuleResolver implements ModuleRepository {
+  private addressToName: Record<string, string> = {}
+  private modules: Record<string, Module> = {}
+
+  get isModuleResolver() {
+    return true
+  }
+
+  add(module: Module): this
+  add(module: Module[]): this
+  add(module: Module | Module[]): this {
+    if (Array.isArray(module)) {
+      module.forEach((module) => this.addSingleModule(module))
+    } else {
+      this.addSingleModule(module)
+    }
+    return this
+  }
+
+  addResolver(_resolver: ModuleResolver): this {
+    throw 'Adding resolvers not supported'
+  }
+
+  remove(address: string | string[]): this {
+    if (Array.isArray(address)) {
+      address.forEach((address) => this.removeSingleModule(address))
+    } else {
+      this.removeSingleModule(address)
+    }
+    return this
+  }
+
+  removeResolver(_resolver: ModuleResolver): this {
+    throw 'Removing resolvers not supported'
+  }
+
+  resolve<T extends Module = Module>(filter?: ModuleFilter): Promisable<T[]> {
+    const filteredByName: T[] = this.resolveByName<T>(Object.values(this.modules) as T[], (filter as NameModuleFilter)?.name)
+
+    const filteredByAddress: T[] = (filter as AddressModuleFilter)?.address
+      ? this.resolveByAddress<T>(filteredByName, (filter as AddressModuleFilter)?.address)
+      : filteredByName
+
+    const filteredByQuery: T[] = (filter as QueryModuleFilter)?.query
+      ? this.resolveByQuery<T>(filteredByAddress, (filter as QueryModuleFilter)?.query)
+      : filteredByAddress
+
+    return filteredByQuery
+  }
+
+  private addSingleModule(module?: Module) {
+    if (module) {
+      this.modules[module.address] = module
+    }
+  }
+
+  private removeSingleModule(address: string) {
+    if (address) {
+      if (this.modules[address]) {
+        delete this.modules[address]
+        const name = this.addressToName[address]
+        if (name) {
+          delete this.addressToName[address]
+        }
+      }
+    }
+  }
+
+  private resolveByAddress<T extends Module = Module>(modules: T[], address?: string[]): T[] {
+    return address
+      ? compact(
+          flatten(
+            address?.map((address) => {
+              return modules.filter((module) => module.address === address)
+            }),
+          ),
+        )
+      : modules
+  }
+
+  private resolveByName<T extends Module = Module>(modules: T[], name?: string[]): T[] {
+    if (name) {
+      return compact(name.map((name) => modules.filter((module) => module.config.name === name)).flat())
+    }
+    return modules
+  }
+
+  private resolveByQuery<T extends Module = Module>(modules: T[], query?: string[][]): T[] {
+    return query
+      ? compact(
+          modules.filter((module) =>
+            query?.reduce((supported, queryList) => {
+              return (
+                queryList.reduce((supported, query) => {
+                  const queryable = module.queries.includes(query)
+                  return supported && queryable
+                }, true) || supported
+              )
+            }, false),
+          ),
+        )
+      : modules
+  }
+}

package/src/Resolver/index.ts

@@ -0,0 +1,8 @@
+import { CompositeModuleResolver } from './CompositeModuleResolver'
+export * from './ResolverEventEmitter'
+
+/** @deprecated use ModuleResolver */
+class SimpleModuleResolver extends CompositeModuleResolver {}
+
+// eslint-disable-next-line deprecation/deprecation
+export { CompositeModuleResolver, SimpleModuleResolver }

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './AbstractModule'
+export * from './BaseEmitter'
+export * from './Error'
+export * from './lib'
+export * from './ModuleWrapper'
+export * from './Query'
+export * from './QueryValidator'
+export * from './Resolver'

package/src/lib/duplicateModules.ts

@@ -0,0 +1,14 @@
+import { Module } from '@xyo-network/module-model'
+
+/**
+ * Used to filter duplicates from an array of modules
+ * @example: modulesArray.filter(duplicateModules)
+ * @param value Current Module
+ * @param index Current Module's index
+ * @param array Module Array
+ * @returns True if the Module's address is the first occurrence of
+ * that address in the array, false otherwise
+ */
+export const duplicateModules = (value: Module, index: number, array: Module[]): value is Module => {
+  return array.findIndex((v) => v.address === value.address) === index
+}

package/src/lib/index.ts

@@ -0,0 +1,2 @@
+export * from './duplicateModules'
+export * from './serializable'

package/src/lib/serializable.ts

@@ -0,0 +1,41 @@
+// Inspired by https://stackoverflow.com/a/49079549/2803259
+
+import every from 'lodash/every'
+import isArray from 'lodash/isArray'
+import isBoolean from 'lodash/isBoolean'
+import isNull from 'lodash/isNull'
+import isNumber from 'lodash/isNumber'
+import isPlainObject from 'lodash/isPlainObject'
+import isString from 'lodash/isString'
+import isUndefined from 'lodash/isUndefined'
+import overSome from 'lodash/overSome'
+
+const JSONPrimitiveChecks = [isUndefined, isNull, isBoolean, isNumber, isString]
+const JSONComplexChecks = [isPlainObject, isArray]
+
+export const serializable = (field: unknown, depth?: number): boolean | null => {
+  let depthExceeded = false
+  const decrementDepth = () => (depth ? depth-- : undefined)
+
+  const recursiveSerializable = (field: unknown) => {
+    if (depth !== undefined && depth < 1) {
+      depthExceeded = true
+      return false
+    }
+
+    // decrement during every recursion
+    decrementDepth()
+
+    const nestedSerializable = (field: unknown): boolean => overSome(JSONComplexChecks)(field) && every(field as object, recursiveSerializable)
+
+    return overSome([...JSONPrimitiveChecks, nestedSerializable])(field)
+  }
+
+  const valid = recursiveSerializable(field)
+
+  return depthExceeded ? null : valid
+}
+
+export const serializableField = (field: unknown) => {
+  return overSome([...JSONPrimitiveChecks, ...JSONComplexChecks])(field)
+}