Geographic and Postal Scalars

/**
 * GraphQL scalar for ISO 3166-1 country code validation
 * Accepts 2-letter (alpha-2) and 3-letter (alpha-3) country codes
 */
const GraphQLCountryCode: GraphQLScalarType;

/**
 * GraphQL scalar for country name validation
 * Accepts standard country names
 */
const GraphQLCountryName: GraphQLScalarType;

/**
 * GraphQL scalar for postal code validation
 * Accepts various international postal code formats
 */
const GraphQLPostalCode: GraphQLScalarType;

/**
 * GraphQL scalar for geographic latitude validation
 * Accepts decimal degrees from -90 to 90
 */
const GraphQLLatitude: GraphQLScalarType;

/**
 * GraphQL scalar for geographic longitude validation
 * Accepts decimal degrees from -180 to 180
 */
const GraphQLLongitude: GraphQLScalarType;

/**
 * GraphQL scalar for locale identifier validation
 * Accepts IETF BCP 47 language tags
 */
const GraphQLLocale: GraphQLScalarType;

import { 
  GraphQLCountryCode,
  GraphQLPostalCode,
  GraphQLLatitude,
  GraphQLLongitude,
  GraphQLLocale
} from "graphql-scalars";

// In a GraphQL schema
const AddressType = new GraphQLObjectType({
  name: "Address",
  fields: {
    countryCode: { type: GraphQLCountryCode },
    postalCode: { type: GraphQLPostalCode },
    latitude: { type: GraphQLLatitude },
    longitude: { type: GraphQLLongitude },
  },
});

const UserType = new GraphQLObjectType({
  name: "User",
  fields: {
    locale: { type: GraphQLLocale },
    address: { type: AddressType },
  },
});

// Using with type definitions
const typeDefs = `
  scalar CountryCode
  scalar PostalCode
  scalar Latitude
  scalar Longitude
  scalar Locale
  
  type Address {
    street: String
    city: String
    countryCode: CountryCode
    postalCode: PostalCode
    latitude: Latitude
    longitude: Longitude
  }
  
  type User {
    name: String!
    locale: Locale
    address: Address
  }
`;

query GetUsersNearLocation($lat: Latitude!, $lng: Longitude!, $radius: Float!) {
  usersNearLocation(latitude: $lat, longitude: $lng, radius: $radius) {
    id
    name
    address {
      countryCode
      postalCode
      latitude
      longitude
    }
  }
}

mutation UpdateUserAddress($userId: ID!, $address: AddressInput!) {
  updateUserAddress(userId: $userId, address: $address) {
    id
    address {
      countryCode
      postalCode
      latitude
      longitude
    }
  }
}

{
  "lat": 40.7128,
  "lng": -74.0060,
  "radius": 10.0,
  "userId": "user-123",
  "address": {
    "street": "123 Main St",
    "city": "New York",
    "countryCode": "US",
    "postalCode": "10001",
    "latitude": 40.7509,
    "longitude": -73.9934
  }
}

// Valid coordinates
const validLocations = [
  { lat: 40.7128, lng: -74.0060 },  // New York City
  { lat: 51.5074, lng: -0.1278 },   // London
  { lat: -33.8688, lng: 151.2093 }, // Sydney
  { lat: 0, lng: 0 },               // Null Island
];

// Invalid coordinates
const invalidLocations = [
  { lat: 91, lng: -74.0060 },       // Latitude > 90
  { lat: 40.7128, lng: 181 },       // Longitude > 180
  { lat: -91, lng: -74.0060 },      // Latitude < -90
  { lat: 40.7128, lng: -181 },      // Longitude < -180
];

// String constants for schema building
const CountryCode: string;  // "scalar CountryCode"
const CountryName: string;  // "scalar CountryName"
const PostalCode: string;   // "scalar PostalCode"
const Latitude: string;     // "scalar Latitude"
const Longitude: string;    // "scalar Longitude"
const Locale: string;       // "scalar Locale"

// Mock data generators for testing
const CountryCodeMock: () => string;
const CountryNameMock: () => string;
const PostalCodeMock: () => string;
const LatitudeMock: () => number;
const LongitudeMock: () => number;
const LocaleMock: () => string;