@simtlix/simfinity-js 1.2.0 → 1.3.0

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

@@ -0,0 +1,63 @@
+const mongoose = require('mongoose');
+const { GraphQLObjectType, GraphQLString, GraphQLID } = require('graphql');
+const simfinity = require('../src/index');
+
+describe('preventCreatingCollection option', () => {
+  let createCollectionSpy;
+
+  beforeEach(() => {
+    // Reset modules to have a clean state for each test
+    jest.resetModules();
+    // Spy on the createCollection method of the mongoose model prototype
+    createCollectionSpy = jest.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');
+    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');
+    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');
+    expect(createCollectionSpy).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/validated-scalar.test.js

@@ -0,0 +1,167 @@
+const {
+  GraphQLObjectType, GraphQLString, GraphQLInt, GraphQLID, GraphQLList, GraphQLNonNull,
+} = require('graphql');
+const { createValidatedScalar } = require('../src/index');
+const simfinity = require('../src/index');
+
+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');
+      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');
+      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');
+      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();
+    });
+  });
+});

package/.eslintignore

@@ -1,2 +0,0 @@
-node_modules/*
-data/*

package/.eslintrc.json

@@ -1,38 +0,0 @@
-{
-    "env": {
-        "commonjs": true,
-        "es2020": true,
-        "node": true,
-        "jest": true
-    },
-    "extends": [
-        "airbnb-base"
-    ],
-    "parserOptions": {
-        "ecmaVersion": 9
-    },
-    "rules": {
-        "default-case": "off",
-        "max-len": 0,
-        "no-console":"off",
-        "no-underscore-dangle": "off",
-        "no-await-in-loop": "off",
-        "no-param-reassign": ["error", { "props": false }],
-        "no-restricted-syntax": [
-            "error",
-            {
-              "selector": "ForInStatement",
-              "message": "for..in loops iterate over the entire prototype chain, which is virtually never what you want. Use Object.{keys,values,entries}, and iterate over the resulting array."
-            },
-            {
-              "selector": "LabeledStatement",
-              "message": "Labels are a form of GOTO; using them makes code confusing and hard to maintain and understand."
-            },
-            {
-              "selector": "WithStatement",
-              "message": "`with` is disallowed in strict mode because it makes code impossible to predict and optimize."
-            }
-          ],
-        "import/no-unresolved": ["error", { "ignore": ["graphql", "mongoose"] }]
-    }
-}