@xyo-network/bridge-abstract 3.7.2 → 3.8.1

package/dist/neutral/index.d.ts

@@ -1,5 +1,433 @@
-export * from './AbstractBridge.ts';
-export * from './AbstractBridgeModuleResolver.ts';
-export * from './AbstractModuleProxy/index.ts';
-export * from './wrapModuleWithType.ts';
-//# sourceMappingURL=index.d.ts.map
+import { Address } from '@xylabs/hex';
+import { Promisable } from '@xylabs/promise';
+import { ArchivistInstance } from '@xyo-network/archivist-model';
+import { QueryBoundWitness } from '@xyo-network/boundwitness-model';
+import { BridgeParams, BridgeModuleEventData, AttachableBridgeInstance, BridgeExposeOptions, BridgeUnexposeOptions, QuerySendFinishedEventArgs, QuerySendStartedEventArgs, BridgeInstance } from '@xyo-network/bridge-model';
+import { AbstractModuleInstance } from '@xyo-network/module-abstract';
+import * as _xyo_network_module_model from '@xyo-network/module-model';
+import { ModuleInstance, ModuleResolverInstance, ModuleIdentifier, ModuleFilterOptions, ModuleQueryHandlerResult, ModuleParams, ModuleConfigSchema, ArchivingModuleConfig, ModuleResolver, ModuleName, Module, AddressPreviousHashPayload, ModuleQueryResult, ModuleIdentifierTransformer, ObjectFilterOptions, CacheConfig } from '@xyo-network/module-model';
+import * as _xyo_network_payload_model from '@xyo-network/payload-model';
+import { Schema, Payload, ModuleError } from '@xyo-network/payload-model';
+import { AccountInstance } from '@xyo-network/account-model';
+import { ModuleResolverParams, CompositeModuleResolver } from '@xyo-network/module-resolver';
+import * as _xylabs_object from '@xylabs/object';
+import * as _xylabs_logger from '@xylabs/logger';
+import { ModuleManifestPayload } from '@xyo-network/manifest-model';
+import * as _xyo_network_account from '@xyo-network/account';
+import { ModuleWrapper } from '@xyo-network/module-wrapper';
+
+declare abstract class AbstractBridge<TParams extends BridgeParams = BridgeParams> extends AbstractModuleInstance<TParams, BridgeModuleEventData> implements AttachableBridgeInstance<TParams, BridgeModuleEventData> {
+    static readonly configSchemas: Schema[];
+    static readonly defaultConfigSchema: Schema;
+    static readonly uniqueName: string;
+    protected _roots?: ModuleInstance[];
+    get allowNameResolution(): boolean;
+    get discoverRoots(): false | "start" | "lazy";
+    get queries(): string[];
+    get resolver(): Promisable<ModuleResolverInstance>;
+    expose(id: ModuleIdentifier, options?: BridgeExposeOptions | undefined): Promise<ModuleInstance[]>;
+    exposed(): Promise<Address[]>;
+    resolve(): Promise<ModuleInstance[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>;
+    startHandler(): Promise<boolean>;
+    unexpose(id: ModuleIdentifier, options?: BridgeUnexposeOptions | undefined): Promise<Address[]>;
+    protected queryHandler<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promise<ModuleQueryHandlerResult>;
+    protected resolveArchivingArchivists(): Promise<ArchivistInstance[]>;
+    abstract exposeHandler(address: Address, options?: BridgeExposeOptions | undefined): Promisable<ModuleInstance[]>;
+    abstract exposedHandler(): Promisable<Address[]>;
+    abstract getRoots(force?: boolean): Promise<ModuleInstance[]>;
+    abstract unexposeHandler(address: Address, options?: BridgeUnexposeOptions | undefined): Promisable<ModuleInstance[]>;
+}
+
+type ModuleProxyParams = ModuleParams<{
+    schema: ModuleConfigSchema;
+}, {
+    account: AccountInstance;
+    archiving?: ArchivingModuleConfig['archiving'] & {
+        resolveArchivists: () => Promise<ArchivistInstance[]>;
+    };
+    host: ModuleResolver;
+    manifest?: ModuleManifestPayload;
+    moduleAddress: Address;
+    onQuerySendFinished?: (args: Omit<QuerySendFinishedEventArgs, 'mod'>) => void;
+    onQuerySendStarted?: (args: Omit<QuerySendStartedEventArgs, 'mod'>) => void;
+    state?: Payload[];
+}>;
+declare abstract class AbstractModuleProxy<TWrappedModule extends ModuleInstance = ModuleInstance, TParams extends Omit<ModuleProxyParams, 'config'> & {
+    config: TWrappedModule['config'];
+} = Omit<ModuleProxyParams, 'config'> & {
+    config: TWrappedModule['config'];
+}> extends AbstractModuleInstance<TParams, TWrappedModule['eventData']> implements ModuleInstance<TParams, TWrappedModule['eventData']> {
+    static readonly requiredQueries: string[];
+    protected _config?: ModuleInstance['config'];
+    protected _publicChildren?: ModuleInstance[];
+    protected _state: Payload[] | undefined;
+    protected _stateInProcess: boolean;
+    private _spamTrap;
+    constructor(params: TParams);
+    get address(): Lowercase<string>;
+    get archiving(): ArchivingModuleConfig['archiving'] | undefined;
+    get config(): _xylabs_object.DeepRestrictToStringKeys<{
+        schema: _xyo_network_payload_model.Schema;
+        readonly archiving?: {
+            readonly archivists?: string[] | undefined;
+            readonly queries?: string[] | undefined;
+        } | undefined;
+        readonly allowedQueries?: string[] | undefined;
+        readonly archivist?: _xyo_network_module_model.ModuleIdentifier | undefined;
+        readonly consoleLogger?: _xylabs_logger.LogLevel | undefined;
+        readonly labels?: {
+            [x: string]: string | undefined;
+        } | undefined;
+        readonly name?: ModuleName | undefined;
+        readonly paging?: {
+            [x: string]: {
+                size?: number | undefined;
+            };
+        } | undefined;
+        readonly retry?: {
+            backoff?: number | undefined;
+            interval?: number | undefined;
+            retries?: number | undefined;
+        } | undefined;
+        readonly security?: {
+            readonly allowAnonymous?: boolean | undefined;
+            readonly allowed?: {
+                [x: string]: (Lowercase<string> | Lowercase<string>[])[];
+            } | undefined;
+            readonly disallowed?: {
+                [x: string]: Lowercase<string>[];
+            } | undefined;
+        } | undefined;
+        readonly sign?: boolean | undefined;
+        readonly storeQueries?: boolean | undefined;
+        readonly timestamp?: boolean | undefined;
+    }>;
+    get queries(): string[];
+    static hasRequiredQueries(mod: Module): boolean;
+    static missingRequiredQueries(mod: Module): string[];
+    addressPreviousHash(): Promise<AddressPreviousHashPayload>;
+    childAddressByName(name: ModuleName): Address | undefined;
+    childAddressMap(): Promise<Record<Address, ModuleName | null>>;
+    manifest(maxDepth?: number): Promise<ModuleManifestPayload>;
+    moduleAddress(): Promise<AddressPreviousHashPayload[]>;
+    previousHash(): Promise<string | undefined>;
+    publicChildren(): Promise<ModuleInstance<_xylabs_object.BaseParamsFields & {
+        account?: AccountInstance | "random";
+        addToResolvers?: boolean;
+        additionalSigners?: AccountInstance[];
+        allowNameResolution?: boolean;
+        config: _xylabs_object.DeepRestrictToStringKeys<{
+            schema: _xyo_network_payload_model.Schema;
+            readonly archiving?: {
+                readonly archivists?: string[] | undefined;
+                readonly queries?: string[] | undefined;
+            } | undefined;
+            readonly allowedQueries?: string[] | undefined;
+            readonly archivist?: _xyo_network_module_model.ModuleIdentifier | undefined;
+            readonly consoleLogger?: _xylabs_logger.LogLevel | undefined;
+            readonly labels?: {
+                [x: string]: string | undefined;
+            } | undefined;
+            readonly name?: ModuleName | undefined;
+            readonly paging?: {
+                [x: string]: {
+                    size?: number | undefined;
+                };
+            } | undefined;
+            readonly retry?: {
+                backoff?: number | undefined;
+                interval?: number | undefined;
+                retries?: number | undefined;
+            } | undefined;
+            readonly security?: {
+                readonly allowAnonymous?: boolean | undefined;
+                readonly allowed?: {
+                    [x: string]: (Lowercase<string> | Lowercase<string>[])[];
+                } | undefined;
+                readonly disallowed?: {
+                    [x: string]: Lowercase<string>[];
+                } | undefined;
+            } | undefined;
+            readonly sign?: boolean | undefined;
+            readonly storeQueries?: boolean | undefined;
+            readonly timestamp?: boolean | undefined;
+        }>;
+        ephemeralQueryAccountEnabled?: boolean;
+        moduleIdentifierTransformers?: _xyo_network_module_model.ModuleIdentifierTransformer[];
+    }, _xyo_network_module_model.ModuleEventData<object>>[]>;
+    query<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promise<ModuleQueryResult>;
+    queryHandler<T extends QueryBoundWitness = QueryBoundWitness>(_query: T, _payloads?: Payload[], _queryConfig?: TWrappedModule['params']['config']): Promise<ModuleQueryHandlerResult>;
+    queryable<T extends QueryBoundWitness = QueryBoundWitness>(_query: T, _payloads?: Payload[], _queryConfig?: TWrappedModule['params']['config']): Promise<boolean>;
+    resolveArchivingArchivists(): Promise<ArchivistInstance[]>;
+    setConfig(config: TWrappedModule['params']['config']): void;
+    setState(state: Payload[]): void;
+    startHandler(): Promise<boolean>;
+    state(): Promise<Payload[]>;
+    protected filterErrors(result: ModuleQueryResult): ModuleError[];
+    private checkSpam;
+    abstract proxyQueryHandler<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promise<ModuleQueryResult>;
+}
+
+interface ModuleProxyResolverOptions {
+    childAddressMap: Record<Address, ModuleName | null>;
+    childManifests?: Record<Address, ModuleManifestPayload>;
+    childStates?: Record<Address, ModuleManifestPayload>;
+    host: ModuleResolver;
+    mod: ModuleInstance;
+    moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
+}
+declare class ModuleProxyResolver<T extends ModuleProxyResolverOptions = ModuleProxyResolverOptions> implements ModuleResolverInstance {
+    private options;
+    private downResolver;
+    constructor(options: T);
+    get priority(): 0;
+    get root(): ModuleInstance<_xylabs_object.BaseParamsFields & {
+        account?: _xyo_network_account.AccountInstance | "random";
+        addToResolvers?: boolean;
+        additionalSigners?: _xyo_network_account.AccountInstance[];
+        allowNameResolution?: boolean;
+        config: _xylabs_object.DeepRestrictToStringKeys<{
+            schema: _xyo_network_payload_model.Schema;
+            readonly archiving?: {
+                readonly archivists?: string[] | undefined;
+                readonly queries?: string[] | undefined;
+            } | undefined;
+            readonly allowedQueries?: string[] | undefined;
+            readonly archivist?: ModuleIdentifier | undefined;
+            readonly consoleLogger?: _xylabs_logger.LogLevel | undefined;
+            readonly labels?: {
+                [x: string]: string | undefined;
+            } | undefined;
+            readonly name?: ModuleName | undefined;
+            readonly paging?: {
+                [x: string]: {
+                    size?: number | undefined;
+                };
+            } | undefined;
+            readonly retry?: {
+                backoff?: number | undefined;
+                interval?: number | undefined;
+                retries?: number | undefined;
+            } | undefined;
+            readonly security?: {
+                readonly allowAnonymous?: boolean | undefined;
+                readonly allowed?: {
+                    [x: string]: (Lowercase<string> | Lowercase<string>[])[];
+                } | undefined;
+                readonly disallowed?: {
+                    [x: string]: Lowercase<string>[];
+                } | undefined;
+            } | undefined;
+            readonly sign?: boolean | undefined;
+            readonly storeQueries?: boolean | undefined;
+            readonly timestamp?: boolean | undefined;
+        }>;
+        ephemeralQueryAccountEnabled?: boolean;
+        moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
+    }, _xyo_network_module_model.ModuleEventData<object>>;
+    protected get childAddressMap(): Record<Lowercase<string>, string | null>;
+    protected get host(): ModuleResolver<ModuleInstance<_xylabs_object.BaseParamsFields & {
+        account?: _xyo_network_account.AccountInstance | "random";
+        addToResolvers?: boolean;
+        additionalSigners?: _xyo_network_account.AccountInstance[];
+        allowNameResolution?: boolean;
+        config: _xylabs_object.DeepRestrictToStringKeys<{
+            schema: _xyo_network_payload_model.Schema;
+            readonly archiving?: {
+                readonly archivists?: string[] | undefined;
+                readonly queries?: string[] | undefined;
+            } | undefined;
+            readonly allowedQueries?: string[] | undefined;
+            readonly archivist?: ModuleIdentifier | undefined;
+            readonly consoleLogger?: _xylabs_logger.LogLevel | undefined;
+            readonly labels?: {
+                [x: string]: string | undefined;
+            } | undefined;
+            readonly name?: ModuleName | undefined;
+            readonly paging?: {
+                [x: string]: {
+                    size?: number | undefined;
+                };
+            } | undefined;
+            readonly retry?: {
+                backoff?: number | undefined;
+                interval?: number | undefined;
+                retries?: number | undefined;
+            } | undefined;
+            readonly security?: {
+                readonly allowAnonymous?: boolean | undefined;
+                readonly allowed?: {
+                    [x: string]: (Lowercase<string> | Lowercase<string>[])[];
+                } | undefined;
+                readonly disallowed?: {
+                    [x: string]: Lowercase<string>[];
+                } | undefined;
+            } | undefined;
+            readonly sign?: boolean | undefined;
+            readonly storeQueries?: boolean | undefined;
+            readonly timestamp?: boolean | undefined;
+        }>;
+        ephemeralQueryAccountEnabled?: boolean;
+        moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
+    }, _xyo_network_module_model.ModuleEventData<object>>>;
+    protected get mod(): ModuleInstance<_xylabs_object.BaseParamsFields & {
+        account?: _xyo_network_account.AccountInstance | "random";
+        addToResolvers?: boolean;
+        additionalSigners?: _xyo_network_account.AccountInstance[];
+        allowNameResolution?: boolean;
+        config: _xylabs_object.DeepRestrictToStringKeys<{
+            schema: _xyo_network_payload_model.Schema;
+            readonly archiving?: {
+                readonly archivists?: string[] | undefined;
+                readonly queries?: string[] | undefined;
+            } | undefined;
+            readonly allowedQueries?: string[] | undefined;
+            readonly archivist?: ModuleIdentifier | undefined;
+            readonly consoleLogger?: _xylabs_logger.LogLevel | undefined;
+            readonly labels?: {
+                [x: string]: string | undefined;
+            } | undefined;
+            readonly name?: ModuleName | undefined;
+            readonly paging?: {
+                [x: string]: {
+                    size?: number | undefined;
+                };
+            } | undefined;
+            readonly retry?: {
+                backoff?: number | undefined;
+                interval?: number | undefined;
+                retries?: number | undefined;
+            } | undefined;
+            readonly security?: {
+                readonly allowAnonymous?: boolean | undefined;
+                readonly allowed?: {
+                    [x: string]: (Lowercase<string> | Lowercase<string>[])[];
+                } | undefined;
+                readonly disallowed?: {
+                    [x: string]: Lowercase<string>[];
+                } | undefined;
+            } | undefined;
+            readonly sign?: boolean | undefined;
+            readonly storeQueries?: boolean | undefined;
+            readonly timestamp?: boolean | undefined;
+        }>;
+        ephemeralQueryAccountEnabled?: boolean;
+        moduleIdentifierTransformers?: ModuleIdentifierTransformer[];
+    }, _xyo_network_module_model.ModuleEventData<object>>;
+    addResolver(_resolver: ModuleResolver): this;
+    childManifest(address: Address): _xylabs_object.DeepRestrictToStringKeys<{
+        schema: "network.xyo.module.manifest";
+        config: {
+            accountPath?: string | undefined;
+            features?: string[] | undefined;
+            labels?: {
+                [x: string]: string | undefined;
+            } | undefined;
+            language?: string | undefined;
+            name: string;
+            os?: string | undefined;
+            schema: string;
+        };
+        lazyStart?: boolean | undefined;
+        status?: {
+            address: Address;
+            children?: {
+                [x: Lowercase<string>]: string | null;
+            } | undefined;
+        } | undefined;
+        description?: string | undefined;
+    }> | _xylabs_object.DeepRestrictToStringKeys<{
+        schema: "network.xyo.node.manifest";
+        config: {
+            accountPath?: string | undefined;
+            features?: string[] | undefined;
+            labels?: {
+                [x: string]: string | undefined;
+            } | undefined;
+            language?: string | undefined;
+            name: string;
+            os?: string | undefined;
+            schema: string;
+        };
+        lazyStart?: boolean | undefined;
+        status?: {
+            address: Address;
+            children?: {
+                [x: Lowercase<string>]: string | null;
+            } | undefined;
+        } | undefined;
+        description?: string | undefined;
+    }> | undefined;
+    childState(address: Address): _xylabs_object.DeepRestrictToStringKeys<{
+        schema: "network.xyo.module.manifest";
+        config: {
+            accountPath?: string | undefined;
+            features?: string[] | undefined;
+            labels?: {
+                [x: string]: string | undefined;
+            } | undefined;
+            language?: string | undefined;
+            name: string;
+            os?: string | undefined;
+            schema: string;
+        };
+        lazyStart?: boolean | undefined;
+        status?: {
+            address: Address;
+            children?: {
+                [x: Lowercase<string>]: string | null;
+            } | undefined;
+        } | undefined;
+        description?: string | undefined;
+    }> | _xylabs_object.DeepRestrictToStringKeys<{
+        schema: "network.xyo.node.manifest";
+        config: {
+            accountPath?: string | undefined;
+            features?: string[] | undefined;
+            labels?: {
+                [x: string]: string | undefined;
+            } | undefined;
+            language?: string | undefined;
+            name: string;
+            os?: string | undefined;
+            schema: string;
+        };
+        lazyStart?: boolean | undefined;
+        status?: {
+            address: Address;
+            children?: {
+                [x: Lowercase<string>]: string | null;
+            } | undefined;
+        } | undefined;
+        description?: string | undefined;
+    }> | undefined;
+    removeResolver(_resolver: ModuleResolver): this;
+    resolve(): Promise<ModuleInstance[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>;
+    resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>;
+    resolveIdentifier(id: ModuleIdentifier, _options?: ObjectFilterOptions): Promisable<Address | undefined>;
+    resolvePrivate<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ObjectFilterOptions<T>): Promise<T[]>;
+    resolvePrivate<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promise<T | undefined>;
+}
+
+interface BridgeModuleResolverParams extends ModuleResolverParams {
+    additionalSigners?: AccountInstance[];
+    archiving?: ArchivingModuleConfig['archiving'] & {
+        resolveArchivists: () => Promise<ArchivistInstance[]>;
+    };
+    bridge: BridgeInstance;
+    cacheConfig?: CacheConfig;
+    onQuerySendFinished?: (args: Omit<QuerySendFinishedEventArgs, 'mod'>) => void;
+    onQuerySendStarted?: (args: Omit<QuerySendStartedEventArgs, 'mod'>) => void;
+    wrapperAccount: AccountInstance;
+}
+declare abstract class AbstractBridgeModuleResolver<TParams extends BridgeModuleResolverParams = BridgeModuleResolverParams, TProxyParams extends ModuleProxyParams = ModuleProxyParams> extends CompositeModuleResolver<TParams> {
+    get priority(): 0;
+    resolveHandler<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>, _params?: Partial<TProxyParams>): Promise<T[]>;
+}
+
+declare const wrapModuleWithType: (mod: Module, account: AccountInstance) => ModuleWrapper;
+
+export { AbstractBridge, AbstractBridgeModuleResolver, AbstractModuleProxy, type BridgeModuleResolverParams, type ModuleProxyParams, ModuleProxyResolver, type ModuleProxyResolverOptions, wrapModuleWithType };

package/dist/neutral/index.mjs

@@ -89,7 +89,7 @@ var AbstractBridge = class _AbstractBridge extends AbstractModuleInstance {
     return modules.map((mod) => mod.address);
   }
   async queryHandler(query, payloads) {
-    const wrapper = await QueryBoundWitnessWrapper.parseQuery(query, payloads);
+    const wrapper = QueryBoundWitnessWrapper.parseQuery(query, payloads);
     const queryPayload = await wrapper.getQuery();
     const resultPayloads = [];
     switch (queryPayload.schema) {
@@ -490,8 +490,8 @@ var AbstractModuleProxy = class _AbstractModuleProxy extends AbstractModuleInsta
     }
     return this._state;
   }
-  async filterErrors(result) {
-    const wrapper = await BoundWitnessWrapper.wrap(result[0], result[1]);
+  filterErrors(result) {
+    const wrapper = BoundWitnessWrapper.wrap(result[0], result[1]);
     return wrapper.payloadsBySchema(ModuleErrorSchema);
   }
   // this checks and warns if we are getting spammed by the same query