@navios/core 0.1.3 → 0.1.5

package/dist/index.mjs

@@ -57,7 +57,7 @@ function envString(key, defaultValue) {
 }
 
 // packages/core/src/config/config.provider.mts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // packages/core/src/logger/utils/cli-colors.util.mts
 var isColorAllowed = () => !process.env.NO_COLOR;
@@ -157,6 +157,9 @@ var isSymbol = (val) => typeof val === "symbol";
 // packages/core/src/logger/console-logger.service.mts
 import { inspect } from "util";
 
+// packages/core/src/service-locator/decorators/injectable.decorator.mts
+import { NaviosException as NaviosException2 } from "@navios/common";
+
 // packages/core/src/service-locator/enums/injectable-scope.enum.mts
 var InjectableScope = /* @__PURE__ */ ((InjectableScope2) => {
   InjectableScope2["Singleton"] = "Singleton";
@@ -176,8 +179,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;
   }
 };
 
@@ -188,6 +221,7 @@ var ErrorsEnum = /* @__PURE__ */ ((ErrorsEnum2) => {
   ErrorsEnum2["InstanceDestroying"] = "InstanceDestroying";
   ErrorsEnum2["UnknownError"] = "UnknownError";
   ErrorsEnum2["FactoryNotFound"] = "FactoryNotFound";
+  ErrorsEnum2["FactoryTokenNotResolved"] = "FactoryTokenNotResolved";
   return ErrorsEnum2;
 })(ErrorsEnum || {});
 
@@ -200,6 +234,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) {
@@ -442,29 +484,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 */) {
@@ -476,13 +537,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);
@@ -492,7 +553,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);
@@ -513,10 +574,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) {
@@ -563,7 +629,7 @@ var ServiceLocator = class {
             );
           });
         }
-        if (holder.ttl === 0) {
+        if (holder.ttl === 0 || !shouldStore) {
           await this.invalidate(instanceName);
         }
         await this.notifyListeners(instanceName);
@@ -635,16 +701,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;
@@ -752,6 +813,9 @@ function getServiceLocator() {
   return serviceLocator;
 }
 
+// packages/core/src/service-locator/resolve-service.mts
+import { NaviosException } from "@navios/common";
+
 // packages/core/src/service-locator/proxy-service-locator.mts
 var ProxyServiceLocator = class {
   constructor(serviceLocator2, ctx) {
@@ -800,14 +864,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);
@@ -831,6 +887,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 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";
@@ -851,62 +941,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 NaviosException2(
               `[ServiceLocator] Factory ${target.name} does not implement the create method.`
             );
           }
-          provideServiceLocator(original);
           return builder.create(ctx, args);
         },
         scope
@@ -969,14 +1019,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);
@@ -1350,7 +1392,7 @@ __runInitializers(_init, 1, _ConsoleLogger);
 var ConsoleLogger = _ConsoleLogger;
 
 // packages/core/src/logger/logger.factory.mts
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // packages/core/src/logger/logger.service.mts
 var DEFAULT_LOGGER = new ConsoleLogger();
@@ -1477,10 +1519,10 @@ var LoggerInstance = _LoggerInstance;
 
 // packages/core/src/logger/logger.factory.mts
 var LoggerInjectionToken = "LoggerInjectionToken";
-var LoggerOptions = z.object({
-  context: z.string().optional(),
-  options: z.object({
-    timestamp: z.boolean().optional()
+var LoggerOptions = z2.object({
+  context: z2.string().optional(),
+  options: z2.object({
+    timestamp: z2.boolean().optional()
   }).optional()
 }).optional();
 var Logger = InjectionToken.create(LoggerInjectionToken, LoggerOptions);
@@ -1551,7 +1593,7 @@ var PinoWrapper = class _PinoWrapper {
 };
 
 // packages/core/src/config/config.service.mts
-import { NaviosException } from "@navios/common";
+import { NaviosException as NaviosException3 } from "@navios/common";
 var ConfigServiceInstance = class {
   constructor(config = {}, logger) {
     this.config = config;
@@ -1590,30 +1632,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 NaviosException(message);
+      throw new NaviosException3(message);
     }
     return value;
   }
 };
 
 // packages/core/src/config/config.provider.mts
-var ConfigProviderInjectionToken = "ConfigProvider";
-var ConfigProviderOptions = z2.object({
-  load: z2.function()
+var ConfigProviderOptions = z3.object({
+  load: z3.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);
@@ -1626,21 +1667,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
@@ -1953,7 +1981,7 @@ var ConflictException = class extends HttpException {
 };
 
 // packages/core/src/services/controller-adapter.service.mts
-import { NaviosException as NaviosException2 } from "@navios/common";
+import { NaviosException as NaviosException4 } from "@navios/common";
 
 // packages/core/src/tokens/application.token.mts
 var ApplicationInjectionToken = "ApplicationInjectionToken";
@@ -2174,7 +2202,7 @@ var _ControllerAdapterService = class _ControllerAdapterService {
         this.logger.error(
           `Unknown endpoint type ${endpointMetadata.type} for ${controller.name}:${endpointMetadata.classMethod}`
         );
-        throw new NaviosException2("Unknown endpoint type");
+        throw new NaviosException4("Unknown endpoint type");
       case "config" /* Config */:
         return this.provideHandlerForConfig(
           controller,
@@ -2183,7 +2211,7 @@ var _ControllerAdapterService = class _ControllerAdapterService {
         );
       case "handler" /* Handler */:
         this.logger.error("Not implemented yet");
-        throw new NaviosException2("Not implemented yet");
+        throw new NaviosException4("Not implemented yet");
     }
   }
   provideHandlerForConfig(controller, executionContext, endpointMetadata) {
@@ -2515,9 +2543,9 @@ export {
   Application,
   AttributeFactory,
   BadRequestException,
+  BoundInjectionToken,
   ConfigProvider,
   ConfigProviderFactory,
-  ConfigProviderInjectionToken,
   ConfigProviderOptions,
   ConfigServiceInstance,
   ConflictException,
@@ -2533,7 +2561,9 @@ export {
   ExecutionContext2 as ExecutionContext,
   ExecutionContextInjectionToken,
   ExecutionContextToken,
+  FactoryInjectionToken,
   FactoryNotFound,
+  FactoryTokenNotResolved,
   ForbiddenException,
   GuardRunnerService,
   Header,
@@ -2599,10 +2629,11 @@ export {
   isString,
   isSymbol,
   isUndefined,
-  makeConfigToken,
   normalizePath,
   override,
+  provideConfig,
   provideServiceLocator,
+  resolveService,
   setPromiseCollector,
   stripEndSlash,
   syncInject,