@simtlix/simfinity-js 2.0.2 → 2.2.0

package/tests/objectid-indexes.test.js

@@ -1,215 +0,0 @@
-import {
-  describe, test, expect, beforeEach, afterEach, vi,
-} from 'vitest';
-import mongoose from 'mongoose';
-import { GraphQLObjectType, GraphQLString, GraphQLID, GraphQLList } from 'graphql';
-import * as simfinity from '../src/index.js';
-
-describe('ObjectId Index Creation', () => {
-  let indexSpy;
-
-  beforeEach(() => {
-    // Spy on the index method of mongoose Schema
-    indexSpy = vi.spyOn(mongoose.Schema.prototype, 'index').mockImplementation(() => {});
-    // Prevent collection creation to avoid database connection issues
-    simfinity.preventCreatingCollection(true);
-  });
-
-  afterEach(() => {
-    // Restore the original implementation
-    indexSpy.mockRestore();
-  });
-
-  test('should create index for direct ObjectId field', () => {
-    const TestType = new GraphQLObjectType({
-      name: 'TestTypeWithObjectId',
-      fields: () => ({
-        id: { type: GraphQLID },
-        name: { type: GraphQLString },
-        userId: { type: GraphQLID },
-      }),
-    });
-
-    simfinity.connect(null, TestType, 'testTypeWithObjectId', 'testTypesWithObjectId');
-    simfinity.createSchema();
-
-    // Should create indexes for both id and userId fields
-    expect(indexSpy).toHaveBeenCalledWith({ id: 1 });
-    expect(indexSpy).toHaveBeenCalledWith({ userId: 1 });
-    expect(indexSpy).toHaveBeenCalledTimes(2);
-  });
-
-  test('should create index for embedded ObjectId field', () => {
-    const EmbeddedType = new GraphQLObjectType({
-      name: 'EmbeddedType',
-      fields: () => ({
-        embeddedId: { type: GraphQLID },
-        embeddedName: { type: GraphQLString },
-      }),
-    });
-
-    const TestType = new GraphQLObjectType({
-      name: 'TestTypeWithEmbedded',
-      fields: () => ({
-        id: { type: GraphQLID },
-        name: { type: GraphQLString },
-        embedded: { 
-          type: EmbeddedType,
-          extensions: {
-            relation: { embedded: true },
-          },
-        },
-      }),
-    });
-
-    // Register the embedded type first
-    simfinity.addNoEndpointType(EmbeddedType);
-    simfinity.connect(null, TestType, 'testTypeWithEmbedded', 'testTypesWithEmbedded');
-    simfinity.createSchema();
-
-    // Should create indexes for id and embedded.embeddedId fields
-    expect(indexSpy).toHaveBeenCalledWith({ id: 1 });
-    expect(indexSpy).toHaveBeenCalledWith({ 'embedded.embeddedId': 1 });
-    expect(indexSpy).toHaveBeenCalledTimes(2);
-  });
-
-  test('should create index for nested embedded ObjectId field', () => {
-    const DeepEmbeddedType = new GraphQLObjectType({
-      name: 'DeepEmbeddedType',
-      fields: () => ({
-        deepId: { type: GraphQLID },
-        deepName: { type: GraphQLString },
-      }),
-    });
-
-    const EmbeddedType = new GraphQLObjectType({
-      name: 'EmbeddedTypeWithDeep',
-      fields: () => ({
-        embeddedId: { type: GraphQLID },
-        embeddedName: { type: GraphQLString },
-        deep: { 
-          type: DeepEmbeddedType,
-          extensions: {
-            relation: { embedded: true },
-          },
-        },
-      }),
-    });
-
-    const TestType = new GraphQLObjectType({
-      name: 'TestTypeWithNestedEmbedded',
-      fields: () => ({
-        id: { type: GraphQLID },
-        name: { type: GraphQLString },
-        embedded: { 
-          type: EmbeddedType,
-          extensions: {
-            relation: { embedded: true },
-          },
-        },
-      }),
-    });
-
-    // Register the embedded types first
-    simfinity.addNoEndpointType(DeepEmbeddedType);
-    simfinity.addNoEndpointType(EmbeddedType);
-    simfinity.connect(null, TestType, 'testTypeWithNestedEmbedded', 'testTypesWithNestedEmbedded');
-    simfinity.createSchema();
-
-    // Should create indexes for all ObjectId fields at all levels
-    expect(indexSpy).toHaveBeenCalledWith({ embeddedId: 1 }); // EmbeddedType
-    expect(indexSpy).toHaveBeenCalledWith({ 'deep.deepId': 1 }); // DeepEmbeddedType
-    expect(indexSpy).toHaveBeenCalledWith({ id: 1 }); // TestType
-    expect(indexSpy).toHaveBeenCalledWith({ 'embedded.embeddedId': 1 }); // embedded field in TestType
-    expect(indexSpy).toHaveBeenCalledWith({ 'embedded.deep.deepId': 1 }); // nested embedded field in TestType
-    expect(indexSpy).toHaveBeenCalledTimes(5);
-  });
-
-  test('should create index for array of embedded objects with ObjectId', () => {
-    const EmbeddedType = new GraphQLObjectType({
-      name: 'EmbeddedTypeForArray',
-      fields: () => ({
-        embeddedId: { type: GraphQLID },
-        embeddedName: { type: GraphQLString },
-      }),
-    });
-
-    const TestType = new GraphQLObjectType({
-      name: 'TestTypeWithEmbeddedArray',
-      fields: () => ({
-        id: { type: GraphQLID },
-        name: { type: GraphQLString },
-        embeddedArray: { 
-          type: new GraphQLList(EmbeddedType),
-          extensions: {
-            relation: { embedded: true },
-          },
-        },
-      }),
-    });
-
-    // Register the embedded type first
-    simfinity.addNoEndpointType(EmbeddedType);
-    simfinity.connect(null, TestType, 'testTypeWithEmbeddedArray', 'testTypesWithEmbeddedArray');
-    simfinity.createSchema();
-
-    // Should create indexes for id and embeddedArray.embeddedId fields
-    expect(indexSpy).toHaveBeenCalledWith({ id: 1 });
-    expect(indexSpy).toHaveBeenCalledWith({ 'embeddedArray.embeddedId': 1 });
-    expect(indexSpy).toHaveBeenCalledTimes(2);
-  });
-
-  test('should not create index for non-ObjectId fields', () => {
-    const TestType = new GraphQLObjectType({
-      name: 'TestTypeWithoutObjectId',
-      fields: () => ({
-        id: { type: GraphQLID },
-        name: { type: GraphQLString },
-        age: { type: GraphQLString },
-        active: { type: GraphQLString },
-      }),
-    });
-
-    simfinity.connect(null, TestType, 'testTypeWithoutObjectId', 'testTypesWithoutObjectId');
-    simfinity.createSchema();
-
-    // Should only create index for id field (ObjectId), not for other fields
-    expect(indexSpy).toHaveBeenCalledWith({ id: 1 });
-    expect(indexSpy).toHaveBeenCalledTimes(1);
-  });
-
-  test('should create index for relationship fields (non-embedded)', () => {
-    const DepartmentType = new GraphQLObjectType({
-      name: 'DepartmentType',
-      fields: () => ({
-        id: { type: GraphQLID },
-        name: { type: GraphQLString },
-      }),
-    });
-
-    const UserType = new GraphQLObjectType({
-      name: 'TestTypeWithRelationship',
-      fields: () => ({
-        id: { type: GraphQLID },
-        name: { type: GraphQLString },
-        department: { 
-          type: DepartmentType,
-          extensions: {
-            relation: { embedded: false },
-          },
-        },
-      }),
-    });
-
-    // Register both types
-    simfinity.connect(null, DepartmentType, 'department', 'departments');
-    simfinity.connect(null, UserType, 'testTypeWithRelationship', 'testTypesWithRelationship');
-    simfinity.createSchema();
-
-    // Should create indexes for id fields in both types and the relationship field
-    expect(indexSpy).toHaveBeenCalledWith({ id: 1 }); // DepartmentType
-    expect(indexSpy).toHaveBeenCalledWith({ id: 1 }); // UserType
-    expect(indexSpy).toHaveBeenCalledWith({ department: 1 }); // relationship field
-    expect(indexSpy).toHaveBeenCalledTimes(3);
-  });
-}); 

