标量类型与输入校验

type Mutation {
  createUser(email: String!, age: Int, birthday: String): User!
}

scalar EmailAddress
scalar DateTime
scalar PositiveInt

type Mutation {
  createUser(email: EmailAddress!, age: PositiveInt, birthday: DateTime): User!
}

import { GraphQLScalarType, Kind, GraphQLError } from 'graphql';

const DateTimeScalar = new GraphQLScalarType({
  name: 'DateTime',
  description: 'ISO 8601 日期时间，例如 2026-10-07T19:46:00+08:00',

  // 出参：把内部值序列化给客户端
  serialize(value) {
    const date = value instanceof Date ? value : new Date(value);
    if (Number.isNaN(date.getTime())) {
      throw new GraphQLError('DateTime 无法序列化非法值');
    }
    return date.toISOString();
  },

  // 入参（变量）：把客户端传入的变量解析成内部值
  parseValue(value) {
    if (typeof value !== 'string') {
      throw new GraphQLError('DateTime 必须是字符串');
    }
    const date = new Date(value);
    if (Number.isNaN(date.getTime())) {
      throw new GraphQLError(`非法的时间格式：${value}`);
    }
    return date;
  },

  // 入参（字面量）：查询里内联的字面量走这里
  parseLiteral(ast) {
    if (ast.kind !== Kind.STRING) {
      throw new GraphQLError('DateTime 字面量必须是字符串');
    }
    return this.parseValue(ast.value);
  },
});

function validationError(message: string, path?: string) {
  return new GraphQLError(message, {
    extensions: {
      code: 'BAD_USER_INPUT',
      field: path,
    },
  });
}

import { DateTimeResolver, EmailAddressResolver, PositiveIntResolver } from 'graphql-scalars';

const resolvers = {
  DateTime: DateTimeResolver,
  EmailAddress: EmailAddressResolver,
  PositiveInt: PositiveIntResolver,
};

type User {
  id: ID!   # 客户端拿到的永远是字符串 "123"，不是数字 123
}

scalar Decimal   # 用字符串传输，服务端用 Decimal 库运算

import Decimal from 'decimal.js';

const DecimalScalar = new GraphQLScalarType({
  name: 'Decimal',
  serialize: (v) => new Decimal(v).toFixed(2),   // 出参固定两位小数
  parseValue: (v) => {
    try { return new Decimal(v); }
    catch { throw new GraphQLError('非法金额格式'); }
  },
  parseLiteral: (ast) =>
    ast.kind === Kind.STRING || ast.kind === Kind.INT || ast.kind === Kind.FLOAT
      ? new Decimal(ast.value)
      : null,
});

directive @constraint(
  minLength: Int
  maxLength: Int
  pattern: String
  min: Int
  max: Int
) on INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION

input CreateUserInput {
  email: EmailAddress!
  nickname: String! @constraint(minLength: 2, maxLength: 20)
  bio: String @constraint(maxLength: 200)
}

import { z } from 'zod';

const CreateUserSchema = z.object({
  email: z.string().email(),
  nickname: z.string().min(2).max(20),
  age: z.number().int().min(0).max(150).optional(),
  birthday: z.coerce.date().optional(),
});

// resolver 内校验
createUser: async (_, { input }, ctx) => {
  const parsed = CreateUserSchema.safeParse(input);
  if (!parsed.success) {
    throw new GraphQLError('输入校验失败', {
      extensions: {
        code: 'BAD_USER_INPUT',
        issues: parsed.error.issues.map((i) => ({
          path: i.path.join('.'),
          message: i.message,
        })),
      },
    });
  }
  return ctx.db.users.create(parsed.data);
}

// codegen.ts
const config: CodegenConfig = {
  schema: './graphql/**/*.graphql',
  generates: {
    './src/generated/graphql.ts': {
      plugins: ['typescript', 'typescript-operations', 'typescript-resolvers'],
      config: {
        scalars: {
          DateTime: 'string',           // 传输层是 ISO 字符串
          Date: 'string',
          EmailAddress: 'string',
          URL: 'string',
          UUID: 'string',
          Decimal: 'string',            // 金额用字符串传输
          JSON: 'Record<string, unknown>',
          JSONObject: 'Record<string, unknown>',
          BigInt: 'bigint',
        },
      },
    },
  },
};
export default config;

config: {
  scalars: { DateTime: 'string' },
  resolverTypeWrapper: { DateTime: 'Date | string' },
}

describe('DateTime 标量', () => {
  test('serialize：Date → ISO 字符串', () => {
    expect(DateTimeScalar.serialize(new Date('2026-10-07T11:46:00Z')))
      .toBe('2026-10-07T11:46:00.000Z');
  });

  test('parseValue：ISO 字符串 → Date（变量路径）', () => {
    const d = DateTimeScalar.parseValue('2026-10-07T11:46:00Z');
    expect(d).toBeInstanceOf(Date);
  });

  test('parseLiteral：内联字面量路径', () => {
    const ast = { kind: Kind.STRING, value: '2026-10-07T11:46:00Z' };
    expect(DateTimeScalar.parseLiteral(ast, null)).toBeInstanceOf(Date);
  });

  test('非法值抛错', () => {
    expect(() => DateTimeScalar.parseValue('not-a-date')).toThrow();
  });
});