@navios/core 0.1.2 → 0.1.4

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

@@ -0,0 +1,46 @@
+import { NaviosException } from '@navios/common'
+
+import type { ClassType } from './injection-token.mjs'
+import type { ServiceLocatorAbstractFactoryContext } from './service-locator-abstract-factory-context.mjs'
+
+import { getServiceLocator, provideServiceLocator } from './injector.mjs'
+import { makeProxyServiceLocator } from './proxy-service-locator.mjs'
+import { setPromiseCollector } from './sync-injector.mjs'
+
+export async function resolveService<T extends ClassType>(
+  ctx: ServiceLocatorAbstractFactoryContext,
+  target: T,
+  args: any[] = [],
+): Promise<InstanceType<T>> {
+  const proxyServiceLocator = makeProxyServiceLocator(getServiceLocator(), ctx)
+  let promises: Promise<any>[] = []
+  const promiseCollector = (promise: Promise<any>) => {
+    promises.push(promise)
+  }
+  const originalPromiseCollector = setPromiseCollector(promiseCollector)
+  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
+}

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

@@ -6,8 +6,17 @@ import type { ServiceLocatorAbstractFactoryContext } from './service-locator-abs
 import type { ServiceLocatorInstanceHolder } from './service-locator-instance-holder.mjs'
 
 import { InjectableScope } from './enums/index.mjs'
-import { ErrorsEnum, FactoryNotFound, UnknownError } from './errors/index.mjs'
-import { getInjectableToken } from './index.mjs'
+import {
+  ErrorsEnum,
+  FactoryNotFound,
+  FactoryTokenNotResolved,
+  UnknownError,
+} from './errors/index.mjs'
+import {
+  BoundInjectionToken,
+  FactoryInjectionToken,
+  getInjectableToken,
+} from './index.mjs'
 import { InjectionToken } from './injection-token.mjs'
 import { ServiceLocatorEventBus } from './service-locator-event-bus.mjs'
 import {
@@ -86,7 +95,7 @@ export class ServiceLocator {
     }
   }
 
-  public getInstanceIdentifier<
+  private resolveTokenArgs<
     Instance,
     Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
   >(
@@ -96,18 +105,57 @@ export class ServiceLocator {
       : Schema extends ZodOptional<AnyZodObject>
         ? z.input<Schema> | undefined
         : undefined,
-  ): string {
-    const validatedArgs = token.schema
-      ? token.schema.safeParse(args)
-      : undefined
+  ):
+    | [
+        undefined,
+        Schema extends AnyZodObject
+          ? z.input<Schema>
+          : Schema extends ZodOptional<AnyZodObject>
+            ? z.input<Schema> | undefined
+            : undefined,
+      ]
+    | [FactoryTokenNotResolved | UnknownError] {
+    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)]
+      }
+    }
+    if (!token.schema) {
+      return [undefined, realArgs]
+    }
+    const validatedArgs = token.schema?.safeParse(realArgs)
     if (validatedArgs && !validatedArgs.success) {
       this.logger?.error(
         `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
         validatedArgs.error,
       )
-      throw new UnknownError(validatedArgs.error)
+      return [new UnknownError(validatedArgs.error)]
+    }
+    // @ts-expect-error We return correct type
+    return [undefined, validatedArgs?.data]
+  }
+
+  public getInstanceIdentifier<
+    Instance,
+    Schema extends AnyZodObject | ZodOptional<AnyZodObject> | undefined,
+  >(
+    token: InjectionToken<Instance, Schema>,
+    args: Schema extends AnyZodObject
+      ? z.input<Schema>
+      : Schema extends ZodOptional<AnyZodObject>
+        ? z.input<Schema> | undefined
+        : undefined,
+  ): string {
+    const [err, realArgs] = this.resolveTokenArgs(token, args)
+    if (err) {
+      throw err
     }
-    return this.makeInstanceName(token, validatedArgs)
+    return this.makeInstanceName(token, realArgs)
   }
 
   public async getInstance<
@@ -121,17 +169,17 @@ export class ServiceLocator {
         ? z.input<Schema> | undefined
         : undefined,
   ): Promise<[undefined, Instance] | [UnknownError | FactoryNotFound]> {
-    const validatedArgs = token.schema
-      ? token.schema.safeParse(args)
-      : undefined
-    if (validatedArgs && !validatedArgs.success) {
-      this.logger?.error(
-        `[ServiceLocator]#getInstance(): Error validating args for ${token.name.toString()}`,
-        validatedArgs.error,
-      )
-      return [new UnknownError(validatedArgs.error)]
+    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, validatedArgs)
+    const instanceName = this.makeInstanceName(token, realArgs)
     const [error, holder] = this.manager.get(instanceName)
     if (!error) {
       if (holder.status === ServiceLocatorInstanceHolderStatus.Creating) {
@@ -167,7 +215,8 @@ export class ServiceLocator {
       default:
         return [error]
     }
-    return this.createInstance(instanceName, token, args)
+    // @ts-expect-error TS2322 It's validated
+    return this.createInstance(instanceName, token, realArgs)
   }
 
   public async getOrThrowInstance<
@@ -213,13 +262,22 @@ export class ServiceLocator {
     this.logger?.log(
       `[ServiceLocator]#createInstance() Creating instance for ${instanceName}`,
     )
+    let realToken =
+      token instanceof BoundInjectionToken ||
+      token instanceof FactoryInjectionToken
+        ? token.token
+        : token
     if (
-      this.abstractFactories.has(token) ||
-      this.instanceFactories.has(token)
+      this.abstractFactories.has(realToken) ||
+      this.instanceFactories.has(realToken)
     ) {
-      return this.createInstanceFromAbstractFactory(instanceName, token, args)
+      return this.createInstanceFromAbstractFactory(
+        instanceName,
+        realToken,
+        args,
+      )
     } else {
-      return [new FactoryNotFound(token.name.toString())]
+      return [new FactoryNotFound(realToken.name.toString())]
     }
   }
 
@@ -276,7 +334,7 @@ export class ServiceLocator {
               )
             })
           }
