@navios/core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1657 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name2, symbol) => (symbol = Symbol[name2]) ? symbol : Symbol.for("Symbol." + name2);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create((base == null ? void 0 : base[__knownSymbol("metadata")]) ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name2, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name: name2, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name2, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name2]() {
+    return __privateGet(this, extra);
+  }, set [name2](x) {
+    return __privateSet(this, extra, x);
+  } }, name2));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name2) : __name(target, name2);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name2, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name2 in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name2];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name2] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name2, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// packages/core/src/metadata/endpoint.metadata.mts
+var EndpointMetadataKey = Symbol("EndpointMetadataKey");
+function getAllEndpointMetadata(context) {
+  if (context.metadata) {
+    const metadata = context.metadata[EndpointMetadataKey];
+    if (metadata) {
+      return metadata;
+    } else {
+      context.metadata[EndpointMetadataKey] = /* @__PURE__ */ new Set();
+      return context.metadata[EndpointMetadataKey];
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+function getEndpointMetadata(target, context) {
+  if (context.metadata) {
+    const metadata = getAllEndpointMetadata(context);
+    if (metadata) {
+      const endpointMetadata = Array.from(metadata).find(
+        (item) => item.classMethod === target.name
+      );
+      if (endpointMetadata) {
+        return endpointMetadata;
+      } else {
+        const newMetadata = {
+          classMethod: target.name,
+          url: "",
+          httpMethod: "GET",
+          config: null,
+          guards: /* @__PURE__ */ new Set(),
+          customAttributes: /* @__PURE__ */ new Map()
+        };
+        metadata.add(newMetadata);
+        return newMetadata;
+      }
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+
+// packages/core/src/metadata/controller.metadata.mts
+var ControllerMetadataKey = Symbol("ControllerMetadataKey");
+function getControllerMetadata(target, context) {
+  if (context.metadata) {
+    const metadata = context.metadata[ControllerMetadataKey];
+    if (metadata) {
+      return metadata;
+    } else {
+      const endpointsMetadata = getAllEndpointMetadata(context);
+      const newMetadata = {
+        endpoints: endpointsMetadata,
+        guards: /* @__PURE__ */ new Set(),
+        customAttributes: /* @__PURE__ */ new Map()
+      };
+      context.metadata[ControllerMetadataKey] = newMetadata;
+      target[ControllerMetadataKey] = newMetadata;
+      return newMetadata;
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+function extractControllerMetadata(target) {
+  const metadata = target[ControllerMetadataKey];
+  if (!metadata) {
+    throw new Error(
+      "[Navios] Controller metadata not found. Make sure to use @Controller decorator."
+    );
+  }
+  return metadata;
+}
+function hasControllerMetadata(target) {
+  const metadata = target[ControllerMetadataKey];
+  return !!metadata;
+}
+
+// packages/core/src/metadata/module.metadata.mts
+var ModuleMetadataKey = Symbol("ControllerMetadataKey");
+function getModuleMetadata(target, context) {
+  if (context.metadata) {
+    const metadata = context.metadata[ModuleMetadataKey];
+    if (metadata) {
+      return metadata;
+    } else {
+      const newMetadata = {
+        controllers: /* @__PURE__ */ new Set(),
+        imports: /* @__PURE__ */ new Set(),
+        guards: /* @__PURE__ */ new Set(),
+        customAttributes: /* @__PURE__ */ new Map()
+      };
+      context.metadata[ModuleMetadataKey] = newMetadata;
+      target[ModuleMetadataKey] = newMetadata;
+      return newMetadata;
+    }
+  }
+  throw new Error("[Navios] Wrong environment.");
+}
+function extractModuleMetadata(target) {
+  const metadata = target[ModuleMetadataKey];
+  if (!metadata) {
+    throw new Error(
+      "[Navios] Module metadata not found. Make sure to use @Module decorator."
+    );
+  }
+  return metadata;
+}
+function hasModuleMetadata(target) {
+  return !!target[ModuleMetadataKey];
+}
+
+// packages/core/src/service-locator/enums/injectable-scope.enum.mts
+var InjectableScope = /* @__PURE__ */ ((InjectableScope2) => {
+  InjectableScope2["Singleton"] = "Singleton";
+  InjectableScope2["Instance"] = "Instance";
+  return InjectableScope2;
+})(InjectableScope || {});
+
+// packages/core/src/service-locator/injection-token.mts
+import { randomUUID } from "crypto";
+var InjectionToken = class _InjectionToken {
+  constructor(name2, schema) {
+    this.name = name2;
+    this.schema = schema;
+  }
+  id = randomUUID();
+  static create(name2, schema) {
+    return new _InjectionToken(name2, schema);
+  }
+  toString() {
+    return this.name;
+  }
+};
+
+// packages/core/src/service-locator/errors/errors.enum.mts
+var ErrorsEnum = /* @__PURE__ */ ((ErrorsEnum2) => {
+  ErrorsEnum2["InstanceExpired"] = "InstanceExpired";
+  ErrorsEnum2["InstanceNotFound"] = "InstanceNotFound";
+  ErrorsEnum2["InstanceDestroying"] = "InstanceDestroying";
+  ErrorsEnum2["UnknownError"] = "UnknownError";
+  ErrorsEnum2["FactoryNotFound"] = "FactoryNotFound";
+  return ErrorsEnum2;
+})(ErrorsEnum || {});
+
+// packages/core/src/service-locator/errors/factory-not-found.mts
+var FactoryNotFound = class extends Error {
+  constructor(name2) {
+    super(`Factory ${name2} not found`);
+    this.name = name2;
+  }
+  code = "FactoryNotFound" /* FactoryNotFound */;
+};
+
+// packages/core/src/service-locator/errors/instance-destroying.mts
+var InstanceDestroying = class extends Error {
+  constructor(name2) {
+    super(`Instance ${name2} destroying`);
+    this.name = name2;
+  }
+  code = "InstanceDestroying" /* InstanceDestroying */;
+};
+
+// packages/core/src/service-locator/errors/instance-expired.mts
+var InstanceExpired = class extends Error {
+  constructor(name2) {
+    super(`Instance ${name2} expired`);
+    this.name = name2;
+  }
+  code = "InstanceExpired" /* InstanceExpired */;
+};
+
+// packages/core/src/service-locator/errors/instance-not-found.mts
+var InstanceNotFound = class extends Error {
+  constructor(name2) {
+    super(`Instance ${name2} not found`);
+    this.name = name2;
+  }
+  code = "InstanceNotFound" /* InstanceNotFound */;
+};
+
+// packages/core/src/service-locator/errors/unknown-error.mts
+var UnknownError = class extends Error {
+  code = "UnknownError" /* UnknownError */;
+  parent;
+  constructor(message) {
+    if (message instanceof Error) {
+      super(message.message);
+      this.parent = message;
+      return;
+    }
+    super(message);
+  }
+};
+
+// packages/core/src/service-locator/service-locator-event-bus.mts
+var ServiceLocatorEventBus = class {
+  constructor(logger = null) {
+    this.logger = logger;
+  }
+  listeners = /* @__PURE__ */ new Map();
+  on(ns, event, listener) {
+    var _a;
+    (_a = this.logger) == null ? void 0 : _a.debug(`[ServiceLocatorEventBus]#on(): ns:${ns} event:${event}`);
+    if (!this.listeners.has(ns)) {
+      this.listeners.set(ns, /* @__PURE__ */ new Map());
+    }
+    const nsEvents = this.listeners.get(ns);
+    if (!nsEvents.has(event)) {
+      nsEvents.set(event, /* @__PURE__ */ new Set());
+    }
+    nsEvents.get(event).add(listener);
+    return () => {
+      var _a2;
+      nsEvents.get(event).delete(listener);
+      if (((_a2 = nsEvents.get(event)) == null ? void 0 : _a2.size) === 0) {
+        nsEvents.delete(event);
+      }
+      if (nsEvents.size === 0) {
+        this.listeners.delete(ns);
+      }
+    };
+  }
+  async emit(key, event) {
+    var _a, _b, _c;
+    if (!this.listeners.has(key)) {
+      return;
+    }
+    const events = this.listeners.get(key);
+    const preEvent = `pre:${event}`;
+    const postEvent = `post:${event}`;
+    (_a = this.logger) == null ? void 0 : _a.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${preEvent}`);
+    await Promise.allSettled(
+      [...events.get(preEvent) ?? []].map((listener) => listener(preEvent))
+    ).then((results) => {
+      results.filter((result) => result.status === "rejected").forEach((result) => {
+        var _a2;
+        (_a2 = this.logger) == null ? void 0 : _a2.warn(
+          `[ServiceLocatorEventBus]#emit(): ${key}:${preEvent} rejected with`,
+          result.reason
+        );
+      });
+    });
+    (_b = this.logger) == null ? void 0 : _b.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${event}`);
+    const res = await Promise.allSettled(
+      [...events.get(event) ?? []].map((listener) => listener(event))
+    ).then((results) => {
+      const res2 = results.filter((result) => result.status === "rejected").map((result) => {
+        var _a2;
+        (_a2 = this.logger) == null ? void 0 : _a2.warn(
+          `[ServiceLocatorEventBus]#emit(): ${key}:${event} rejected with`,
+          result.reason
+        );
+        return result;
+      });
+      if (res2.length > 0) {
+        return Promise.reject(res2);
+      }
+      return results;
+    });
+    (_c = this.logger) == null ? void 0 : _c.debug(`[ServiceLocatorEventBus]#emit(): ${key}:${postEvent}`);
+    await Promise.allSettled(
+      [...events.get(postEvent) ?? []].map((listener) => listener(postEvent))
+    ).then((results) => {
+      results.filter((result) => result.status === "rejected").forEach((result) => {
+        var _a2;
+        (_a2 = this.logger) == null ? void 0 : _a2.warn(
+          `[ServiceLocatorEventBus]#emit(): ${key}:${postEvent} rejected with`,
+          result.reason
+        );
+      });
+    });
+    return res;
+  }
+};
+
+// packages/core/src/service-locator/service-locator-instance-holder.mts
+var ServiceLocatorInstanceHolderKind = /* @__PURE__ */ ((ServiceLocatorInstanceHolderKind2) => {
+  ServiceLocatorInstanceHolderKind2["Instance"] = "instance";
+  ServiceLocatorInstanceHolderKind2["Factory"] = "factory";
+  ServiceLocatorInstanceHolderKind2["AbstractFactory"] = "abstractFactory";
+  return ServiceLocatorInstanceHolderKind2;
+})(ServiceLocatorInstanceHolderKind || {});
+var ServiceLocatorInstanceHolderStatus = /* @__PURE__ */ ((ServiceLocatorInstanceHolderStatus2) => {
+  ServiceLocatorInstanceHolderStatus2["Created"] = "created";
+  ServiceLocatorInstanceHolderStatus2["Creating"] = "creating";
+  ServiceLocatorInstanceHolderStatus2["Destroying"] = "destroying";
+  return ServiceLocatorInstanceHolderStatus2;
+})(ServiceLocatorInstanceHolderStatus || {});
+
+// packages/core/src/service-locator/service-locator-manager.mts
+var ServiceLocatorManager = class {
+  constructor(logger = null) {
+    this.logger = logger;
+  }
+  instancesHolders = /* @__PURE__ */ new Map();
+  get(name2) {
+    var _a, _b, _c;
+    const holder = this.instancesHolders.get(name2);
+    if (holder) {
+      if (holder.ttl !== Infinity) {
+        const now = Date.now();
+        if (now - holder.createdAt > holder.ttl) {
+          (_a = this.logger) == null ? void 0 : _a.log(
+            `[ServiceLocatorManager]#getInstanceHolder() TTL expired for ${holder.name}`
+          );
+          return [new InstanceExpired(holder.name), holder];
+        }
+      } else if (holder.status === "destroying" /* Destroying */) {
+        (_b = this.logger) == null ? void 0 : _b.log(
+          `[ServiceLocatorManager]#getInstanceHolder() Instance ${holder.name} is destroying`
+        );
+        return [new InstanceDestroying(holder.name), holder];
+      }
+      return [void 0, holder];
+    } else {
+      (_c = this.logger) == null ? void 0 : _c.log(
+        `[ServiceLocatorManager]#getInstanceHolder() Instance ${name2} not found`
+      );
+      return [new InstanceNotFound(name2)];
+    }
+  }
+  set(name2, holder) {
+    this.instancesHolders.set(name2, holder);
+  }
+  has(name2) {
+    const [error, holder] = this.get(name2);
+    if (!error) {
+      return [void 0, true];
+    }
+    if (["InstanceExpired" /* InstanceExpired */, "InstanceDestroying" /* InstanceDestroying */].includes(
+      error.code
+    )) {
+      return [error];
+    }
+    return [void 0, !!holder];
+  }
+  delete(name2) {
+    return this.instancesHolders.delete(name2);
+  }
+  filter(predicate) {
+    return new Map(
+      [...this.instancesHolders].filter(
+        ([key, value]) => predicate(value, key)
+      )
+    );
+  }
+};
+
+// packages/core/src/service-locator/service-locator.mts
+var ServiceLocator = class {
+  constructor(logger = null) {
+    this.logger = logger;
+    this.eventBus = new ServiceLocatorEventBus(logger);
+    this.manager = new ServiceLocatorManager(logger);
+  }
+  abstractFactories = /* @__PURE__ */ new Map();
+  instanceFactories = /* @__PURE__ */ new Map();
+  eventBus;
+  manager;
+  getEventBus() {
+    return this.eventBus;
+  }
+  registerInstance(token, instance) {
+    const instanceName = this.getInstanceIdentifier(token, void 0);
+    this.manager.set(instanceName, {
+      name: instanceName,
+      instance,
+      status: "created" /* Created */,
+      kind: "instance" /* Instance */,
+      createdAt: Date.now(),
+      ttl: Infinity,
+      deps: [],
+      destroyListeners: [],
+      effects: [],
+      destroyPromise: null,
+      creationPromise: null
+    });
+  }
+  removeInstance(token) {
+    const instanceName = this.getInstanceIdentifier(token, void 0);
+    return this.invalidate(instanceName);
+  }
+  registerAbstractFactory(token, factory, type = "Singleton" /* Singleton */) {
+    var _a;
+    (_a = this.logger) == null ? void 0 : _a.log(
+      `[ServiceLocator]#registerAbstractFactory(): Registering abstract factory for ${name}`
+    );
+    if (type === "Instance" /* Instance */) {
+      this.instanceFactories.set(token, factory);
+      this.abstractFactories.delete(token);
+    } else {
+      this.abstractFactories.set(token, factory);
+      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);
+    }
+    return this.makeInstanceName(token, validatedArgs);
+  }
+  async getInstance(token, args) {
+    var _a, _b, _c;
+    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
+      );
+      return [new UnknownError(validatedArgs.error)];
+    }
+    const instanceName = this.makeInstanceName(token, validatedArgs);
+    const [error, holder] = this.manager.get(instanceName);
+    if (!error) {
+      if (holder.status === "creating" /* Creating */) {
+        return holder.creationPromise;
+      } else if (holder.status === "destroying" /* Destroying */) {
+        return [new UnknownError("InstanceDestroying" /* InstanceDestroying */)];
+      }
+      return [void 0, holder.instance];
+    }
+    switch (error.code) {
+      case "InstanceDestroying" /* InstanceDestroying */:
+        (_b = this.logger) == null ? void 0 : _b.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(
+          `[ServiceLocator]#getInstance() TTL expired for ${holder == null ? void 0 : holder.name}`
+        );
+        await this.invalidate(instanceName);
+        return this.getInstance(token, args);
+      case "InstanceNotFound" /* InstanceNotFound */:
+        break;
+      default:
+        return [error];
+    }
+    return this.createInstance(instanceName, token, args);
+  }
+  async getOrThrowInstance(token, args) {
+    const [error, instance] = await this.getInstance(token, args);
+    if (error) {
+      throw error;
+    }
+    return instance;
+  }
+  notifyListeners(name2, event = "create") {
+    var _a;
+    (_a = this.logger) == null ? void 0 : _a.log(
+      `[ServiceLocator]#notifyListeners() Notifying listeners for ${name2} with event ${event}`
+    );
+    return this.eventBus.emit(name2, event);
+  }
+  async createInstance(instanceName, token, args) {
+    var _a;
+    (_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);
+    } else {
+      return [new FactoryNotFound(token.name.toString())];
+    }
+  }
+  async createInstanceFromAbstractFactory(instanceName, token, args) {
+    var _a;
+    (_a = this.logger) == null ? void 0 : _a.log(
+      `[ServiceLocator]#createInstanceFromAbstractFactory(): Creating instance for ${instanceName} from abstract factory`
+    );
+    const ctx = this.createContextForAbstractFactory(instanceName);
+    let shouldStore = true;
+    let abstractFactory = this.abstractFactories.get(token);
+    if (!abstractFactory) {
+      abstractFactory = this.instanceFactories.get(token);
+      shouldStore = false;
+      if (!abstractFactory) {
+        return [new FactoryNotFound(token.name.toString())];
+      }
+    }
+    const holder = {
+      name: instanceName,
+      instance: null,
+      status: "creating" /* Creating */,
+      kind: "abstractFactory" /* AbstractFactory */,
+      // @ts-expect-error TS2322 This is correct type
+      creationPromise: abstractFactory(ctx, args).then(async (instance) => {
+        var _a2;
+        holder.instance = instance;
+        holder.status = "created" /* Created */;
+        holder.deps = ctx.getDependencies();
+        holder.destroyListeners = ctx.getDestroyListeners();
+        holder.ttl = ctx.getTtl();
+        if (holder.deps.length > 0) {
+          (_a2 = this.logger) == null ? void 0 : _a2.log(
+            `[ServiceLocator]#createInstanceFromAbstractFactory(): Adding subscriptions for ${instanceName} dependencies for their invalidations: ${holder.deps.join(
+              ", "
+            )}`
+          );
+          holder.deps.forEach((dependency) => {
+            holder.destroyListeners.push(
+              this.eventBus.on(
+                dependency,
+                "destroy",
+                () => this.invalidate(instanceName)
+              )
+            );
+          });
+        }
+        if (holder.ttl === 0) {
+          await this.invalidate(instanceName);
+        }
+        await this.notifyListeners(instanceName);
+        return [void 0, instance];
+      }).catch((error) => {
+        var _a2;
+        (_a2 = this.logger) == null ? void 0 : _a2.error(
+          `[ServiceLocator]#createInstanceFromAbstractFactory(): Error creating instance for ${instanceName}`,
+          error
+        );
+        return [new UnknownError(error)];
+      }),
+      effects: [],
+      deps: [],
+      destroyListeners: [],
+      createdAt: Date.now(),
+      ttl: Infinity
+    };
+    if (shouldStore) {
+      this.manager.set(instanceName, holder);
+    }
+    return holder.creationPromise;
+  }
+  createContextForAbstractFactory(instanceName) {
+    const dependencies = /* @__PURE__ */ new Set();
+    const destroyListeners = /* @__PURE__ */ new Set();
+    const self = this;
+    function invalidate(name2 = instanceName) {
+      return self.invalidate(name2);
+    }
+    function addEffect(listener) {
+      destroyListeners.add(listener);
+    }
+    let ttl = Infinity;
+    function setTtl(value) {
+      ttl = value;
+    }
+    function getTtl() {
+      return ttl;
+    }
+    function on(key, event, listener) {
+      destroyListeners.add(self.eventBus.on(key, event, listener));
+    }
+    return {
+      // @ts-expect-error This is correct type
+      async inject(token, args) {
+        let injectionToken = token;
+        if (typeof token === "function") {
+          injectionToken = getInjectableToken(token);
+        }
+        if (injectionToken instanceof InjectionToken) {
+          const validatedArgs = token.schema ? token.schema.safeParse(args) : void 0;
+          const instanceName2 = self.makeInstanceName(token, validatedArgs);
+          dependencies.add(instanceName2);
+          return self.getOrThrowInstance(injectionToken, args);
+        }
+        throw new Error(
+          `[ServiceLocator]#inject(): Invalid token type: ${typeof token}. Expected a class or an InjectionToken.`
+        );
+      },
+      invalidate,
+      eventBus: self.eventBus,
+      on,
+      getDependencies: () => Array.from(dependencies),
+      addEffect,
+      getDestroyListeners: () => Array.from(destroyListeners),
+      setTtl,
+      getTtl
+    };
+  }
+  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 instanceName = this.makeInstanceName(token, validatedArgs);
+    const [error, holder] = this.manager.get(instanceName);
+    if (error) {
+      return null;
+    }
+    return holder.instance;
+  }
+  invalidate(service, round = 1) {
+    var _a, _b, _c, _d, _e;
+    (_a = this.logger) == null ? void 0 : _a.log(
+      `[ServiceLocator]#invalidate(): Starting Invalidating process of ${service}`
+    );
+    const toInvalidate = this.manager.filter(
+      (holder) => holder.name === service || holder.deps.includes(service)
+    );
+    const promises = [];
+    for (const [key, holder] of toInvalidate.entries()) {
+      if (holder.status === "destroying" /* Destroying */) {
+        (_b = this.logger) == null ? void 0 : _b.trace(
+          `[ServiceLocator]#invalidate(): ${key} is already being destroyed`
+        );
+        promises.push(holder.destroyPromise);
+        continue;
+      }
+      if (holder.status === "creating" /* Creating */) {
+        (_c = this.logger) == null ? void 0 : _c.trace(
+          `[ServiceLocator]#invalidate(): ${key} is being created, waiting for creation to finish`
+        );
+        promises.push(
+          (_d = holder.creationPromise) == null ? void 0 : _d.then(() => {
+            var _a2;
+            if (round > 3) {
+              (_a2 = this.logger) == null ? void 0 : _a2.error(
+                `[ServiceLocator]#invalidate(): ${key} creation is triggering a new invalidation round, but it is still not created`
+              );
+              return;
+            }
+            return this.invalidate(key, round + 1);
+          })
+        );
+        continue;
+      }
+      holder.status = "destroying" /* Destroying */;
+      (_e = this.logger) == null ? void 0 : _e.log(
+        `[ServiceLocator]#invalidate(): Invalidating ${key} and notifying listeners`
+      );
+      holder.destroyPromise = Promise.all(
+        holder.destroyListeners.map((listener) => listener())
+      ).then(async () => {
+        this.manager.delete(key);
+        await this.notifyListeners(key, "destroy");
+      });
+      promises.push(holder.destroyPromise);
+    }
+    return Promise.all(promises);
+  }
+  async ready() {
+    return Promise.all(
+      Array.from(this.manager.filter(() => true)).map(([, holder]) => {
+        var _a;
+        if (holder.status === "creating" /* Creating */) {
+          return (_a = holder.creationPromise) == null ? void 0 : _a.then(() => null);
+        }
+        if (holder.status === "destroying" /* Destroying */) {
+          return holder.destroyPromise.then(() => null);
+        }
+        return Promise.resolve(null);
+      })
+    ).then(() => null);
+  }
+  makeInstanceName(token, args) {
+    let stringifiedArgs = args ? ":" + JSON.stringify(args).replaceAll(/"/g, "").replaceAll(/:/g, "=").replaceAll(/,/g, "|") : "";
+    const { name: name2 } = token;
+    if (typeof name2 === "function") {
+      const className = name2.name;
+      return `${className}(${token.id})${stringifiedArgs}`;
+    } else if (typeof name2 === "symbol") {
+      return `${name2.toString()}(${token.id})${stringifiedArgs}`;
+    } else {
+      return `${name2}(${token.id})${stringifiedArgs}`;
+    }
+  }
+};
+
+// packages/core/src/service-locator/injector.mts
+var serviceLocator = new ServiceLocator();
+function provideServiceLocator(locator) {
+  const original = serviceLocator;
+  serviceLocator = locator;
+  return original;
+}
+function getServiceLocator() {
+  if (!serviceLocator) {
+    throw new Error(
+      "[ServiceLocator] Service locator is not initialized. Please provide the service locator before using the @Injectable decorator."
+    );
+  }
+  return serviceLocator;
+}
+
+// packages/core/src/service-locator/proxy-service-locator.mts
+var ProxyServiceLocator = class {
+  constructor(serviceLocator2, ctx) {
+    this.serviceLocator = serviceLocator2;
+    this.ctx = ctx;
+  }
+  get abstractFactories() {
+    return this.serviceLocator["abstractFactories"];
+  }
+  getEventBus() {
+    return this.serviceLocator.getEventBus();
+  }
+  registerAbstractFactory(token, factory) {
+    return this.serviceLocator.registerAbstractFactory(token, factory);
+  }
+  getInstance(token, args) {
+    return this.ctx.inject(token, args).then(
+      (instance) => {
+        return [void 0, instance];
+      },
+      (error) => {
+        return [error];
+      }
+    );
+  }
+  getOrThrowInstance(token, args) {
+    return this.ctx.inject(token, args);
+  }
+  getSyncInstance(token, args) {
+    return this.serviceLocator.getSyncInstance(token, args);
+  }
+  invalidate(service, round) {
+    return this.serviceLocator.invalidate(service, round);
+  }
+  ready() {
+    return this.serviceLocator.ready();
+  }
+  makeInstanceName(token, args) {
+    return this.serviceLocator.makeInstanceName(token, args);
+  }
+};
+function makeProxyServiceLocator(serviceLocator2, ctx) {
+  return new ProxyServiceLocator(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);
+  }
+  const instance = getServiceLocator().getSyncInstance(realToken, args);
+  if (!instance) {
+    if (promiseCollector) {
+      const promise = getServiceLocator().getInstance(realToken, args);
+      promiseCollector(promise);
+    } else {
+      throw new Error(
+        `[ServiceLocator] No instance found for ${realToken.name.toString()}`
+      );
+    }
+  }
+  return instance;
+}
+function setPromiseCollector(collector) {
+  const original = promiseCollector;
+  promiseCollector = collector;
+  return original;
+}
+
+// packages/core/src/service-locator/decorators/injectable.decorator.mts
+var InjectableType = /* @__PURE__ */ ((InjectableType2) => {
+  InjectableType2["Class"] = "Class";
+  InjectableType2["Factory"] = "Factory";
+  return InjectableType2;
+})(InjectableType || {});
+var InjectableTokenMeta = Symbol("InjectableTokenMeta");
+function Injectable({
+  scope = "Singleton" /* Singleton */,
+  type = "Class" /* Class */,
+  token
+} = {}) {
+  return (target, context) => {
+    if (context.kind !== "class") {
+      throw new Error(
+        "[ServiceLocator] @Injectable decorator can only be used on classes."
+      );
+    }
+    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;
+        },
+        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();
+          if (typeof builder.create !== "function") {
+            throw new Error(
+              `[ServiceLocator] Factory ${target.name} does not implement the create method.`
+            );
+          }
+          provideServiceLocator(original);
+          return builder.create(ctx, args);
+        },
+        scope
+      );
+    }
+    target[InjectableTokenMeta] = injectableToken;
+    return target;
+  };
+}
+
+// packages/core/src/service-locator/decorators/get-injectable-token.mts
+function getInjectableToken(target) {
+  const token = target[InjectableTokenMeta];
+  if (!token) {
+    throw new Error(
+      `[ServiceLocator] Class ${target.name} is not decorated with @Injectable.`
+    );
+  }
+  return token;
+}
+
+// packages/core/src/service-locator/event-emitter.mts
+var EventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(listener);
+    return () => {
+      this.off(event, listener);
+    };
+  }
+  off(event, listener) {
+    if (!this.listeners.has(event)) {
+      return;
+    }
+    this.listeners.get(event).delete(listener);
+    if (this.listeners.get(event).size === 0) {
+      this.listeners.delete(event);
+    }
+  }
+  once(event, listener) {
+    const off = this.on(event, (...args) => {
+      off();
+      listener(...args);
+    });
+    return off;
+  }
+  async emit(event, ...args) {
+    if (!this.listeners.has(event)) {
+      return;
+    }
+    return Promise.all(Array.from(this.listeners.get(event)).map((listener) => listener(...args)));
+  }
+  addChannel(ns, event, target) {
+    return this.on(event, (...args) => target.emit(ns, event, ...args));
+  }
+};
+
+// 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);
+  }
+  return getServiceLocator().getOrThrowInstance(realToken, args);
+}
+
+// packages/core/src/service-locator/override.mts
+function override(token, target) {
+  const serviceLocator2 = getServiceLocator();
+  const originalDefinition = serviceLocator2["abstractFactories"].get(token);
+  serviceLocator2.registerAbstractFactory(token, async (ctx, args) => {
+    const builder = new target();
+    return builder.create(ctx, args);
+  });
+  return () => {
+    if (originalDefinition) {
+      serviceLocator2.registerAbstractFactory(token, originalDefinition);
+    }
+  };
+}
+
+// packages/core/src/decorators/controller.decorator.mts
+function Controller({ guards } = {}) {
+  return function(target, context) {
+    if (context.kind !== "class") {
+      throw new Error(
+        "[Navios] @Controller decorator can only be used on classes."
+      );
+    }
+    const token = InjectionToken.create(target);
+    if (context.metadata) {
+      const controllerMetadata = getControllerMetadata(target, context);
+      if (guards) {
+        for (const guard of Array.from(guards).reverse()) {
+          controllerMetadata.guards.add(guard);
+        }
+      }
+    }
+    return Injectable({
+      token,
+      type: "Class" /* Class */,
+      scope: "Instance" /* Instance */
+    })(target, context);
+  };
+}
+
+// packages/core/src/decorators/endpoint.decorator.mts
+function Endpoint(endpoint) {
+  return (target, context) => {
+    if (typeof target !== "function") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on functions."
+      );
+    }
+    if (context.kind !== "method") {
+      throw new Error(
+        "[Navios] Endpoint decorator can only be used on methods."
+      );
+    }
+    const config = endpoint.config;
+    if (context.metadata) {
+      let endpointMetadata = getEndpointMetadata(target, context);
+      if (endpointMetadata.config && endpointMetadata.config.url) {
+        throw new Error(
+          `[Navios] Endpoint ${config.method} ${config.url} already exists. Please use a different method or url.`
+        );
+      }
+      endpointMetadata.config = config;
+      endpointMetadata.classMethod = target.name;
+      endpointMetadata.httpMethod = config.method;
+      endpointMetadata.url = config.url;
+    }
+    return target;
+  };
+}
+
+// packages/core/src/decorators/module.decorator.mts
+function Module(metadata) {
+  return (target, context) => {
+    if (context.kind !== "class") {
+      throw new Error("[Navios] @Module decorator can only be used on classes.");
+    }
+    const token = InjectionToken.create(target);
+    const moduleMetadata = getModuleMetadata(target, context);
+    if (metadata.controllers) {
+      for (const controller of metadata.controllers) {
+        moduleMetadata.controllers.add(controller);
+      }
+    }
+    if (metadata.imports) {
+      for (const importedModule of metadata.imports) {
+        moduleMetadata.imports.add(importedModule);
+      }
+    }
+    if (metadata.guards) {
+      for (const guard of Array.from(metadata.guards).reverse()) {
+        moduleMetadata.guards.add(guard);
+      }
+    }
+    return Injectable({
+      token,
+      type: "Class" /* Class */,
+      scope: "Singleton" /* Singleton */
+    })(target, context);
+  };
+}
+
+// packages/core/src/decorators/use-guards.decorator.mts
+function UseGuards(...guards) {
+  return function(target, context) {
+    if (context.kind === "class") {
+      const controllerMetadata = getControllerMetadata(
+        target,
+        context
+      );
+      for (const guard of guards.reverse()) {
+        controllerMetadata.guards.add(guard);
+      }
+    } else if (context.kind === "method") {
+      const endpointMetadata = getEndpointMetadata(target, context);
+      for (const guard of guards.reverse()) {
+        endpointMetadata.guards.add(guard);
+      }
+    } else {
+      throw new Error(
+        "[Navios] @UseGuards decorator can only be used on classes or methods."
+      );
+    }
+    return target;
+  };
+}
+
+// packages/core/src/exceptions/http.exception.mts
+var HttpException = class {
+  constructor(statusCode, response, error) {
+    this.statusCode = statusCode;
+    this.response = response;
+    this.error = error;
+  }
+};
+
+// packages/core/src/exceptions/bad-request.exception.mts
+var BadRequestException = class extends HttpException {
+  constructor(message) {
+    super(400, message);
+  }
+};
+
+// packages/core/src/exceptions/forbidden.exception.mts
+var ForbiddenException = class extends HttpException {
+  constructor(message) {
+    super(403, message);
+  }
+};
+
+// packages/core/src/exceptions/internal-server-error.exception.mts
+var InternalServerErrorException = class extends HttpException {
+  constructor(message, error) {
+    super(500, message, error);
+  }
+};
+
+// packages/core/src/exceptions/not-found.exception.mts
+var NotFoundException = class extends HttpException {
+  constructor(response, error) {
+    super(404, response, error);
+    this.response = response;
+    this.error = error;
+  }
+};
+
+// packages/core/src/exceptions/unauthorized.exception.mts
+var UnauthorizedException = class extends HttpException {
+  constructor(message, error) {
+    super(401, message, error);
+  }
+};
+
+// packages/core/src/exceptions/conflict.exception.mts
+var ConflictException = class extends HttpException {
+  constructor(message, error) {
+    super(409, message, error);
+  }
+};
+
+// packages/core/src/tokens/application.token.mts
+var ApplicationInjectionToken = "ApplicationInjectionToken";
+var Application = InjectionToken.create(
+  ApplicationInjectionToken
+);
+
+// packages/core/src/tokens/execution-context.token.mts
+var ExecutionContextInjectionToken = "ExecutionContextInjectionToken";
+var ExecutionContextToken = InjectionToken.create(
+  ExecutionContextInjectionToken
+);
+
+// packages/core/src/tokens/reply.token.mts
+var ReplyInjectionToken = "ReplyInjectionToken";
+var Reply = InjectionToken.create(ReplyInjectionToken);
+
+// packages/core/src/tokens/request.token.mts
+var RequestInjectionToken = "RequestInjectionToken";
+var Request = InjectionToken.create(
+  RequestInjectionToken
+);
+
+// packages/core/src/services/execution-context.mts
+var ExecutionContext2 = class {
+  constructor(module, controller, handler) {
+    this.module = module;
+    this.controller = controller;
+    this.handler = handler;
+  }
+  request;
+  reply;
+  getModule() {
+    return this.module;
+  }
+  getController() {
+    return this.controller;
+  }
+  getHandler() {
+    return this.handler;
+  }
+  getRequest() {
+    if (!this.request) {
+      throw new Error(
+        "[Navios] Request is not set. Make sure to set it before using it."
+      );
+    }
+    return this.request;
+  }
+  getReply() {
+    if (!this.reply) {
+      throw new Error(
+        "[Navios] Reply is not set. Make sure to set it before using it."
+      );
+    }
+    return this.reply;
+  }
+  provideRequest(request) {
+    this.request = request;
+  }
+  provideReply(reply) {
+    this.reply = reply;
+  }
+};
+
+// packages/core/src/services/guard-runner.service.mts
+var _GuardRunnerService_decorators, _init;
+_GuardRunnerService_decorators = [Injectable()];
+var GuardRunnerService = class {
+  async runGuards(allGuards, executionContext) {
+    let canActivate = true;
+    for (const guard of Array.from(allGuards).reverse()) {
+      const guardInstance = await inject(
+        guard
+      );
+      if (!guardInstance.canActivate) {
+        throw new Error(
+          `[Navios] Guard ${guard.name} does not implement canActivate()`
+        );
+      }
+      try {
+        canActivate = await guardInstance.canActivate(executionContext);
+        if (!canActivate) {
+          break;
+        }
+      } catch (error) {
+        if (error instanceof HttpException) {
+          executionContext.getReply().status(error.statusCode).send(error.response);
+          return false;
+        } else {
+          executionContext.getReply().status(500).send({
+            message: "Internal server error",
+            error: error.message
+          });
+          return false;
+        }
+      }
+    }
+    if (!canActivate) {
+      executionContext.getReply().status(403).send({
+        message: "Forbidden"
+      });
+      return false;
+    }
+    return canActivate;
+  }
+  makeContext(executionContext) {
+    const guards = /* @__PURE__ */ new Set();
+    const endpointGuards = executionContext.getHandler().guards;
+    const controllerGuards = executionContext.getController().guards;
+    const moduleGuards = executionContext.getModule().guards;
+    if (endpointGuards.size > 0) {
+      for (const guard of endpointGuards) {
+        guards.add(guard);
+      }
+    }
+    if (controllerGuards.size > 0) {
+      for (const guard of controllerGuards) {
+        guards.add(guard);
+      }
+    }
+    if (moduleGuards.size > 0) {
+      for (const guard of moduleGuards) {
+        guards.add(guard);
+      }
+    }
+    return guards;
+  }
+};
+_init = __decoratorStart(null);
+GuardRunnerService = __decorateElement(_init, 0, "GuardRunnerService", _GuardRunnerService_decorators, GuardRunnerService);
+__runInitializers(_init, 1, GuardRunnerService);
+
+// packages/core/src/services/controller-adapter.service.mts
+var _ControllerAdapterService_decorators, _init2;
+_ControllerAdapterService_decorators = [Injectable()];
+var ControllerAdapterService = class {
+  guardRunner = syncInject(GuardRunnerService);
+  setupController(controller, instance, moduleMetadata) {
+    const controllerMetadata = extractControllerMetadata(controller);
+    for (const endpoint of controllerMetadata.endpoints) {
+      const { classMethod, url, httpMethod, config } = endpoint;
+      if (!url || !config) {
+        throw new Error(
+          `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`
+        );
+      }
+      const executionContext = new ExecutionContext2(
+        moduleMetadata,
+        controllerMetadata,
+        endpoint
+      );
+      const guards = this.guardRunner.makeContext(executionContext);
+      const { querySchema, requestSchema, responseSchema } = config;
+      const schema = {};
+      if (querySchema) {
+        schema.querystring = querySchema;
+      }
+      if (requestSchema) {
+        schema.body = requestSchema;
+      }
+      if (responseSchema) {
+        schema.response = {
+          200: responseSchema
+        };
+      }
+      instance.withTypeProvider().route({
+        method: httpMethod,
+        url: url.replaceAll("$", ":"),
+        schema,
+        preHandler: async (request, reply) => {
+          if (guards.size > 0) {
+            getServiceLocator().registerInstance(Request, request);
+            getServiceLocator().registerInstance(Reply, reply);
+            getServiceLocator().registerInstance(
+              ExecutionContextToken,
+              executionContext
+            );
+            executionContext.provideRequest(request);
+            executionContext.provideReply(reply);
+            const canActivate = await this.guardRunner.runGuards(
+              guards,
+              executionContext
+            );
+            getServiceLocator().removeInstance(Request);
+            getServiceLocator().removeInstance(Reply);
+            getServiceLocator().removeInstance(ExecutionContextToken);
+            if (!canActivate) {
+              return reply;
+            }
+          }
+        },
+        handler: async (request, reply) => {
+          getServiceLocator().registerInstance(Request, request);
+          getServiceLocator().registerInstance(Reply, reply);
+          getServiceLocator().registerInstance(
+            ExecutionContextToken,
+            executionContext
+          );
+          executionContext.provideRequest(request);
+          executionContext.provideReply(reply);
+          const controllerInstance = await inject(controller);
+          try {
+            const { query, params, body } = request;
+            const argument = {};
+            if (query && Object.keys(query).length > 0) {
+              argument.params = query;
+            }
+            if (params && Object.keys(params).length > 0) {
+              argument.urlParams = params;
+            }
+            if (body) {
+              argument.data = body;
+            }
+            const result = await controllerInstance[classMethod](argument);
+            reply.status(200).send(result);
+          } catch (error) {
+            if (error instanceof HttpException) {
+              reply.status(error.statusCode).send(error.response);
+            } else {
+              reply.status(500).send({
+                message: "Internal server error",
+                error: error.message
+              });
+            }
+          } finally {
+            getServiceLocator().removeInstance(Request);
+            getServiceLocator().removeInstance(Reply);
+            getServiceLocator().removeInstance(ExecutionContextToken);
+          }
+        }
+      });
+    }
+  }
+};
+_init2 = __decoratorStart(null);
+ControllerAdapterService = __decorateElement(_init2, 0, "ControllerAdapterService", _ControllerAdapterService_decorators, ControllerAdapterService);
+__runInitializers(_init2, 1, ControllerAdapterService);
+
+// packages/core/src/services/module-loader.service.mts
+var _ModuleLoaderService_decorators, _init3;
+_ModuleLoaderService_decorators = [Injectable()];
+var ModuleLoaderService = class {
+  modulesMetadata = /* @__PURE__ */ new Map();
+  loadedModules = /* @__PURE__ */ new Map();
+  initialized = false;
+  async loadModules(appModule) {
+    if (this.initialized) {
+      return;
+    }
+    await this.traverseModules(appModule);
+    this.initialized = true;
+  }
+  async traverseModules(module, parentMetadata) {
+    const metadata = extractModuleMetadata(module);
+    if (parentMetadata) {
+      this.mergeMetadata(metadata, parentMetadata);
+    }
+    const moduleName = module.name;
+    if (this.modulesMetadata.has(moduleName)) {
+      return;
+    }
+    this.modulesMetadata.set(moduleName, metadata);
+    const imports = metadata.imports ?? /* @__PURE__ */ new Set();
+    const loadingPromises = Array.from(imports).map(
+      async (importedModule) => this.traverseModules(importedModule, metadata)
+    );
+    await Promise.all(loadingPromises);
+    const instance = await inject(module);
+    if (instance.onModuleInit) {
+      await instance.onModuleInit();
+    }
+    this.loadedModules.set(moduleName, instance);
+  }
+  mergeMetadata(metadata, parentMetadata) {
+    if (parentMetadata.guards) {
+      for (const guard of parentMetadata.guards) {
+        metadata.guards.add(guard);
+      }
+    }
+    if (parentMetadata.customAttributes) {
+      for (const [key, value] of parentMetadata.customAttributes) {
+        if (metadata.customAttributes.has(key)) {
+          continue;
+        }
+        metadata.customAttributes.set(key, value);
+      }
+    }
+  }
+  getAllModules() {
+    return this.modulesMetadata;
+  }
+};
+_init3 = __decoratorStart(null);
+ModuleLoaderService = __decorateElement(_init3, 0, "ModuleLoaderService", _ModuleLoaderService_decorators, ModuleLoaderService);
+__runInitializers(_init3, 1, ModuleLoaderService);
+
+// packages/core/src/attribute.factory.mts
+var AttributeFactory = class {
+  static createAttribute(token, schema) {
+    const res = (value) => (target, context) => {
+      if (context.kind !== "class" && context.kind !== "method") {
+        throw new Error(
+          "[Navios] Attribute can only be applied to classes or methods"
+        );
+      }
+      const isController = context.kind === "class" && hasControllerMetadata(target);
+      const isModule = context.kind === "class" && hasModuleMetadata(target);
+      if (context.kind === "class" && !isController && !isModule) {
+        throw new Error(
+          "[Navios] Attribute can only be applied to classes with @Controller or @Module decorators"
+        );
+      }
+      let metadata = context.kind === "class" ? isController ? getControllerMetadata(target, context) : getModuleMetadata(target, context) : getEndpointMetadata(target, context);
+      if (schema) {
+        const validatedValue = schema.safeParse(value);
+        if (!validatedValue.success) {
+          throw new Error(
+            `[Navios] Invalid value for attribute ${token.toString()}: ${validatedValue.error}`
+          );
+        }
+        metadata.customAttributes.set(token, validatedValue.data);
+      } else {
+        metadata.customAttributes.set(token, true);
+      }
+      return target;
+    };
+    res.token = token;
+    if (schema) {
+      res.schema = schema;
+    }
+    return res;
+  }
+  static get(attribute, target) {
+    return target.customAttributes.get(attribute.token) ?? null;
+  }
+  static getAll(attribute, target) {
+    const values = Array.from(target.customAttributes.entries()).filter(([key]) => key === attribute.token).map(([, value]) => value);
+    return values.length > 0 ? values : null;
+  }
+  static getLast(attribute, target) {
+    for (let i = target.length - 1; i >= 0; i--) {
+      const value = target[i].customAttributes.get(attribute.token);
+      if (value) {
+        return value;
+      }
+    }
+    return null;
+  }
+  static has(attribute, target) {
+    return target.customAttributes.has(attribute.token);
+  }
+};
+
+// packages/core/src/navios.application.mts
+import cors from "@fastify/cors";
+import { fastify } from "fastify";
+import {
+  serializerCompiler,
+  validatorCompiler
+} from "fastify-type-provider-zod";
+var _NaviosApplication_decorators, _init4;
+_NaviosApplication_decorators = [Injectable()];
+var NaviosApplication = class {
+  moduleLoader = syncInject(ModuleLoaderService);
+  controllerAdapter = syncInject(ControllerAdapterService);
+  server = null;
+  corsOptions = null;
+  globalPrefix = null;
+  appModule = null;
+  options = {};
+  setup(appModule, options = {}) {
+    this.appModule = appModule;
+    this.options = options;
+  }
+  async init() {
+    if (!this.appModule) {
+      throw new Error("App module is not set. Call setAppModule() first.");
+    }
+    await this.moduleLoader.loadModules(this.appModule);
+    this.server = fastify(this.options);
+    getServiceLocator().registerInstance(Application, this.server);
+    this.server.setValidatorCompiler(validatorCompiler);
+    this.server.setSerializerCompiler(serializerCompiler);
+    if (this.corsOptions) {
+      await this.server.register(cors, this.corsOptions);
+    }
+    const modules = this.moduleLoader.getAllModules();
+    const globalPrefix = this.globalPrefix ?? "";
+    for (const [moduleName, moduleMetadata] of modules) {
+      if (!moduleMetadata.controllers || moduleMetadata.controllers.size === 0) {
+        continue;
+      }
+      this.server.register(
+        (instance, opts, done) => {
+          for (const controller of moduleMetadata.controllers) {
+            this.controllerAdapter.setupController(
+              controller,
+              instance,
+              moduleMetadata
+            );
+          }
+          done();
+        },
+        {
+          prefix: globalPrefix
+        }
+      );
+    }
+  }
+  enableCors(options) {
+    var _a;
+    this.corsOptions = options;
+    (_a = this.server) == null ? void 0 : _a.register;
+  }
+  setGlobalPrefix(prefix) {
+    this.globalPrefix = prefix;
+  }
+  getServer() {
+    if (!this.server) {
+      throw new Error("Server is not initialized. Call init() first.");
+    }
+    return this.server;
+  }
+  async listen(options) {
+    if (!this.server) {
+      throw new Error("Server is not initialized. Call init() first.");
+    }
+    await this.server.listen(options);
+  }
+};
+_init4 = __decoratorStart(null);
+NaviosApplication = __decorateElement(_init4, 0, "NaviosApplication", _NaviosApplication_decorators, NaviosApplication);
+__runInitializers(_init4, 1, NaviosApplication);
+
+// packages/core/src/navios.factory.mts
+var NaviosFactory = class {
+  static async create(appModule, options = {}) {
+    const app = await inject(NaviosApplication);
+    app.setup(appModule, options);
+    return app;
+  }
+};
+export {
+  Application,
+  AttributeFactory,
+  BadRequestException,
+  ConflictException,
+  Controller,
+  ControllerAdapterService,
+  ControllerMetadataKey,
+  Endpoint,
+  EndpointMetadataKey,
+  ErrorsEnum,
+  EventEmitter,
+  ExecutionContext2 as ExecutionContext,
+  ExecutionContextInjectionToken,
+  ExecutionContextToken,
+  FactoryNotFound,
+  ForbiddenException,
+  GuardRunnerService,
+  HttpException,
+  Injectable,
+  InjectableScope,
+  InjectableTokenMeta,
+  InjectableType,
+  InjectionToken,
+  InstanceDestroying,
+  InstanceExpired,
+  InstanceNotFound,
+  InternalServerErrorException,
+  Module,
+  ModuleLoaderService,
+  ModuleMetadataKey,
+  NaviosApplication,
+  NaviosFactory,
+  NotFoundException,
+  Reply,
+  Request,
+  ServiceLocator,
+  ServiceLocatorEventBus,
+  ServiceLocatorInstanceHolderKind,
+  ServiceLocatorInstanceHolderStatus,
+  ServiceLocatorManager,
+  UnauthorizedException,
+  UnknownError,
+  UseGuards,
+  extractControllerMetadata,
+  extractModuleMetadata,
+  getAllEndpointMetadata,
+  getControllerMetadata,
+  getEndpointMetadata,
+  getInjectableToken,
+  getModuleMetadata,
+  getServiceLocator,
+  hasControllerMetadata,
+  hasModuleMetadata,
+  inject,
+  override,
+  provideServiceLocator,
+  setPromiseCollector,
+  syncInject
+};
+//# sourceMappingURL=index.mjs.map