@navios/core 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/core",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"

package/src/config/config-service.interface.mts

@@ -0,0 +1,16 @@
+import type { Path, PathValue } from './types.mjs'
+
+export interface ConfigService<Config = Record<string, unknown>> {
+  getConfig: () => Config
+  get: <Key extends Path<Config>>(key: Key) => PathValue<Config, Key> | null
+
+  getOrDefault: <Key extends Path<Config>>(
+    key: Key,
+    defaultValue: PathValue<Config, Key>,
+  ) => PathValue<Config, Key>
+
+  getOrThrow: <Key extends Path<Config>>(
+    key: Key,
+    errorMessage?: string,
+  ) => PathValue<Config, Key>
+}

package/src/config/config.provider.mts

@@ -0,0 +1,63 @@
+import { z } from 'zod'
+
+import type { ConfigService } from './config-service.interface.mjs'
+
+import { Logger } from '../logger/index.mjs'
+import {
+  getInjectableToken,
+  inject,
+  Injectable,
+  InjectableType,
+  InjectionToken,
+  syncInject,
+} from '../service-locator/index.mjs'
+import { ConfigServiceInstance } from './config.service.mjs'
+
+export const ConfigProviderInjectionToken = 'ConfigProvider'
+
+export const ConfigProviderOptions = z.object({
+  load: z.function(),
+})
+export const ConfigProvider = InjectionToken.create<
+  ConfigService,
+  typeof ConfigProviderOptions
+>(ConfigProviderInjectionToken, ConfigProviderOptions)
+
+@Injectable({
+  token: ConfigProvider,
+  type: InjectableType.Factory,
+})
+export class ConfigProviderFactory {
+  logger = inject(Logger, {
+    context: 'ConfigService',
+  })
+
+  async create(ctx: any, args: z.infer<typeof ConfigProviderOptions>) {
+    const { load } = args
+    const logger = await this.logger
+    try {
+      const config = await load()
+
+      return new ConfigServiceInstance(config, logger)
+    } catch (error) {
+      logger.error('Error loading config', error)
+      throw error
+    }
+  }
+}
+
+export function makeConfigToken<Config extends Record<string, unknown>>(
+  options: z.input<typeof ConfigProviderOptions>,
+): InjectionToken<ConfigService<Config>> {
+  @Injectable({
+    type: InjectableType.Factory,
+  })
+  class ConfigServiceImpl {
+    configService = inject(ConfigProvider, options)
+
+    create() {
+      return this.configService
+    }
+  }
+  return getInjectableToken(ConfigServiceImpl)
+}

package/src/config/config.service.mts

@@ -0,0 +1,69 @@
+import { NaviosException } from '@navios/common'
+
+import type { LoggerService } from '../logger/index.mjs'
+import type { ConfigService } from './config-service.interface.mjs'
+import type { Path, PathValue } from './types.mjs'
+
+export class ConfigServiceInstance<Config = Record<string, unknown>>
+  implements ConfigService<Config>
+{
+  constructor(
+    private config: Config = {} as Config,
+    private logger: LoggerService,
+  ) {}
+
+  getConfig(): Config {
+    return this.config
+  }
+
+  get<Key extends Path<Config>>(key: Key): PathValue<Config, Key> | null {
+    try {
+      const parts = String(key).split('.')
+      let value: any = this.config
+
+      for (const part of parts) {
+        if (
+          value === null ||
+          value === undefined ||
+          typeof value !== 'object'
+        ) {
+          return null
+        }
+        value = value[part]
+      }
+
+      return (value as PathValue<Config, Key>) ?? null
+    } catch (error) {
+      this.logger.debug?.(
+        `Failed to get config value for key ${String(key)}`,
+        error,
+      )
+      return null
+    }
+  }
+
+  getOrDefault<Key extends Path<Config>>(
+    key: Key,
+    defaultValue: PathValue<Config, Key>,
+  ): PathValue<Config, Key> {
+    const value = this.get(key)
+    return value !== null ? value : defaultValue
+  }
+
+  getOrThrow<Key extends Path<Config>>(
+    key: Key,
+    errorMessage?: string,
+  ): PathValue<Config, Key> {
+    const value = this.get(key)
+
+    if (value === null) {
+      const message =
+        errorMessage ||
+        `Configuration value for key "${String(key)}" is not defined`
+      this.logger.error(message)
+      throw new NaviosException(message)
+    }
+
+    return value
+  }
+}

package/src/config/index.mts

@@ -0,0 +1,5 @@
+export * from './utils/index.mjs'
+export * from './config.provider.mjs'
+export * from './config.service.mjs'
+export * from './config-service.interface.mjs'
+export * from './types.mjs'

package/src/config/types.mts

