@simtlix/simfinity-js 2.0.2 → 2.2.0

package/src/validators.js

@@ -0,0 +1,250 @@
+import SimfinityError from './errors/simfinity.error.js';
+
+/**
+ * Creates a validation object that works for both 'save' (CREATE) and 'update' (UPDATE) operations.
+ * The validators will be applied to both operations.
+ * For CREATE operations, the value must be provided and valid.
+ * For UPDATE operations, undefined/null values are allowed (field might not be updated),
+ * but if a value is provided, it must be valid.
+ */
+const createValidator = (validatorFn, required = false) => {
+  // Validator for CREATE operations - value is required if required=true
+  const validateCreate = async (typeName, fieldName, value, session) => {
+    if (required && (value === null || value === undefined)) {
+      throw new SimfinityError(`${fieldName} is required`, 'VALIDATION_ERROR', 400);
+    }
+    if (value !== null && value !== undefined) {
+      await validatorFn(typeName, fieldName, value, session);
+    }
+  };
+
+  // Validator for UPDATE operations - value is optional
+  const validateUpdate = async (typeName, fieldName, value, session) => {
+    // Skip validation if value is not provided (field is not being updated)
+    if (value === null || value === undefined) {
+      return;
+    }
+    // If value is provided, validate it
+    await validatorFn(typeName, fieldName, value, session);
+  };
+
+  const validatorCreate = { validate: validateCreate };
+  const validatorUpdate = { validate: validateUpdate };
+  
+  // Return validations for both CREATE and UPDATE operations
+  // Also support 'save'/'update' for backward compatibility (though code uses CREATE/UPDATE)
+  return {
+    CREATE: [validatorCreate],
+    UPDATE: [validatorUpdate],
+    save: [validatorCreate], // For backward compatibility
+    update: [validatorUpdate], // For backward compatibility
+  };
+};
+
+/**
+ * String validators
+ */
+export const stringLength = (name, min, max) => {
+  return createValidator(async (typeName, fieldName, value) => {
+    if (typeof value !== 'string') {
+      throw new SimfinityError(`${name} must be a string`, 'VALIDATION_ERROR', 400);
+    }
+    
+    if (min !== undefined && value.length < min) {
+      throw new SimfinityError(`${name} must be at least ${min} characters`, 'VALIDATION_ERROR', 400);
+    }
+    
+    if (max !== undefined && value.length > max) {
+      throw new SimfinityError(`${name} must be at most ${max} characters`, 'VALIDATION_ERROR', 400);
+    }
+  }, true); // Required for CREATE operations
+};
+
+export const maxLength = (name, max) => {
+  return createValidator(async (typeName, fieldName, value) => {
+    if (typeof value !== 'string') {
+      throw new SimfinityError(`${name} must be a string`, 'VALIDATION_ERROR', 400);
+    }
+    
+    if (value.length > max) {
+      throw new SimfinityError(`${name} must be at most ${max} characters`, 'VALIDATION_ERROR', 400);
+    }
+  }, false); // Optional
+};
+
+export const pattern = (name, regex, message) => {
+  const regexObj = typeof regex === 'string' ? new RegExp(regex) : regex;
+  const errorMessage = message || `${name} format is invalid`;
+  
+  return createValidator(async (typeName, fieldName, value) => {
+    if (typeof value !== 'string') {
+      throw new SimfinityError(`${name} must be a string`, 'VALIDATION_ERROR', 400);
+    }
+    
+    if (!regexObj.test(value)) {
+      throw new SimfinityError(errorMessage, 'VALIDATION_ERROR', 400);
+    }
+  }, false); // Optional
+};
+
+export const email = () => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  
+  return createValidator(async (typeName, fieldName, value) => {
+    if (typeof value !== 'string') {
+      throw new SimfinityError('Email must be a string', 'VALIDATION_ERROR', 400);
+    }
+    
+    if (!emailRegex.test(value)) {
+      throw new SimfinityError('Invalid email format', 'VALIDATION_ERROR', 400);
+    }
+  }, false); // Optional
+};
+
+export const url = () => {
+  return createValidator(async (typeName, fieldName, value) => {
+    if (typeof value !== 'string') {
+      throw new SimfinityError('URL must be a string', 'VALIDATION_ERROR', 400);
+    }
+    
+    try {
+      // Use URL constructor for better validation
+      new URL(value);
+    } catch (e) {
+        console.log('Invalid URL format', e);
+      throw new SimfinityError('Invalid URL format', 'VALIDATION_ERROR', 400);
+    }
+  }, false); // Optional
+};
+
+/**
+ * Number validators
+ */
+export const numberRange = (name, min, max) => {
+  return createValidator(async (typeName, fieldName, value) => {
+    if (typeof value !== 'number' || isNaN(value)) {
+      throw new SimfinityError(`${name} must be a number`, 'VALIDATION_ERROR', 400);
+    }
+    
+    if (min !== undefined && value < min) {
+      throw new SimfinityError(`${name} must be at least ${min}`, 'VALIDATION_ERROR', 400);
+    }
+    
+    if (max !== undefined && value > max) {
+      throw new SimfinityError(`${name} must be at most ${max}`, 'VALIDATION_ERROR', 400);
+    }
+  }, false); // Optional
+};
+
+export const positive = (name) => {
+  return createValidator(async (typeName, fieldName, value) => {
+    if (typeof value !== 'number' || isNaN(value)) {
+      throw new SimfinityError(`${name} must be a number`, 'VALIDATION_ERROR', 400);
+    }
+    
+    if (value <= 0) {
+      throw new SimfinityError(`${name} must be positive`, 'VALIDATION_ERROR', 400);
+    }
+  }, false); // Optional
+};
+
+/**
+ * Array validators
+ */
+export const arrayLength = (name, maxItems, itemValidator) => {
+  return createValidator(async (typeName, fieldName, value, session) => {
+    if (!Array.isArray(value)) {
+      throw new SimfinityError(`${name} must be an array`, 'VALIDATION_ERROR', 400);
+    }
+    
+    if (maxItems !== undefined && value.length > maxItems) {
+      throw new SimfinityError(`${name} must have at most ${maxItems} items`, 'VALIDATION_ERROR', 400);
+    }
+    
+    // If itemValidator is provided, validate each item
+    if (itemValidator && Array.isArray(itemValidator)) {
+      for (let i = 0; i < value.length; i++) {
+        for (const validator of itemValidator) {
+          await validator.validate(typeName, fieldName, value[i], session);
+        }
+      }
+    }
+  }, false); // Optional
+};
+
+/**
+ * Date validators
+ */
+export const dateFormat = (name, format) => {
+  return createValidator(async (typeName, fieldName, value) => {
+    // Handle Date objects, ISO strings, and timestamps
+    let date;
+    if (value instanceof Date) {
+      date = value;
+    } else if (typeof value === 'string') {
+      date = new Date(value);
+    } else if (typeof value === 'number') {
+      date = new Date(value);
+    } else {
+      throw new SimfinityError(`${name} must be a valid date`, 'VALIDATION_ERROR', 400);
+    }
+    
+    if (isNaN(date.getTime())) {
+      throw new SimfinityError(`${name} must be a valid date`, 'VALIDATION_ERROR', 400);
+    }
+    
+    // If format is provided, validate format
+    if (format && typeof value === 'string') {
+      // Simple format validation - can be enhanced
+      const formatRegex = /^\d{4}-\d{2}-\d{2}$/; // YYYY-MM-DD
+      if (format === 'YYYY-MM-DD' && !formatRegex.test(value)) {
+        throw new SimfinityError(`${name} must be in format ${format}`, 'VALIDATION_ERROR', 400);
+      }
+      // Add more format patterns as needed
+    }
+  }, false); // Optional
+};
+
+export const futureDate = (name) => {
+  return createValidator(async (typeName, fieldName, value) => {
+    let date;
+    if (value instanceof Date) {
+      date = value;
+    } else if (typeof value === 'string') {
+      date = new Date(value);
+    } else if (typeof value === 'number') {
+      date = new Date(value);
+    } else {
+      throw new SimfinityError(`${name} must be a valid date`, 'VALIDATION_ERROR', 400);
+    }
+    
+    if (isNaN(date.getTime())) {
+      throw new SimfinityError(`${name} must be a valid date`, 'VALIDATION_ERROR', 400);
+    }
+    
+    if (date <= new Date()) {
+      throw new SimfinityError(`${name} must be a future date`, 'VALIDATION_ERROR', 400);
+    }
+  }, false); // Optional
+};
+
+// Export all validators as an object
+const validators = {
+  // String validators
+  stringLength,
+  maxLength,
+  pattern,
+  email,
+  url,
+  // Number validators
+  numberRange,
+  positive,
+  // Array validators
+  arrayLength,
+  // Date validators
+  dateFormat,
+  futureDate,
+};
+
+export default validators;
+

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,10 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: "[BUG]"
-labels: bug
-assignees: ''
-
----
-
-**Describe the bug*

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,10 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: "[FEATURE]"
-labels: feature
-assignees: ''
-
----
-
-** Describe the feature **

package/.github/workflows/master.yml

@@ -1,19 +0,0 @@
-name: Build on master
-
-on:
-  push:
-    branches: master
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-      - 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
-

package/.github/workflows/publish.yml

@@ -1,45 +0,0 @@
-name: Publish packages
-
-on:
-  create:
-    tags:
-      - 'v*'
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    steps:
-      - 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 test
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v2.3.4
-      - uses: actions/setup-node@v1.4.4
-        with:
-          node-version: 14
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.NPMJS_TOKEN}}
-  publish-gpr:
-    needs: build
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v2.3.4
-      - uses: actions/setup-node@v1.4.4
-        with:
-          node-version: 14
-          registry-url: https://npm.pkg.github.com/
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

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.