@simtlix/simfinity-js 2.1.0 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simtlix/simfinity-js",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "",
   "main": "src/index.js",
   "type": "module",

package/src/index.js

@@ -614,53 +614,53 @@ const executeRegisteredMutation = async (args, callback, session) => {
   }
 };
 
-const iterateonCollectionFields = async (materializedModel, gqltype, objectId, session) => {
+const iterateonCollectionFields = async (materializedModel, gqltype, objectId, session, context) => {
   for (const [collectionFieldKey, collectionField] of
     Object.entries(materializedModel.collectionFields)) {
     if (collectionField.added) {
        
       await executeItemFunction(gqltype, collectionFieldKey, objectId, session,
-        collectionField.added, operations.SAVE);
+        collectionField.added, operations.SAVE, context);
     }
     if (collectionField.updated) {
        
       await executeItemFunction(gqltype, collectionFieldKey, objectId, session,
-        collectionField.updated, operations.UPDATE);
+        collectionField.updated, operations.UPDATE, context);
     }
     if (collectionField.deleted) {
        
       await executeItemFunction(gqltype, collectionFieldKey, objectId, session,
-        collectionField.deleted, operations.DELETE);
+        collectionField.deleted, operations.DELETE, context);
     }
   }
 };
 
-const onDeleteObject = async (Model, gqltype, controller, args, session) => {
+const onDeleteObject = async (Model, gqltype, controller, args, session, context) => {
   const deletedObject = await Model.findById({ _id: args }).session(session).lean();
 
   if (controller && controller.onDelete) {
-    await controller.onDelete(deletedObject, session);
+    await controller.onDelete(deletedObject, session, context);
   }
 
   return Model.findByIdAndDelete({ _id: args }).session(session);
 };
 
-const onDeleteSubject = async (Model, controller, id, session) => {
+const onDeleteSubject = async (Model, controller, id, session, context) => {
   const currentObject = await Model.findById({ _id: id }).session(session).lean();
 
   if (controller && controller.onDelete) {
-    await controller.onDelete(currentObject, session);
+    await controller.onDelete(currentObject, session, context);
   }
 
   return Model.findByIdAndDelete({ _id: id }).session(session);
 };
 
-const onUpdateSubject = async (Model, gqltype, controller, args, session, linkToParent) => {
+const onUpdateSubject = async (Model, gqltype, controller, args, session, linkToParent, context) => {
   const materializedModel = await materializeModel(args, gqltype, linkToParent, 'UPDATE', session);
   const objectId = args.id;
 
   if (materializedModel.collectionFields) {
-    await iterateonCollectionFields(materializedModel, gqltype, objectId, session);
+    await iterateonCollectionFields(materializedModel, gqltype, objectId, session, context);
   }
 
   const currentObject = await Model.findById({ _id: objectId }).lean();
@@ -688,7 +688,7 @@ const onUpdateSubject = async (Model, gqltype, controller, args, session, linkTo
   });
 
   if (controller && controller.onUpdating) {
-    await controller.onUpdating(objectId, materializedModel.modelArgs, session);
+    await controller.onUpdating(objectId, materializedModel.modelArgs, session, context);
   }
 
   const result = Model.findByIdAndUpdate(
@@ -696,13 +696,13 @@ const onUpdateSubject = async (Model, gqltype, controller, args, session, linkTo
   ).session(session);
 
   if (controller && controller.onUpdated) {
-    await controller.onUpdated(result, session);
+    await controller.onUpdated(result, session, context);
   }
 
   return result;
 };
 
-const onStateChanged = async (Model, gqltype, controller, args, session, actionField) => {
+const onStateChanged = async (Model, gqltype, controller, args, session, actionField, context) => {
   const storedModel = await Model.findById(args.id);
   if (!storedModel) {
     throw new SimfinityError(`${gqltype.name} ${args.id} is not valid`, 'NOT_VALID_ID', 404);
@@ -713,7 +713,7 @@ const onStateChanged = async (Model, gqltype, controller, args, session, actionF
     }
 
     args.state = actionField.to.name;
-    let result = await onUpdateSubject(Model, gqltype, controller, args, session);
+    let result = await onUpdateSubject(Model, gqltype, controller, args, session, null, context);
     result = result.toObject();
     result.state = actionField.to.value;
     return result;
@@ -721,7 +721,7 @@ const onStateChanged = async (Model, gqltype, controller, args, session, actionF
   throw new SimfinityError(`Action is not allowed from state ${storedModel.state}`, 'BAD_REQUEST', 400);
 };
 
-const onSaveObject = async (Model, gqltype, controller, args, session, linkToParent) => {
+const onSaveObject = async (Model, gqltype, controller, args, session, linkToParent, context) => {
   const materializedModel = await materializeModel(args, gqltype, linkToParent, 'CREATE', session);
   if (typesDict.types[gqltype.name].stateMachine) {
     materializedModel.modelArgs.state = typesDict.types[gqltype.name]
@@ -732,17 +732,17 @@ const onSaveObject = async (Model, gqltype, controller, args, session, linkToPar
   newObject.$session(session);
 
   if (controller && controller.onSaving) {
-    await controller.onSaving(newObject, args, session);
+    await controller.onSaving(newObject, args, session, context);
   }
 
   if (materializedModel.collectionFields) {
-    await iterateonCollectionFields(materializedModel, gqltype, newObject._id, session);
+    await iterateonCollectionFields(materializedModel, gqltype, newObject._id, session, context);
   }
 
   let result = await newObject.save();
   result = result.toObject();
   if (controller && controller.onSaved) {
-    await controller.onSaved(result, args, session);
+    await controller.onSaved(result, args, session, context);
   }
   if (typesDict.types[gqltype.name].stateMachine) {
     result.state = typesDict.types[gqltype.name].stateMachine.initialState.value;
@@ -750,29 +750,29 @@ const onSaveObject = async (Model, gqltype, controller, args, session, linkToPar
   return result;
 };
 
-export const saveObject = async (typeName, args, session) => {
+export const saveObject = async (typeName, args, session, context) => {
   const type = typesDict.types[typeName];
-  return onSaveObject(type.model, type.gqltype, type.controller, args, session);
+  return onSaveObject(type.model, type.gqltype, type.controller, args, session, null, context);
 };
 
 const executeOperation = async (Model, gqltype, controller,
-  args, operation, actionField, session) => {
+  args, operation, actionField, session, context) => {
   const mySession = session || await mongoose.startSession();
   await mySession.startTransaction();
   try {
     let newObject = null;
     switch (operation) {
       case operations.SAVE:
-        newObject = await onSaveObject(Model, gqltype, controller, args, mySession);
+        newObject = await onSaveObject(Model, gqltype, controller, args, mySession, null, context);
         break;
       case operations.UPDATE:
-        newObject = await onUpdateSubject(Model, gqltype, controller, args, mySession);
+        newObject = await onUpdateSubject(Model, gqltype, controller, args, mySession, null, context);
         break;
       case operations.DELETE:
-        newObject = await onDeleteObject(Model, gqltype, controller, args, mySession);
+        newObject = await onDeleteObject(Model, gqltype, controller, args, mySession, context);
         break;
       case operations.STATE_CHANGED:
-        newObject = await onStateChanged(Model, gqltype, controller, args, mySession, actionField);
+        newObject = await onStateChanged(Model, gqltype, controller, args, mySession, actionField, context);
         break;
     }
     await mySession.commitTransaction();
@@ -781,7 +781,7 @@ const executeOperation = async (Model, gqltype, controller,
   } catch (error) {
     await mySession.abortTransaction();
     if (error.errorLabels && error.errorLabels.includes('TransientTransactionError')) {
-      return executeOperation(Model, gqltype, controller, args, operation, actionField, mySession);
+      return executeOperation(Model, gqltype, controller, args, operation, actionField, mySession, context);
     }
     mySession.endSession();
     throw error;
@@ -789,7 +789,7 @@ const executeOperation = async (Model, gqltype, controller,
 };
 
 const executeItemFunction = async (gqltype, collectionField, objectId, session,
-  collectionFieldsList, operationType) => {
+  collectionFieldsList, operationType, context) => {
   const argTypes = gqltype.getFields();
   const collectionGQLType = argTypes[collectionField].type.ofType;
   const { connectionField } = argTypes[collectionField].extensions.relation;
@@ -802,7 +802,7 @@ const executeItemFunction = async (gqltype, collectionField, objectId, session,
         await onSaveObject(typesDict.types[collectionGQLType.name].model, collectionGQLType,
           typesDict.types[collectionGQLType.name].controller, collectionItem, session, (item) => {
             item[connectionField] = objectId;
-          });
+          }, context);
       };
       break;
     case operations.UPDATE:
@@ -810,13 +810,13 @@ const executeItemFunction = async (gqltype, collectionField, objectId, session,
         await onUpdateSubject(typesDict.types[collectionGQLType.name].model, collectionGQLType,
           typesDict.types[collectionGQLType.name].controller, collectionItem, session, (item) => {
             item[connectionField] = objectId;
-          });
+          }, context);
       };
       break;
     case operations.DELETE:
       operationFunction = async (collectionItem) => {
         await onDeleteSubject(typesDict.types[collectionGQLType.name].model,
-          typesDict.types[collectionGQLType.name].controller, collectionItem, session);
+          typesDict.types[collectionGQLType.name].controller, collectionItem, session, context);
       };
   }
 
@@ -846,6 +846,31 @@ const excecuteMiddleware = (context) => {
   middleware();
 };
 
+const executeScope = async (params) => {
+  const { type, args, operation, context } = params;
+  
+  if (!type || !type.gqltype || !type.gqltype.extensions) {
+    return null;
+  }
+
+  const extensions = type.gqltype.extensions;
+  if (!extensions.scope || !extensions.scope[operation]) {
+    return null;
+  }
+
+  const scopeFunction = extensions.scope[operation];
+  if (typeof scopeFunction !== 'function') {
+    return null;
+  }
+
+  // Call the scope function with the same params as middleware
+  const result = await scopeFunction({ type, args, operation, context });
+  
+  // For get_by_id, the scope function returns additional filters to merge
+  // For find and aggregate, it modifies args in place
+  return result;
+};
+
 const buildMutation = (name, includedMutationTypes, includedCustomMutations) => {
   const rootQueryArgs = {};
   rootQueryArgs.name = name;
@@ -872,7 +897,7 @@ const buildMutation = (name, includedMutationTypes, includedCustomMutations) =>
 
             excecuteMiddleware(params);
             return executeOperation(type.model, type.gqltype, type.controller,
-              args.input, operations.SAVE);
+              args.input, operations.SAVE, null, null, context);
           },
         };
         rootQueryArgs.fields[`delete${type.simpleEntityEndpointName}`] = {
@@ -889,7 +914,7 @@ const buildMutation = (name, includedMutationTypes, includedCustomMutations) =>
 
             excecuteMiddleware(params);
             return executeOperation(type.model, type.gqltype, type.controller,
-              args.id, operations.DELETE);
+              args.id, operations.DELETE, null, null, context);
           },
         };
       }
@@ -914,7 +939,7 @@ const buildMutation = (name, includedMutationTypes, includedCustomMutations) =>
 
             excecuteMiddleware(params);
             return executeOperation(type.model, type.gqltype, type.controller,
-              args.input, operations.UPDATE);
+              args.input, operations.UPDATE, null, null, context);
           },
         };
         if (type.stateMachine) {
@@ -936,7 +961,7 @@ const buildMutation = (name, includedMutationTypes, includedCustomMutations) =>
 
                   excecuteMiddleware(params);
                   return executeOperation(type.model, type.gqltype, type.controller,
-                    args.input, operations.STATE_CHANGED, actionField);
+                    args.input, operations.STATE_CHANGED, actionField, null, context);
                 },
               };
             }
