@navios/core 0.1.3 → 0.1.4

package/dist/index.js

@@ -77,9 +77,9 @@ __export(src_exports, {
   Application: () => Application,
   AttributeFactory: () => AttributeFactory,
   BadRequestException: () => BadRequestException,
+  BoundInjectionToken: () => BoundInjectionToken,
   ConfigProvider: () => ConfigProvider,
   ConfigProviderFactory: () => ConfigProviderFactory,
-  ConfigProviderInjectionToken: () => ConfigProviderInjectionToken,
   ConfigProviderOptions: () => ConfigProviderOptions,
   ConfigServiceInstance: () => ConfigServiceInstance,
   ConflictException: () => ConflictException,
@@ -95,7 +95,9 @@ __export(src_exports, {
   ExecutionContext: () => ExecutionContext2,
   ExecutionContextInjectionToken: () => ExecutionContextInjectionToken,
   ExecutionContextToken: () => ExecutionContextToken,
+  FactoryInjectionToken: () => FactoryInjectionToken,
   FactoryNotFound: () => FactoryNotFound,
+  FactoryTokenNotResolved: () => FactoryTokenNotResolved,
   ForbiddenException: () => ForbiddenException,
   GuardRunnerService: () => GuardRunnerService,
   Header: () => Header,
@@ -161,10 +163,11 @@ __export(src_exports, {
   isString: () => isString,
   isSymbol: () => isSymbol,
   isUndefined: () => isUndefined,
-  makeConfigToken: () => makeConfigToken,
   normalizePath: () => normalizePath,
   override: () => override,
+  provideConfig: () => provideConfig,
   provideServiceLocator: () => provideServiceLocator,
+  resolveService: () => resolveService,
   setPromiseCollector: () => setPromiseCollector,
   stripEndSlash: () => stripEndSlash,
   syncInject: () => syncInject,
@@ -283,6 +286,9 @@ var isSymbol = (val) => typeof val === "symbol";
 // packages/core/src/logger/console-logger.service.mts
 var import_util = require("util");
 
+// packages/core/src/service-locator/decorators/injectable.decorator.mts
+var import_common2 = require("@navios/common");
+
 // packages/core/src/service-locator/enums/injectable-scope.enum.mts
 var InjectableScope = /* @__PURE__ */ ((InjectableScope2) => {
   InjectableScope2["Singleton"] = "Singleton";
@@ -302,8 +308,38 @@ var InjectionToken = class _InjectionToken {
   static create(name2, schema) {
     return new _InjectionToken(name2, schema);
   }
-  toString() {
-    return this.name;
+  static bound(token, value) {
+    return new BoundInjectionToken(token, value);
+  }
+  static factory(token, factory) {
+    return new FactoryInjectionToken(token, factory);
+  }
+  static refineType(token) {
+    return token;
+  }
+};
+var BoundInjectionToken = class extends InjectionToken {
+  constructor(token, value) {
+    super(token.name, token.schema);
+    this.token = token;
+    this.value = value;
+    this.id = token.id;
+  }
+};
+var FactoryInjectionToken = class extends InjectionToken {
+  constructor(token, factory) {
+    super(token.name, token.schema);
+    this.token = token;
+    this.factory = factory;
+  }
+  value;
+  resolved = false;
+  async resolve() {
+    if (!this.value) {
+      this.value = await this.factory();
+      this.resolved = true;
+    }
+    return this.value;
   }
 };
 
@@ -314,6 +350,7 @@ var ErrorsEnum = /* @__PURE__ */ ((ErrorsEnum2) => {
   ErrorsEnum2["InstanceDestroying"] = "InstanceDestroying";
   ErrorsEnum2["UnknownError"] = "UnknownError";
   ErrorsEnum2["FactoryNotFound"] = "FactoryNotFound";
+  ErrorsEnum2["FactoryTokenNotResolved"] = "FactoryTokenNotResolved";
   return ErrorsEnum2;
 })(ErrorsEnum || {});
 
@@ -326,6 +363,14 @@ var FactoryNotFound = class extends Error {
   code = "FactoryNotFound" /* FactoryNotFound */;
 };
 
+// packages/core/src/service-locator/errors/factory-token-not-resolved.mts
+var FactoryTokenNotResolved = class extends Error {
+  code = "FactoryTokenNotResolved" /* FactoryTokenNotResolved */;
+  constructor(name2) {
+    super(`Factory token not resolved: ${name2.toString()}`);
+  }
+};
+
 // packages/core/src/service-locator/errors/instance-destroying.mts
 var InstanceDestroying = class extends Error {
   constructor(name2) {
@@ -568,29 +613,48 @@ var ServiceLocator = class {
       this.instanceFactories.delete(token);
     }
   }
-  getInstanceIdentifier(token, args) {
-    var _a;
-    const validatedArgs = token.schema ? token.schema.safeParse(args) : void 0;
-    if (validatedArgs && !validatedArgs.success) {
-      (_a = this.logger) == null ? void 0 : _a.error(
-        `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
-        validatedArgs.error
-      );
-      throw new UnknownError(validatedArgs.error);
+  resolveTokenArgs(token, args) {
+    var _a, _b;
+    let realArgs = args;
+    if (token instanceof BoundInjectionToken) {
+      realArgs = token.value;
+    } else if (token instanceof FactoryInjectionToken) {
+      if (token.resolved) {
+        realArgs = token.value;
+      } else {
+        return [new FactoryTokenNotResolved(token.name)];
+      }
     }
-    return this.makeInstanceName(token, validatedArgs);
-  }
-  async getInstance(token, args) {
-    var _a, _b, _c;
-    const validatedArgs = token.schema ? token.schema.safeParse(args) : void 0;
+    if (!token.schema) {
+      return [void 0, realArgs];
+    }
+    const validatedArgs = (_a = token.schema) == null ? void 0 : _a.safeParse(realArgs);
     if (validatedArgs && !validatedArgs.success) {
-      (_a = this.logger) == null ? void 0 : _a.error(
+      (_b = this.logger) == null ? void 0 : _b.error(
         `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
         validatedArgs.error
       );
       return [new UnknownError(validatedArgs.error)];
     }
-    const instanceName = this.makeInstanceName(token, validatedArgs);
+    return [void 0, validatedArgs == null ? void 0 : validatedArgs.data];
+  }
+  getInstanceIdentifier(token, args) {
+    const [err, realArgs] = this.resolveTokenArgs(token, args);
+    if (err) {
+      throw err;
+    }
+    return this.makeInstanceName(token, realArgs);
+  }
+  async getInstance(token, args) {
+    var _a, _b;
+    const [err, realArgs] = this.resolveTokenArgs(token, args);
+    if (err instanceof UnknownError) {
+      throw err;
+    } else if (err instanceof FactoryTokenNotResolved && token instanceof FactoryInjectionToken) {
+      await token.resolve();
+      return this.getInstance(token, args);
+    }
+    const instanceName = this.makeInstanceName(token, realArgs);
     const [error, holder] = this.manager.get(instanceName);
     if (!error) {
       if (holder.status === "creating" /* Creating */) {
@@ -602,13 +666,13 @@ var ServiceLocator = class {
     }
     switch (error.code) {
       case "InstanceDestroying" /* InstanceDestroying */:
-        (_b = this.logger) == null ? void 0 : _b.log(
+        (_a = this.logger) == null ? void 0 : _a.log(
           `[ServiceLocator]#getInstance() TTL expired for ${holder == null ? void 0 : holder.name}`
         );
         await (holder == null ? void 0 : holder.destroyPromise);
         return this.getInstance(token, args);
       case "InstanceExpired" /* InstanceExpired */:
-        (_c = this.logger) == null ? void 0 : _c.log(
+        (_b = this.logger) == null ? void 0 : _b.log(
           `[ServiceLocator]#getInstance() TTL expired for ${holder == null ? void 0 : holder.name}`
         );
         await this.invalidate(instanceName);
@@ -618,7 +682,7 @@ var ServiceLocator = class {
       default:
         return [error];
     }
-    return this.createInstance(instanceName, token, args);
+    return this.createInstance(instanceName, token, realArgs);
   }
   async getOrThrowInstance(token, args) {
     const [error, instance] = await this.getInstance(token, args);
@@ -639,10 +703,15 @@ var ServiceLocator = class {
     (_a = this.logger) == null ? void 0 : _a.log(
       `[ServiceLocator]#createInstance() Creating instance for ${instanceName}`
     );
-    if (this.abstractFactories.has(token) || this.instanceFactories.has(token)) {
-      return this.createInstanceFromAbstractFactory(instanceName, token, args);
+    let realToken = token instanceof BoundInjectionToken || token instanceof FactoryInjectionToken ? token.token : token;
+    if (this.abstractFactories.has(realToken) || this.instanceFactories.has(realToken)) {
+      return this.createInstanceFromAbstractFactory(
+        instanceName,
+        realToken,
+        args
+      );
     } else {
-      return [new FactoryNotFound(token.name.toString())];
+      return [new FactoryNotFound(realToken.name.toString())];
     }
   }
   async createInstanceFromAbstractFactory(instanceName, token, args) {
@@ -689,7 +758,7 @@ var ServiceLocator = class {
             );
           });
         }
-        if (holder.ttl === 0) {
+        if (holder.ttl === 0 || !shouldStore) {
           await this.invalidate(instanceName);
         }
         await this.notifyListeners(instanceName);
@@ -761,16 +830,11 @@ var ServiceLocator = class {
     };
   }
   getSyncInstance(token, args) {
-    var _a;
-    const validatedArgs = token.schema ? token.schema.safeParse(args) : void 0;
-    if (validatedArgs && !validatedArgs.success) {
-      (_a = this.logger) == null ? void 0 : _a.error(
-        `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
-        validatedArgs.error
-      );
-      throw new UnknownError(validatedArgs.error);
+    const [err, realArgs] = this.resolveTokenArgs(token, args);
+    if (err) {
+      return null;
     }
-    const instanceName = this.makeInstanceName(token, validatedArgs);
+    const instanceName = this.makeInstanceName(token, realArgs);
     const [error, holder] = this.manager.get(instanceName);
     if (error) {
       return null;
@@ -878,6 +942,9 @@ function getServiceLocator() {
   return serviceLocator;
 }
 
+// packages/core/src/service-locator/resolve-service.mts
+var import_common = require("@navios/common");
+
 // packages/core/src/service-locator/proxy-service-locator.mts
 var ProxyServiceLocator = class {
   constructor(serviceLocator2, ctx) {
@@ -926,14 +993,6 @@ function makeProxyServiceLocator(serviceLocator2, ctx) {
 // packages/core/src/service-locator/sync-injector.mts
 var promiseCollector = null;
 function syncInject(token, args) {
-  if (token.schema) {
-    const parsed = token.schema.safeParse(args);
-    if (!parsed.success) {
-      throw new Error(
-        `[ServiceLocator] Invalid arguments for ${token.name.toString()}: ${parsed.error}`
-      );
-    }
-  }
   let realToken = token;
   if (!(token instanceof InjectionToken)) {
     realToken = getInjectableToken(token);
@@ -957,6 +1016,40 @@ function setPromiseCollector(collector) {
   return original;
 }
 
+// packages/core/src/service-locator/resolve-service.mts
+async function resolveService(ctx, target, args = []) {
+  const proxyServiceLocator = makeProxyServiceLocator(getServiceLocator(), ctx);
+  let promises = [];
+  const promiseCollector2 = (promise) => {
+    promises.push(promise);
+  };
+  const originalPromiseCollector = setPromiseCollector(promiseCollector2);
+  const tryLoad = () => {
+    const original = provideServiceLocator(proxyServiceLocator);
+    let result = new target(...args);
+    provideServiceLocator(original);
+    return result;
+  };
+  let instance = tryLoad();
+  setPromiseCollector(originalPromiseCollector);
+  if (promises.length > 0) {
+    await Promise.all(promises);
+    promises = [];
+    instance = tryLoad();
+  }
+  if (promises.length > 0) {
+    console.error(`[ServiceLocator] ${target.name} has problem with it's definition.
+     
+     One or more of the dependencies are registered as a InjectableScope.Instance and are used with syncInject.
+     
+     Please use inject instead of syncInject to load those dependencies.`);
+    throw new import_common.NaviosException(
+      `[ServiceLocator] Service ${target.name} cannot be instantiated.`
+    );
+  }
+  return instance;
+}
+
 // packages/core/src/service-locator/decorators/injectable.decorator.mts
 var InjectableType = /* @__PURE__ */ ((InjectableType2) => {
   InjectableType2["Class"] = "Class";
@@ -977,62 +1070,22 @@ function Injectable({
     }
     let injectableToken = token ?? InjectionToken.create(target);
     const locator = getServiceLocator();
-    if (!locator) {
-      throw new Error(
-        "[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator."
-      );
-    }
     if (type === "Class" /* Class */) {
       locator.registerAbstractFactory(
         injectableToken,
-        async (ctx) => {
-          if (scope === "Instance" /* Instance */) {
-            ctx.setTtl(0);
-          }
-          const proxyServiceLocator = makeProxyServiceLocator(
-            getServiceLocator(),
-            ctx
-          );
-          const promises = [];
-          const promiseCollector2 = (promise) => {
-            promises.push(promise);
-          };
-          const originalPromiseCollector = setPromiseCollector(promiseCollector2);
-          const tryInit = () => {
-            const original = provideServiceLocator(proxyServiceLocator);
-            let result2 = new target();
-            provideServiceLocator(original);
-            return result2;
-          };
-          const result = tryInit();
-          setPromiseCollector(originalPromiseCollector);
-          if (promises.length > 0) {
-            await Promise.all(promises);
-            return tryInit();
-          }
-          return result;
-        },
+        async (ctx) => resolveService(ctx, target),
         scope
       );
     } else if (type === "Factory" /* Factory */) {
       locator.registerAbstractFactory(
         injectableToken,
         async (ctx, args) => {
-          if (scope === "Instance" /* Instance */) {
-            ctx.setTtl(0);
-          }
-          const proxyServiceLocator = makeProxyServiceLocator(
-            getServiceLocator(),
-            ctx
-          );
-          const original = provideServiceLocator(proxyServiceLocator);
-          const builder = new target();
+          const builder = await resolveService(ctx, target);
           if (typeof builder.create !== "function") {
-            throw new Error(
+            throw new import_common2.NaviosException(
               `[ServiceLocator] Factory ${target.name} does not implement the create method.`
             );
           }
-          provideServiceLocator(original);
           return builder.create(ctx, args);
         },
         scope
@@ -1095,14 +1148,6 @@ var EventEmitter = class {
 
 // packages/core/src/service-locator/inject.mts
 function inject(token, args) {
-  if (token.schema) {
-    const parsed = token.schema.safeParse(args);
-    if (!parsed.success) {
-      throw new Error(
-        `[ServiceLocator] Invalid arguments for ${token.name.toString()}: ${parsed.error}`
-      );
-    }
-  }
   let realToken = token;
   if (!(token instanceof InjectionToken)) {
     realToken = getInjectableToken(token);
@@ -1677,7 +1722,7 @@ var PinoWrapper = class _PinoWrapper {
 };
 
 // packages/core/src/config/config.service.mts
-var import_common = require("@navios/common");
+var import_common3 = require("@navios/common");
 var ConfigServiceInstance = class {
   constructor(config = {}, logger) {
     this.config = config;
@@ -1716,30 +1761,29 @@ var ConfigServiceInstance = class {
     if (value === null) {
       const message = errorMessage || `Configuration value for key "${String(key)}" is not defined`;
       this.logger.error(message);
-      throw new import_common.NaviosException(message);
+      throw new import_common3.NaviosException(message);
     }
     return value;
   }
 };
 
 // packages/core/src/config/config.provider.mts
-var ConfigProviderInjectionToken = "ConfigProvider";
 var ConfigProviderOptions = import_zod3.z.object({
   load: import_zod3.z.function()
 });
-var ConfigProvider = InjectionToken.create(ConfigProviderInjectionToken, ConfigProviderOptions);
+var ConfigProvider = InjectionToken.create(ConfigServiceInstance, ConfigProviderOptions);
 var _ConfigProviderFactory_decorators, _init4;
 _ConfigProviderFactory_decorators = [Injectable({
   token: ConfigProvider,
   type: "Factory" /* Factory */
 })];
 var ConfigProviderFactory = class {
-  logger = inject(Logger, {
+  logger = syncInject(Logger, {
     context: "ConfigService"
   });
   async create(ctx, args) {
     const { load } = args;
-    const logger = await this.logger;
+    const logger = this.logger;
     try {
       const config = await load();
       return new ConfigServiceInstance(config, logger);
@@ -1752,21 +1796,8 @@ var ConfigProviderFactory = class {
 _init4 = __decoratorStart(null);
 ConfigProviderFactory = __decorateElement(_init4, 0, "ConfigProviderFactory", _ConfigProviderFactory_decorators, ConfigProviderFactory);
 __runInitializers(_init4, 1, ConfigProviderFactory);
-function makeConfigToken(options) {
-  var _ConfigServiceImpl_decorators, _init9;
-  _ConfigServiceImpl_decorators = [Injectable({
-    type: "Factory" /* Factory */
-  })];
-  class ConfigServiceImpl {
-    configService = inject(ConfigProvider, options);
-    create() {
-      return this.configService;
-    }
-  }
-  _init9 = __decoratorStart(null);
-  ConfigServiceImpl = __decorateElement(_init9, 0, "ConfigServiceImpl", _ConfigServiceImpl_decorators, ConfigServiceImpl);
-  __runInitializers(_init9, 1, ConfigServiceImpl);
-  return getInjectableToken(ConfigServiceImpl);
+function provideConfig(options) {
+  return InjectionToken.bound(ConfigProvider, options);
 }
 
 // packages/core/src/metadata/endpoint.metadata.mts
@@ -2079,7 +2110,7 @@ var ConflictException = class extends HttpException {
 };
 
 // packages/core/src/services/controller-adapter.service.mts
-var import_common2 = require("@navios/common");
+var import_common4 = require("@navios/common");
 
 // packages/core/src/tokens/application.token.mts
 var ApplicationInjectionToken = "ApplicationInjectionToken";
@@ -2300,7 +2331,7 @@ var _ControllerAdapterService = class _ControllerAdapterService {
         this.logger.error(
           `Unknown endpoint type ${endpointMetadata.type} for ${controller.name}:${endpointMetadata.classMethod}`
         );
-        throw new import_common2.NaviosException("Unknown endpoint type");
+        throw new import_common4.NaviosException("Unknown endpoint type");
       case "config" /* Config */:
         return this.provideHandlerForConfig(
           controller,
@@ -2309,7 +2340,7 @@ var _ControllerAdapterService = class _ControllerAdapterService {
         );
       case "handler" /* Handler */:
         this.logger.error("Not implemented yet");
-        throw new import_common2.NaviosException("Not implemented yet");
+        throw new import_common4.NaviosException("Not implemented yet");
     }
   }
   provideHandlerForConfig(controller, executionContext, endpointMetadata) {
@@ -2639,9 +2670,9 @@ var NaviosFactory = class {
   Application,
   AttributeFactory,
   BadRequestException,
+  BoundInjectionToken,
   ConfigProvider,
   ConfigProviderFactory,
-  ConfigProviderInjectionToken,
   ConfigProviderOptions,
   ConfigServiceInstance,
   ConflictException,
@@ -2657,7 +2688,9 @@ var NaviosFactory = class {
   ExecutionContext,
   ExecutionContextInjectionToken,
   ExecutionContextToken,
+  FactoryInjectionToken,
   FactoryNotFound,
+  FactoryTokenNotResolved,
   ForbiddenException,
   GuardRunnerService,
   Header,
@@ -2723,10 +2756,11 @@ var NaviosFactory = class {
   isString,
   isSymbol,
   isUndefined,
-  makeConfigToken,
   normalizePath,
   override,
+  provideConfig,
   provideServiceLocator,
+  resolveService,
   setPromiseCollector,
   stripEndSlash,
   syncInject,