Dependency injection brakes if serialize is used to wrap a transformer

[JanStevens]

Package version

2.3.1

Describe the bug

Hi,

When using serialize to return the transformed resource, dependency injection fails. For example when using

import User from '#models/user'
import UserTransformer from '#transformers/user_transformer'
import type { HttpContext } from '@adonisjs/core/http'

export default class UsersController {
  async index({ serialize }: HttpContext) {
    const users = await User.query().paginate(1, 10)
    return serialize(UserTransformer.paginate(users.all(), users.getMeta()))
  }
}

with a UserTransformer which does a DI

import { inject } from '@adonisjs/core'
import { HttpContext } from '@adonisjs/core/http'
import type User from '#models/user'
import { BaseTransformer } from '@adonisjs/core/transformers'

@inject()
class GetAppUrls {
  constructor(protected ctx: HttpContext) {}
  handle() {
    return {
      url: this.ctx.request.url(),
    }
  }
}

export default class UserTransformer extends BaseTransformer<User> {
  @inject()
  toObject(getAppUrls: GetAppUrls) {
    return {
      ...this.pick(this.resource, [
        'id',
        'fullName',
        'email',
        'createdAt',
        'updatedAt',
        'initials',
      ]),
      url: getAppUrls.handle(),
    }
  }
}

The test then fails with

err: {
      "type": "RuntimeException",
      "message": "Cannot inject \"[class HttpContext]\" in \"[class EventTransformer]\"",
      "stack":
          Error
              at inject (file:///Users/project/node_modules/@adonisjs/fold/build/index.js:410:59)
              at <anonymous> (/Users/project/app/transformers/event_transformer.ts:134:1)
              at process.processTicksAndRejections (node:internal/process/task_queues:103:5)
      "name": "RuntimeException",
      "status": 500,
      "code": "E_RUNTIME_EXCEPTION",
      "help": "Container is not able to resolve \"EventTransformer\" class dependencies. Did you forget to use @inject() decorator?"
    }

I've added a repo with the reproduction steps to clearly pinpoint the issue. If you need any more info let me know.

Regards

Reproduction repo

https://github.com/JanStevens/adonisv7-serialize-inject-issue

[JanStevens]

After some digging found the potential issue,

The serialize method accepts a second argument the containerResolver if its not provided it creates it using new Container().createResolver() which obviously doesn't know about the bindings.

I've work around it by now wrapping it in a middleware which basically is the same as how inertia does it. There the InertiaManager is used to create a request with the context that renders an inertia page which then uses the inertia serializer passing in the context

[thetutlage]

Yup, indeed an issue. Has to be fixed within the starter kits

[JanStevens]

For reference I have the following now as a middlware

import type { ContainerResolver } from '@adonisjs/core/container'
import type { HttpContext } from '@adonisjs/core/http'
import { BaseSerializer } from '@adonisjs/core/transformers'
import type { NextFn } from '@adonisjs/core/types/http'

/**
 * Correctly types the pagination metadata for lucid paginated responses
 * Is used in our API responses to correctly type the pagination metadata
 */
export type InertiaPaginationMeta = {
  total: number
  perPage: number
  currentPage: number
  lastPage: number
  firstPage: number
  firstPageUrl: string
  lastPageUrl: string
  nextPageUrl: string | null
  previousPageUrl: string | null
}


/**
 * Custom serializer for API responses that ensures consistent JSON structure
 * across all API endpoints. Wraps response data in a 'data' property and handles
 * pagination metadata for Lucid ORM query results.
 */
class ApiSerializer extends BaseSerializer<{
  Wrap: undefined
  PaginationMetaData: InertiaPaginationMeta
}> {
  /**
   * Wraps all serialized data under this key in the response object.
   * Example: { data: [...] } instead of returning raw arrays/objects
   */
  wrap: undefined

  /**
   * Validates and defines pagination metadata structure for paginated responses.
   * Ensures that pagination info from Lucid queries is properly formatted.
   *
   * @throws Error if metadata doesn't match Lucid's pagination structure
   */
  definePaginationMetaData(metaData: unknown): InertiaPaginationMeta {
    if (!this.isLucidPaginatorMetaData(metaData)) {
      throw new Error(
        'Invalid pagination metadata. Expected metadata to contain Lucid pagination keys'
      )
    }
    // A bit odd but SimplePaginatorMetaKeys shows all keys are strings, but they are numbers...
    // So we need to cast it to unknown and then to InertiaPaginationMeta
    return metaData as unknown as InertiaPaginationMeta
  }
}

const serializer = new ApiSerializer()
type Serialize = typeof serializer.serialize

// Wraps the serializer with the container resolver
// TODO: Remove this when https://github.com/adonisjs/http-transformers/issues/3 is fixed
const wrapSerializerWithContext = (containerResolver: ContainerResolver<any>) => (data: any) => {
  return serializer.serialize(data, containerResolver).then((response) => {
    return response
  })
}

export default class SerializeMiddleware {
  async handle(ctx: HttpContext, next: NextFn) {
    // @ts-expect-error don't want to type this
    ctx.serialize = wrapSerializerWithContext(ctx.containerResolver)

    return next()
  }
}

declare module '@adonisjs/core/http' {
  export interface HttpContext {
    serialize: Serialize
  }
}

[thetutlage]

Can you try this within the api_provider without the middleware and tell me if that works fine?

import { HttpContext } from '@adonisjs/core/http'
import { BaseSerializer } from '@adonisjs/core/transformers'
import { type SimplePaginatorMetaKeys } from '@adonisjs/lucid/types/querybuilder'

/**
 * Custom serializer for API responses that ensures consistent JSON structure
 * across all API endpoints. Wraps response data in a 'data' property and handles
 * pagination metadata for Lucid ORM query results.
 */
class ApiSerializer extends BaseSerializer<{
  Wrap: 'data'
  PaginationMetaData: SimplePaginatorMetaKeys
}> {
  /**
   * Wraps all serialized data under this key in the response object.
   * Example: { data: [...] } instead of returning raw arrays/objects
   */
  wrap: 'data' = 'data'

  /**
   * Validates and defines pagination metadata structure for paginated responses.
   * Ensures that pagination info from Lucid queries is properly formatted.
   *
   * @throws Error if metadata doesn't match Lucid's pagination structure
   */
  definePaginationMetaData(metaData: unknown): SimplePaginatorMetaKeys {
    if (!this.isLucidPaginatorMetaData(metaData)) {
      throw new Error(
        'Invalid pagination metadata. Expected metadata to contain Lucid pagination keys'
      )
    }
    return metaData
  }
}

/**
 * Single instance of ApiSerializer used across the application
 */
const serializer = new ApiSerializer()

const serialize = Object.assign(
  function (this: HttpContext, ...[data, resolver]: Parameters<ApiSerializer['serialize']>) {
    return serializer.serialize(data, resolver ?? this.containerResolver)
  },
  {
    withoutWrapping(
      this: HttpContext,
      ...[data, resolver]: Parameters<ApiSerializer['serializeWithoutWrapping']>
    ) {
      return serializer.serializeWithoutWrapping(data, resolver ?? this.containerResolver)
    },
  }
) as ApiSerializer['serialize'] & { withoutWrapping: ApiSerializer['serializeWithoutWrapping'] }

HttpContext.instanceProperty('serialize', serialize)

/**
 * Module augmentation to add the serialize method to HttpContext.
 * This allows controllers to use ctx.serialize() for consistent API responses.
 */
declare module '@adonisjs/core/http' {
  export interface HttpContext {
    serialize: typeof serialize
  }
}

[JanStevens]

@thetutlage yep that does it!