@simtlix/simfinity-js 2.4.6 → 2.5.0

package/.claude/worktrees/agitated-kepler/src/plugins.js

@@ -0,0 +1,53 @@
+import { createAuthPlugin } from './auth/index.js';
+
+export { createAuthPlugin } from './auth/index.js';
+
+/**
+ * Apollo Server plugin to add count to GraphQL response extensions
+ * @returns {Object} Apollo Server plugin
+ */
+export const apolloCountPlugin = () => {
+  return {
+    async requestDidStart() {
+      return {
+        async willSendResponse({ contextValue, response }) {
+          if (response.body.kind === 'single' && contextValue?.count) {
+            response.body.singleResult.extensions = {
+              ...(response.body.singleResult.extensions || {}),
+              count: contextValue.count,
+            };
+          }
+        },
+      };
+    },
+  };
+};
+
+/**
+ * Envelop plugin to add count to GraphQL response extensions
+ * @returns {Object} Envelop plugin
+ */
+export const envelopCountPlugin = () => {
+  return {
+    onExecute() {
+      return {
+        onExecuteDone({ result, args }) {
+          if (args.contextValue?.count) {
+            result.extensions = {
+              ...result.extensions,
+              count: args.contextValue.count,
+            };
+          }
+        },
+      };
+    },
+  };
+};
+
+const plugins = {
+  createAuthPlugin,
+  apolloCountPlugin,
+  envelopCountPlugin,
+};
+
+export default plugins;

package/.claude/worktrees/agitated-kepler/src/scalars.js

@@ -0,0 +1,188 @@
+import {
+  GraphQLString, GraphQLInt, GraphQLFloat,
+} from 'graphql';
+import { createValidatedScalar } from './index.js';
+
+/**
+ * Email scalar - validates email format
+ * Type name: Email_String
+ */
+export const EmailScalar = createValidatedScalar(
+  'Email',
+  'A valid email address',
+  GraphQLString,
+  (value) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(value)) {
+      throw new Error('Invalid email format');
+    }
+  },
+);
+
+/**
+ * URL scalar - validates URL format
+ * Type name: URL_String
+ */
+export const URLScalar = createValidatedScalar(
+  'URL',
+  'A valid URL',
+  GraphQLString,
+  (value) => {
+    try {
+      new URL(value);
+    } catch {
+      throw new Error('Invalid URL format');
+    }
+  },
+);
+
+/**
+ * PositiveInt scalar - validates positive integers
+ * Type name: PositiveInt_Int
+ */
+export const PositiveIntScalar = createValidatedScalar(
+  'PositiveInt',
+  'A positive integer',
+  GraphQLInt,
+  (value) => {
+    if (value <= 0) {
+      throw new Error('Value must be positive');
+    }
+  },
+);
+
+/**
+ * PositiveFloat scalar - validates positive floats
+ * Type name: PositiveFloat_Float
+ */
+export const PositiveFloatScalar = createValidatedScalar(
+  'PositiveFloat',
+  'A positive float',
+  GraphQLFloat,
+  (value) => {
+    if (value <= 0) {
+      throw new Error('Value must be positive');
+    }
+  },
+);
+
+/**
+ * Factory function to create a bounded string scalar
+ * @param {string} name - Name for the scalar
+ * @param {number} min - Minimum length
+ * @param {number} max - Maximum length
+ * @returns {GraphQLScalarType} A scalar type with length validation
+ */
+export const createBoundedStringScalar = (name, min, max) => {
+  return createValidatedScalar(
+    name,
+    `A string with length between ${min} and ${max} characters`,
+    GraphQLString,
+    (value) => {
+      if (typeof value !== 'string') {
+        throw new Error('Value must be a string');
+      }
+      if (min !== undefined && value.length < min) {
+        throw new Error(`String must be at least ${min} characters`);
+      }
+      if (max !== undefined && value.length > max) {
+        throw new Error(`String must be at most ${max} characters`);
+      }
+    },
+  );
+};
+
+/**
+ * Factory function to create a bounded integer scalar
+ * @param {string} name - Name for the scalar
+ * @param {number} min - Minimum value
+ * @param {number} max - Maximum value
+ * @returns {GraphQLScalarType} A scalar type with range validation
+ */
+export const createBoundedIntScalar = (name, min, max) => {
+  return createValidatedScalar(
+    name,
+    `An integer between ${min} and ${max}`,
+    GraphQLInt,
+    (value) => {
+      if (typeof value !== 'number' || isNaN(value)) {
+        throw new Error('Value must be a number');
+      }
+      if (min !== undefined && value < min) {
+        throw new Error(`Value must be at least ${min}`);
+      }
+      if (max !== undefined && value > max) {
+        throw new Error(`Value must be at most ${max}`);
+      }
+    },
+  );
+};
+
+/**
+ * Factory function to create a bounded float scalar
+ * @param {string} name - Name for the scalar
+ * @param {number} min - Minimum value
+ * @param {number} max - Maximum value
+ * @returns {GraphQLScalarType} A scalar type with range validation
+ */
+export const createBoundedFloatScalar = (name, min, max) => {
+  return createValidatedScalar(
+    name,
+    `A float between ${min} and ${max}`,
+    GraphQLFloat,
+    (value) => {
+      if (typeof value !== 'number' || isNaN(value)) {
+        throw new Error('Value must be a number');
+      }
+      if (min !== undefined && value < min) {
+        throw new Error(`Value must be at least ${min}`);
+      }
+      if (max !== undefined && value > max) {
+        throw new Error(`Value must be at most ${max}`);
+      }
+    },
+  );
+};
+
+/**
+ * Factory function to create a regex pattern string scalar
+ * @param {string} name - Name for the scalar
+ * @param {RegExp|string} pattern - Regex pattern to validate against
+ * @param {string} message - Error message if validation fails
+ * @returns {GraphQLScalarType} A scalar type with pattern validation
+ */
+export const createPatternStringScalar = (name, pattern, message) => {
+  const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+  const errorMessage = message || 'Value does not match required pattern';
+
+  return createValidatedScalar(
+    name,
+    `A string matching the pattern: ${pattern}`,
+    GraphQLString,
+    (value) => {
+      if (typeof value !== 'string') {
+        throw new Error('Value must be a string');
+      }
+      if (!regex.test(value)) {
+        throw new Error(errorMessage);
+      }
+    },
+  );
+};
+
+// Export all scalars as an object for convenience
+const scalars = {
+  // Pre-built scalars
+  EmailScalar,
+  URLScalar,
+  PositiveIntScalar,
+  PositiveFloatScalar,
+  // Factory functions
+  createBoundedStringScalar,
+  createBoundedIntScalar,
+  createBoundedFloatScalar,
+  createPatternStringScalar,
+};
+
+export default scalars;
+

package/.claude/worktrees/agitated-kepler/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;
+