@@ -1829,7 +1854,44 @@ const buildRootQuery = (name, includedTypes) => {
               context,
             };
             excecuteMiddleware(params);
-            return await type.model.findById(args.id);
+            
+            // Check if scope is defined for get_by_id
+            const hasScope = type.gqltype.extensions && type.gqltype.extensions.scope && type.gqltype.extensions.scope.get_by_id;
+            
+            if (hasScope) {
+              // Build query args with id filter - scope function will modify this
+              const queryArgs = {
+                id: { operator: 'EQ', value: args.id },
+              };
+              
+              // Create temporary params with queryArgs for scope function
+              const scopeParams = {
+                type,
+                args: queryArgs,
+                operation: 'get_by_id',
+                context,
+              };
+              
+              // Execute scope which will modify queryArgs in place
+              await executeScope(scopeParams);
+              
+              // Build aggregation pipeline from the combined filters
+              const aggregateClauses = await buildQuery(queryArgs, type.gqltype);
+              
+              // Execute the query and get the first result
+              let result;
+              if (aggregateClauses.length === 0) {
+                result = await type.model.findOne({ _id: args.id });
+              } else {
+                const results = await type.model.aggregate(aggregateClauses);
+                result = results.length > 0 ? results[0] : null;
+              }
+              
+              return result;
+            } else {
+              // No scope defined, use the original findById
+              return await type.model.findById(args.id);
+            }
           },
         };
 
@@ -1848,6 +1910,7 @@ const buildRootQuery = (name, includedTypes) => {
               context,
             };
             excecuteMiddleware(params);
+            await executeScope(params);
             const aggregateClauses = await buildQuery(args, type.gqltype);
             if (args.pagination && args.pagination.count) {
               const aggregateClausesForCount = await buildQuery(args, type.gqltype, true);
@@ -1882,6 +1945,7 @@ const buildRootQuery = (name, includedTypes) => {
               context,
             };
             excecuteMiddleware(params);
+            await executeScope(params);
             const aggregateClauses = await buildAggregationQuery(args, type.gqltype, args.aggregation);
             const result = await type.model.aggregate(aggregateClauses);
             return result;
@@ -2075,6 +2139,9 @@ export const addNoEndpointType = (gqltype) => {
 
 export { createValidatedScalar };
 
+export { default as validators } from './validators.js';
+export { default as scalars } from './scalars.js';
+
 const createArgsForQuery = (argTypes) => {
     const argsObject = {};
 

package/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;
+