@xyo-network/module-abstract 5.3.22 → 5.3.24

package/src/AbstractModuleInstance.ts

@@ -1,357 +0,0 @@
-import type {
-  Address, Promisable,
-  TypeCheck,
-  TypedValue,
-} from '@xylabs/sdk-js'
-import {
-  exists, globallyUnique, isDefined,
-} from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/account-model'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import { asArchivistInstance } from '@xyo-network/archivist-model'
-import type { ModuleManifestPayload } from '@xyo-network/manifest-model'
-import { ModuleManifestPayloadSchema } from '@xyo-network/manifest-model'
-import type {
-  AddressPayload,
-  AddressPreviousHashPayload,
-  AttachableModuleInstance,
-  ModuleEventData,
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleInstance,
-  ModuleInstanceParams,
-  ModuleManifestQuery,
-  ModuleName,
-  ModuleNameResolver,
-  ModuleQueryResult,
-  ModuleStateQuery,
-  ObjectFilterOptions,
-  ResolveHelperConfig,
-} from '@xyo-network/module-model'
-import {
-  duplicateModules,
-  ModuleManifestQuerySchema,
-  ModuleStateQuerySchema,
-  resolveAll,
-  resolveAllDown,
-  resolveAllUp,
-  ResolveHelper,
-  resolvePathToInstance,
-} from '@xyo-network/module-model'
-import { CompositeModuleResolver } from '@xyo-network/module-resolver'
-import type { NodeInstance } from '@xyo-network/node-model'
-import { asNodeInstance } from '@xyo-network/node-model'
-import type { Payload, Query } from '@xyo-network/payload-model'
-
-import { AbstractModule } from './AbstractModule.ts'
-
-function filterIdentity<T extends TypedValue>(mod?: ModuleInstance, identityFunc?: TypeCheck<T>): T
-function filterIdentity<T extends TypedValue>(mods?: ModuleInstance[], identityFunc?: TypeCheck<T>): T[]
-function filterIdentity<T extends TypedValue>(mod?: ModuleInstance | ModuleInstance[], identityFunc?: TypeCheck<T>) {
-  if (Array.isArray(mod)) {
-    if (identityFunc) {
-      return mod.map(m => identityFunc(m)).filter(exists)
-    }
-    return mod
-  }
-  return (mod ? (identityFunc ? identityFunc(mod) : true) : false) ? mod : undefined
-}
-
-export abstract class AbstractModuleInstance<TParams extends ModuleInstanceParams = ModuleInstanceParams, TEventData extends ModuleEventData = ModuleEventData>
-  extends AbstractModule<TParams, TEventData>
-  implements AttachableModuleInstance<TParams, TEventData>, ModuleNameResolver {
-  static override readonly uniqueName = globallyUnique('AbstractModuleInstance', AbstractModuleInstance, 'xyo')
-
-  // switches between old and new resolution system
-  static readonly useNewResolver = false
-
-  private _downResolver?: CompositeModuleResolver
-  private _parents: NodeInstance[] = []
-  private _privateResolver?: CompositeModuleResolver
-  private _upResolver?: CompositeModuleResolver
-
-  get downResolver() {
-    this._downResolver
-      = this._downResolver
-        ?? new CompositeModuleResolver({
-          allowNameResolution: this.allowNameResolution,
-          moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
-          root: this,
-        })
-    return this._downResolver
-  }
-
-  override get modName() {
-    return super.modName
-  }
-
-  get moduleIdentifierTransformers() {
-    return this.params.moduleIdentifierTransformers ?? ResolveHelper.transformers
-  }
-
-  get privateResolver() {
-    this._privateResolver
-      = this._privateResolver
-        ?? new CompositeModuleResolver({
-          allowNameResolution: this.allowNameResolution,
-          moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
-          root: this,
-        })
-    return this._privateResolver
-  }
-
-  get root() {
-    return this
-  }
-
-  get timeBudget() {
-    return this.config.timeBudget
-  }
-
-  get upResolver() {
-    this._upResolver
-      = this._upResolver
-        ?? new CompositeModuleResolver({
-          allowNameResolution: this.allowNameResolution,
-          moduleIdentifierTransformers: this.params.moduleIdentifierTransformers,
-          root: this,
-        })
-    return this._upResolver
-  }
-
-  addParent(mod: ModuleInstance) {
-    const existingEntry = this._parents.find(parent => parent.address === mod.address)
-    if (!existingEntry) {
-      this._parents.push(asNodeInstance(mod, 'Only NodeInstances can be parents', { required: true }))
-    }
-  }
-
-  async certifyParents(): Promise<Payload[]> {
-    const parents = await this.parents()
-    return (
-      await Promise.all(
-        parents.map(async (parent) => {
-          const [bw, payloads, errors] = await parent.certifyQuery(this.address)
-          return errors.length === 0 ? [bw, ...payloads] : []
-        }),
-      )
-    ).flat()
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    const addToResolvers = this.params.addToResolvers ?? true
-    if (addToResolvers) {
-      this.upResolver.add(this)
-      this.downResolver.add(this)
-    }
-  }
-
-  manifest(maxDepth?: number): Promise<ModuleManifestPayload> {
-    this._checkDead()
-    return this.busy(async () => {
-      return await this.manifestHandler(maxDepth)
-    })
-  }
-
-  async manifestQuery(account: AccountInstance, maxDepth?: number): Promise<ModuleQueryResult<ModuleManifestPayload>> {
-    const queryPayload: ModuleManifestQuery = { schema: ModuleManifestQuerySchema, ...(maxDepth === undefined ? {} : { maxDepth }) }
-    return await this.sendQueryRaw<ModuleManifestQuery, Payload, ModuleManifestPayload>(queryPayload, undefined, account)
-  }
-
-  moduleAddress(): Promise<(AddressPayload | AddressPreviousHashPayload)[]> {
-    this._checkDead()
-    return this.busy(async () => {
-      return await this.moduleAddressHandler()
-    })
-  }
-
-  parents(): Promisable<NodeInstance[]> {
-    return this._parents
-  }
-
-  privateChildren(): Promisable<ModuleInstance[]> {
-    return [...this.params.privateChildren ?? []]
-  }
-
-  publicChildren(): Promisable<ModuleInstance[]> {
-    return [...this.params.publicChildren ?? []]
-  }
-
-  removeParent(address: Address) {
-    this._parents = this._parents.filter(item => item.address !== address)
-  }
-
-  async resolve(): Promise<ModuleInstance[]>
-  async resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>
-  async resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>
-  async resolve<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier = '*',
-    options: ModuleFilterOptions<T> = {},
-  ): Promise<T | T[] | undefined> {
-    if (AbstractModuleInstance.useNewResolver) {
-      if (id === '*') {
-        const { maxDepth = 10, direction } = options
-        if (direction === 'down') {
-          return filterIdentity<T>((await resolveAllDown(this, maxDepth)) ?? [], options.identity)
-        }
-        if (direction === 'up') {
-          return filterIdentity<T>(await resolveAllUp(this, maxDepth) ?? [], options.identity)
-        }
-        return filterIdentity<T>(await resolveAll(this, maxDepth) ?? [], options.identity)
-      } else if (typeof id === 'string') {
-        return filterIdentity<T>(await resolvePathToInstance(this, id, true), options.identity)
-      } else {
-        throw new TypeError('Invalid id type')
-      }
-    } else {
-      const config: ResolveHelperConfig = {
-        address: this.address,
-        dead: this.dead,
-        downResolver: this.downResolver,
-        logger: this.logger,
-        mod: this,
-        transformers: this.moduleIdentifierTransformers,
-        upResolver: this.upResolver,
-      }
-      if (id === '*') {
-        return filterIdentity<T>(await ResolveHelper.resolve(config, '*', options) ?? [], options.identity)
-      }
-      return filterIdentity<T>(await ResolveHelper.resolve(config, id, options), options.identity)
-    }
-  }
-
-  resolveIdentifier(id: ModuleIdentifier, options?: ObjectFilterOptions): Promise<Address | undefined> {
-    const { direction = 'all' } = options ?? {}
-    switch (direction) {
-      case 'down': {
-        return this.downResolver.resolveIdentifier(id, options)
-      }
-      default: {
-        const mutatedOptions = { ...options, direction: 'all' } as ObjectFilterOptions
-        return this.upResolver.resolveIdentifier(id, mutatedOptions)
-      }
-    }
-  }
-
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>
-  async resolvePrivate<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier = '*',
-    options: ModuleFilterOptions<T> = {},
-  ): Promise<T | T[] | undefined> {
-    return (
-      (await this.privateResolver.resolve(id, options))
-      ?? (await this.upResolver.resolve(id, options))
-      ?? (await this.downResolver.resolve(id, options))
-    )
-  }
-
-  async siblings(): Promise<ModuleInstance[]> {
-    return (await Promise.all((await this.parents()).map(parent => parent.publicChildren()))).flat().filter(duplicateModules)
-  }
-
-  state() {
-    this._checkDead()
-    return this.busy(async () => {
-      return await this.stateHandler()
-    })
-  }
-
-  async stateQuery(account: AccountInstance): Promise<ModuleQueryResult> {
-    const queryPayload: ModuleStateQuery = { schema: ModuleStateQuerySchema }
-    return await this.sendQueryRaw(queryPayload, undefined, account)
-  }
-
-  subscribe(_queryAccount?: AccountInstance) {
-    this._checkDead()
-    return this.subscribeHandler()
-  }
-
-  protected override async manifestHandler(maxDepth: number = 1, _ignoreAddresses: Address[] = []): Promise<ModuleManifestPayload> {
-    const cachedResult = this._cachedManifests.get(maxDepth)
-    if (cachedResult) {
-      return cachedResult
-    }
-    const modName = this.modName ?? '<Anonymous>'
-    const children = await this.publicChildren()
-    const childAddressToName: Record<Address, ModuleName | null> = {}
-    for (const child of children) {
-      if (child.address !== this.address) {
-        childAddressToName[child.address] = child.modName ?? null
-      }
-    }
-    const result = {
-      config: { name: modName, ...this.config },
-      name: modName,
-      schema: ModuleManifestPayloadSchema,
-      status: { address: this.address, children: childAddressToName },
-    }
-    this._cachedManifests.set(maxDepth, result)
-    return result
-  }
-
-  protected async resolveArchivingArchivists(): Promise<ArchivistInstance[]> {
-    const archivists = this.archiving?.archivists
-    if (!archivists) return []
-    const resolved = await Promise.all(archivists.map(archivist => this.resolve(archivist)))
-    return (resolved.map(mod => asArchivistInstance(mod))).filter(exists)
-  }
-
-  protected async sendQuery<T extends Query, P extends Payload = Payload, R extends Payload = Payload>(
-    queryPayload: T,
-    payloads?: P[],
-    account?: AccountInstance,
-  ): Promise<R[]> {
-    const queryResults = await this.sendQueryRaw(queryPayload, payloads, account)
-    const [, resultPayloads, errors] = queryResults
-
-    /* TODO: Figure out what to do with the returning BW.  Should we store them in a queue in case the caller wants to see them? */
-
-    if (isDefined(errors) && errors.length > 0) {
-      /* TODO: Figure out how to rollup multiple Errors */
-      throw errors[0]
-    }
-
-    return resultPayloads as R[]
-  }
-
-  protected async sendQueryRaw<T extends Query, P extends Payload = Payload, R extends Payload = Payload>(
-    queryPayload: T,
-    payloads?: P[],
-    account?: AccountInstance,
-  ): Promise<ModuleQueryResult<R>> {
-    // Bind them
-    const query = await this.bindQuery(queryPayload, payloads, account, this.additionalSigners)
-
-    // Send them off
-    return (await this.query(query[0], query[1])) as ModuleQueryResult<R>
-  }
-
-  protected override startHandler() {
-    this._checkDead()
-    return this.busy(async () => {
-      if (this.status === 'started' || this.status === 'creating') {
-        return
-      }
-      await super.startHandler()
-    })
-  }
-
-  protected async storeToArchivists(payloads: Payload[]): Promise<Payload[]> {
-    try {
-      const archivists = await this.resolveArchivingArchivists()
-      return (
-        await Promise.all(
-          archivists.map((archivist) => {
-            return archivist.insert?.(payloads)
-          }),
-        )
-      ).map(([bw]) => bw)
-    } catch (ex) {
-      const error = ex as Error
-      this.logger?.error(`Error storing to archivists: ${error.message}`)
-      return []
-    }
-  }
-}

