@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/GraphQL/transformers/query.js

@@ -0,0 +1,237 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformQueryInputToParse = exports.transformQueryConstraintInputToParse = void 0;
+var _graphqlRelay = require("graphql-relay");
+const parseQueryMap = {
+  OR: '$or',
+  AND: '$and',
+  NOR: '$nor'
+};
+const parseConstraintMap = {
+  equalTo: '$eq',
+  notEqualTo: '$ne',
+  lessThan: '$lt',
+  lessThanOrEqualTo: '$lte',
+  greaterThan: '$gt',
+  greaterThanOrEqualTo: '$gte',
+  in: '$in',
+  notIn: '$nin',
+  exists: '$exists',
+  inQueryKey: '$select',
+  notInQueryKey: '$dontSelect',
+  inQuery: '$inQuery',
+  notInQuery: '$notInQuery',
+  containedBy: '$containedBy',
+  contains: '$all',
+  matchesRegex: '$regex',
+  options: '$options',
+  text: '$text',
+  search: '$search',
+  term: '$term',
+  language: '$language',
+  caseSensitive: '$caseSensitive',
+  diacriticSensitive: '$diacriticSensitive',
+  nearSphere: '$nearSphere',
+  maxDistance: '$maxDistance',
+  maxDistanceInRadians: '$maxDistanceInRadians',
+  maxDistanceInMiles: '$maxDistanceInMiles',
+  maxDistanceInKilometers: '$maxDistanceInKilometers',
+  within: '$within',
+  box: '$box',
+  geoWithin: '$geoWithin',
+  polygon: '$polygon',
+  centerSphere: '$centerSphere',
+  geoIntersects: '$geoIntersects',
+  point: '$point'
+};
+const transformQueryConstraintInputToParse = (constraints, parentFieldName, className, parentConstraints, parseClasses) => {
+  const fields = parseClasses[className].fields;
+  if (parentFieldName === 'id' && className) {
+    Object.keys(constraints).forEach(constraintName => {
+      const constraintValue = constraints[constraintName];
+      if (typeof constraintValue === 'string') {
+        const globalIdObject = (0, _graphqlRelay.fromGlobalId)(constraintValue);
+        if (globalIdObject.type === className) {
+          constraints[constraintName] = globalIdObject.id;
+        }
+      } else if (Array.isArray(constraintValue)) {
+        constraints[constraintName] = constraintValue.map(value => {
+          const globalIdObject = (0, _graphqlRelay.fromGlobalId)(value);
+          if (globalIdObject.type === className) {
+            return globalIdObject.id;
+          }
+          return value;
+        });
+      }
+    });
+    parentConstraints.objectId = constraints;
+    delete parentConstraints.id;
+  }
+  Object.keys(constraints).forEach(fieldName => {
+    let fieldValue = constraints[fieldName];
+    if (parseConstraintMap[fieldName]) {
+      constraints[parseConstraintMap[fieldName]] = constraints[fieldName];
+      delete constraints[fieldName];
+    }
+    /**
+     * If we have a key-value pair, we need to change the way the constraint is structured.
+     *
+     * Example:
+     *   From:
+     *   {
+     *     "someField": {
+     *       "lessThan": {
+     *         "key":"foo.bar",
+     *         "value": 100
+     *       },
+     *       "greaterThan": {
+     *         "key":"foo.bar",
+     *         "value": 10
+     *       }
+     *     }
+     *   }
+     *
+     *   To:
+     *   {
+     *     "someField.foo.bar": {
+     *       "$lt": 100,
+     *       "$gt": 10
+     *      }
+     *   }
+     */
+    if (fieldValue.key && fieldValue.value !== undefined && parentConstraints && parentFieldName) {
+      delete parentConstraints[parentFieldName];
+      parentConstraints[`${parentFieldName}.${fieldValue.key}`] = {
+        ...parentConstraints[`${parentFieldName}.${fieldValue.key}`],
+        [parseConstraintMap[fieldName]]: fieldValue.value
+      };
+    } else if (fields[parentFieldName] && (fields[parentFieldName].type === 'Pointer' || fields[parentFieldName].type === 'Relation')) {
+      const {
+        targetClass
+      } = fields[parentFieldName];
+      if (fieldName === 'exists') {
+        if (fields[parentFieldName].type === 'Relation') {
+          const whereTarget = fieldValue ? 'where' : 'notWhere';
+          if (constraints[whereTarget]) {
+            if (constraints[whereTarget].objectId) {
+              constraints[whereTarget].objectId = {
+                ...constraints[whereTarget].objectId,
+                $exists: fieldValue
+              };
+            } else {
+              constraints[whereTarget].objectId = {
+                $exists: fieldValue
+              };
+            }
+          } else {
+            const parseWhereTarget = fieldValue ? '$inQuery' : '$notInQuery';
+            parentConstraints[parentFieldName][parseWhereTarget] = {
+              where: {
+                objectId: {
+                  $exists: true
+                }
+              },
+              className: targetClass
+            };
+          }
+          delete constraints.$exists;
+        } else {
+          parentConstraints[parentFieldName].$exists = fieldValue;
+        }
+        return;
+      }
+      switch (fieldName) {
+        case 'have':
+          parentConstraints[parentFieldName].$inQuery = {
+            where: fieldValue,
+            className: targetClass
+          };
+          transformQueryInputToParse(parentConstraints[parentFieldName].$inQuery.where, targetClass, parseClasses);
+          break;
+        case 'haveNot':
+          parentConstraints[parentFieldName].$notInQuery = {
+            where: fieldValue,
+            className: targetClass
+          };
+          transformQueryInputToParse(parentConstraints[parentFieldName].$notInQuery.where, targetClass, parseClasses);
+          break;
+      }
+      delete constraints[fieldName];
+      return;
+    }
+    switch (fieldName) {
+      case 'point':
+        if (typeof fieldValue === 'object' && !fieldValue.__type) {
+          fieldValue.__type = 'GeoPoint';
+        }
+        break;
+      case 'nearSphere':
+        if (typeof fieldValue === 'object' && !fieldValue.__type) {
+          fieldValue.__type = 'GeoPoint';
+        }
+        break;
+      case 'box':
+        if (typeof fieldValue === 'object' && fieldValue.bottomLeft && fieldValue.upperRight) {
+          fieldValue = [{
+            __type: 'GeoPoint',
+            ...fieldValue.bottomLeft
+          }, {
+            __type: 'GeoPoint',
+            ...fieldValue.upperRight
+          }];
+          constraints[parseConstraintMap[fieldName]] = fieldValue;
+        }
+        break;
+      case 'polygon':
+        if (Array.isArray(fieldValue)) {
+          fieldValue.forEach(geoPoint => {
+            if (typeof geoPoint === 'object' && !geoPoint.__type) {
+              geoPoint.__type = 'GeoPoint';
+            }
+          });
+        }
+        break;
+      case 'centerSphere':
+        if (typeof fieldValue === 'object' && fieldValue.center && fieldValue.distance) {
+          fieldValue = [{
+            __type: 'GeoPoint',
+            ...fieldValue.center
+          }, fieldValue.distance];
+          constraints[parseConstraintMap[fieldName]] = fieldValue;
+        }
+        break;
+    }
+    if (typeof fieldValue === 'object') {
+      if (fieldName === 'where') {
+        transformQueryInputToParse(fieldValue, className, parseClasses);
+      } else {
+        transformQueryConstraintInputToParse(fieldValue, fieldName, className, constraints, parseClasses);
+      }
+    }
+  });
+};
+exports.transformQueryConstraintInputToParse = transformQueryConstraintInputToParse;
+const transformQueryInputToParse = (constraints, className, parseClasses) => {
+  if (!constraints || typeof constraints !== 'object') {
+    return;
+  }
+  Object.keys(constraints).forEach(fieldName => {
+    const fieldValue = constraints[fieldName];
+    if (parseQueryMap[fieldName]) {
+      delete constraints[fieldName];
+      fieldName = parseQueryMap[fieldName];
+      constraints[fieldName] = fieldValue;
+      fieldValue.forEach(fieldValueItem => {
+        transformQueryInputToParse(fieldValueItem, className, parseClasses);
+      });
+      return;
+    } else {
+      transformQueryConstraintInputToParse(fieldValue, fieldName, className, constraints, parseClasses);
+    }
+  });
+};
+exports.transformQueryInputToParse = transformQueryInputToParse;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_graphqlRelay","require","parseQueryMap","OR","AND","NOR","parseConstraintMap","equalTo","notEqualTo","lessThan","lessThanOrEqualTo","greaterThan","greaterThanOrEqualTo","in","notIn","exists","inQueryKey","notInQueryKey","inQuery","notInQuery","containedBy","contains","matchesRegex","options","text","search","term","language","caseSensitive","diacriticSensitive","nearSphere","maxDistance","maxDistanceInRadians","maxDistanceInMiles","maxDistanceInKilometers","within","box","geoWithin","polygon","centerSphere","geoIntersects","point","transformQueryConstraintInputToParse","constraints","parentFieldName","className","parentConstraints","parseClasses","fields","Object","keys","forEach","constraintName","constraintValue","globalIdObject","fromGlobalId","type","id","Array","isArray","map","value","objectId","fieldName","fieldValue","key","undefined","targetClass","whereTarget","$exists","parseWhereTarget","where","$inQuery","transformQueryInputToParse","$notInQuery","__type","bottomLeft","upperRight","geoPoint","center","distance","exports","fieldValueItem"],"sources":["../../../src/GraphQL/transformers/query.js"],"sourcesContent":["import { fromGlobalId } from 'graphql-relay';\n\nconst parseQueryMap = {\n  OR: '$or',\n  AND: '$and',\n  NOR: '$nor',\n};\n\nconst parseConstraintMap = {\n  equalTo: '$eq',\n  notEqualTo: '$ne',\n  lessThan: '$lt',\n  lessThanOrEqualTo: '$lte',\n  greaterThan: '$gt',\n  greaterThanOrEqualTo: '$gte',\n  in: '$in',\n  notIn: '$nin',\n  exists: '$exists',\n  inQueryKey: '$select',\n  notInQueryKey: '$dontSelect',\n  inQuery: '$inQuery',\n  notInQuery: '$notInQuery',\n  containedBy: '$containedBy',\n  contains: '$all',\n  matchesRegex: '$regex',\n  options: '$options',\n  text: '$text',\n  search: '$search',\n  term: '$term',\n  language: '$language',\n  caseSensitive: '$caseSensitive',\n  diacriticSensitive: '$diacriticSensitive',\n  nearSphere: '$nearSphere',\n  maxDistance: '$maxDistance',\n  maxDistanceInRadians: '$maxDistanceInRadians',\n  maxDistanceInMiles: '$maxDistanceInMiles',\n  maxDistanceInKilometers: '$maxDistanceInKilometers',\n  within: '$within',\n  box: '$box',\n  geoWithin: '$geoWithin',\n  polygon: '$polygon',\n  centerSphere: '$centerSphere',\n  geoIntersects: '$geoIntersects',\n  point: '$point',\n};\n\nconst transformQueryConstraintInputToParse = (\n  constraints,\n  parentFieldName,\n  className,\n  parentConstraints,\n  parseClasses\n) => {\n  const fields = parseClasses[className].fields;\n  if (parentFieldName === 'id' && className) {\n    Object.keys(constraints).forEach(constraintName => {\n      const constraintValue = constraints[constraintName];\n      if (typeof constraintValue === 'string') {\n        const globalIdObject = fromGlobalId(constraintValue);\n\n        if (globalIdObject.type === className) {\n          constraints[constraintName] = globalIdObject.id;\n        }\n      } else if (Array.isArray(constraintValue)) {\n        constraints[constraintName] = constraintValue.map(value => {\n          const globalIdObject = fromGlobalId(value);\n\n          if (globalIdObject.type === className) {\n            return globalIdObject.id;\n          }\n\n          return value;\n        });\n      }\n    });\n    parentConstraints.objectId = constraints;\n    delete parentConstraints.id;\n  }\n  Object.keys(constraints).forEach(fieldName => {\n    let fieldValue = constraints[fieldName];\n    if (parseConstraintMap[fieldName]) {\n      constraints[parseConstraintMap[fieldName]] = constraints[fieldName];\n      delete constraints[fieldName];\n    }\n    /**\n     * If we have a key-value pair, we need to change the way the constraint is structured.\n     *\n     * Example:\n     *   From:\n     *   {\n     *     \"someField\": {\n     *       \"lessThan\": {\n     *         \"key\":\"foo.bar\",\n     *         \"value\": 100\n     *       },\n     *       \"greaterThan\": {\n     *         \"key\":\"foo.bar\",\n     *         \"value\": 10\n     *       }\n     *     }\n     *   }\n     *\n     *   To:\n     *   {\n     *     \"someField.foo.bar\": {\n     *       \"$lt\": 100,\n     *       \"$gt\": 10\n     *      }\n     *   }\n     */\n    if (fieldValue.key && fieldValue.value !== undefined && parentConstraints && parentFieldName) {\n      delete parentConstraints[parentFieldName];\n      parentConstraints[`${parentFieldName}.${fieldValue.key}`] = {\n        ...parentConstraints[`${parentFieldName}.${fieldValue.key}`],\n        [parseConstraintMap[fieldName]]: fieldValue.value,\n      };\n    } else if (\n      fields[parentFieldName] &&\n      (fields[parentFieldName].type === 'Pointer' || fields[parentFieldName].type === 'Relation')\n    ) {\n      const { targetClass } = fields[parentFieldName];\n      if (fieldName === 'exists') {\n        if (fields[parentFieldName].type === 'Relation') {\n          const whereTarget = fieldValue ? 'where' : 'notWhere';\n          if (constraints[whereTarget]) {\n            if (constraints[whereTarget].objectId) {\n              constraints[whereTarget].objectId = {\n                ...constraints[whereTarget].objectId,\n                $exists: fieldValue,\n              };\n            } else {\n              constraints[whereTarget].objectId = {\n                $exists: fieldValue,\n              };\n            }\n          } else {\n            const parseWhereTarget = fieldValue ? '$inQuery' : '$notInQuery';\n            parentConstraints[parentFieldName][parseWhereTarget] = {\n              where: { objectId: { $exists: true } },\n              className: targetClass,\n            };\n          }\n          delete constraints.$exists;\n        } else {\n          parentConstraints[parentFieldName].$exists = fieldValue;\n        }\n        return;\n      }\n      switch (fieldName) {\n        case 'have':\n          parentConstraints[parentFieldName].$inQuery = {\n            where: fieldValue,\n            className: targetClass,\n          };\n          transformQueryInputToParse(\n            parentConstraints[parentFieldName].$inQuery.where,\n            targetClass,\n            parseClasses\n          );\n          break;\n        case 'haveNot':\n          parentConstraints[parentFieldName].$notInQuery = {\n            where: fieldValue,\n            className: targetClass,\n          };\n          transformQueryInputToParse(\n            parentConstraints[parentFieldName].$notInQuery.where,\n            targetClass,\n            parseClasses\n          );\n          break;\n      }\n      delete constraints[fieldName];\n      return;\n    }\n    switch (fieldName) {\n      case 'point':\n        if (typeof fieldValue === 'object' && !fieldValue.__type) {\n          fieldValue.__type = 'GeoPoint';\n        }\n        break;\n      case 'nearSphere':\n        if (typeof fieldValue === 'object' && !fieldValue.__type) {\n          fieldValue.__type = 'GeoPoint';\n        }\n        break;\n      case 'box':\n        if (typeof fieldValue === 'object' && fieldValue.bottomLeft && fieldValue.upperRight) {\n          fieldValue = [\n            {\n              __type: 'GeoPoint',\n              ...fieldValue.bottomLeft,\n            },\n            {\n              __type: 'GeoPoint',\n              ...fieldValue.upperRight,\n            },\n          ];\n          constraints[parseConstraintMap[fieldName]] = fieldValue;\n        }\n        break;\n      case 'polygon':\n        if (Array.isArray(fieldValue)) {\n          fieldValue.forEach(geoPoint => {\n            if (typeof geoPoint === 'object' && !geoPoint.__type) {\n              geoPoint.__type = 'GeoPoint';\n            }\n          });\n        }\n        break;\n      case 'centerSphere':\n        if (typeof fieldValue === 'object' && fieldValue.center && fieldValue.distance) {\n          fieldValue = [\n            {\n              __type: 'GeoPoint',\n              ...fieldValue.center,\n            },\n            fieldValue.distance,\n          ];\n          constraints[parseConstraintMap[fieldName]] = fieldValue;\n        }\n        break;\n    }\n    if (typeof fieldValue === 'object') {\n      if (fieldName === 'where') {\n        transformQueryInputToParse(fieldValue, className, parseClasses);\n      } else {\n        transformQueryConstraintInputToParse(\n          fieldValue,\n          fieldName,\n          className,\n          constraints,\n          parseClasses\n        );\n      }\n    }\n  });\n};\n\nconst transformQueryInputToParse = (constraints, className, parseClasses) => {\n  if (!constraints || typeof constraints !== 'object') {\n    return;\n  }\n\n  Object.keys(constraints).forEach(fieldName => {\n    const fieldValue = constraints[fieldName];\n\n    if (parseQueryMap[fieldName]) {\n      delete constraints[fieldName];\n      fieldName = parseQueryMap[fieldName];\n      constraints[fieldName] = fieldValue;\n      fieldValue.forEach(fieldValueItem => {\n        transformQueryInputToParse(fieldValueItem, className, parseClasses);\n      });\n      return;\n    } else {\n      transformQueryConstraintInputToParse(\n        fieldValue,\n        fieldName,\n        className,\n        constraints,\n        parseClasses\n      );\n    }\n  });\n};\n\nexport { transformQueryConstraintInputToParse, transformQueryInputToParse };\n"],"mappings":"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","ignoreList":[]}

