如何使用 GraphQL 处理 long Int？

Question

如您所知，GraphQL 没有像 long int 这样的数据类型。所以，每当数字像10000000000 这样大的时候，它就会抛出这样的错误：Int cannot represent non 32-bit signed integer value: 1000000000000

为此，我知道两种解决方案：

1. 使用标量。

import { GraphQLScalarType } from 'graphql';
import { makeExecutableSchema } from '@graphql-tools/schema';

const myCustomScalarType = new GraphQLScalarType({
  name: 'MyCustomScalar',
  description: 'Description of my custom scalar type',
  serialize(value) {
    let result;
    return result;
  },
  parseValue(value) {
    let result;
    return result;
  },
  parseLiteral(ast) {
    switch (ast.kind) {
    }
  }
});

const schemaString = `

scalar MyCustomScalar

type Foo {
  aField: MyCustomScalar
}

type Query {
  foo: Foo
}

`;

const resolverFunctions = {
  MyCustomScalar: myCustomScalarType
};

const jsSchema = makeExecutableSchema({
  typeDefs: schemaString,
  resolvers: resolverFunctions,
});

1. 使用apollo-type-bigint package。

这两种解决方案都将大整数转换为string，我宁愿不使用字符串（我更喜欢数字类型）。

Answer 1

正确，graphQL 中没有 bigInt 这样的概念。

您可以尝试以下方法之一：

1. 将类型设置为Float 而不是Int - 它将处理所有大的int 值并将它们发送为number [以下是技术选项，尽管您表示不喜欢 string 解决方案]
2. 按照您的描述将类型设置为String
3. 如您所述，提供（npm 提供的数据类型，例如）BigInt。它将处理大整数，但会将您的值转换为string

npm bigInt 依赖选项：

• https://www.npmjs.com/package/apollo-type-bigint
• https://www.npmjs.com/package/graphql-bigint
• https://www.npmjs.com/package/graphql-type-bigint

Answer 2

Graphql 引入了标量。我正在使用 Java，所以我可以用 Java 提供一些解决方案。您可以按照以下步骤实现相同的目的。

请在您的 .graphqls 文件中定义标量

scalar Long

type Movie{
movieId: String
movieName: String
producer: String
director: String
demoId : Long
}

现在你必须在你的接线中注册这个标量。

return RuntimeWiring.newRuntimeWiring().type("Query", typeWiring -> typeWiring
                .dataFetcher("allMovies", allMoviesDataFetcher).dataFetcher("movie", movieDataFetcher)
                .dataFetcher("getMovie", getMovieDataFetcher)).scalar(ExtendedScalars.GraphQLLong).build();

现在您必须为 Long 定义标量配置，如下所示。

@Configuration
public class LongScalarConfiguration {
     @Bean
        public GraphQLScalarType longScalar() {
            return GraphQLScalarType.newScalar()
                .name("Long")
                .description("Java 8 Long as scalar.")
                .coercing(new Coercing<Long, String>() {
                    @Override
                    public String serialize(final Object dataFetcherResult) {
                        if (dataFetcherResult instanceof Long) {
                            return dataFetcherResult.toString();
                        } else {
                            throw new CoercingSerializeException("Expected a Long object.");
                        }
                    }

                    @Override
                    public Long parseValue(final Object input) {
                        try {
                            if (input instanceof String) {
                                return new Long((String) input);
                            } else {
                                throw new CoercingParseValueException("Expected a String");
                            }
                        } catch (Exception e) {
                            throw new CoercingParseValueException(String.format("Not a valid Long: '%s'.", input), e
                            );
                        }
                    }

                    @Override
                    public Long parseLiteral(final Object input) {
                        if (input instanceof StringValue) {
                            try {
                                return new Long(((StringValue) input).getValue());
                            } catch (Exception e) {
                                throw new CoercingParseLiteralException(e);
                            }
                        } else {
                            throw new CoercingParseLiteralException("Expected a StringValue.");
                        }
                    }
                }).build();
        }

}

它应该可以解决您的问题。 Java相关应用请尝试一下。

Answer 3

我建议在这种情况下使用graphql-bigint 包。此实现为您提供 53 位整数。 52 位以上的任何类似整数的数字都将截断其较低的值。所以如果你需要 52bit 以上，使用字符串会更安全。