@simtlix/simfinity-js 2.6.1 → 2.6.4

package/README.md

@@ -352,6 +352,25 @@ query {
 }
 ```
 
+As an equivalent shorthand, you can pass the full dotted path in `field` and omit `path`:
+
+```graphql
+query {
+  books(
+    OR: [
+      { conditions: [{ field: "author.name", operator: LIKE, value: "Adams" }] }
+      { conditions: [{ field: "author.name", operator: LIKE, value: "Pratchett" }] }
+    ]
+  ) {
+    id
+    title
+    author { name }
+  }
+}
+```
+
+Both forms produce the same query. Multi-segment paths work too — e.g. `field: "author.country.code"` is equivalent to `field: "author", path: "country.code"`. Supplying both a dotted `field` and a separate `path` is rejected as ambiguous.
+
 #### Mixing Flat Filters with AND/OR
 
 You can freely combine the existing flat filter syntax with AND/OR groups. Flat filters and AND groups are all ANDed together at the top level:
@@ -439,7 +458,8 @@ query {
           AND: [
             { conditions: [{ field: "year", operator: GTE, value: 2022 }] }
             { conditions: [
-                { field: "episodes", path: "name", operator: LIKE, value: "Final" }
+                # Equivalent to: { field: "episodes", path: "name", ... }
+                { field: "episodes.name", operator: LIKE, value: "Final" }
             ] }
           ]
         }
@@ -462,8 +482,8 @@ This translates to: `number > 1 AND (year = 2020 OR (year >= 2022 AND episodes.n
 | `QLFilterGroup` | `AND: [QLFilterGroup]`, `OR: [QLFilterGroup]`, `conditions: [QLFilterCondition]` | Recursive logical group |
 | `QLFilterCondition` | `field: String!`, `operator: QLOperator`, `value: QLValue`, `path: String` | Individual filter condition |
 
-- `field` identifies the entity field by name (e.g., `"title"`, `"author"`)
-- `path` is required for object/relationship fields (e.g., `"name"`, `"country.name"`)
+- `field` identifies the entity field by name (e.g., `"title"`, `"author"`). For object/relationship fields you can also pass the full dotted path here as a shorthand (e.g., `"author.name"`, `"author.country.name"`)
+- `path` is required for object/relationship fields when `field` is just the top-level name (e.g., `"name"`, `"country.name"`). Omit `path` if you used the dotted-`field` shorthand. Supplying both is an error.
 - Multiple `conditions` in the same group are combined with AND
 - Maximum nesting depth: 5 levels
 

package/package.json

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

package/src/index.js

@@ -28,6 +28,7 @@ const GraphQLJSON = new GraphQLScalarType({
       case Kind.BOOLEAN:
         return ast.value;
       case Kind.INT:
+        return parseInt(ast.value, 10);
       case Kind.FLOAT:
         return parseFloat(ast.value);
       case Kind.OBJECT: {
@@ -300,6 +301,40 @@ const buildRelationLookup = ({
   unwind: { $unwind: { path: `$${alias}`, preserveNullAndEmptyArrays: true } },
 });
 
+const escapeRegex = (s) => String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+const PATH_SEGMENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+const assertValidFilterPath = (path) => {
+  if (typeof path !== 'string' || path.length === 0) {
+    throw new SimfinityError('Filter path must be a non-empty string', 'INVALID_FILTER_PATH', 400);
+  }
+  for (const segment of path.split('.')) {
+    if (!PATH_SEGMENT_RE.test(segment)) {
+      throw new SimfinityError(`Invalid filter path segment: "${segment}"`, 'INVALID_FILTER_PATH', 400);
+    }
+  }
+};
+
+const normalizeFilterCondition = (condition) => {
+  const { field } = condition;
+  if (typeof field !== 'string') return condition;
+  const dotIdx = field.indexOf('.');
+  if (dotIdx < 0) return condition;
+  if (condition.path != null && condition.path !== '') {
+    throw new SimfinityError(
+      'Filter condition cannot use both dotted field syntax and a separate path',
+      'AMBIGUOUS_FILTER_FIELD',
+      400,
+    );
+  }
+  return {
+    ...condition,
+    field: field.slice(0, dotIdx),
+    path: field.slice(dotIdx + 1),
+  };
+};
+
 const OP_TO_MONGO = {
   LT: (v) => ({ $lt: v }),
   GT: (v) => ({ $gt: v }),
@@ -307,7 +342,7 @@ const OP_TO_MONGO = {
   GTE: (v) => ({ $gte: v }),
   NE: (v) => ({ $ne: v }),
   BTW: (v) => ({ $gte: v[0], $lte: v[1] }),
-  LIKE: (v) => ({ $regex: `.*${v}.*` }),
+  LIKE: (v) => ({ $regex: `.*${escapeRegex(v)}.*` }),
 };
 
 const AGG_OP_TO_MONGO = {
@@ -379,7 +414,13 @@ function createValidatedScalar(name, description, baseScalarType, validate) {
 const createTypeWithExcludedField = (inputNamePrefix, originalType, fieldToExclude) => {
   const originalFields = originalType.getFields();
   const newFields = Object.fromEntries(
-    Object.entries(originalFields).filter(([fieldName]) => fieldName !== fieldToExclude),
+    Object.entries(originalFields)
+      .filter(([fieldName]) => fieldName !== fieldToExclude)
+      .map(([fieldName, field]) => [fieldName, {
+        type: field.type,
+        description: field.description,
+        defaultValue: field.defaultValue,
+      }]),
   );
 
   return new GraphQLInputObjectType({
@@ -446,9 +487,9 @@ const buildInputType = (gqltype) => {
 
     if (!fieldEntry.extensions || !fieldEntry.extensions.readOnly) {
       const hasStateMachine = !!typesDict.types[gqltype.name].stateMachine;
-      const doesEstateFieldExistButIsManagedByStateMachine = !!(fieldEntryName === 'state' && hasStateMachine);
+      const stateFieldManagedByStateMachine = !!(fieldEntryName === 'state' && hasStateMachine);
 
-      if (!doesEstateFieldExistButIsManagedByStateMachine) {
+      if (!stateFieldManagedByStateMachine) {
         if (fieldEntry.type instanceof GraphQLScalarType
           || fieldEntry.type instanceof GraphQLEnumType
           || isNonNullOfType(fieldEntry.type, GraphQLScalarType)
@@ -484,8 +525,8 @@ const buildInputType = (gqltype) => {
           if (fieldEntry.type.ofType === gqltype) {
             selfReferenceCollections[fieldEntryName] = fieldEntry;
           } else {
-            const listInputTypeForAdd = graphQLListInputType(typesDict, fieldEntry, fieldEntryName, gqltype.name + 'A', fieldEntry.extensions?.relation?.connectionField);
-            const listInputTypeForUpdate = graphQLListInputType(typesDictForUpdate, fieldEntry, fieldEntryName, gqltype.name +'U', fieldEntry.extensions?.relation?.connectionField);
+            const listInputTypeForAdd = graphQLListInputType(typesDict, fieldEntry, fieldEntryName, `${gqltype.name}A`, fieldEntry.extensions?.relation?.connectionField);
+            const listInputTypeForUpdate = graphQLListInputType(typesDictForUpdate, fieldEntry, fieldEntryName, `${gqltype.name}U`, fieldEntry.extensions?.relation?.connectionField);
             if (listInputTypeForAdd && listInputTypeForUpdate) {
               fieldArg.type = listInputTypeForAdd;
               fieldArgForUpdate.type = listInputTypeForUpdate;
@@ -557,29 +598,35 @@ const getInputType = (type) => typesDict.types[type.name].inputType;
 export { getInputType };
 
 const buildPendingInputTypes = (waitingForInputType) => {
-  const stillWaitingInputType = {};
-  let isThereAtLeastOneWaiting = false;
-
-  Object.entries(waitingForInputType).forEach(([key, value]) => {
-    const { gqltype } = value;
+  let pending = waitingForInputType;
+  let previousPendingCount = Object.keys(pending).length + 1;
+
+  while (Object.keys(pending).length > 0) {
+    const currentCount = Object.keys(pending).length;
+    if (currentCount >= previousPendingCount) {
+      const unresolved = Object.keys(pending).join(', ');
+      throw new SimfinityError(
+        `Could not build input types for: ${unresolved}. Check for circular or misconfigured relations.`,
+        'INPUT_TYPE_UNRESOLVED',
+        500,
+      );
+    }
+    previousPendingCount = currentCount;
 
-    if (!typesDict.types[gqltype.name].inputType) {
-      const buildInputTypeResult = buildInputType(gqltype);
+    const stillWaiting = {};
+    for (const [key, value] of Object.entries(pending)) {
+      const { gqltype } = value;
+      if (typesDict.types[gqltype.name].inputType) continue;
 
-      if (buildInputTypeResult && buildInputTypeResult.inputTypeBody
-        && buildInputTypeResult.inputTypeBodyForUpdate) {
-        typesDict.types[gqltype.name].inputType = buildInputTypeResult.inputTypeBody;
-        typesDictForUpdate.types[gqltype.name].inputType = buildInputTypeResult
-          .inputTypeBodyForUpdate;
+      const result = buildInputType(gqltype);
+      if (result && result.inputTypeBody && result.inputTypeBodyForUpdate) {
+        typesDict.types[gqltype.name].inputType = result.inputTypeBody;
+        typesDictForUpdate.types[gqltype.name].inputType = result.inputTypeBodyForUpdate;
       } else {
-        stillWaitingInputType[key] = value;
-        isThereAtLeastOneWaiting = true;
+        stillWaiting[key] = value;
       }
     }
-  });
-
-  if (isThereAtLeastOneWaiting) {
-    buildPendingInputTypes(stillWaitingInputType);
+    pending = stillWaiting;
   }
 };
 
@@ -622,9 +669,11 @@ const materializeModel = async (args, gqltype, linkToParent, operation, session)
               null, operation, session)).modelArgs;
           }
         } else {
-          modelArgs[fieldEntry.name] = new mongoose.Types
-            .ObjectId(args[fieldEntryName].id);
-          console.warn(`Configuration issue: Field ${fieldEntryName} does not define extensions.relation`);
+          throw new SimfinityError(
+            `Field ${gqltype.name}.${fieldEntryName} is an object type but does not define extensions.relation`,
+            'MISSING_RELATION_EXTENSION',
+            500,
+          );
         }
       } else if (fieldEntry.type instanceof GraphQLList) {
         const { ofType } = fieldEntry.type;
@@ -668,34 +717,38 @@ const materializeModel = async (args, gqltype, linkToParent, operation, session)
 const MAX_TRANSIENT_RETRIES = 5;
 
 const withTransaction = async (session, body) => {
+  const ownsSession = !session;
   const mySession = session || await mongoose.startSession();
-  for (let attempt = 0; attempt <= MAX_TRANSIENT_RETRIES; attempt++) {
-    await mySession.startTransaction();
-    try {
-      const result = await body(mySession);
-      await mySession.commitTransaction();
-      mySession.endSession();
-      return result;
-    } catch (error) {
-      await mySession.abortTransaction();
-      const isTransient = error.errorLabels?.includes('TransientTransactionError');
-      if (isTransient && attempt < MAX_TRANSIENT_RETRIES) {
-        continue;
+  try {
+    for (let attempt = 0; attempt <= MAX_TRANSIENT_RETRIES; attempt++) {
+      await mySession.startTransaction();
+      try {
+        const result = await body(mySession);
+        await mySession.commitTransaction();
+        return result;
+      } catch (error) {
+        await mySession.abortTransaction();
+        const isTransient = error.errorLabels?.includes('TransientTransactionError');
+        if (isTransient && attempt < MAX_TRANSIENT_RETRIES) {
+          continue;
+        }
+        throw error;
       }
+    }
+    throw new SimfinityError('Transaction exceeded retry limit', 'TRANSACTION_RETRY_EXCEEDED', 500);
+  } finally {
+    if (ownsSession) {
       mySession.endSession();
-      throw error;
     }
   }
-  mySession.endSession();
-  throw new SimfinityError('Transaction exceeded retry limit', 'TRANSACTION_RETRY_EXCEEDED', 500);
 };
 
-const executeRegisteredMutation = (args, callback, session) => withTransaction(
+const executeRegisteredMutation = (args, callback, context, session) => withTransaction(
   session,
-  (mySession) => callback(args, mySession),
+  (mySession) => callback(args, mySession, context),
 );
 
-const iterateonCollectionFields = async (materializedModel, gqltype, objectId, session, context) => {
+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,
@@ -741,7 +794,7 @@ const onUpdateSubject = async (Model, gqltype, controller, args, session, linkTo
 
   if (embeddedFieldNames.length > 0) {
     const projection = Object.fromEntries(embeddedFieldNames.map((name) => [name, 1]));
-    const currentObject = await Model.findById(objectId, projection).lean();
+    const currentObject = await Model.findById(objectId, projection).session(session).lean();
     if (currentObject) {
       for (const fieldEntryName of embeddedFieldNames) {
         const oldObjectData = currentObject[fieldEntryName];
@@ -775,7 +828,7 @@ const onUpdateSubject = async (Model, gqltype, controller, args, session, linkTo
   ).session(session);
 
   if (materializedModel.collectionFields) {
-    await iterateonCollectionFields(materializedModel, gqltype, objectId, session, context);
+    await iterateOnCollectionFields(materializedModel, gqltype, objectId, session, context);
   }
 
   if (controller && controller.onUpdated) {
@@ -786,7 +839,7 @@ const onUpdateSubject = async (Model, gqltype, controller, args, session, linkTo
 };
 
 const onStateChanged = async (Model, gqltype, controller, args, session, actionField, context) => {
-  const storedModel = await Model.findById(args.id);
+  const storedModel = await Model.findById(args.id).session(session);
   if (!storedModel) {
     throw new SimfinityError(`${gqltype.name} ${args.id} is not valid`, 'NOT_VALID_ID', 404);
   }
@@ -822,10 +875,9 @@ const onSaveObject = async (Model, gqltype, controller, args, session, linkToPar
   result = result.toObject();
 
   if (materializedModel.collectionFields) {
-    await iterateonCollectionFields(materializedModel, gqltype, newObject._id, session, context);
+    await iterateOnCollectionFields(materializedModel, gqltype, newObject._id, session, context);
   }
 
-  
   if (controller && controller.onSaved) {
     await controller.onSaved(result, args, session, context);
   }
@@ -898,27 +950,25 @@ const executeItemFunction = async (gqltype, collectionField, objectId, session,
 const shouldNotBeIncludedInSchema = (includedTypes,
   type) => includedTypes && !includedTypes.includes(type);
 
-const excecuteMiddleware = (context) => {
+const executeMiddleware = async (context) => {
   const buildNext = (middlewaresParam) => {
     if (!middlewaresParam) {
-      return () => {};
+      return async () => {};
     }
-    const next = () => {
+    return async () => {
       const middleware = middlewaresParam[0];
       if (middleware) {
-        middleware(context, buildNext(middlewaresParam.slice(1)));
+        await middleware(context, buildNext(middlewaresParam.slice(1)));
       }
     };
-    return next;
   };
 
-  const middleware = buildNext(middlewares);
-  middleware();
+  await buildNext(middlewares)();
 };
 
 const executeScope = async (params) => {
   const { type, args, operation, context } = params;
-  
+
   if (!type || !type.gqltype || !type.gqltype.extensions) {
     return null;
   }
@@ -960,7 +1010,7 @@ const buildMutation = (name, includedMutationTypes, includedCustomMutations) =>
               context,
             };
 
-            excecuteMiddleware(params);
+            await executeMiddleware(params);
             return executeOperation(type.model, type.gqltype, type.controller,
               args.input, operations.SAVE, null, null, context);
           },
@@ -977,7 +1027,7 @@ const buildMutation = (name, includedMutationTypes, includedCustomMutations) =>
               context,
             };
 
-            excecuteMiddleware(params);
+            await executeMiddleware(params);
             return executeOperation(type.model, type.gqltype, type.controller,
               args.id, operations.DELETE, null, null, context);
           },
@@ -1002,7 +1052,7 @@ const buildMutation = (name, includedMutationTypes, includedCustomMutations) =>
               context,
             };
 
-            excecuteMiddleware(params);
+            await executeMiddleware(params);
             return executeOperation(type.model, type.gqltype, type.controller,
               args.input, operations.UPDATE, null, null, context);
           },
@@ -1024,7 +1074,7 @@ const buildMutation = (name, includedMutationTypes, includedCustomMutations) =>
                     context,
                   };
 
-                  excecuteMiddleware(params);
+                  await executeMiddleware(params);
                   return executeOperation(type.model, type.gqltype, type.controller,
                     args.input, operations.STATE_CHANGED, actionField, null, context);
                 },
@@ -1051,8 +1101,8 @@ const buildMutation = (name, includedMutationTypes, includedCustomMutations) =>
             entry,
             context,
           };
-          excecuteMiddleware(params);
-          return executeRegisteredMutation(args.input, registeredMutation.callback);
+          await executeMiddleware(params);
+          return executeRegisteredMutation(args.input, registeredMutation.callback, context);
         },
       };
     }
@@ -1128,10 +1178,10 @@ const generateSchemaDefinition = (gqlType) => {
 
 const findObjectIdFields = (schemaDefinition, parentPath = '') => {
   const objectIdFields = [];
-  
+
   for (const [fieldName, fieldDefinition] of Object.entries(schemaDefinition)) {
     const currentPath = parentPath ? `${parentPath}.${fieldName}` : fieldName;
-    
+
     if (fieldDefinition === mongoose.Schema.Types.ObjectId) {
       objectIdFields.push(currentPath);
     } else if (typeof fieldDefinition === 'object' && fieldDefinition !== null) {
@@ -1147,7 +1197,7 @@ const findObjectIdFields = (schemaDefinition, parentPath = '') => {
       }
     }
   }
-  
+
   return objectIdFields;
 };
 
@@ -1172,7 +1222,12 @@ const generateModel = (gqlType, onModelCreated, { createCollection = true } = {}
   return model;
 };
 
-const coerceIdArray = (value) => value.map((element) => new mongoose.Types.ObjectId(element));
+const coerceIdArray = (value) => value.map((element) => {
+  if (element === null || element === undefined) {
+    throw new SimfinityError('ID value cannot be null in collection filter', 'INVALID_FILTER_VALUE', 400);
+  }
+  return new mongoose.Types.ObjectId(element);
+});
 
 const buildMatchesClause = (fieldname, operator, value) => {
   const isIdField = fieldname.endsWith('_id');
@@ -1181,11 +1236,12 @@ const buildMatchesClause = (fieldname, operator, value) => {
   if (op === 'EQ') {
     return { [fieldname]: isIdField ? new mongoose.Types.ObjectId(value) : value };
   }
-  if (op === 'IN') {
-    return { [fieldname]: { $in: value && isIdField ? coerceIdArray(value) : value } };
-  }
-  if (op === 'NIN') {
-    return { [fieldname]: { $nin: value && isIdField ? coerceIdArray(value) : value } };
+  if (op === 'IN' || op === 'NIN') {
+    if (!Array.isArray(value)) {
+      throw new SimfinityError(`${op} requires an array value for ${fieldname}`, 'INVALID_FILTER_VALUE', 400);
+    }
+    const coerced = isIdField ? coerceIdArray(value) : value;
+    return { [fieldname]: { [op === 'IN' ? '$in' : '$nin']: coerced } };
   }
   const builder = OP_TO_MONGO[op];
   return builder ? { [fieldname]: builder(value) } : {};
@@ -1223,9 +1279,14 @@ const buildAggregationsForSort = (filterField, qlField, fieldName) => {
     return aggregateClauses;
   }
 
+  if (!Array.isArray(filterField?.terms) || filterField.terms.length === 0) {
+    return aggregateClauses;
+  }
+
   const resolvedFieldType = unwrapNonNull(fieldType);
 
   filterField.terms.forEach((term) => {
+    assertValidFilterPath(term.path);
     if (qlField.extensions?.relation && !qlField.extensions.relation.embedded
       && !aggregateClauses[fieldName]) {
       aggregateClauses[fieldName] = topLevelRelationLookup(qlField, resolvedFieldType, fieldName);
@@ -1267,6 +1328,10 @@ const buildQueryTerms = async (filterField, qlField, fieldName) => {
   const matchesClauses = {};
   const fieldType = unwrapListAndNonNull(qlField.type);
 
+  if (filterField == null) {
+    return { aggregateClauses, matchesClauses };
+  }
+
   if (fieldType instanceof GraphQLScalarType
     || isNonNullOfType(fieldType, GraphQLScalarType)
     || fieldType instanceof GraphQLEnumType
@@ -1280,9 +1345,14 @@ const buildQueryTerms = async (filterField, qlField, fieldName) => {
     return { aggregateClauses, matchesClauses };
   }
 
+  if (!Array.isArray(filterField.terms) || filterField.terms.length === 0) {
+    return { aggregateClauses, matchesClauses };
+  }
+
   const resolvedFieldType = unwrapNonNull(fieldType);
 
   filterField.terms.forEach((term) => {
+    assertValidFilterPath(term.path);
     if (qlField.extensions?.relation && !qlField.extensions.relation.embedded
       && !aggregateClauses[fieldName]) {
       aggregateClauses[fieldName] = topLevelRelationLookup(qlField, resolvedFieldType, fieldName);
@@ -1346,7 +1416,8 @@ const buildFilterGroupMatch = async (filterGroup, gqltype, aggregateClauses, agg
   const fields = gqltype.getFields();
 
   if (filterGroup.conditions?.length > 0) {
-    for (const condition of filterGroup.conditions) {
+    for (const rawCondition of filterGroup.conditions) {
+      const condition = normalizeFilterCondition(rawCondition);
       const qlField = fields[condition.field];
       if (!qlField) {
         throw new SimfinityError(`Unknown filter field: ${condition.field}`, 'INVALID_FILTER_FIELD', 400);
@@ -1467,6 +1538,7 @@ const buildSortClause = (sortTerms, gqltype, aggregateClauses, aggregationsInclu
   const fields = gqltype.getFields();
 
   sortTerms.forEach((sort) => {
+    assertValidFilterPath(sort.field);
     let fixedSortField = sort.field;
     if (sort.field.indexOf('.') >= 0) {
       const sortParts = sort.field.split('.');
@@ -1506,19 +1578,19 @@ const buildQuery = async (input, gqltype, isCount) => {
     aggregateClauses.push(buildSortClause(input.sort.terms, gqltype, aggregateClauses, aggregationsIncluded));
   }
 
-  let limitClause = { $limit: 100 };
   let skipClause = { $skip: 0 };
+  let limitClause = { $limit: 100 };
   if (input.pagination?.page && input.pagination?.size) {
-    const skip = input.pagination.size * (input.pagination.page - 1);
-    limitClause = { $limit: input.pagination.size + skip };
-    skipClause = { $skip: skip };
+    skipClause = { $skip: input.pagination.size * (input.pagination.page - 1) };
+    limitClause = { $limit: input.pagination.size };
   }
-  aggregateClauses.push(limitClause, skipClause);
+  aggregateClauses.push(skipClause, limitClause);
 
   return aggregateClauses;
 };
 
 const buildFieldPath = (gqltype, fieldPath) => {
+  assertValidFilterPath(fieldPath);
   const pathParts = fieldPath.split('.');
   const lookupPairs = [];
   let currentPath = '';
@@ -1617,7 +1689,7 @@ const buildAggregationQuery = async (input, gqltype, aggregationExpression) => {
 
   if (input.pagination?.page && input.pagination?.size) {
     const skip = input.pagination.size * (input.pagination.page - 1);
-    aggregateClauses.push({ $limit: input.pagination.size + skip }, { $skip: skip });
+    aggregateClauses.push({ $skip: skip }, { $limit: input.pagination.size });
   }
 
   return aggregateClauses;
@@ -1643,7 +1715,7 @@ const buildRootQuery = (name, includedTypes) => {
             const params = {
               type, args, operation: 'get_by_id', context,
             };
-            excecuteMiddleware(params);
+            await executeMiddleware(params);
 
             const hasScope = type.gqltype.extensions?.scope?.get_by_id;
             if (!hasScope) {
@@ -1677,7 +1749,7 @@ const buildRootQuery = (name, includedTypes) => {
               operation: 'find',
               context,
             };
-            excecuteMiddleware(params);
+            await executeMiddleware(params);
             await executeScope(params);
             const aggregateClauses = await buildQuery(args, type.gqltype);
             const wantsCount = !!(args.pagination && args.pagination.count);
@@ -1712,7 +1784,7 @@ const buildRootQuery = (name, includedTypes) => {
               operation: 'aggregate',
               context,
             };
-            excecuteMiddleware(params);
+            await executeMiddleware(params);
             await executeScope(params);
             const aggregateClauses = await buildAggregationQuery(args, type.gqltype, args.aggregation);
             const result = await type.model.aggregate(aggregateClauses);

package/.claude/worktrees/agitated-kepler/.claude/settings.local.json

@@ -1,23 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm test:*)",
-      "Bash(/usr/local/bin/node ./node_modules/.bin/vitest run)",
-      "Bash(/opt/homebrew/bin/npx vitest:*)",
-      "Bash(PATH=\"/opt/homebrew/bin:$PATH\" npm test)",
-      "Bash(PATH=\"/opt/homebrew/bin:$PATH\" npm run lint)",
-      "Bash(PATH=\"/opt/homebrew/bin:$PATH\" npx eslint tests/and-or-filters.test.js src/index.js)",
-      "Bash(PATH=\"/opt/homebrew/bin:$PATH\" npx eslint tests/and-or-filters.test.js)",
-      "Bash(PATH=\"/opt/homebrew/bin:$PATH\" git status)",
-      "Bash(PATH=\"/opt/homebrew/bin:$PATH\" git diff --stat)",
-      "Bash(PATH=\"/opt/homebrew/bin:$PATH\" git log --oneline -5)",
-      "Bash(PATH=\"/opt/homebrew/bin:$PATH\" git diff README.md src/index.js)",
-      "Bash(PATH=\"/opt/homebrew/bin:$PATH\" git add src/index.js tests/and-or-filters.test.js README.md)",
-      "Bash(PATH=\"/opt/homebrew/bin:$PATH\" git checkout master)",
-      "Bash(git merge:*)",
-      "Bash(curl -s http://localhost:3000/graphql -H \"Content-Type: application/json\" -d '{\"\"\"\"query\"\"\"\":\"\"\"\"{ __schema { queryType { fields { name args { name type { name kind ofType { name } } } } } } }\"\"\"\"}')",
-      "Bash(curl -s http://localhost:3000/graphql -H \"Content-Type: application/json\" -d '{\"\"\"\"query\"\"\"\":\"\"\"\"{ barbershops\\(pagination: { page: 1, size: 3 }\\) { id name state averageRating reviewCount } }\"\"\"\"}')",
-      "Bash(PATH=\"/opt/homebrew/bin:$PATH\" node -p \"JSON.stringify\\(JSON.parse\\(require\\(''''fs''''\\).readFileSync\\(''''/dev/stdin'''',''''utf8''''\\)\\),null,2\\)\")"
-    ]
-  }
-}