package/lib/GraphQL/transformers/schemaFields.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformToParse = exports.transformToGraphQL = void 0;
+var _node = _interopRequireDefault(require("parse/node"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const transformToParse = (graphQLSchemaFields, existingFields) => {
+  if (!graphQLSchemaFields) {
+    return {};
+  }
+  let parseSchemaFields = {};
+  const reducerGenerator = type => (parseSchemaFields, field) => {
+    if (type === 'Remove') {
+      if (existingFields[field.name]) {
+        return {
+          ...parseSchemaFields,
+          [field.name]: {
+            __op: 'Delete'
+          }
+        };
+      } else {
+        return parseSchemaFields;
+      }
+    }
+    if (graphQLSchemaFields.remove && graphQLSchemaFields.remove.find(removeField => removeField.name === field.name)) {
+      return parseSchemaFields;
+    }
+    if (parseSchemaFields[field.name] || existingFields && existingFields[field.name]) {
+      throw new _node.default.Error(_node.default.Error.INVALID_KEY_NAME, `Duplicated field name: ${field.name}`);
+    }
+    if (type === 'Relation' || type === 'Pointer') {
+      return {
+        ...parseSchemaFields,
+        [field.name]: {
+          type,
+          targetClass: field.targetClassName
+        }
+      };
+    }
+    return {
+      ...parseSchemaFields,
+      [field.name]: {
+        type
+      }
+    };
+  };
+  if (graphQLSchemaFields.addStrings) {
+    parseSchemaFields = graphQLSchemaFields.addStrings.reduce(reducerGenerator('String'), parseSchemaFields);
+  }
+  if (graphQLSchemaFields.addNumbers) {
+    parseSchemaFields = graphQLSchemaFields.addNumbers.reduce(reducerGenerator('Number'), parseSchemaFields);
+  }
+  if (graphQLSchemaFields.addBooleans) {
+    parseSchemaFields = graphQLSchemaFields.addBooleans.reduce(reducerGenerator('Boolean'), parseSchemaFields);
+  }
+  if (graphQLSchemaFields.addArrays) {
+    parseSchemaFields = graphQLSchemaFields.addArrays.reduce(reducerGenerator('Array'), parseSchemaFields);
+  }
+  if (graphQLSchemaFields.addObjects) {
+    parseSchemaFields = graphQLSchemaFields.addObjects.reduce(reducerGenerator('Object'), parseSchemaFields);
+  }
+  if (graphQLSchemaFields.addDates) {
+    parseSchemaFields = graphQLSchemaFields.addDates.reduce(reducerGenerator('Date'), parseSchemaFields);
+  }
+  if (graphQLSchemaFields.addFiles) {
+    parseSchemaFields = graphQLSchemaFields.addFiles.reduce(reducerGenerator('File'), parseSchemaFields);
+  }
+  if (graphQLSchemaFields.addGeoPoint) {
+    parseSchemaFields = [graphQLSchemaFields.addGeoPoint].reduce(reducerGenerator('GeoPoint'), parseSchemaFields);
+  }
+  if (graphQLSchemaFields.addPolygons) {
+    parseSchemaFields = graphQLSchemaFields.addPolygons.reduce(reducerGenerator('Polygon'), parseSchemaFields);
+  }
+  if (graphQLSchemaFields.addBytes) {
+    parseSchemaFields = graphQLSchemaFields.addBytes.reduce(reducerGenerator('Bytes'), parseSchemaFields);
+  }
+  if (graphQLSchemaFields.addPointers) {
+    parseSchemaFields = graphQLSchemaFields.addPointers.reduce(reducerGenerator('Pointer'), parseSchemaFields);
+  }
+  if (graphQLSchemaFields.addRelations) {
+    parseSchemaFields = graphQLSchemaFields.addRelations.reduce(reducerGenerator('Relation'), parseSchemaFields);
+  }
+  if (existingFields && graphQLSchemaFields.remove) {
+    parseSchemaFields = graphQLSchemaFields.remove.reduce(reducerGenerator('Remove'), parseSchemaFields);
+  }
+  return parseSchemaFields;
+};
+exports.transformToParse = transformToParse;
+const transformToGraphQL = parseSchemaFields => {
+  return Object.keys(parseSchemaFields).map(name => ({
+    name,
+    type: parseSchemaFields[name].type,
+    targetClassName: parseSchemaFields[name].targetClass
+  }));
+};
+exports.transformToGraphQL = transformToGraphQL;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","_interopRequireDefault","require","e","__esModule","default","transformToParse","graphQLSchemaFields","existingFields","parseSchemaFields","reducerGenerator","type","field","name","__op","remove","find","removeField","Parse","Error","INVALID_KEY_NAME","targetClass","targetClassName","addStrings","reduce","addNumbers","addBooleans","addArrays","addObjects","addDates","addFiles","addGeoPoint","addPolygons","addBytes","addPointers","addRelations","exports","transformToGraphQL","Object","keys","map"],"sources":["../../../src/GraphQL/transformers/schemaFields.js"],"sourcesContent":["import Parse from 'parse/node';\n\nconst transformToParse = (graphQLSchemaFields, existingFields) => {\n  if (!graphQLSchemaFields) {\n    return {};\n  }\n\n  let parseSchemaFields = {};\n\n  const reducerGenerator = type => (parseSchemaFields, field) => {\n    if (type === 'Remove') {\n      if (existingFields[field.name]) {\n        return {\n          ...parseSchemaFields,\n          [field.name]: {\n            __op: 'Delete',\n          },\n        };\n      } else {\n        return parseSchemaFields;\n      }\n    }\n    if (\n      graphQLSchemaFields.remove &&\n      graphQLSchemaFields.remove.find(removeField => removeField.name === field.name)\n    ) {\n      return parseSchemaFields;\n    }\n    if (parseSchemaFields[field.name] || (existingFields && existingFields[field.name])) {\n      throw new Parse.Error(Parse.Error.INVALID_KEY_NAME, `Duplicated field name: ${field.name}`);\n    }\n    if (type === 'Relation' || type === 'Pointer') {\n      return {\n        ...parseSchemaFields,\n        [field.name]: {\n          type,\n          targetClass: field.targetClassName,\n        },\n      };\n    }\n    return {\n      ...parseSchemaFields,\n      [field.name]: {\n        type,\n      },\n    };\n  };\n\n  if (graphQLSchemaFields.addStrings) {\n    parseSchemaFields = graphQLSchemaFields.addStrings.reduce(\n      reducerGenerator('String'),\n      parseSchemaFields\n    );\n  }\n  if (graphQLSchemaFields.addNumbers) {\n    parseSchemaFields = graphQLSchemaFields.addNumbers.reduce(\n      reducerGenerator('Number'),\n      parseSchemaFields\n    );\n  }\n  if (graphQLSchemaFields.addBooleans) {\n    parseSchemaFields = graphQLSchemaFields.addBooleans.reduce(\n      reducerGenerator('Boolean'),\n      parseSchemaFields\n    );\n  }\n  if (graphQLSchemaFields.addArrays) {\n    parseSchemaFields = graphQLSchemaFields.addArrays.reduce(\n      reducerGenerator('Array'),\n      parseSchemaFields\n    );\n  }\n  if (graphQLSchemaFields.addObjects) {\n    parseSchemaFields = graphQLSchemaFields.addObjects.reduce(\n      reducerGenerator('Object'),\n      parseSchemaFields\n    );\n  }\n  if (graphQLSchemaFields.addDates) {\n    parseSchemaFields = graphQLSchemaFields.addDates.reduce(\n      reducerGenerator('Date'),\n      parseSchemaFields\n    );\n  }\n  if (graphQLSchemaFields.addFiles) {\n    parseSchemaFields = graphQLSchemaFields.addFiles.reduce(\n      reducerGenerator('File'),\n      parseSchemaFields\n    );\n  }\n  if (graphQLSchemaFields.addGeoPoint) {\n    parseSchemaFields = [graphQLSchemaFields.addGeoPoint].reduce(\n      reducerGenerator('GeoPoint'),\n      parseSchemaFields\n    );\n  }\n  if (graphQLSchemaFields.addPolygons) {\n    parseSchemaFields = graphQLSchemaFields.addPolygons.reduce(\n      reducerGenerator('Polygon'),\n      parseSchemaFields\n    );\n  }\n  if (graphQLSchemaFields.addBytes) {\n    parseSchemaFields = graphQLSchemaFields.addBytes.reduce(\n      reducerGenerator('Bytes'),\n      parseSchemaFields\n    );\n  }\n  if (graphQLSchemaFields.addPointers) {\n    parseSchemaFields = graphQLSchemaFields.addPointers.reduce(\n      reducerGenerator('Pointer'),\n      parseSchemaFields\n    );\n  }\n  if (graphQLSchemaFields.addRelations) {\n    parseSchemaFields = graphQLSchemaFields.addRelations.reduce(\n      reducerGenerator('Relation'),\n      parseSchemaFields\n    );\n  }\n  if (existingFields && graphQLSchemaFields.remove) {\n    parseSchemaFields = graphQLSchemaFields.remove.reduce(\n      reducerGenerator('Remove'),\n      parseSchemaFields\n    );\n  }\n\n  return parseSchemaFields;\n};\n\nconst transformToGraphQL = parseSchemaFields => {\n  return Object.keys(parseSchemaFields).map(name => ({\n    name,\n    type: parseSchemaFields[name].type,\n    targetClassName: parseSchemaFields[name].targetClass,\n  }));\n};\n\nexport { transformToParse, transformToGraphQL };\n"],"mappings":"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","ignoreList":[]}

package/lib/InstallationDedup.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyDuplicateDeviceTokenMerge = applyDuplicateDeviceTokenMerge;
+exports.default = void 0;
+exports.removeConflictingDeviceToken = removeConflictingDeviceToken;
+var _node = _interopRequireDefault(require("parse/node"));
+var _logger = _interopRequireDefault(require("./logger"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const CLASS_NAME = '_Installation';
+function logResult(action, count, err) {
+  if (err && err.code === _node.default.Error.OBJECT_NOT_FOUND) {
+    _logger.default.verbose(`Installation dedup ${action} matched no rows; nothing to do.`);
+    return;
+  }
+  if (err && err.code === _node.default.Error.OPERATION_FORBIDDEN) {
+    _logger.default.warn(`Installation dedup ${action} skipped: caller has no permission to ${action} the conflicting row(s). The conflicting row remains.`);
+    return;
+  }
+  if (err) {
+    _logger.default.error(`Installation dedup ${action} failed: ${err.message || err}`);
+    return;
+  }
+  _logger.default.verbose(`Installation dedup ${action} applied to ${count == null ? 'matching' : count} conflicting row(s).`);
+}
+async function performAction({
+  database,
+  query,
+  action,
+  fieldToClear,
+  runOptions,
+  many,
+  validSchemaController
+}) {
+  if (action === 'delete') {
+    return database.destroy(CLASS_NAME, query, runOptions, validSchemaController);
+  }
+  if (action === 'update') {
+    return database.update(CLASS_NAME, query, {
+      [fieldToClear]: {
+        __op: 'Delete'
+      }
+    }, {
+      ...runOptions,
+      many
+    }, false, false, validSchemaController);
+  }
+  throw new Error(`Unknown installation dedup action: ${action}`);
+}
+
+/**
+ * Removes or updates `_Installation` rows that hold a `deviceToken` matching the query,
+ * allowing the caller to claim that `deviceToken` exclusively. Used when a new or updated
+ * install collides with one or more existing rows on `deviceToken`.
+ *
+ * @param {Object} options
+ * @param {DatabaseController} options.database
+ * @param {Object} options.query e.g. { deviceToken: 'X', installationId: { $ne: 'I' } }
+ * @param {'delete'|'update'} options.action
+ * @param {boolean} options.enforceAuth
+ * @param {Object} options.runOptions RestWrite.runOptions
+ * @param {SchemaController} options.validSchemaController
+ */
+async function removeConflictingDeviceToken({
+  database,
+  query,
+  action,
+  enforceAuth,
+  runOptions,
+  validSchemaController
+}) {
+  const opts = enforceAuth ? runOptions : {};
+  try {
+    await performAction({
+      database,
+      query,
+      action,
+      fieldToClear: 'deviceToken',
+      runOptions: opts,
+      many: true,
+      validSchemaController
+    });
+    logResult(action, null, null);
+  } catch (err) {
+    if (err && err.code === _node.default.Error.OBJECT_NOT_FOUND) {
+      logResult(action, 0, err);
+      return;
+    }
+    if (err && err.code === _node.default.Error.OPERATION_FORBIDDEN) {
+      logResult(action, null, err);
+      return;
+    }
+    logResult(action, null, err);
+    throw err;
+  }
+}
+
+/**
+ * Resolves a merge conflict between two `_Installation` rows that together represent the
+ * same install: one matched by `installationId`/`objectId` (`idMatch`), and another holding
+ * the same `deviceToken` but no `installationId` (`deviceTokenMatch`). The `mergePriority`
+ * determines which row survives; the loser receives the configured `action`. Returns the
+ * survivor's `objectId` so the save flow can target it.
+ *
+ * @param {Object} options
+ * @param {DatabaseController} options.database
+ * @param {{ objectId: string, installationId?: string, deviceToken?: string }} options.idMatch
+ * @param {{ objectId: string, deviceToken?: string }} options.deviceTokenMatch
+ * @param {'delete'|'update'} options.action
+ * @param {'deviceToken'|'installationId'} options.mergePriority
+ * @param {boolean} options.enforceAuth
+ * @param {Object} options.runOptions
+ * @param {SchemaController} options.validSchemaController
+ * @returns {Promise<string>} survivor's objectId
+ */
+async function applyDuplicateDeviceTokenMerge({
+  database,
+  idMatch,
+  deviceTokenMatch,
+  action,
+  mergePriority,
+  enforceAuth,
+  runOptions,
+  validSchemaController
+}) {
+  // Self-merge guard: when both matches resolve to the same row, there's
+  // nothing to clean up. Skip the action so we don't destroy/update the row
+  // we're about to return as the survivor.
+  if (idMatch.objectId === deviceTokenMatch.objectId) {
+    return idMatch.objectId;
+  }
+  const opts = enforceAuth ? runOptions : {};
+  let loser;
+  let survivorId;
+  let fieldToClear;
+  if (mergePriority === 'deviceToken') {
+    loser = idMatch;
+    survivorId = deviceTokenMatch.objectId;
+    fieldToClear = 'installationId';
+  } else if (mergePriority === 'installationId') {
+    loser = deviceTokenMatch;
+    survivorId = idMatch.objectId;
+    fieldToClear = 'deviceToken';
+  } else {
+    throw new Error(`Unknown installation dedup mergePriority: ${mergePriority}`);
+  }
+  try {
+    await performAction({
+      database,
+      query: {
+        objectId: loser.objectId
+      },
+      action,
+      fieldToClear,
+      runOptions: opts,
+      many: false,
+      validSchemaController
+    });
+    logResult(action, 1, null);
+  } catch (err) {
+    if (err && err.code === _node.default.Error.OBJECT_NOT_FOUND) {
+      logResult(action, 0, err);
+    } else if (err && err.code === _node.default.Error.OPERATION_FORBIDDEN) {
+      logResult(action, null, err);
+    } else {
+      logResult(action, null, err);
+      throw err;
+    }
+  }
+  return survivorId;
+}
+var _default = exports.default = {
+  removeConflictingDeviceToken,
+  applyDuplicateDeviceTokenMerge
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","_interopRequireDefault","require","_logger","e","__esModule","default","CLASS_NAME","logResult","action","count","err","code","Parse","Error","OBJECT_NOT_FOUND","logger","verbose","OPERATION_FORBIDDEN","warn","error","message","performAction","database","query","fieldToClear","runOptions","many","validSchemaController","destroy","update","__op","removeConflictingDeviceToken","enforceAuth","opts","applyDuplicateDeviceTokenMerge","idMatch","deviceTokenMatch","mergePriority","objectId","loser","survivorId","_default","exports"],"sources":["../src/InstallationDedup.js"],"sourcesContent":["import Parse from 'parse/node';\nimport logger from './logger';\n\nconst CLASS_NAME = '_Installation';\n\nfunction logResult(action, count, err) {\n  if (err && err.code === Parse.Error.OBJECT_NOT_FOUND) {\n    logger.verbose(`Installation dedup ${action} matched no rows; nothing to do.`);\n    return;\n  }\n  if (err && err.code === Parse.Error.OPERATION_FORBIDDEN) {\n    logger.warn(\n      `Installation dedup ${action} skipped: caller has no permission to ${action} the conflicting row(s). The conflicting row remains.`\n    );\n    return;\n  }\n  if (err) {\n    logger.error(`Installation dedup ${action} failed: ${err.message || err}`);\n    return;\n  }\n  logger.verbose(\n    `Installation dedup ${action} applied to ${count == null ? 'matching' : count} conflicting row(s).`\n  );\n}\n\nasync function performAction({\n  database,\n  query,\n  action,\n  fieldToClear,\n  runOptions,\n  many,\n  validSchemaController,\n}) {\n  if (action === 'delete') {\n    return database.destroy(CLASS_NAME, query, runOptions, validSchemaController);\n  }\n  if (action === 'update') {\n    return database.update(\n      CLASS_NAME,\n      query,\n      { [fieldToClear]: { __op: 'Delete' } },\n      { ...runOptions, many },\n      false,\n      false,\n      validSchemaController\n    );\n  }\n  throw new Error(`Unknown installation dedup action: ${action}`);\n}\n\n/**\n * Removes or updates `_Installation` rows that hold a `deviceToken` matching the query,\n * allowing the caller to claim that `deviceToken` exclusively. Used when a new or updated\n * install collides with one or more existing rows on `deviceToken`.\n *\n * @param {Object} options\n * @param {DatabaseController} options.database\n * @param {Object} options.query e.g. { deviceToken: 'X', installationId: { $ne: 'I' } }\n * @param {'delete'|'update'} options.action\n * @param {boolean} options.enforceAuth\n * @param {Object} options.runOptions RestWrite.runOptions\n * @param {SchemaController} options.validSchemaController\n */\nexport async function removeConflictingDeviceToken({\n  database,\n  query,\n  action,\n  enforceAuth,\n  runOptions,\n  validSchemaController,\n}) {\n  const opts = enforceAuth ? runOptions : {};\n  try {\n    await performAction({\n      database,\n      query,\n      action,\n      fieldToClear: 'deviceToken',\n      runOptions: opts,\n      many: true,\n      validSchemaController,\n    });\n    logResult(action, null, null);\n  } catch (err) {\n    if (err && err.code === Parse.Error.OBJECT_NOT_FOUND) {\n      logResult(action, 0, err);\n      return;\n    }\n    if (err && err.code === Parse.Error.OPERATION_FORBIDDEN) {\n      logResult(action, null, err);\n      return;\n    }\n    logResult(action, null, err);\n    throw err;\n  }\n}\n\n/**\n * Resolves a merge conflict between two `_Installation` rows that together represent the\n * same install: one matched by `installationId`/`objectId` (`idMatch`), and another holding\n * the same `deviceToken` but no `installationId` (`deviceTokenMatch`). The `mergePriority`\n * determines which row survives; the loser receives the configured `action`. Returns the\n * survivor's `objectId` so the save flow can target it.\n *\n * @param {Object} options\n * @param {DatabaseController} options.database\n * @param {{ objectId: string, installationId?: string, deviceToken?: string }} options.idMatch\n * @param {{ objectId: string, deviceToken?: string }} options.deviceTokenMatch\n * @param {'delete'|'update'} options.action\n * @param {'deviceToken'|'installationId'} options.mergePriority\n * @param {boolean} options.enforceAuth\n * @param {Object} options.runOptions\n * @param {SchemaController} options.validSchemaController\n * @returns {Promise<string>} survivor's objectId\n */\nexport async function applyDuplicateDeviceTokenMerge({\n  database,\n  idMatch,\n  deviceTokenMatch,\n  action,\n  mergePriority,\n  enforceAuth,\n  runOptions,\n  validSchemaController,\n}) {\n  // Self-merge guard: when both matches resolve to the same row, there's\n  // nothing to clean up. Skip the action so we don't destroy/update the row\n  // we're about to return as the survivor.\n  if (idMatch.objectId === deviceTokenMatch.objectId) {\n    return idMatch.objectId;\n  }\n  const opts = enforceAuth ? runOptions : {};\n  let loser;\n  let survivorId;\n  let fieldToClear;\n  if (mergePriority === 'deviceToken') {\n    loser = idMatch;\n    survivorId = deviceTokenMatch.objectId;\n    fieldToClear = 'installationId';\n  } else if (mergePriority === 'installationId') {\n    loser = deviceTokenMatch;\n    survivorId = idMatch.objectId;\n    fieldToClear = 'deviceToken';\n  } else {\n    throw new Error(`Unknown installation dedup mergePriority: ${mergePriority}`);\n  }\n\n  try {\n    await performAction({\n      database,\n      query: { objectId: loser.objectId },\n      action,\n      fieldToClear,\n      runOptions: opts,\n      many: false,\n      validSchemaController,\n    });\n    logResult(action, 1, null);\n  } catch (err) {\n    if (err && err.code === Parse.Error.OBJECT_NOT_FOUND) {\n      logResult(action, 0, err);\n    } else if (err && err.code === Parse.Error.OPERATION_FORBIDDEN) {\n      logResult(action, null, err);\n    } else {\n      logResult(action, null, err);\n      throw err;\n    }\n  }\n  return survivorId;\n}\n\nexport default {\n  removeConflictingDeviceToken,\n  applyDuplicateDeviceTokenMerge,\n};\n"],"mappings":"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","ignoreList":[]}

package/lib/KeyPromiseQueue.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KeyPromiseQueue = void 0;
+// KeyPromiseQueue is a simple promise queue
+// used to queue operations per key basis.
+// Once the tail promise in the key-queue fulfills,
+// the chain on that key will be cleared.
+class KeyPromiseQueue {
+  constructor() {
+    this.queue = {};
+  }
+  enqueue(key, operation) {
+    const tuple = this.beforeOp(key);
+    const toAwait = tuple[1];
+    const nextOperation = toAwait.then(operation);
+    const wrappedOperation = nextOperation.then(result => {
+      this.afterOp(key);
+      return result;
+    });
+    tuple[1] = wrappedOperation;
+    return wrappedOperation;
+  }
+  beforeOp(key) {
+    let tuple = this.queue[key];
+    if (!tuple) {
+      tuple = [0, Promise.resolve()];
+      this.queue[key] = tuple;
+    }
+    tuple[0]++;
+    return tuple;
+  }
+  afterOp(key) {
+    const tuple = this.queue[key];
+    if (!tuple) {
+      return;
+    }
+    tuple[0]--;
+    if (tuple[0] <= 0) {
+      delete this.queue[key];
+      return;
+    }
+  }
+}
+exports.KeyPromiseQueue = KeyPromiseQueue;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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