@xyo-network/node 2.39.0-rc.1 → 2.39.0-rc.3

package/src/XyoNode.ts

@@ -12,18 +12,16 @@ export abstract class XyoNode<TConfig extends NodeConfig = NodeConfig, TModule e
   extends XyoModule<TConfig>
   implements NodeModule
 {
-  private async storeInstanceData() {
-    const payload = { address: this.address, queries: this.queries, schema: XyoModuleInstanceSchema }
-    const [bw] = await this.bindResult([payload])
-    await new XyoArchivistWrapper(await this.getArchivist()).insert([bw, payload])
+  private _archivist?: Module
+
+  attached(): string[] {
+    throw new Error('Method not implemented.')
   }
 
-  /** Query Functions - Start */
-  abstract attach(_address: string): void
-  abstract detach(_address: string): void
-  abstract resolve(_address: string[]): (TModule | null)[]
+  attachedModules(): TModule[] {
+    throw new Error('Method not implemented.')
+  }
 
-  private _archivist?: Module
   public async getArchivist(): Promise<Module> {
     if (!this._archivist) {
       this._archivist =
@@ -34,21 +32,6 @@ export abstract class XyoNode<TConfig extends NodeConfig = NodeConfig, TModule e
     return this._archivist
   }
 
-  registered(): string[] {
-    throw new Error('Method not implemented.')
-  }
-  attached(): string[] {
-    throw new Error('Method not implemented.')
-  }
-
-  registeredModules(): TModule[] {
-    throw new Error('Method not implemented.')
-  }
-  attachedModules(): TModule[] {
-    throw new Error('Method not implemented.')
-  }
-  /** Query Functions - End */
-
   override async query<T extends XyoQueryBoundWitness = XyoQueryBoundWitness>(query: T, payloads?: XyoPayload[]): Promise<ModuleQueryResult> {
     const wrapper = QueryBoundWitnessWrapper.parseQuery<XyoNodeQuery>(query)
     const typedQuery = wrapper.query.payload
@@ -84,13 +67,31 @@ export abstract class XyoNode<TConfig extends NodeConfig = NodeConfig, TModule e
     return this.bindResult(resultPayloads, queryAccount)
   }
 
+  register(_module: TModule): void {
+    throw new Error('Method not implemented.')
+  }
+
+  registered(): string[] {
+    throw new Error('Method not implemented.')
+  }
+
+  registeredModules(): TModule[] {
+    throw new Error('Method not implemented.')
+  }
+
   override async start() {
     await super.start()
     await this.storeInstanceData()
     return this
   }
 
-  register(_module: TModule): void {
-    throw new Error('Method not implemented.')
+  private async storeInstanceData() {
+    const payload = { address: this.address, queries: this.queries, schema: XyoModuleInstanceSchema }
+    const [bw] = await this.bindResult([payload])
+    await new XyoArchivistWrapper(await this.getArchivist()).insert([bw, payload])
   }
+
+  abstract attach(_address: string): void
+  abstract detach(_address: string): void
+  abstract resolve(_address: string[]): (TModule | null)[]
 }

package/src/XyoNodeWrapper.ts

@@ -23,16 +23,13 @@ export class XyoNodeWrapper extends XyoModuleWrapper implements NodeModule {
     return this._archivist
   }
 
-  register(_module: Module): void {
-    throw Error('Not implemented')
-  }
-  async registered(): Promise<string[]> {
-    const queryPayload = PayloadWrapper.parse<XyoNodeRegisteredQuery>({ schema: XyoNodeRegisteredQuerySchema })
+  async attach(address: string): Promise<void> {
+    const queryPayload = PayloadWrapper.parse<XyoNodeAttachQuery>({ address, schema: XyoNodeAttachQuerySchema })
     const query = await this.bindQuery(queryPayload)
     const result = await this.module.query(query[0], query[1])
     this.throwErrors(query, result)
-    return compact(result[1].map((payload) => payload?.schema))
   }
+
   async attached(): Promise<string[]> {
     const queryPayload = PayloadWrapper.parse<XyoNodeAttachedQuery>({ schema: XyoNodeAttachedQuerySchema })
     const query = await this.bindQuery(queryPayload)
@@ -40,27 +37,35 @@ export class XyoNodeWrapper extends XyoModuleWrapper implements NodeModule {
     this.throwErrors(query, result)
     return compact(result[1].map((payload) => payload?.schema))
   }
-  async attach(address: string): Promise<void> {
-    const queryPayload = PayloadWrapper.parse<XyoNodeAttachQuery>({ address, schema: XyoNodeAttachQuerySchema })
+
+  async attachedModules(): Promise<XyoModule[]> {
+    const addresses = await this.attached()
+    return compact(await this.resolve(addresses))
+  }
+
+  async detach(address: string): Promise<void> {
+    const queryPayload = PayloadWrapper.parse<XyoNodeDetachQuery>({ address, schema: XyoNodeDetachQuerySchema })
     const query = await this.bindQuery(queryPayload)
     const result = await this.module.query(query[0], query[1])
     this.throwErrors(query, result)
   }
-  async detach(address: string): Promise<void> {
-    const queryPayload = PayloadWrapper.parse<XyoNodeDetachQuery>({ address, schema: XyoNodeDetachQuerySchema })
+
+  register(_module: Module): void {
+    throw Error('Not implemented')
+  }
+
+  async registered(): Promise<string[]> {
+    const queryPayload = PayloadWrapper.parse<XyoNodeRegisteredQuery>({ schema: XyoNodeRegisteredQuerySchema })
     const query = await this.bindQuery(queryPayload)
     const result = await this.module.query(query[0], query[1])
     this.throwErrors(query, result)
+    return compact(result[1].map((payload) => payload?.schema))
   }
 
   async registeredModules(): Promise<XyoModule[]> {
     const addresses = await this.registered()
     return compact(await this.resolve(addresses))
   }
-  async attachedModules(): Promise<XyoModule[]> {
-    const addresses = await this.attached()
-    return compact(await this.resolve(addresses))
-  }
 
   resolve(_address: string[]): Promisable<(XyoModule | null)[]> {
     throw Error('Not implemented')