-          if (holder.ttl === 0) {
+          if (holder.ttl === 0 || !shouldStore) {
             // One time instance
             await this.invalidate(instanceName)
           }
@@ -371,17 +429,11 @@ export class ServiceLocator {
         ? z.input<Schema> | undefined
         : undefined,
   ): Instance | null {
-    const validatedArgs = token.schema
-      ? token.schema.safeParse(args)
-      : undefined
-    if (validatedArgs && !validatedArgs.success) {
-      this.logger?.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

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

@@ -24,14 +24,6 @@ export function syncInject<
   Token extends InjectionToken<T>,
   S extends AnyZodObject | unknown = Token['schema'],
 >(token: Token, args?: S extends AnyZodObject ? z.input<S> : never): T {
-  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: InjectionToken<T, S> = token
   if (!(token instanceof InjectionToken)) {
     realToken = getInjectableToken(token) as InjectionToken<T, S>

package/src/services/controller-adapter.service.mts

@@ -1,12 +1,13 @@
-import type { FastifyInstance } from 'fastify'
+import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
 import type { ZodTypeProvider } from 'fastify-type-provider-zod'
 
-import type { ModuleMetadata } from '../metadata/index.mjs'
+import { NaviosException } from '@navios/common'
+
+import type { EndpointMetadata, ModuleMetadata } from '../metadata/index.mjs'
 import type { ClassType } from '../service-locator/index.mjs'
 
-import { HttpException } from '../exceptions/index.mjs'
 import { Logger } from '../logger/index.mjs'
-import { extractControllerMetadata } from '../metadata/index.mjs'
+import { EndpointType, extractControllerMetadata } from '../metadata/index.mjs'
 import {
   getServiceLocator,
   inject,
@@ -31,9 +32,9 @@ export class ControllerAdapterService {
   ): void {
     const controllerMetadata = extractControllerMetadata(controller)
     for (const endpoint of controllerMetadata.endpoints) {
-      const { classMethod, url, httpMethod, config } = endpoint
+      const { classMethod, url, httpMethod } = endpoint
 
-      if (!url || !config) {
+      if (!url) {
         throw new Error(
           `[Navios] Malformed Endpoint ${controller.name}:${classMethod}`,
         )
@@ -43,47 +44,24 @@ export class ControllerAdapterService {
         controllerMetadata,
         endpoint,
       )
-      const guards = this.guardRunner.makeContext(executionContext)
-      const { querySchema, requestSchema, responseSchema } = config
-      const schema: Record<string, any> = {}
-      if (querySchema) {
-        schema.querystring = querySchema
-      }
-      if (requestSchema) {
-        schema.body = requestSchema
-      }
-      if (responseSchema) {
-        schema.response = {
-          200: responseSchema,
-        }
-      }
       instance.withTypeProvider<ZodTypeProvider>().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) => {
+        schema: this.provideSchemaForConfig(endpoint),
+        preHandler: this.providePreHandler(executionContext),
+        handler: this.provideHandler(controller, executionContext, endpoint),
+      })
+
+      this.logger.debug(
+        `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`,
+      )
+    }
+  }
+
+  providePreHandler(executionContext: ExecutionContext) {
+    const guards = this.guardRunner.makeContext(executionContext)
+    return guards.size > 0
+      ? async (request: FastifyRequest, reply: FastifyReply) => {
           getServiceLocator().registerInstance(Request, request)
           getServiceLocator().registerInstance(Reply, reply)
           getServiceLocator().registerInstance(
@@ -92,41 +70,108 @@ export class ControllerAdapterService {
           )
           executionContext.provideRequest(request)
           executionContext.provideReply(reply)
-          const controllerInstance = await inject(controller)
+          let canActivate = true
           try {
-            const { query, params, body } = request
-            const argument: Record<string, any> = {}
-            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 as Error).message,
-              })
-            }
+            canActivate = await this.guardRunner.runGuards(
+              guards,
+              executionContext,
+            )
           } finally {
             getServiceLocator().removeInstance(Request)
             getServiceLocator().removeInstance(Reply)
             getServiceLocator().removeInstance(ExecutionContextToken)
           }
-        },
-      })
+          if (!canActivate) {
+            return reply
+          }
+        }
+      : undefined
+  }
 
