refactor(libraries): implement initialization validation and standardize nullable fields

Author: Exeloo

packages/asset-manager/src/asset-manager.library.ts

@@ -1,7 +1,7 @@
 import { BaseAssetManagerLibrary, type InitContext, NfFile, NfNotFound } from "@nanoforge/common";
 
 export class AssetManagerLibrary extends BaseAssetManagerLibrary {
-  private _assets: Map<string, string>;
+  private _assets?: Map<string, string>;
 
   get __name(): string {
     return "AssetManagerLibrary";
@@ -12,6 +12,7 @@ export class AssetManagerLibrary extends BaseAssetManagerLibrary {
   }
 
   public getAsset(path: string): NfFile {
+    if (!this._assets) this.throwNotInitializedError();
     const res = this._assets.get(this._parsePath(path));
     if (!res) throw new NfNotFound(path, "Asset");
     return new NfFile(res);

packages/common/src/context/contexts/library.context.ts

@@ -5,7 +5,7 @@ export enum LibraryStatusEnum {
 }
 
 export class LibraryContext {
-  protected _status: LibraryStatusEnum;
+  protected _status: LibraryStatusEnum = LibraryStatusEnum.UNLOADED;
 
   get status() {
     return this._status;

packages/common/src/exception/exceptions/not-initialized.exception.ts

@@ -0,0 +1,11 @@
+import { NfException } from "../abstracts/exception.abstract";
+
+export class NfNotInitializedException extends NfException {
+  get code(): number {
+    return 404;
+  }
+
+  constructor(item: string, type?: string) {
+    super(`${type ? `${type} - ` : ""}${item} not initialized.`);
+  }
+}

packages/common/src/exception/index.ts

@@ -1,2 +1,3 @@
-export { NfNotFound } from "./exceptions/not-found.exception";
 export { NfFetchException } from "./exceptions/fetch.exception";
+export { NfNotFound } from "./exceptions/not-found.exception";
+export { NfNotInitializedException } from "./exceptions/not-initialized.exception";

packages/common/src/library/libraries/library.ts

@@ -1,4 +1,5 @@
 import { type ClearContext, type InitContext } from "../../context";
+import { NfNotInitializedException } from "../../exception";
 import { RelationshipHandler } from "../relationship/relationship-handler";
 import { DEFAULT_LIBRARY_OPTIONS } from "./consts/library-options-default.const";
 import { type ILibrary, type ILibraryOptions } from "./library.type";
@@ -30,4 +31,8 @@ export abstract class Library implements ILibrary {
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public async __clear(_context: ClearContext): Promise<void> {}
+
+  protected throwNotInitializedError(): never {
+    throw new NfNotInitializedException(this.__name, "Library");
+  }
 }

packages/common/src/library/manager/managers/base-library.manager.ts

@@ -4,9 +4,7 @@ import { LibraryHandle } from "../handle/library.handle";
 
 export class BaseLibraryManager {
   protected _libraries: LibraryHandle[] = [];
-  private _librariesIndex: {
-    [sym: symbol]: number;
-  };
+  private _librariesIndex: Record<symbol, number> = {};
 
   /**
    * @todo Add error management

packages/core/src/application/nanoforge-application.ts

@@ -4,6 +4,7 @@ import {
   type ILibrary,
   type INetworkLibrary,
   type IRunOptions,
+  NfNotInitializedException,
 } from "@nanoforge/common";
 
 import { EditableApplicationContext } from "../common/context/contexts/application.editable-context";
@@ -13,7 +14,7 @@ import type { IApplicationOptions } from "./application-options.type";
 
 export abstract class NanoforgeApplication {
   protected applicationConfig: ApplicationConfig;
-  private _core: Core;
+  private _core?: Core;
   private readonly _options: IApplicationOptions;
 
   constructor(options?: Partial<IApplicationOptions>) {
@@ -51,6 +52,7 @@ export abstract class NanoforgeApplication {
   }
 
   public run() {
-    return this._core.run();
+    if (!this._core) throw new NfNotInitializedException("Core");
+    return this._core?.run();
   }
 }

packages/core/src/common/library/manager/library.manager.ts

@@ -24,6 +24,10 @@ import {
 import { EditableLibraryContext } from "../../context/contexts/library.editable-context";
 import { Relationship } from "../relationship-functions";
 
+const hasMethod = (obj: any, method: string) => {
+  return typeof obj[method] === "function";
+};
+
 export class EditableLibraryManager extends LibraryManager {
   public set(sym: symbol, library: ILibrary) {
     this.setNewLibrary(sym, library, new EditableLibraryContext());
@@ -90,13 +94,13 @@ export class EditableLibraryManager extends LibraryManager {
 
   public getMutableLibraries(): LibraryHandle<IMutableLibrary>[] {
     return this._libraries.filter(
-      (handle) => handle && typeof handle.library["mute"] === "function",
+      (handle) => handle && hasMethod(handle.library, "mute"),
     ) as LibraryHandle<IMutableLibrary>[];
   }
 
   private _getRunnerLibraries(): LibraryHandle<IRunnerLibrary>[] {
     return this._libraries.filter(
-      (handle) => handle && typeof handle.library["__run"] === "function",
+      (handle) => handle && hasMethod(handle.library, "__run"),
     ) as LibraryHandle<IRunnerLibrary>[];
   }
 }

packages/core/src/core/core.ts

@@ -8,6 +8,7 @@ import {
   InitContext,
   type LibraryHandle,
   LibraryStatusEnum,
+  NfNotInitializedException,
 } from "@nanoforge/common";
 
 import { type ApplicationConfig } from "../application/application-config";
@@ -19,8 +20,8 @@ import { ConfigRegistry } from "../config/config-registry";
 export class Core {
   private readonly config: ApplicationConfig;
   private readonly context: ApplicationContext;
-  private options: IApplicationOptions;
-  private _configRegistry: ConfigRegistry;
+  private options?: IApplicationOptions;
+  private _configRegistry?: ConfigRegistry;
 
   constructor(config: ApplicationConfig, context: ApplicationContext) {
     this.config = config;
@@ -34,6 +35,8 @@ export class Core {
   }
 
   public async run(): Promise<void> {
+    if (!this.options) throw new NfNotInitializedException("Core");
+
     const context = this.getExecutionContext();
     const clientContext = this.getClientContext();
     const libraries = this.config.libraryManager.getExecutionLibraries();
@@ -58,6 +61,8 @@ export class Core {
   }
 
   private getInitContext(options: IRunOptions): InitContext {
+    if (!this._configRegistry) throw new NfNotInitializedException("Core");
+
     return new InitContext(this.context, this.config.libraryManager, this._configRegistry, options);
   }
 

packages/ecs/.prettierignore

@@ -4,6 +4,5 @@ package-lock.json
 yarn.lock
 bun.lock
 
-*.js
 *.d.ts
 build