Option to provide custom Typescript mapping

[ValentinH]

We are using graphql-zeus to interact with a Hasura GraphQL server and some common types from Hasura end up being typed as any or unknown. For example, uuid, timestampz or numeric.

Ideally, I would like to be able to extend the typeScriptMap used here, here and here.

One approach I have in mind would be to provide a new option --tsMappingFile that would read a JSON file like:

{
  "uuid": "string",
  "timestampz": "string",
  "numeric": "string"
}

this custom mapping would be added to the default typeScriptMap I mentioned above.

If you agree that this could be a nice addition, I'm ready to do a pull request for this (I would probably need a bit of guidance though).

[ValentinH]

I explored a bit the codebase and slightly changed the way to support these custom types.

Instead of overriding the typescriptMap, I created a customScalarsMap (which should ideally be coming from a JSON config to make this configurable) and used it like this:
elba-security@1cb5233

[aexol]

It will be handled soon with functions:

const result = await chain(HOST)({},{
  URL: (u) => u as string,
  JSON: (u) => u as { settings: string }
})

So the scalar type will be return type of the function you provide to scalar resolvers dictionary

[ValentinH]

This means that this would be done at runtime, wouldn't it?
The approach I suggest is done at generation time though.

[aexol]

Yes but only once per each Scalar definition.

[ValentinH]

Will it support TS?

[CryptoGraffe]

I have need for a similar thing. I'm using the citext extension for postgres, which leads hasura describing the column as a custom type citext and so zeus generates a custom type called citext but it maps in typescript to type unknown ... I just want it to map to TS string instead of unknown. Is there any other workaround for this?

['citext']: unknown;

needs to become

['citext']: string;

my IDE is unhappy with me

[aexol]

Check [email protected]
https://zeus.graphqleditor.com/page/graphql/scalars.html
How to provide decoders and encoders. This is still fresh and experimental but works and its type safe and tested :)

[ValentinH]

This looks nice but I think it would be even nicer to be able to have this done at generation time. Indeed, when having a lot of occurrences of the same scalar, it would be cumbersome to do this for every query.

[aexol]

Yes I plan to move it to Chain do you don't have specify it every time

[aexol]

But moving to generation is not a good idea not typesafe at all

[ValentinH]

It actually depends on the use case. In my original issue, I'm talking about the timestamp type from Hasura which can always be set to string in TS.

[aexol]

Yeah but it is better to provide it to the function as a parameter to Thunder or Chain. Right now it is just in Chain execution result which is not so handy. But still, the PoC works that makes me happy :)

[ItsWendell]

What is the recommended way to create a custom global client? I did this for Hasura to support typescript with custom scalars:

import {
  Chain,
  GenericOperation,
  GraphQLTypes,
  InputType,
  OperationOptions,
  ScalarDefinition,
  ValueTypes,
} from "./generated/zeus";
import { Ops } from "./generated/zeus/const";

export * from "./generated/zeus";

const scalars = {
  jsonb: {
    encode: (e: unknown) => JSON.stringify(e) as string,
    decode: (e: unknown) => JSON.parse(e as string) as string,
  },
  JSON: {
    encode: (e: unknown) => JSON.stringify(e) as string,
    decode: (e: unknown) => JSON.parse(e as string) as string,
  },
  timestamptz: {
    encode: (e: unknown) => JSON.stringify(e) as string,
    decode: (e: unknown) => JSON.parse(e as string) as string,
  },
};

export const ZeusClient =
  (endpoint: string, secret: string) =>
  <
    O extends keyof typeof Ops,
    R extends keyof ValueTypes = GenericOperation<O>
  >(
    operation: O
  ) => {
    const chain = Chain(endpoint, {
      headers: {
        "x-hasura-admin-secret": secret,
      },
    })(operation);

    return <Z extends ValueTypes[R], SCLR extends ScalarDefinition>(
      o: Z | ValueTypes[R],
      ops?: OperationOptions & {
        scalars?: SCLR;
      }
    ): Promise<InputType<GraphQLTypes[R], Z, SCLR & typeof scalars>> =>
      chain(o as any, {
        ...ops,
        scalars: scalars,
      }) as any;
  };

export type ZeusClient = ReturnType<typeof ZeusClient>;

export default ZeusClient;

Seems a bit tedious, I was wondering if there is an easier way to accomplish this?

[aexol]

Of course. As I responded to the other issue. I will move scalars definition one level up as a Chain/Thunder param to make construction of those easier

[aexol]

Check [email protected]
https://zeus.graphqleditor.com/page/graphql/scalars.html

[aexol]

I moved scalars level up

[aexol]

forgot to publish - publishing now