@@ -0,0 +1,58 @@
+/**
+ * Evaluates to `true` if `T` is `any`. `false` otherwise.
+ * (c) https://stackoverflow.com/a/68633327/5290447
+ */
+type IsAny<T> = unknown extends T
+  ? [keyof T] extends [never]
+    ? false
+    : true
+  : false
+
+type ExcludedParts =
+  | 'services'
+  | 'mailer'
+  | 'aws'
+  | 'computedTimeRates'
+  | 'aiModelsRates'
+type ExcludedKeys = 'computedTimeRates' | 'aiModelsRates' | 'aiModel'
+
+export type PathImpl<T, Key extends keyof T> = Key extends string
+  ? Key extends ExcludedKeys
+    ? never
+    : IsAny<T[Key]> extends true
+      ? never
+      : T[Key] extends string
+        ? never
+        : T[Key] extends any[]
+          ? never
+          : T[Key] extends Record<string, any>
+            ? Key extends ExcludedParts
+              ? `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}`
+              :
+                  | `${Key}.${PathImpl<T[Key], Exclude<keyof T[Key], keyof any[]>> & string}`
+                  | `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}`
+            : never
+  : never
+
+export type PathImpl2<T> = PathImpl<T, keyof T> | keyof T
+
+export type Path<T> = keyof T extends string
+  ? PathImpl2<T> extends infer P
+    ? P extends string | keyof T
+      ? P
+      : keyof T
+    : keyof T
+  : never
+
+export type PathValue<
+  T,
+  P extends Path<T>,
+> = P extends `${infer Key}.${infer Rest}`
+  ? Key extends keyof T
+    ? Rest extends Path<T[Key]>
+      ? PathValue<T[Key], Rest>
+      : never
+    : never
+  : P extends keyof T
+    ? T[P]
+    : never

package/src/config/utils/helpers.mts

@@ -0,0 +1,23 @@
+import { env } from 'node:process'
+
+export function envInt(
+  key: keyof NodeJS.ProcessEnv,
+  defaultValue: number,
+): number {
+  const envKey = env[key] || process.env[key]
+
+  return envKey ? parseInt(envKey as string, 10) : defaultValue
+}
+
+export function envString<
+  DefaultValue extends string | undefined,
+  Ensured = DefaultValue extends string ? true : false,
+>(
+  key: keyof NodeJS.ProcessEnv,
+  defaultValue?: DefaultValue,
+): Ensured extends true ? string : string | undefined {
+  return (env[key] ||
+    process.env[key] ||
+    defaultValue ||
+    undefined) as Ensured extends true ? string : string | undefined
+}

package/src/config/utils/index.mts

@@ -0,0 +1 @@
+export * from './helpers.mjs'

package/src/index.mts

@@ -1,3 +1,4 @@
+export * from './config/index.mjs'
 export * from './decorators/index.mjs'
 export * from './exceptions/index.mjs'
 export * from './interfaces/index.mjs'

package/src/service-locator/proxy-service-locator.mts

@@ -1,4 +1,4 @@
-import type { AnyZodObject, input, output } from 'zod'
+import type { AnyZodObject, output, z, ZodOptional } from 'zod'
 
 import type { FactoryNotFound, UnknownError } from './index.mjs'
 import type { InjectionToken } from './injection-token.mjs'
@@ -33,11 +33,17 @@ export class ProxyServiceLocator implements ServiceLocator {
   ): void {
     return this.serviceLocator.registerAbstractFactory(token, factory)
   }
-  public getInstance<Instance, Schema extends AnyZodObject | undefined>(
+  public getInstance<
+    Instance,
+    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+  >(
     token: InjectionToken<Instance, Schema>,
-    args: Schema extends AnyZodObject ? input<Schema> : undefined,
+    args: Schema extends AnyZodObject
+      ? z.input<Schema>
+      : Schema extends ZodOptional<AnyZodObject>
+        ? z.input<Schema> | undefined
+        : undefined,
   ): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]> {
-    // @ts-expect-error
     return this.ctx.inject(token, args).then(
       (instance) => {
         return [undefined, instance]
@@ -47,16 +53,29 @@ export class ProxyServiceLocator implements ServiceLocator {
       },
     )
   }
-  public getOrThrowInstance<Instance, Schema extends AnyZodObject | undefined>(
+  public getOrThrowInstance<
+    Instance,
+    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+  >(
     token: InjectionToken<Instance, Schema>,
-    args: Schema extends AnyZodObject ? input<Schema> : undefined,
+    args: Schema extends AnyZodObject
+      ? z.input<Schema>
+      : Schema extends ZodOptional<AnyZodObject>
+        ? z.input<Schema> | undefined
+        : undefined,
   ): Promise<Instance> {
-    // @ts-expect-error We need to pass the args to the ctx.inject method
     return this.ctx.inject(token, args)
   }
-  public getSyncInstance<Instance, Schema extends AnyZodObject | undefined>(
+  public getSyncInstance<
+    Instance,
+    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+  >(
     token: InjectionToken<Instance, Schema>,
-    args: Schema extends AnyZodObject ? input<Schema> : undefined,
+    args: Schema extends AnyZodObject
+      ? z.input<Schema>
+      : Schema extends ZodOptional<AnyZodObject>
+        ? z.input<Schema> | undefined
+        : undefined,
   ): Instance | null {
     return this.serviceLocator.getSyncInstance(token, args)
   }

package/src/service-locator/service-locator.mts

@@ -456,7 +456,15 @@ export class ServiceLocator {
   makeInstanceName(token: InjectionToken<any, any>, args: any) {
     let stringifiedArgs = args
       ? ':' +
-        JSON.stringify(args)
+        JSON.stringify(args, (_, value) => {
+          if (typeof value === 'function') {
+            return `function:${value.name}(${value.length})`
+          }
+          if (typeof value === 'symbol') {
+            return value.toString()
+          }
+          return value
+        })
           .replaceAll(/"/g, '')
           .replaceAll(/:/g, '=')
           .replaceAll(/,/g, '|')