@xyo-network/module-model 2.64.7 → 2.64.9

package/src/Queries/index.ts

@@ -1,12 +1,15 @@
 import { Query } from '../Query'
+import { ModuleDescribeQuery } from './Describe'
 import { ModuleDiscoverQuery } from './Discover'
 import { ModuleAddressQuery } from './ModuleAddress'
 import { ModuleSubscribeQuery } from './Subscribe'
 
+export * from './Describe'
 export * from './Discover'
+export * from './Manifest'
 export * from './ModuleAddress'
 export * from './Subscribe'
 
-export type ModuleQueryBase = ModuleDiscoverQuery | ModuleAddressQuery | ModuleSubscribeQuery
+export type ModuleQueryBase = ModuleDiscoverQuery | ModuleAddressQuery | ModuleSubscribeQuery | ModuleDescribeQuery
 
 export type ModuleQuery<T extends Query | void = void> = T extends Query ? ModuleQueryBase | T : ModuleQueryBase

package/src/asModule.ts

@@ -0,0 +1,39 @@
+import { assertEx } from '@xylabs/assert'
+
+import { InstanceTypeCheck, isModule, isModuleInstance } from './isModule'
+
+export const AsFactory = {
+  create: <TModule extends object>(typeCheck: InstanceTypeCheck<TModule>) => {
+    function func(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      module: any,
+    ): TModule | undefined
+    function func(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      module: any,
+      assert: string | (() => string),
+    ): TModule
+    function func(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      module: any,
+      assert?: string | (() => string),
+    ): TModule | undefined {
+      const result = typeCheck(module) ? module : undefined
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const noUndefined = (assert: any): assert is TModule => {
+        return !!assert
+      }
+
+      if (noUndefined(assert)) {
+        return assertEx(result, typeof assert === 'function' ? assert() : assert)
+      } else {
+        return result
+      }
+    }
+    return func
+  },
+}
+
+export const asModule = AsFactory.create(isModule)
+export const asModuleInstance = AsFactory.create(isModuleInstance)

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from './asModule'
 export * from './Config'
 export * from './CreatableModule'
 export * from './Error'

package/src/isModule.ts

@@ -1,10 +1,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { ModuleInstance } from './Module'
-import { ModuleAddressQuerySchema, ModuleDiscoverQuerySchema } from './Queries'
+import { DirectModule, IndirectModule, Module, ModuleInstance } from './Module'
 
 export type InstanceTypeCheck<T extends object = object> = (module: object) => module is T
 
-export type ModuleTypeCheck<T extends ModuleInstance = ModuleInstance> = InstanceTypeCheck<T>
+export type ModuleTypeCheck<T extends Module = Module> = InstanceTypeCheck<T>
 
 export type FieldType = 'string' | 'number' | 'object' | 'symbol' | 'symbol' | 'undefined' | 'null' | 'array' | 'function' | 'payload'
 
@@ -22,7 +21,7 @@ export const isType = (value: any, expectedType: FieldType) => {
 
 export const IsInstanceFactory = {
   create: <T extends object = object>(shape?: InstanceTypeShape, additionalCheck?: (module: any) => boolean): InstanceTypeCheck<T> => {
-    return (module: any): module is T => {
+    return (module: any = {}): module is T => {
       return (
         (additionalCheck?.(module) ?? true) &&
         (Object.entries(shape ?? {}).reduce((prev, [key, type]) => prev && isType(module[key], type), true) ?? true)
@@ -31,9 +30,9 @@ export const IsInstanceFactory = {
   },
 }
 
-export const IsModuleFactory = {
-  create: <T extends ModuleInstance = ModuleInstance>(expectedQueries?: string[], additionalCheck?: (module: any) => boolean): ModuleTypeCheck<T> => {
-    return (module: any): module is T => {
+export const IsIndirectModuleFactory = {
+  create: <T extends IndirectModule = IndirectModule>(expectedQueries?: string[], additionalCheck?: (module: any) => boolean): ModuleTypeCheck<T> => {
+    return (module: any = {}): module is T => {
       return (
         isModuleInstance(module) &&
         (additionalCheck?.(module) ?? true) &&
@@ -43,13 +42,13 @@ export const IsModuleFactory = {
   },
 }
 
-export const isModuleInstance: InstanceTypeCheck<ModuleInstance> = IsInstanceFactory.create<ModuleInstance>({
+export const IsModuleFactory = IsIndirectModuleFactory
+
+export const isIndirectModuleInstance: InstanceTypeCheck<ModuleInstance> = IsInstanceFactory.create<ModuleInstance>({
   account: 'object',
   address: 'string',
   config: 'object',
-  discover: 'function',
   downResolver: 'object',
-  manifest: 'function',
   params: 'object',
   queries: 'array',
   query: 'function',
@@ -57,4 +56,37 @@ export const isModuleInstance: InstanceTypeCheck<ModuleInstance> = IsInstanceFac
   upResolver: 'object',
 })
 
-export const isModule: ModuleTypeCheck<ModuleInstance> = IsModuleFactory.create<ModuleInstance>([ModuleAddressQuerySchema, ModuleDiscoverQuerySchema])
+export const isDirectModuleInstance: InstanceTypeCheck<ModuleInstance> = IsInstanceFactory.create<ModuleInstance>({
+  description: 'function',
+  discover: 'function',
+  manifest: 'function',
+  subscribe: 'function',
+})
+
+export const isModuleInstance = isIndirectModuleInstance
+
+export const isDirectModule = <T extends DirectModule = DirectModule>(
+  module: any = {},
+  expectedQueries?: string[],
+  additionalCheck?: (module: any) => boolean,
+): module is T => {
+  return (
+    isDirectModuleInstance(module) &&
+    (additionalCheck?.(module) ?? true) &&
+    (expectedQueries?.reduce((prev, query) => prev && module.queries.includes(query), true) ?? true)
+  )
+}
+
+export const isIndirectModule = <T extends IndirectModule = IndirectModule>(
+  module: any = {},
+  expectedQueries?: string[],
+  additionalCheck?: (module: any) => boolean,
+): module is T => {
+  return (
+    isIndirectModuleInstance(module) &&
+    (additionalCheck?.(module) ?? true) &&
+    (expectedQueries?.reduce((prev, query) => prev && module.queries.includes(query), true) ?? true)
+  )
+}
+
+export const isModule = isIndirectModule

package/src/withModule.ts

@@ -2,7 +2,7 @@ import { InstanceTypeCheck, isModule, isModuleInstance } from './isModule'
 
 export const WithFactory = {
   create: <T extends object>(typeCheck: InstanceTypeCheck<T>) => {
-    return <R extends void = void>(
+    return <R>(
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       module: any,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any