package/tests/prevent-collection-creation.test.js

@@ -1,67 +0,0 @@
-import {
-  describe, test, expect, beforeEach, afterEach, vi,
-} from 'vitest';
-import mongoose from 'mongoose';
-import { GraphQLObjectType, GraphQLString, GraphQLID } from 'graphql';
-import * as simfinity from '../src/index.js';
-
-describe('preventCreatingCollection option', () => {
-  let createCollectionSpy;
-
-  beforeEach(() => {
-    // Spy on the createCollection method of the mongoose model prototype
-    createCollectionSpy = vi.spyOn(mongoose.Model, 'createCollection').mockImplementation(() => Promise.resolve());
-  });
-
-  afterEach(() => {
-    // Restore the original implementation
-    createCollectionSpy.mockRestore();
-  });
-
-  test('should create collection by default', () => {
-    const TestType = new GraphQLObjectType({
-      name: 'TestTypeDefault',
-      fields: () => ({
-        id: { type: GraphQLID },
-        name: { type: GraphQLString },
-      }),
-    });
-
-    simfinity.connect(null, TestType, 'testTypeDefault', 'testTypesDefault');
-    simfinity.createSchema(); // Models are now generated during schema creation
-    expect(createCollectionSpy).toHaveBeenCalledTimes(1);
-  });
-
-  test('should NOT create collection when preventCreatingCollection is true', () => {
-    simfinity.preventCreatingCollection(true);
-
-    const TestType = new GraphQLObjectType({
-      name: 'TestTypePrevent',
-      fields: () => ({
-        id: { type: GraphQLID },
-        name: { type: GraphQLString },
-      }),
-    });
-
-    simfinity.connect(null, TestType, 'testTypePrevent', 'testTypesPrevent');
-    simfinity.createSchema(); // Models are now generated during schema creation
-    expect(createCollectionSpy).not.toHaveBeenCalled();
-  });
-
-  test('should create collection when preventCreatingCollection is set back to false', () => {
-    simfinity.preventCreatingCollection(true); // first prevent
-    simfinity.preventCreatingCollection(false); // then allow
-
-    const TestType = new GraphQLObjectType({
-      name: 'TestTypeAllow',
-      fields: () => ({
-        id: { type: GraphQLID },
-        name: { type: GraphQLString },
-      }),
-    });
-
-    simfinity.connect(null, TestType, 'testTypeAllow', 'testTypesAllow');
-    simfinity.createSchema(); // Models are now generated during schema creation
-    expect(createCollectionSpy).toHaveBeenCalledTimes(1);
-  });
-});