-      this.logger.debug(
-        `Registered ${httpMethod} ${url} for ${controller.name}:${classMethod}`,
+  private provideSchemaForConfig(endpointMetadata: EndpointMetadata) {
+    if (!endpointMetadata.config) {
+      this.logger.warn(`No config found for endpoint ${endpointMetadata.url}`)
+      return {}
+    }
+    const { querySchema, requestSchema, responseSchema } =
+      endpointMetadata.config
+    const schema: Record<string, any> = {}
+    if (querySchema) {
+      schema.querystring = querySchema
+    }
+    if (requestSchema) {
+      schema.body = requestSchema
+    }
+    if (responseSchema) {
+      schema.response = {
+        200: responseSchema,
+      }
+    }
+
+    return schema
+  }
+
+  private provideHandler(
+    controller: ClassType,
+    executionContext: ExecutionContext,
+    endpointMetadata: EndpointMetadata,
+  ): (request: FastifyRequest, reply: FastifyReply) => Promise<void> {
+    switch (endpointMetadata.type) {
+      case EndpointType.Unknown:
+        this.logger.error(
+          `Unknown endpoint type ${endpointMetadata.type} for ${controller.name}:${endpointMetadata.classMethod}`,
+        )
+        throw new NaviosException('Unknown endpoint type')
+      case EndpointType.Config:
+        return this.provideHandlerForConfig(
+          controller,
+          executionContext,
+          endpointMetadata,
+        )
+      case EndpointType.Handler:
+        this.logger.error('Not implemented yet')
+        throw new NaviosException('Not implemented yet')
+    }
+  }
+
+  private provideHandlerForConfig(
+    controller: ClassType,
+    executionContext: ExecutionContext,
+    endpointMetadata: EndpointMetadata,
+  ): (request: FastifyRequest, reply: FastifyReply) => Promise<void> {
+    return 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: Record<string, any> = {}
+        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[endpointMetadata.classMethod](argument)
+        reply
+          .status(endpointMetadata.successStatusCode)
+          .headers(endpointMetadata.headers)
+          .send(result)
+      } finally {
+        getServiceLocator().removeInstance(Request)
+        getServiceLocator().removeInstance(Reply)
+        getServiceLocator().removeInstance(ExecutionContextToken)
+      }
     }
   }
 }