@xyo-network/sentinel 2.66.9 → 2.67.0-rc.2

package/src/MemorySentinel.ts

@@ -1,12 +1,11 @@
 import { assertEx } from '@xylabs/assert'
-import { fulfilled } from '@xylabs/promise'
+import { fulfilled, rejected } from '@xylabs/promise'
 import { Account } from '@xyo-network/account'
 import { QueryBoundWitness, QueryBoundWitnessWrapper } from '@xyo-network/boundwitness-builder'
 import { handleError, handleErrorAsync } from '@xyo-network/error'
 import { AnyConfigSchema, ModuleConfig, ModuleErrorBuilder, ModuleQueryResult } from '@xyo-network/module'
 import { ModuleError, Payload } from '@xyo-network/payload-model'
-import { WitnessWrapper } from '@xyo-network/witness'
-import compact from 'lodash/compact'
+import { WitnessInstance } from '@xyo-network/witness'
 
 import { AbstractSentinel } from './AbstractSentinel'
 import { SentinelConfig, SentinelConfigSchema } from './Config'
@@ -34,9 +33,10 @@ export class MemorySentinel<
     const resultPayloads: Payload[] = []
 
     try {
-      const generatedPayloads = compact(await this.generatePayloads(allWitnesses))
+      const [generatedPayloads, generatedErrors] = await this.generateResults(allWitnesses)
       const combinedPayloads = [...generatedPayloads, ...payloads]
       resultPayloads.push(...combinedPayloads)
+      errors.push(...generatedErrors)
     } catch (ex) {
       handleError(ex, (error) => {
         errors.push(error)
@@ -84,10 +84,16 @@ export class MemorySentinel<
     return (await this.bindQueryResult(queryPayload, resultPayloads, [queryAccount], errorPayloads))[0]
   }
 
-  private async generatePayloads(witnesses: WitnessWrapper[]): Promise<Payload[]> {
-    return (await Promise.allSettled(witnesses?.map((witness) => witness.observe())))
+  private async generateResults(witnesses: WitnessInstance[]): Promise<[Payload[], Error[]]> {
+    const results = await Promise.allSettled(witnesses?.map((witness) => witness.observe()))
+    const payloads = results
       .filter(fulfilled)
       .map((result) => result.value)
       .flat()
+    const errors = results
+      .filter(rejected)
+      .map((result) => result.reason)
+      .flat()
+    return [payloads, errors]
   }
 }

package/src/SentinelModel.ts

@@ -1,6 +1,6 @@
 import { BoundWitness } from '@xyo-network/boundwitness-model'
 import { AnyObject } from '@xyo-network/core'
-import { AnyConfigSchema, EventData, Module, ModuleEventArgs, ModuleEventData, ModuleParams } from '@xyo-network/module'
+import { AnyConfigSchema, EventData, Module, ModuleEventArgs, ModuleEventData, ModuleInstance, ModuleParams } from '@xyo-network/module'
 import { Payload } from '@xyo-network/payload-model'
 import { Promisable } from '@xyo-network/promise'
 
@@ -50,4 +50,4 @@ export type SentinelModule<
 export type SentinelInstance<
   TParams extends SentinelParams = SentinelParams,
   TEventData extends SentinelModuleEventData = SentinelModuleEventData,
-> = SentinelModule<TParams, TEventData> & Sentinel
+> = SentinelModule<TParams, TEventData> & ModuleInstance & Sentinel

package/src/Wrapper.ts

@@ -1,19 +1,21 @@
 import { constructableModuleWrapper, ModuleWrapper } from '@xyo-network/module'
 import { Payload } from '@xyo-network/payload-model'
-import { PayloadWrapper } from '@xyo-network/payload-wrapper'
 
 import { SentinelReportQuery, SentinelReportQuerySchema } from './Queries'
-import { SentinelModule } from './SentinelModel'
+import { SentinelInstance, SentinelModule } from './SentinelModel'
 import { isSentinelInstance, isSentinelModule } from './typeChecks'
 
 constructableModuleWrapper()
-export class SentinelWrapper<TModule extends SentinelModule = SentinelModule> extends ModuleWrapper<TModule> implements SentinelModule {
+export class SentinelWrapper<TModule extends SentinelModule = SentinelModule>
+  extends ModuleWrapper<TModule>
+  implements SentinelInstance<TModule['params']>
+{
   static override instanceIdentityCheck = isSentinelInstance
   static override moduleIdentityCheck = isSentinelModule
   static override requiredQueries = [SentinelReportQuerySchema, ...super.requiredQueries]
 
   async report(payloads?: Payload[]): Promise<Payload[]> {
-    const queryPayload = PayloadWrapper.wrap<SentinelReportQuery>({ schema: SentinelReportQuerySchema })
+    const queryPayload: SentinelReportQuery = { schema: SentinelReportQuerySchema }
     const result = await this.sendQuery(queryPayload, payloads)
     return result
   }

package/src/typeChecks.ts

@@ -1,12 +1,13 @@
-import { AsFactory, IsInstanceFactory, IsModuleFactory, isModuleInstance, WithFactory } from '@xyo-network/module-model'
+import { IsInstanceFactory, IsModuleFactory, isModuleInstance, WithFactory } from '@xyo-network/module-model'
+import { AsObjectFactory } from '@xyo-network/object-identity'
 
 import { SentinelReportQuerySchema } from './Queries'
 import { SentinelInstance, SentinelModule } from './SentinelModel'
 
-export const isSentinelInstance = IsInstanceFactory.create<SentinelInstance>({ report: 'function' }, isModuleInstance)
-export const isSentinelModule = IsModuleFactory.create<SentinelModule>([SentinelReportQuerySchema])
+export const isSentinelInstance = new IsInstanceFactory<SentinelInstance>().create({ report: 'function' }, [isModuleInstance])
+export const isSentinelModule = new IsModuleFactory<SentinelModule>().create([SentinelReportQuerySchema])
 
-export const asSentinelModule = AsFactory.create(isSentinelModule)
-export const asSentinelInstance = AsFactory.create(isSentinelInstance)
+export const asSentinelModule = AsObjectFactory.create(isSentinelModule)
+export const asSentinelInstance = AsObjectFactory.create(isSentinelInstance)
 export const withSentinelModule = WithFactory.create(isSentinelModule)
 export const withSentinelInstance = WithFactory.create(isSentinelInstance)