@simtlix/simfinity-js 2.0.1 → 2.1.0

package/.github/workflows/release.yml

@@ -1,65 +0,0 @@
-name: Generate Release
-
-on:
-  push:
-    branches:
-      - release/*
-
-jobs:
-  generate_release:
-    runs-on: ubuntu-24.04
-    steps:
-      - name: Inject slug/short variables
-        uses: rlespinasse/github-slug-action@3.1.0
-      - uses: actions/checkout@v2.3.4
-      - uses: actions/setup-node@v1.4.4
-        with:
-          node-version: 14
-      - run: npm ci
-      - run: npx json -f package.json peerDependencies | npx json -ka | xargs -i{} bash -c 'echo $0@$(npx json -f package.json peerDependencies.$0)' {} | xargs -i{}  npm install --save-optional {}
-      - run: npm run lint
-      - run: npm test
-      - run: npm version --no-git-tag-version $(echo ${{ env.GITHUB_REF_SLUG }} | cut -d"-" -f 2)
-      - name: Set release version
-        uses: stefanzweifel/git-auto-commit-action@v4
-        with:
-          commit_message: "Set Release version to ${{ env.GITHUB_REF_SLUG }}"
-      - name: Push changes to master
-        uses: ad-m/github-push-action@master
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          branch: ${{ env.GITHUB_REF_SLUG }}
-      - name: Create tag
-        uses: Klemensas/action-autotag@stable
-        id: update_tag
-        with:
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-          tag_prefix: "v"
-      - name: Create Release
-        if: steps.update_tag.outputs.tagname
-        id: create_release
-        uses: actions/create-release@v1
-        env:
-            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-            tag_name: ${{ steps.update_tag.outputs.tagname }}
-            release_name: Release ${{ steps.update_tag.outputs.tagname }}
-            body: |
-              Changes in this Release
-            draft: false
-            prerelease: false
-
-      - name: "Set next development version"
-        uses: actions/setup-node@v1.4.4
-        with:
-          node-version: 14
-      - run: npm version --no-git-tag-version preminor --preid alpha
-      - name: "Push next development version to master"
-        uses: stefanzweifel/git-auto-commit-action@v4
-        with:
-          commit_message: "Set next development version"
-      - name: Push changes
-        uses: ad-m/github-push-action@master
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          branch: master

package/BACKUP_README.md

@@ -1,26 +0,0 @@
-[![npm version](https://badge.fury.io/js/%40simtlix%2Fsimfinity-js.svg)](https://badge.fury.io/js/%40simtlix%2Fsimfinity-js)
-
-# How to
-## Install
-```bash
-npm install @simtlix/simfinity-js --save
-```
-
-To use this lib:
-* Define your mongoose models
-* Define your GraphQL types
-* Register models and types using `connect` function for **non embedded** types and `addNoEndpointType` function for **embedded** ones
-* Create the GraphQL schema using `createSchema` function
-
-## Test
-On this project root directory
-`npm link`
-
-On the test project root directory
-`npm link @simtlix/simfinity-js`
-
-Run test project with *preserve-symlinks* flag. E.g.:
-`node --preserve-symlinks app.js`
-
-# Example
-There is a sample of an app using this lib at [simfinity.js-samples](https://github.com/simtlix/simfinity.js-samples)

package/README_INDEX_EXAMPLE.md

@@ -1,252 +0,0 @@
-# Automatic ObjectId Index Creation
-
-This feature automatically creates MongoDB indexes for all ObjectId fields when models are generated, including nested embedded objects.
-
-## How it works
-
-When you define GraphQL types with ObjectId fields (GraphQLID), the system will automatically:
-
-1. Analyze the schema definition to find all ObjectId fields
-2. Create indexes for each ObjectId field found
-3. Handle nested embedded objects recursively
-4. Create indexes for arrays of embedded objects
-5. Create indexes for relationship fields (foreign keys between types)
-
-## Examples
-
-### Simple ObjectId fields
-
-```javascript
-import { GraphQLObjectType, GraphQLString, GraphQLID } from 'graphql';
-import * as simfinity from '@simtlix/simfinity-js';
-
-const UserType = new GraphQLObjectType({
-  name: 'User',
-  fields: () => ({
-    id: { type: GraphQLID },
-    name: { type: GraphQLString },
-    email: { type: GraphQLString },
-    managerId: { type: GraphQLID }, // This will get an index
-  }),
-});
-
-simfinity.connect(null, UserType, 'user', 'users');
-simfinity.createSchema();
-```
-
-This will create indexes for:
-- `id` field
-- `managerId` field
-
-### Relationship fields (non-embedded)
-
-```javascript
-const DepartmentType = new GraphQLObjectType({
-  name: 'Department',
-  fields: () => ({
-    id: { type: GraphQLID },
-    name: { type: GraphQLString },
-  }),
-});
-
-const UserType = new GraphQLObjectType({
-  name: 'User',
-  fields: () => ({
-    id: { type: GraphQLID },
-    name: { type: GraphQLString },
-    email: { type: GraphQLString },
-    department: { 
-      type: DepartmentType,
-      extensions: {
-        relation: { embedded: false } // or omit this line (default is false)
-      }
-    },
-  }),
-});
-
-// Register both types
-simfinity.connect(null, DepartmentType, 'department', 'departments');
-simfinity.connect(null, UserType, 'user', 'users');
-simfinity.createSchema();
-```
-
-This will create indexes for:
-- `id` field (in both User and Department)
-- `department` field (the foreign key field that references Department)
-
-### One-to-Many relationships
-
-```javascript
-const OrderType = new GraphQLObjectType({
-  name: 'Order',
-  fields: () => ({
-    id: { type: GraphQLID },
-    orderNumber: { type: GraphQLString },
-    customerId: { type: GraphQLID }, // This will get an index
-    items: { 
-      type: new GraphQLList(OrderItemType),
-      extensions: {
-        relation: { embedded: false }
-      }
-    },
-  }),
-});
-
-const OrderItemType = new GraphQLObjectType({
-  name: 'OrderItem',
-  fields: () => ({
-    id: { type: GraphQLID },
-    productId: { type: GraphQLID }, // This will get an index
-    quantity: { type: GraphQLString },
-    orderId: { type: GraphQLID }, // This will get an index (foreign key)
-  }),
-});
-
-// Register both types
-simfinity.connect(null, OrderItemType, 'orderItem', 'orderItems');
-simfinity.connect(null, OrderType, 'order', 'orders');
-simfinity.createSchema();
-```
-
-This will create indexes for:
-- `id` field (in both Order and OrderItem)
-- `customerId` field (in Order)
-- `productId` field (in OrderItem)
-- `orderId` field (in OrderItem - the foreign key that references Order)
-
-### Embedded objects with ObjectId
-
-```javascript
-const AddressType = new GraphQLObjectType({
-  name: 'Address',
-  fields: () => ({
-    street: { type: GraphQLString },
-    city: { type: GraphQLString },
-    countryId: { type: GraphQLID }, // This will get an index
-  }),
-});
-
-const UserType = new GraphQLObjectType({
-  name: 'User',
-  fields: () => ({
-    id: { type: GraphQLID },
-    name: { type: GraphQLString },
-    address: { 
-      type: AddressType,
-      extensions: {
-        relation: { embedded: true }
-      }
-    },
-  }),
-});
-
-// Register the embedded type
-simfinity.addNoEndpointType(AddressType);
-simfinity.connect(null, UserType, 'user', 'users');
-simfinity.createSchema();
-```
-
-This will create indexes for:
-- `id` field
-- `countryId` field (from AddressType)
-- `address.countryId` field (embedded path)
-
-### Nested embedded objects
-
-```javascript
-const CityType = new GraphQLObjectType({
-  name: 'City',
-  fields: () => ({
-    name: { type: GraphQLString },
-    stateId: { type: GraphQLID }, // This will get an index
-  }),
-});
-
-const AddressType = new GraphQLObjectType({
-  name: 'Address',
-  fields: () => ({
-    street: { type: GraphQLString },
-    city: { 
-      type: CityType,
-      extensions: {
-        relation: { embedded: true }
-      }
-    },
-  }),
-});
-
-const UserType = new GraphQLObjectType({
-  name: 'User',
-  fields: () => ({
-    id: { type: GraphQLID },
-    name: { type: GraphQLString },
-    address: { 
-      type: AddressType,
-      extensions: {
-        relation: { embedded: true }
-      }
-    },
-  }),
-});
-
-// Register the embedded types
-simfinity.addNoEndpointType(CityType);
-simfinity.addNoEndpointType(AddressType);
-simfinity.connect(null, UserType, 'user', 'users');
-simfinity.createSchema();
-```
-
-This will create indexes for:
-- `id` field
-- `stateId` field (from CityType)
-- `city.stateId` field (from AddressType)
-- `address.city.stateId` field (nested embedded path)
-
-### Arrays of embedded objects
-
-```javascript
-const OrderItemType = new GraphQLObjectType({
-  name: 'OrderItem',
-  fields: () => ({
-    productId: { type: GraphQLID }, // This will get an index
-    quantity: { type: GraphQLString },
-  }),
-});
-
-const OrderType = new GraphQLObjectType({
-  name: 'Order',
-  fields: () => ({
-    id: { type: GraphQLID },
-    customerId: { type: GraphQLID },
-    items: { 
-      type: new GraphQLList(OrderItemType),
-      extensions: {
-        relation: { embedded: true }
-      }
-    },
-  }),
-});
-
-// Register the embedded type
-simfinity.addNoEndpointType(OrderItemType);
-simfinity.connect(null, OrderType, 'order', 'orders');
-simfinity.createSchema();
-```
-
-This will create indexes for:
-- `id` field
-- `customerId` field
-- `productId` field (from OrderItemType)
-- `items.productId` field (array embedded path)
-
-## Benefits
-
-1. **Automatic Performance Optimization**: ObjectId fields are automatically indexed for better query performance
-2. **Relationship Optimization**: Foreign key fields are automatically indexed for efficient joins and lookups
-3. **No Manual Configuration**: No need to manually specify which fields should be indexed
-4. **Handles Complex Schemas**: Works with nested embedded objects and arrays
-5. **Consistent**: All ObjectId fields get the same treatment regardless of their location in the schema
-
-## Technical Details
-
-The system uses the `mongoose.Schema` constructor to create schemas and then calls `schema.index()` for each ObjectId field found. The index creation happens during model generation, so it's transparent to the application code. 

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);
-  });
-});