package/src/Error.ts

@@ -1,44 +0,0 @@
-import type { Hash, JsonValue } from '@xylabs/sdk-js'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { ModuleError, Schema } from '@xyo-network/payload-model'
-import { ModuleErrorSchema } from '@xyo-network/payload-model'
-
-export class ModuleErrorBuilder extends PayloadBuilder<ModuleError> {
-  _details?: JsonValue
-  _message?: string
-  _name?: string
-  _query?: Hash | Schema
-  constructor() {
-    super({ schema: ModuleErrorSchema })
-  }
-
-  override build(): ModuleError {
-    this.fields({
-      details: this._details,
-      message: this._message,
-      name: this._name,
-      query: this._query,
-    })
-    return super.build()
-  }
-
-  details(details?: JsonValue) {
-    this._details = details
-    return this
-  }
-
-  message(message: string) {
-    this._message = message
-    return this
-  }
-
-  name(name: string) {
-    this._name = name
-    return this
-  }
-
-  query(query: Hash | Schema) {
-    this._query = query
-    return this
-  }
-}

package/src/LoggerModuleStatusReporter.ts

@@ -1,21 +0,0 @@
-import type {
-  CreatableName, CreatableStatus, Logger,
-} from '@xylabs/sdk-js'
-import type { ModuleStatusReporter } from '@xyo-network/module-model'
-
-export class LoggerModuleStatusReporter implements ModuleStatusReporter {
-  protected logger: Logger
-
-  protected statusMap: Record<CreatableName, CreatableStatus> = {}
-
-  constructor(logger: Logger) {
-    this.logger = logger
-  }
-
-  report(name: CreatableName, status: CreatableStatus, progress?: number | Error): void {
-    this.statusMap[name] = status
-    const starting = (Object.entries(this.statusMap).map(([, value]): number => value === 'starting' ? 1 : 0)).reduce((a, b) => a + b, 0)
-    const started = (Object.entries(this.statusMap).map(([, value]): number => value === 'started' ? 1 : 0)).reduce((a, b) => a + b, 0)
-    this.logger.log(`${started}/${starting + started} ${name} status: ${status}`, { progress })
-  }
-}

