@xyo-network/module-abstract 3.18.9 → 4.0.0

package/dist/neutral/index.mjs

@@ -1,31 +1,35 @@
 // src/AbstractModule.ts
 import { assertEx as assertEx2 } from "@xylabs/assert";
-import { Base, globallyUnique } from "@xylabs/base";
+import { globallyUnique } from "@xylabs/base";
+import { AbstractCreatable } from "@xylabs/creatable";
 import { handleError, handleErrorAsync } from "@xylabs/error";
 import { exists } from "@xylabs/exists";
 import { forget } from "@xylabs/forget";
 import {
   ConsoleLogger,
   IdLogger,
+  LevelLogger,
   LogLevel
 } from "@xylabs/logger";
 import { PromiseEx } from "@xylabs/promise";
 import { spanAsync } from "@xylabs/telemetry";
 import {
   isDefined,
+  isObject,
   isString,
   isUndefined
 } from "@xylabs/typeof";
 import { Account as Account2 } from "@xyo-network/account";
+import { isAccountInstance } from "@xyo-network/account-model";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
 import { BoundWitnessBuilder, QueryBoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
 import { isQueryBoundWitness } from "@xyo-network/boundwitness-model";
 import { QueryBoundWitnessWrapper as QueryBoundWitnessWrapper3 } from "@xyo-network/boundwitness-wrapper";
 import { ConfigSchema } from "@xyo-network/config-payload-plugin";
-import { ModuleBaseEmitter } from "@xyo-network/module-event-emitter";
 import {
   AddressPreviousHashSchema,
   AddressSchema,
+  creatableModule,
   DeadModuleError,
   isModuleName,
   isSerializable,
@@ -177,7 +181,8 @@ var SupportedQueryValidator = class {
 
 // src/AbstractModule.ts
 var MODULE_NOT_STARTED = "Module not Started";
-var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
+creatableModule();
+var AbstractModule = class _AbstractModule extends AbstractCreatable {
   static allowRandomAccount = true;
   static configSchemas = [ModuleConfigSchema];
   static defaultConfigSchema = ModuleConfigSchema;
@@ -191,23 +196,14 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
   _account;
   // cache manifest based on maxDepth
   _cachedManifests = new LRUCache({ max: 10, ttl: 1e3 * 60 * 5 });
-  _globalReentrancyMutex = void 0;
+  _globalReentrancyMutex;
   _lastError;
-  _startPromise = void 0;
-  _started = void 0;
-  moduleConfigQueryValidator;
-  supportedQueryValidator;
+  _moduleConfigQueryValidator;
+  _startPromise;
+  _supportedQueryValidator;
   _busyCount = 0;
   _logger = void 0;
-  _status = "stopped";
-  constructor(privateConstructorKey, params, account) {
-    assertEx2(_AbstractModule.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
-    const mutatedParams = { ...params };
-    super(mutatedParams);
-    this._account = account;
-    this.supportedQueryValidator = new SupportedQueryValidator(this).queryable;
-    this.moduleConfigQueryValidator = new ModuleConfigQueryValidator(mutatedParams?.config).queryable;
-  }
+  _status = "creating";
   get account() {
     return assertEx2(this._account, () => "Missing account");
   }
@@ -215,7 +211,7 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
     return this.params.additionalSigners ?? [];
   }
   get address() {
-    return this._account?.address;
+    return this.account.address;
   }
   get allowAnonymous() {
     return !!this.config.security?.allowAnonymous;
@@ -230,10 +226,10 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
     return this.config.archivist;
   }
   get config() {
-    return this.params.config;
+    return { ...this.params.config, schema: this.params.config.schema ?? ModuleConfigSchema };
   }
   get dead() {
-    return this.status === "dead";
+    return this.status === "error";
   }
   get ephemeralQueryAccountEnabled() {
     return !!this.params.ephemeralQueryAccountEnabled;
@@ -246,9 +242,12 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
     return this.modName ?? this.address;
   }
   get logger() {
-    const logLevel = this.config.logLevel;
-    this._logger = this._logger ?? this.params?.logger ?? (isDefined(logLevel) ? new ConsoleLogger(logLevel) : Base.defaultLogger);
-    return this._logger;
+    if (isUndefined(this._logger)) {
+      const logLevel = this.config.logLevel;
+      const newLogger = this._logger ?? (this.params?.logger ? new IdLogger(this.params.logger, () => `${this.constructor.name}[${this.id}]`) : null);
+      this._logger = isObject(newLogger) && isDefined(logLevel) ? new LevelLogger(newLogger, logLevel) : newLogger;
+    }
+    return this._logger ?? void 0;
   }
   get modName() {
     return this.config.name;
@@ -271,11 +270,19 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
   get timestamp() {
     return this.config.timestamp ?? false;
   }
+  get moduleConfigQueryValidator() {
+    return assertEx2(this._moduleConfigQueryValidator, () => "ModuleConfigQueryValidator not initialized");
+  }
   set status(value) {
-    if (this._status !== "dead") {
-      this._status = value;
+    this._status = value;
+    if (value === "error") {
+      this.statusReporter?.report(`${this.constructor.name}:${this.id}`, value, new Error("Module status changed to error"));
+    } else {
+      this.statusReporter?.report(`${this.constructor.name}:${this.id}`, value, 100);
     }
-    this.statusReporter?.reportStatus(`${this.constructor.name}:${this.id}`, value);
+  }
+  get supportedQueryValidator() {
+    return assertEx2(this._supportedQueryValidator, () => "SupportedQueryValidator not initialized");
   }
   static _getRootFunction(funcName) {
     let anyThis = this;
@@ -289,28 +296,19 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
     const rootFunc = this._getRootFunction(functionName);
     assertEx2(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`);
   }
-  static async create(params) {
-    this._noOverride("create");
-    if (this.configSchemas.length === 0) {
-      throw new Error(`Missing configSchema [${params?.config?.schema}][${this.name}]`);
-    }
-    assertEx2(params?.config?.name === void 0 || isModuleName(params.config.name), () => `Invalid module name: ${params?.config?.name}`);
-    const { account } = params ?? {};
-    const schema = params?.config?.schema ?? this.defaultConfigSchema;
-    const allowedSchemas = this.configSchemas;
-    assertEx2(allowedSchemas.includes(schema), () => `Bad Config Schema [Received ${schema}] [Expected ${JSON.stringify(allowedSchemas)}]`);
-    const mutatedConfig = { ...params?.config, schema };
-    params?.logger?.debug(`config: ${JSON.stringify(mutatedConfig, null, 2)}`);
-    const mutatedParams = { ...params, config: mutatedConfig };
-    const activeLogger = params?.logger ?? _AbstractModule.defaultLogger;
-    const generatedAccount = await _AbstractModule.determineAccount({ account });
-    const address = generatedAccount.address;
-    mutatedParams.logger = new IdLogger(activeLogger, () => `0x${address}`);
-    const newModule = new this(_AbstractModule.privateConstructorKey, mutatedParams, generatedAccount, address);
-    if (!_AbstractModule.enableLazyLoad) {
-      await newModule.start?.();
+  static async createHandler(inInstance) {
+    const instance = await super.createHandler(inInstance);
+    if (instance instanceof _AbstractModule) {
+      if (this.configSchemas.length === 0) {
+        throw new Error(`No allowed config schemas for [${this.name}]`);
+      }
+      const schema = instance.config.schema ?? this.defaultConfigSchema;
+      const allowedSchemas = this.configSchemas;
+      assertEx2(this.isAllowedSchema(schema), () => `Bad Config Schema [Received ${schema}] [Expected ${JSON.stringify(allowedSchemas)}]`);
+    } else {
+      throw new TypeError(`Invalid instance type [${instance.constructor.name}] for [${this.name}]`);
     }
-    return newModule;
+    return instance;
   }
   static async determineAccount(params) {
     return await determineAccount(params, this.allowRandomAccount);
@@ -318,6 +316,19 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
   static factory(params) {
     return ModuleFactory.withParams(this, params);
   }
+  static isAllowedSchema(schema) {
+    return this.configSchemas.includes(schema);
+  }
+  static async paramsHandler(inParams = {}) {
+    const superParams = await super.paramsHandler(inParams);
+    const params = {
+      ...superParams,
+      account: await this.determineAccount(superParams),
+      config: { schema: this.defaultConfigSchema, ...superParams.config },
+      logger: superParams.logger ?? this.defaultLogger
+    };
+    return params;
+  }
   // eslint-disable-next-line sonarjs/no-identical-functions
   _getRootFunction(funcName) {
     let anyThis = this;
@@ -344,6 +355,21 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
       }
     }
   }
+  async createHandler() {
+    await super.createHandler();
+    assertEx2(this.name === void 0 || isModuleName(this.name), () => `Invalid module name: ${this.name}`);
+    if (this.params.account === "random") {
+      this._account = await Account2.random();
+    } else if (isAccountInstance(this.params.account)) {
+      this._account = this.params.account;
+    }
+    assertEx2(isAccountInstance(this._account), () => `Invalid account instance: ${this._account}`);
+    this._supportedQueryValidator = new SupportedQueryValidator(this).queryable;
+    this._moduleConfigQueryValidator = new ModuleConfigQueryValidator(this.config).queryable;
+    if (!_AbstractModule.enableLazyLoad) {
+      await this.start?.();
+    }
+  }
   emit(eventName, eventArgs) {
     return super.emit(eventName, eventArgs);
   }
@@ -422,40 +448,28 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
     }
     return true;
   }
-  async start(timeout) {
-    this._noOverride("start");
-    this.status = "starting";
-    let startingTime = 0;
-    const startingStatus = setInterval(() => {
-      startingTime += 1e3;
-      this.statusReporter?.reportStatus(`${this.constructor.name}:${this.id}`, "starting", startingTime);
-    }, 1e3);
-    this._startPromise = this._startPromise ?? await this.startHandler(timeout);
-    const result = await this._startPromise;
-    this.status = result ? "started" : "dead";
-    clearInterval(startingStatus);
-    return result;
-  }
   async started(notStartedAction = "log", tryStart = true) {
-    if (isDefined(this._started) && await this._started === true) {
+    if (isString(this.status) && this.status === "started") {
       return true;
     }
-    if (isUndefined(this._started)) {
-      this._started = (async () => {
+    if (this.status === "created" || this.status === "stopped") {
+      this._startPromise = this._startPromise ?? (async () => {
         if (tryStart) {
           try {
             await this.start();
             return true;
           } catch (ex) {
             handleError(ex, (error) => {
-              this.logger?.warn(`Autostart of Module Failed: ${error.message})`);
-              this._started = void 0;
+              this.status = "error";
+              this.logger?.warn(`Autostart of Module Failed: ${error.message}`);
             });
+          } finally {
+            this._startPromise = void 0;
           }
         }
         switch (notStartedAction) {
           case "throw": {
-            throw new Error(`${MODULE_NOT_STARTED} [${this.address}]`);
+            throw new Error(`${MODULE_NOT_STARTED} [${this.address}] current state: ${this.status}`);
           }
           case "warn": {
             this.logger?.warn(MODULE_NOT_STARTED);
@@ -476,34 +490,16 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
         return false;
       })();
     }
-    if (isUndefined(this._started)) {
-      throw "Failed to create start promise";
+    if (isUndefined(this._startPromise)) {
+      throw new Error(`Failed to create start promise: ${this.status}`);
     }
-    return await this._started;
-  }
-  async stop(_timeout) {
-    this._noOverride("stop");
-    return await spanAsync("start", async () => {
-      return await this.busy(async () => {
-        const result = await this.stopHandler();
-        this._started = void 0;
-        this._startPromise = void 0;
-        this.status = result ? "stopped" : "dead";
-        return result;
-      });
-    }, this.tracer);
+    return await this._startPromise;
   }
   _checkDead() {
     if (this.dead) {
       throw new DeadModuleError(this.id, this._lastError);
     }
   }
-  // eslint-disable-next-line sonarjs/no-identical-functions
-  _noOverride(functionName) {
-    const thisFunc = this[functionName];
-    const rootFunc = this._getRootFunction(functionName);
-    assertEx2(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`);
-  }
   async archivistInstance(required = false) {
     const archivist = this.archivist;
     if (isUndefined(archivist)) {
@@ -644,18 +640,16 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
     }
     return PayloadBuilder2.omitPrivateStorageMeta(resultPayloads);
   }
-  async startHandler(_timeout) {
+  async startHandler() {
     this.validateConfig();
-    await Promise.resolve();
-    this._started = true;
-    return true;
+    await super.startHandler();
   }
   async stateHandler() {
     return [await this.manifestHandler(), ...await this.generateConfigAndAddress(), await this.generateDescribe()];
   }
-  stopHandler(_timeout) {
-    this._started = void 0;
-    return true;
+  async stopHandler() {
+    await super.stopHandler();
+    this._startPromise = void 0;
   }
   subscribeHandler() {
     return;
@@ -691,7 +685,6 @@ var AbstractModule = class _AbstractModule extends ModuleBaseEmitter {
 };
 
 // src/AbstractModuleInstance.ts
-import { assertEx as assertEx3 } from "@xylabs/assert";
 import { globallyUnique as globallyUnique2 } from "@xylabs/base";
 import { exists as exists2 } from "@xylabs/exists";
 import { isDefined as isDefined2 } from "@xylabs/typeof";
@@ -726,16 +719,6 @@ var AbstractModuleInstance = class _AbstractModuleInstance extends AbstractModul
   _parents = [];
   _privateResolver;
   _upResolver;
-  constructor(privateConstructorKey, params, account) {
-    assertEx3(AbstractModule.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
-    const mutatedParams = { ...params };
-    const addToResolvers = mutatedParams.addToResolvers ?? true;
-    super(privateConstructorKey, mutatedParams, account);
-    if (addToResolvers) {
-      this.upResolver.add(this);
-      this.downResolver.add(this);
-    }
-  }
   get downResolver() {
     this._downResolver = this._downResolver ?? new CompositeModuleResolver({
       allowNameResolution: this.allowNameResolution,
@@ -772,7 +755,7 @@ var AbstractModuleInstance = class _AbstractModuleInstance extends AbstractModul
   addParent(mod) {
     const existingEntry = this._parents.find((parent) => parent.address === mod.address);
     if (!existingEntry) {
-      this._parents.push(asNodeInstance(mod, "Only NodeInstances can be parents"));
+      this._parents.push(asNodeInstance(mod, "Only NodeInstances can be parents", { required: true }));
     }
   }
   async certifyParents() {
@@ -784,6 +767,16 @@ var AbstractModuleInstance = class _AbstractModuleInstance extends AbstractModul
       })
     )).flat();
   }
+  async createHandler() {
+    this.status = "creating";
+    await super.createHandler();
+    const addToResolvers = this.params.addToResolvers ?? true;
+    if (addToResolvers) {
+      this.upResolver.add(this);
+      this.downResolver.add(this);
+    }
+    this.status = "created";
+  }
   manifest(maxDepth) {
     this._checkDead();
     return this.busy(async () => {
@@ -862,12 +855,6 @@ var AbstractModuleInstance = class _AbstractModuleInstance extends AbstractModul
   async siblings() {
     return (await Promise.all((await this.parents()).map((parent) => parent.publicChildren()))).flat().filter(duplicateModules);
   }
-  /* override start(_timeout?: number): Promisable<boolean> {
-    if (this.parents.length === 0) {
-      this.logger.warn(`Module is being started without being attached to a parent: ${this.id} [${this.address}]`)
-    }
-    return super.start()
-  } */
   state() {
     this._checkDead();
     return this.busy(async () => {
@@ -897,6 +884,7 @@ var AbstractModuleInstance = class _AbstractModuleInstance extends AbstractModul
     }
     const result = {
       config: { name: modName, ...this.config },
+      name: modName,
       schema: ModuleManifestPayloadSchema,
       status: { address: this.address, children: childAddressToName }
     };
@@ -921,6 +909,17 @@ var AbstractModuleInstance = class _AbstractModuleInstance extends AbstractModul
     const query = await this.bindQuery(queryPayload, payloads, account, this.additionalSigners);
     return await this.query(query[0], query[1]);
   }
+  startHandler() {
+    this._checkDead();
+    return this.busy(async () => {
+      if (this.status === "started" || this.status === "creating") {
+        return;
+      }
+      this.status = "starting";
+      await super.startHandler();
+      this.status = "started";
+    });
+  }
   async storeToArchivists(payloads) {
     try {
       const archivists = await this.resolveArchivingArchivists();
@@ -944,7 +943,7 @@ var LoggerModuleStatusReporter = class {
   constructor(logger) {
     this.logger = logger;
   }
-  reportStatus(name, status, progress) {
+  report(name, status, progress) {
     this.statusMap[name] = status;
     const starting = Object.entries(this.statusMap).map(([, value]) => value === "starting" ? 1 : 0).reduce((a, b) => a + b, 0);
     const started = Object.entries(this.statusMap).map(([, value]) => value === "started" ? 1 : 0).reduce((a, b) => a + b, 0);