@simtlix/simfinity-js 1.9.0 → 1.9.1

package/README.md

@@ -1072,13 +1072,13 @@ const OrderType = new GraphQLObjectType({
 
 ### Custom Validated Scalar Types
 
-Create custom scalar types with built-in validation:
+Create custom scalar types with built-in validation. The generated type names follow the pattern `{name}_{baseScalarTypeName}`:
 
 ```javascript
 const { GraphQLString, GraphQLInt } = require('graphql');
 const { createValidatedScalar } = require('@simtlix/simfinity-js');
 
-// Email scalar with validation
+// Email scalar with validation (generates type name: Email_String)
 const EmailScalar = createValidatedScalar(
   'Email',
   'A valid email address',
@@ -1091,7 +1091,7 @@ const EmailScalar = createValidatedScalar(
   }
 );
 
-// Positive integer scalar
+// Positive integer scalar (generates type name: PositiveInt_Int)
 const PositiveIntScalar = createValidatedScalar(
   'PositiveInt',
   'A positive integer',
@@ -1108,8 +1108,8 @@ const UserType = new GraphQLObjectType({
   name: 'User',
   fields: () => ({
     id: { type: GraphQLID },
-    email: { type: EmailScalar },
-    age: { type: PositiveIntScalar },
+    email: { type: EmailScalar }, // Type name: Email_String
+    age: { type: PositiveIntScalar }, // Type name: PositiveInt_Int
   }),
 });
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simtlix/simfinity-js",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "",
   "main": "src/index.js",
   "type": "module",
@@ -18,7 +18,7 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/simtlix/simfinity.git"
+    "url": "git+https://github.com/simtlix/simfinity.git"
   },
   "peerDependencies": {
     "graphql": "^16.11.0",

package/src/index.js

@@ -202,7 +202,7 @@ function createValidatedScalar(name, description, baseScalarType, validate) {
   const baseKind = kindMap[baseScalarType.name] || Kind.STRING;
 
   const scalar = new GraphQLScalarType({
-    name,
+    name: `${name}_${baseScalarType.name}`,
     description,
     serialize(value) {
       validate(value);
@@ -214,7 +214,7 @@ function createValidatedScalar(name, description, baseScalarType, validate) {
     },
     parseLiteral(ast, variables) {
       if (ast.kind !== baseKind) {
-        throw new Error(`${name} must be a ${baseScalarType.name}`);
+        throw new Error(`${name}_${baseScalarType.name} must be a ${baseScalarType.name}`);
       }
       const value = baseScalarType.parseLiteral(ast, variables);
       validate(value);

package/tests/scalar-naming.test.js

@@ -0,0 +1,125 @@
+import {
+  describe, test, expect,
+} from 'vitest';
+import { GraphQLString, GraphQLInt, GraphQLFloat, GraphQLBoolean, GraphQLID } from 'graphql';
+import { createValidatedScalar } from '../src/index.js';
+
+describe('Validated Scalar Naming Convention', () => {
+  test('should generate correct type names with base scalar type suffix', () => {
+    const EmailScalar = createValidatedScalar(
+      'Email',
+      'A valid email address',
+      GraphQLString,
+      (value) => {
+        if (!value.includes('@')) {
+          throw new Error('Invalid email format');
+        }
+      },
+    );
+
+    const EpisodeNumberScalar = createValidatedScalar(
+      'EpisodeNumber',
+      'A valid episode number',
+      GraphQLInt,
+      (value) => {
+        if (value <= 0) {
+          throw new Error('Episode number must be positive');
+        }
+      },
+    );
+
+    const RatingScalar = createValidatedScalar(
+      'Rating',
+      'A valid rating between 0 and 10',
+      GraphQLFloat,
+      (value) => {
+        if (value < 0 || value > 10) {
+          throw new Error('Rating must be between 0 and 10');
+        }
+      },
+    );
+
+    const IsActiveScalar = createValidatedScalar(
+      'IsActive',
+      'A boolean indicating if something is active',
+      GraphQLBoolean,
+      (value) => {
+        // Boolean validation is usually not needed, but this is for testing
+        if (typeof value !== 'boolean') {
+          throw new Error('Must be a boolean value');
+        }
+      },
+    );
+
+    const CustomIdScalar = createValidatedScalar(
+      'CustomId',
+      'A custom ID with specific format',
+      GraphQLID,
+      (value) => {
+        if (!value.startsWith('CUST_')) {
+          throw new Error('Custom ID must start with CUST_');
+        }
+      },
+    );
+
+    // Test the naming convention
+    expect(EmailScalar.name).toBe('Email_String');
+    expect(EpisodeNumberScalar.name).toBe('EpisodeNumber_Int');
+    expect(RatingScalar.name).toBe('Rating_Float');
+    expect(IsActiveScalar.name).toBe('IsActive_Boolean');
+    expect(CustomIdScalar.name).toBe('CustomId_ID');
+  });
+
+  test('should maintain baseScalarType property', () => {
+    const EmailScalar = createValidatedScalar(
+      'Email',
+      'A valid email address',
+      GraphQLString,
+      (value) => {
+        if (!value.includes('@')) {
+          throw new Error('Invalid email format');
+        }
+      },
+    );
+
+    expect(EmailScalar.baseScalarType).toBe(GraphQLString);
+    expect(EmailScalar.name).toBe('Email_String');
+  });
+
+  test('should work with validation functions', () => {
+    const EpisodeNumberScalar = createValidatedScalar(
+      'EpisodeNumber',
+      'A valid episode number',
+      GraphQLInt,
+      (value) => {
+        if (value <= 0) {
+          throw new Error('Episode number must be positive');
+        }
+      },
+    );
+
+    // Test valid value
+    expect(() => EpisodeNumberScalar.serialize(5)).not.toThrow();
+    expect(EpisodeNumberScalar.serialize(5)).toBe(5);
+
+    // Test invalid value
+    expect(() => EpisodeNumberScalar.serialize(0)).toThrow('Episode number must be positive');
+    expect(() => EpisodeNumberScalar.serialize(-1)).toThrow('Episode number must be positive');
+  });
+
+  test('should generate error messages with correct type names', () => {
+    const EpisodeNumberScalar = createValidatedScalar(
+      'EpisodeNumber',
+      'A valid episode number',
+      GraphQLInt,
+      (value) => {
+        if (value <= 0) {
+          throw new Error('Episode number must be positive');
+        }
+      },
+    );
+
+    // The error message should include the full type name
+    expect(() => EpisodeNumberScalar.serialize(0)).toThrow('Episode number must be positive');
+  });
+}); 

package/tests/validated-scalar.test.js

@@ -70,7 +70,7 @@ describe('Custom Validated Scalar Types', () => {
   describe('createValidatedScalar function', () => {
     test('should create a valid scalar type with baseScalarType property', () => {
       expect(EmailScalar).toBeDefined();
-      expect(EmailScalar.name).toBe('Email');
+      expect(EmailScalar.name).toBe('Email_String');
       expect(EmailScalar.baseScalarType).toBe(GraphQLString);
       expect(EmailScalar.serialize).toBeDefined();
       expect(EmailScalar.parseValue).toBeDefined();