package/src/QueryValidator/ModuleConfigQueryValidator.ts

@@ -1,75 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { QueryBoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import type {
-  AnyConfigSchema, CosigningAddressSet, ModuleConfig, ModuleQueries,
-} from '@xyo-network/module-model'
-import { asSchema, type Schema } from '@xyo-network/payload-model'
-
-import type { Queryable, QueryValidator } from './QueryValidator.ts'
-
-export type SortedPipedAddressesString = string
-
-const delimiter = ''
-
-export class ModuleConfigQueryValidator<TConfig extends AnyConfigSchema<ModuleConfig>> implements QueryValidator {
-  protected allowed: Record<Schema, SortedPipedAddressesString[]> = {}
-  protected disallowed: Record<Schema, SortedPipedAddressesString[]> = {}
-  protected readonly hasAllowedRules: boolean
-  protected readonly hasDisallowedRules: boolean
-  protected readonly hasRules: boolean
-
-  constructor(config?: TConfig) {
-    if (config?.security?.allowed) {
-      for (const [schema, addresses] of Object.entries(config.security?.allowed)) {
-        const typedSchema = asSchema(schema, true)
-        this.allowed[typedSchema] = addresses.map(toAddressesString)
-      }
-    }
-    if (config?.security?.disallowed) {
-      for (const [schema, addresses] of Object.entries(config.security?.disallowed)) {
-        const typedSchema = asSchema(schema, true)
-        this.disallowed[typedSchema] = addresses.map(toAddressesString)
-      }
-    }
-    this.hasAllowedRules = Object.keys(this.allowed).length > 0
-    this.hasDisallowedRules = Object.keys(this.disallowed).length > 0
-    this.hasRules = this.hasAllowedRules || this.hasDisallowedRules
-  }
-
-  queryable: Queryable = async (query, payloads) => {
-    if (!this.hasRules) return true
-    const addresses = query.addresses
-    if (addresses.length === 0) return false
-    const wrapper = QueryBoundWitnessWrapper.parseQuery<ModuleQueries>(query, payloads)
-    const schema = (await wrapper.getQuery()).schema
-    return this.queryAllowed(schema, addresses) && !this.queryDisallowed(schema, addresses)
-  }
-
-  protected queryAllowed = (schema: Schema, addresses: Address[]): boolean => {
-    if (!this.hasAllowedRules) return true
-    // All cosigners must sign
-    if (addresses.length > 1) {
-      const signatories = toAddressesString(addresses)
-      const validCosigners = this.allowed?.[schema]?.includes(signatories)
-      if (validCosigners) return true
-    }
-    // OR all signers have to be allowed individually
-    return addresses.every(address => this.allowed?.[schema]?.includes(address) || false)
-  }
-
-  protected queryDisallowed = (schema: Schema, addresses: string[]): boolean => {
-    if (!this.hasDisallowedRules) return false
-    return addresses.some(address => this.disallowed?.[schema]?.includes(address))
-  }
-}
-
-// TODO: Handle 0x prefix
-const toAddressesString = (addresses: string | CosigningAddressSet): SortedPipedAddressesString => {
-  return Array.isArray(addresses)
-    ? addresses
-        // eslint-disable-next-line sonarjs/no-alphabetical-sort
-        .toSorted()
-        .map(address => address.toLowerCase())
-        .join(delimiter)
-    : addresses.toLowerCase()
-}

package/src/QueryValidator/QueryValidator.ts

@@ -1,9 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-export type Queryable<T extends QueryBoundWitness = QueryBoundWitness> = (query: T, payloads?: Payload[]) => Promisable<boolean>
-
-export interface QueryValidator<T extends QueryBoundWitness = QueryBoundWitness> {
-  queryable: Queryable<T>
-}

package/src/QueryValidator/SupportedQueryValidator.ts

@@ -1,27 +0,0 @@
-import type { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { QueryBoundWitnessWrapper } from '@xyo-network/boundwitness-wrapper'
-import type { ModuleQueries, QueryableModule } from '@xyo-network/module-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { Queryable, QueryValidator } from './QueryValidator.ts'
-
-export const isQuerySupportedByModule = async <T extends QueryBoundWitness = QueryBoundWitness>(
-  mod: QueryableModule,
-  query: T,
-  payloads?: Payload[],
-): Promise<boolean> => {
-  const wrapper = QueryBoundWitnessWrapper.parseQuery<ModuleQueries>(query, payloads)
-  const schema = (await wrapper.getQuery()).schema
-  return mod.queries.includes(schema)
-}
-
-export class SupportedQueryValidator implements QueryValidator {
-  protected readonly mod: QueryableModule
-  constructor(mod: QueryableModule) {
-    this.mod = mod
-  }
-
-  queryable: Queryable = (query, payloads) => {
-    return isQuerySupportedByModule(this.mod, query, payloads)
-  }
-}

package/src/QueryValidator/index.ts

@@ -1,3 +0,0 @@
-export * from './ModuleConfigQueryValidator.ts'
-export * from './QueryValidator.ts'
-export * from './SupportedQueryValidator.ts'

package/src/determineAccount.ts

@@ -1,53 +0,0 @@
-import {
-  assertEx,
-  isDefined, isString, isUndefined,
-} from '@xylabs/sdk-js'
-import { Account } from '@xyo-network/account'
-import type { AccountInstance } from '@xyo-network/account-model'
-import type { WalletInstance } from '@xyo-network/wallet-model'
-
-export interface DetermineAccountFromAccountParams {
-  account: AccountInstance | 'random'
-  accountPath?: never
-  wallet?: never
-}
-
-export interface DetermineAccountFromWalletParams {
-  account?: never
-  accountPath?: string
-  wallet: WalletInstance
-}
-
-export interface DetermineRandomParams {}
-
-export type DetermineAccountParams = DetermineAccountFromAccountParams | DetermineAccountFromWalletParams | DetermineRandomParams
-
-const isDetermineAccountFromAccountParams = (params: DetermineAccountParams): params is DetermineAccountFromAccountParams => {
-  assertEx(isUndefined((params as DetermineAccountFromWalletParams).accountPath), () => 'accountPath may not be provided when account is provided')
-  return isDefined((params as DetermineAccountFromAccountParams).account)
-}
-
-const isDetermineAccountFromWalletParams = (params: DetermineAccountParams): params is DetermineAccountFromWalletParams => {
-  return isDefined((params as DetermineAccountFromWalletParams).wallet)
-}
-
-export async function determineAccount(params: DetermineAccountParams, allowRandomAccount = true): Promise<AccountInstance> {
-  if (isDetermineAccountFromAccountParams(params)) {
-    if (params.account === 'random') {
-      assertEx(allowRandomAccount, () => 'Random address not allowed')
-      return await Account.random()
-    }
-    return params.account
-  }
-
-  if (isDetermineAccountFromWalletParams(params)) {
-    return assertEx(
-      isString(params.accountPath) ? await params.wallet.derivePath(params.accountPath) : params.wallet,
-      () => 'Failed to derive account from path',
-    )
-  }
-
-  // this should eventually be removed/thrown
-  console.warn('AbstractModule.determineAccount: No account or wallet provided - Creating Random account')
-  return await Account.random()
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './AbstractModule.ts'
-export * from './AbstractModuleInstance.ts'
-export * from './Error.ts'
-export * from './LoggerModuleStatusReporter.ts'
-export * from './QueryValidator/index.ts'