package/tests/scalar-naming.test.js

@@ -1,125 +0,0 @@
-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

@@ -1,172 +0,0 @@
-import {
-  describe, test, expect, beforeAll,
-} from 'vitest';
-import {
-  GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLID, GraphQLList, GraphQLNonNull,
-} from 'graphql';
-import { createValidatedScalar } from '../src/index.js';
-import * as simfinity from '../src/index.js';
-
-describe('Custom Validated Scalar Types', () => {
-  let EmailScalar;
-  let PositiveIntScalar;
-  let PhoneScalar;
-  let UserType;
-
-  beforeAll(() => {
-    simfinity.preventCreatingCollection(true);
-    // Create custom validated scalar types
-    EmailScalar = createValidatedScalar(
-      'Email',
-      'A valid email address',
-      GraphQLString,
-      (value) => {
-        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-        if (!emailRegex.test(value)) {
-          throw new Error('Invalid email format');
-        }
-      },
-    );
-
-    PositiveIntScalar = createValidatedScalar(
-      'PositiveInt',
-      'A positive integer',
-      GraphQLInt,
-      (value) => {
-        if (value <= 0) {
-          throw new Error('Value must be positive');
-        }
-      },
-    );
-
-    PhoneScalar = createValidatedScalar(
-      'Phone',
-      'A valid phone number',
-      GraphQLString,
-      (value) => {
-        const phoneRegex = /^\+?[\d\s\-()]+$/;
-        if (!phoneRegex.test(value)) {
-          throw new Error('Invalid phone number format');
-        }
-      },
-    );
-
-    // Create a test type with custom scalars
-    UserType = new GraphQLObjectType({
-      name: 'User',
-      fields: () => ({
-        id: { type: GraphQLID },
-        name: { type: GraphQLString },
-        email: { type: EmailScalar },
-        age: { type: PositiveIntScalar },
-        phone: { type: PhoneScalar },
-        emails: { type: new GraphQLList(EmailScalar) },
-        requiredEmail: { type: new GraphQLNonNull(EmailScalar) },
-        ages: { type: new GraphQLList(PositiveIntScalar) },
-      }),
-    });
-  });
-
-  describe('createValidatedScalar function', () => {
-    test('should create a valid scalar type with baseScalarType property', () => {
-      expect(EmailScalar).toBeDefined();
-      expect(EmailScalar.name).toBe('Email_String');
-      expect(EmailScalar.baseScalarType).toBe(GraphQLString);
-      expect(EmailScalar.serialize).toBeDefined();
-      expect(EmailScalar.parseValue).toBeDefined();
-      expect(EmailScalar.parseLiteral).toBeDefined();
-    });
-
-    test('should validate baseScalarType parameter', () => {
-      expect(() => {
-        createValidatedScalar('Test', 'Test', null, () => {});
-      }).toThrow('baseScalarType is required');
-
-      expect(() => {
-        createValidatedScalar('Test', 'Test', 'not a scalar', () => {});
-      }).toThrow('baseScalarType must be a valid GraphQL scalar type');
-    });
-
-    test('should handle different base scalar types', () => {
-      expect(PositiveIntScalar.baseScalarType).toBe(GraphQLInt);
-      expect(PhoneScalar.baseScalarType).toBe(GraphQLString);
-    });
-  });
-
-  describe('Custom scalar validation', () => {
-    test('should validate email format correctly', () => {
-      expect(() => EmailScalar.serialize('test@example.com')).not.toThrow();
-      expect(() => EmailScalar.serialize('invalid-email')).toThrow('Invalid email format');
-    });
-
-    test('should validate positive integers correctly', () => {
-      expect(() => PositiveIntScalar.serialize(5)).not.toThrow();
-      expect(() => PositiveIntScalar.serialize(0)).toThrow('Value must be positive');
-      expect(() => PositiveIntScalar.serialize(-1)).toThrow('Value must be positive');
-    });
-
-    test('should validate phone numbers correctly', () => {
-      expect(() => PhoneScalar.serialize('+1-555-123-4567')).not.toThrow();
-      expect(() => PhoneScalar.serialize('555-123-4567')).not.toThrow();
-      expect(() => PhoneScalar.serialize('invalid phone')).toThrow('Invalid phone number format');
-    });
-  });
-
-  describe('Schema generation with custom scalars', () => {
-    let UserModel;
-
-    beforeAll(() => {
-      simfinity.connect(null, UserType, 'user', 'users');
-      simfinity.createSchema(); // Models are now generated during schema creation
-      UserModel = simfinity.getModel(UserType);
-    });
-
-    test('should generate schema with correct types for custom scalars', () => {
-      const schema = UserModel.schema.obj;
-
-      // Test individual fields
-      expect(schema.email).toBe(String);
-      expect(schema.age).toBe(Number);
-      expect(schema.phone).toBe(String);
-
-      // Test array fields
-      expect(Array.isArray(schema.emails)).toBe(true);
-      expect(schema.emails[0]).toBe(String);
-      expect(Array.isArray(schema.ages)).toBe(true);
-      expect(schema.ages[0]).toBe(Number);
-
-      // Test required fields
-      expect(schema.requiredEmail).toBe(String);
-    });
-
-    test('should preserve unique constraints', () => {
-      const UserWithUniqueType = new GraphQLObjectType({
-        name: 'UserWithUnique',
-        fields: () => ({
-          id: { type: GraphQLID },
-          email: {
-            type: EmailScalar,
-            extensions: { unique: true },
-          },
-        }),
-      });
-      simfinity.connect(null, UserWithUniqueType, 'userWithUnique', 'usersWithUnique');
-      simfinity.createSchema(); // Models are now generated during schema creation
-      const UserWithUniqueModel = simfinity.getModel(UserWithUniqueType);
-      const schema = UserWithUniqueModel.schema.obj;
-
-      expect(schema.email).toEqual({ type: String, unique: true });
-    });
-  });
-
-  describe('GraphQL schema integration', () => {
-    test('should create valid GraphQL schema with custom scalars', () => {
-      const schema = simfinity.createSchema();
-
-      // The schema should be created without errors
-      expect(schema).toBeDefined();
-      expect(schema.getQueryType()).toBeDefined();
-      expect(schema.getMutationType()).toBeDefined();
-    });
-  });
-});