Using ProxyQueryService with a custom CreateOneInputType

[abrenoch]

(Reposting from here)

I'm trying to add an additional field to the 'createOneX' input that is not stored with the entity:

import { Field, InputType } from '@nestjs/graphql';
import { CreateOneInputType } from '@ptc-org/nestjs-query-graphql';

import { AssetDTO } from '../asset.dto';

@InputType('CreateOneAssetInput')
export class CreateOneAssetInputDTO extends CreateOneInputType(
  'asset',
  AssetDTO,
) {
  @Field(() => String)
  filePath: string;
}

filePath is used to create or lookup an associated entry, making my graphql schema look like this:

type CreateOneAssetInput {
  asset: CreateAsset!
  filePath: String!
}

The query service looks like:

export class AssetQueryService extends ProxyQueryService<
  AssetEntity,
  CreateOneAssetInputDTO
> {
  fileRepository: Repository<FileEntity>;

  constructor(
    @InjectQueryService(AssetEntity)
    service: QueryService<AssetEntity, CreateOneAssetInputDTO>,
    @InjectRepository(FileEntity)
    fileRepository: Repository<FileEntity>,
  ) {
    super(service);
    this.fileRepository = fileRepository;
  }

  async createOne(input: CreateOneAssetInputDTO): Promise<AssetEntity> {
    const { filePath } = input;

    const file = await this.fileRepository
      .createQueryBuilder()
      .insert()
      .into(FileEntity)
      .orIgnore()
      .values({
        location: filePath,
      })
      .updateEntity(false)
      .execute();

    // ... more stuff

    return this.proxied.createOne(input);
  }
}

The problem I'm having is input: CreateOneAssetInputDTO in createOne is delivered as AssetDTO rather than the whole input argument ({ asset: ..., filePath: ... }).

Am I going about this the right way? As always your help is appreciated!

[TriPSs]

Are you setting CreateOneAssetInputDTO inside the module's CreateDTOClass?

[abrenoch]

@TriPSs Hey finally got around to putting together a minimal repo: https://github.com/abrenoch/nest-query-test

The exact spot the issue can be seen is here:
https://github.com/abrenoch/nest-query-test/blob/fed806be57333fba5ad96f651b05644caa334fed/src/asset-query.service.ts#L20

The input provided by createOne is of DeepPartial<AssetEntity>, though I'm trying to get it to play nicely with the CreateOneAssetInputDTO (which is provided via the asset.module file). The createOne response is just a fake object in this demo code, should be sufficient in illustrating the problem.

Please let me know if there is anything I can clarify! I think this is the only thing we haven't been able to work out with this package yet. 🚀

mutation:

mutation CreateOneAsset($input: CreateOneAssetInput!) {
  createOneAsset(input: $input) {
    id
  }
}

input:

{
  "input":  {
    "asset": {
      "id":1,
      "assetName": "help tripss!"
    },
    "filePath": "test"
  }
}

[TriPSs]

Could you add something to start the database with?

And just to make sure, the console log here is not logging the filePath right?

[abrenoch]

Hey @TriPSs sorry for the delay.

The repo has been updated to build a database - added a .env for the DB settings and the npm script migration:run to fire it up.

You are correct, I'm expecting to see filePath present in the console log right there.

As always your help is appreciated! 🙏

[TriPSs]

Hi @abrenoch,

Sorry that it took me a while but I figured it out, the thing is that this is actually expected behavior. What you could do is use the normal TypeORMQueryService (or keep what you have, but update it to receive DeepPartial<AssetEntity>) and add the following to the AssetModel

@BeforeCreateOne((input: CreateOneAssetInputDTO) => {
  console.log('asset', input.input);
  console.log('filePath', input.filePath);
  return input;
})

Here you can update the input (that is send the service), do checks etc.

[abrenoch]

Hey thanks for looking into this - I must have overlooked those decorator hooks.

Seems like for our specific case it might be easier to make a custom gql resolver rather than try to wrestle the generated methods into submission.

I appreciate the insight, thanks for taking the time.