@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/GraphQL/loaders/schemaDirectives.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.load = exports.definitions = void 0;
+var _utils = require("@graphql-tools/utils");
+var _FunctionsRouter = require("../../Routers/FunctionsRouter");
+const definitions = exports.definitions = `
+  directive @resolve(to: String) on FIELD_DEFINITION
+  directive @mock(with: Any!) on FIELD_DEFINITION
+`;
+const load = parseGraphQLSchema => {
+  parseGraphQLSchema.graphQLSchemaDirectivesDefinitions = definitions;
+  const resolveDirective = schema => (0, _utils.mapSchema)(schema, {
+    [_utils.MapperKind.OBJECT_FIELD]: fieldConfig => {
+      const directive = (0, _utils.getDirective)(schema, fieldConfig, 'resolve')?.[0];
+      if (directive) {
+        const {
+          to: targetCloudFunction
+        } = directive;
+        fieldConfig.resolve = async (_source, args, context, gqlInfo) => {
+          try {
+            const {
+              config,
+              auth,
+              info
+            } = context;
+            const functionName = targetCloudFunction || gqlInfo.fieldName;
+            return (await _FunctionsRouter.FunctionsRouter.handleCloudFunction({
+              params: {
+                functionName
+              },
+              config,
+              auth,
+              info,
+              body: args
+            })).response.result;
+          } catch (e) {
+            parseGraphQLSchema.handleError(e);
+          }
+        };
+      }
+      return fieldConfig;
+    }
+  });
+  const mockDirective = schema => (0, _utils.mapSchema)(schema, {
+    [_utils.MapperKind.OBJECT_FIELD]: fieldConfig => {
+      const directive = (0, _utils.getDirective)(schema, fieldConfig, 'mock')?.[0];
+      if (directive) {
+        const {
+          with: mockValue
+        } = directive;
+        fieldConfig.resolve = async () => mockValue;
+      }
+      return fieldConfig;
+    }
+  });
+  parseGraphQLSchema.graphQLSchemaDirectives = schema => mockDirective(resolveDirective(schema));
+};
+exports.load = load;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/GraphQL/loaders/schemaMutations.js

@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.load = void 0;
+var _node = _interopRequireDefault(require("parse/node"));
+var _graphql = require("graphql");
+var _graphqlRelay = require("graphql-relay");
+var schemaTypes = _interopRequireWildcard(require("./schemaTypes"));
+var _schemaFields = require("../transformers/schemaFields");
+var _parseGraphQLUtils = require("../parseGraphQLUtils");
+var _schemaQueries = require("./schemaQueries");
+var _Error = require("../../Error");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const load = parseGraphQLSchema => {
+  const createClassMutation = (0, _graphqlRelay.mutationWithClientMutationId)({
+    name: 'CreateClass',
+    description: 'The createClass mutation can be used to create the schema for a new object class.',
+    inputFields: {
+      name: schemaTypes.CLASS_NAME_ATT,
+      schemaFields: {
+        description: "These are the schema's fields of the object class.",
+        type: schemaTypes.SCHEMA_FIELDS_INPUT
+      }
+    },
+    outputFields: {
+      class: {
+        description: 'This is the created class.',
+        type: new _graphql.GraphQLNonNull(schemaTypes.CLASS)
+      }
+    },
+    mutateAndGetPayload: async (args, context) => {
+      try {
+        const {
+          name,
+          schemaFields
+        } = (0, _parseGraphQLUtils.cloneArgs)(args);
+        const {
+          config,
+          auth
+        } = context;
+        (0, _parseGraphQLUtils.enforceMasterKeyAccess)(auth, config);
+        if (auth.isReadOnly) {
+          throw (0, _Error.createSanitizedError)(_node.default.Error.OPERATION_FORBIDDEN, "read-only masterKey isn't allowed to create a schema.", config);
+        }
+        const schema = await config.database.loadSchema({
+          clearCache: true
+        });
+        const parseClass = await schema.addClassIfNotExists(name, (0, _schemaFields.transformToParse)(schemaFields));
+        return {
+          class: {
+            name: parseClass.className,
+            schemaFields: (0, _schemaFields.transformToGraphQL)(parseClass.fields)
+          }
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  });
+  parseGraphQLSchema.addGraphQLType(createClassMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(createClassMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('createClass', createClassMutation, true, true);
+  const updateClassMutation = (0, _graphqlRelay.mutationWithClientMutationId)({
+    name: 'UpdateClass',
+    description: 'The updateClass mutation can be used to update the schema for an existing object class.',
+    inputFields: {
+      name: schemaTypes.CLASS_NAME_ATT,
+      schemaFields: {
+        description: "These are the schema's fields of the object class.",
+        type: schemaTypes.SCHEMA_FIELDS_INPUT
+      }
+    },
+    outputFields: {
+      class: {
+        description: 'This is the updated class.',
+        type: new _graphql.GraphQLNonNull(schemaTypes.CLASS)
+      }
+    },
+    mutateAndGetPayload: async (args, context) => {
+      try {
+        const {
+          name,
+          schemaFields
+        } = (0, _parseGraphQLUtils.cloneArgs)(args);
+        const {
+          config,
+          auth
+        } = context;
+        (0, _parseGraphQLUtils.enforceMasterKeyAccess)(auth, config);
+        if (auth.isReadOnly) {
+          throw (0, _Error.createSanitizedError)(_node.default.Error.OPERATION_FORBIDDEN, "read-only masterKey isn't allowed to update a schema.", config);
+        }
+        const schema = await config.database.loadSchema({
+          clearCache: true
+        });
+        const existingParseClass = await (0, _schemaQueries.getClass)(name, schema);
+        const parseClass = await schema.updateClass(name, (0, _schemaFields.transformToParse)(schemaFields, existingParseClass.fields), undefined, undefined, config.database);
+        return {
+          class: {
+            name: parseClass.className,
+            schemaFields: (0, _schemaFields.transformToGraphQL)(parseClass.fields)
+          }
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  });
+  parseGraphQLSchema.addGraphQLType(updateClassMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(updateClassMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('updateClass', updateClassMutation, true, true);
+  const deleteClassMutation = (0, _graphqlRelay.mutationWithClientMutationId)({
+    name: 'DeleteClass',
+    description: 'The deleteClass mutation can be used to delete an existing object class.',
+    inputFields: {
+      name: schemaTypes.CLASS_NAME_ATT
+    },
+    outputFields: {
+      class: {
+        description: 'This is the deleted class.',
+        type: new _graphql.GraphQLNonNull(schemaTypes.CLASS)
+      }
+    },
+    mutateAndGetPayload: async (args, context) => {
+      try {
+        const {
+          name
+        } = (0, _parseGraphQLUtils.cloneArgs)(args);
+        const {
+          config,
+          auth
+        } = context;
+        (0, _parseGraphQLUtils.enforceMasterKeyAccess)(auth, config);
+        if (auth.isReadOnly) {
+          throw (0, _Error.createSanitizedError)(_node.default.Error.OPERATION_FORBIDDEN, "read-only masterKey isn't allowed to delete a schema.", config);
+        }
+        const schema = await config.database.loadSchema({
+          clearCache: true
+        });
+        const existingParseClass = await (0, _schemaQueries.getClass)(name, schema);
+        await config.database.deleteSchema(name);
+        return {
+          class: {
+            name: existingParseClass.className,
+            schemaFields: (0, _schemaFields.transformToGraphQL)(existingParseClass.fields)
+          }
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  });
+  parseGraphQLSchema.addGraphQLType(deleteClassMutation.args.input.type.ofType, true, true);
+  parseGraphQLSchema.addGraphQLType(deleteClassMutation.type, true, true);
+  parseGraphQLSchema.addGraphQLMutation('deleteClass', deleteClassMutation, true, true);
+};
+exports.load = load;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","_interopRequireDefault","require","_graphql","_graphqlRelay","schemaTypes","_interopRequireWildcard","_schemaFields","_parseGraphQLUtils","_schemaQueries","_Error","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","load","parseGraphQLSchema","createClassMutation","mutationWithClientMutationId","name","description","inputFields","CLASS_NAME_ATT","schemaFields","type","SCHEMA_FIELDS_INPUT","outputFields","class","GraphQLNonNull","CLASS","mutateAndGetPayload","args","context","cloneArgs","config","auth","enforceMasterKeyAccess","isReadOnly","createSanitizedError","Parse","Error","OPERATION_FORBIDDEN","schema","database","loadSchema","clearCache","parseClass","addClassIfNotExists","transformToParse","className","transformToGraphQL","fields","handleError","addGraphQLType","input","ofType","addGraphQLMutation","updateClassMutation","existingParseClass","getClass","updateClass","undefined","deleteClassMutation","deleteSchema","exports"],"sources":["../../../src/GraphQL/loaders/schemaMutations.js"],"sourcesContent":["import Parse from 'parse/node';\nimport { GraphQLNonNull } from 'graphql';\n\nimport { mutationWithClientMutationId } from 'graphql-relay';\nimport * as schemaTypes from './schemaTypes';\nimport { transformToParse, transformToGraphQL } from '../transformers/schemaFields';\nimport { enforceMasterKeyAccess, cloneArgs } from '../parseGraphQLUtils';\nimport { getClass } from './schemaQueries';\nimport { createSanitizedError } from '../../Error';\n\nconst load = parseGraphQLSchema => {\n  const createClassMutation = mutationWithClientMutationId({\n    name: 'CreateClass',\n    description:\n      'The createClass mutation can be used to create the schema for a new object class.',\n    inputFields: {\n      name: schemaTypes.CLASS_NAME_ATT,\n      schemaFields: {\n        description: \"These are the schema's fields of the object class.\",\n        type: schemaTypes.SCHEMA_FIELDS_INPUT,\n      },\n    },\n    outputFields: {\n      class: {\n        description: 'This is the created class.',\n        type: new GraphQLNonNull(schemaTypes.CLASS),\n      },\n    },\n    mutateAndGetPayload: async (args, context) => {\n      try {\n        const { name, schemaFields } = cloneArgs(args);\n        const { config, auth } = context;\n\n        enforceMasterKeyAccess(auth, config);\n\n        if (auth.isReadOnly) {\n          throw createSanitizedError(\n            Parse.Error.OPERATION_FORBIDDEN,\n            \"read-only masterKey isn't allowed to create a schema.\",\n            config\n          );\n        }\n\n        const schema = await config.database.loadSchema({ clearCache: true });\n        const parseClass = await schema.addClassIfNotExists(name, transformToParse(schemaFields));\n        return {\n          class: {\n            name: parseClass.className,\n            schemaFields: transformToGraphQL(parseClass.fields),\n          },\n        };\n      } catch (e) {\n        parseGraphQLSchema.handleError(e);\n      }\n    },\n  });\n\n  parseGraphQLSchema.addGraphQLType(createClassMutation.args.input.type.ofType, true, true);\n  parseGraphQLSchema.addGraphQLType(createClassMutation.type, true, true);\n  parseGraphQLSchema.addGraphQLMutation('createClass', createClassMutation, true, true);\n\n  const updateClassMutation = mutationWithClientMutationId({\n    name: 'UpdateClass',\n    description:\n      'The updateClass mutation can be used to update the schema for an existing object class.',\n    inputFields: {\n      name: schemaTypes.CLASS_NAME_ATT,\n      schemaFields: {\n        description: \"These are the schema's fields of the object class.\",\n        type: schemaTypes.SCHEMA_FIELDS_INPUT,\n      },\n    },\n    outputFields: {\n      class: {\n        description: 'This is the updated class.',\n        type: new GraphQLNonNull(schemaTypes.CLASS),\n      },\n    },\n    mutateAndGetPayload: async (args, context) => {\n      try {\n        const { name, schemaFields } = cloneArgs(args);\n        const { config, auth } = context;\n\n        enforceMasterKeyAccess(auth, config);\n\n        if (auth.isReadOnly) {\n          throw createSanitizedError(\n            Parse.Error.OPERATION_FORBIDDEN,\n            \"read-only masterKey isn't allowed to update a schema.\",\n            config\n          );\n        }\n\n        const schema = await config.database.loadSchema({ clearCache: true });\n        const existingParseClass = await getClass(name, schema);\n        const parseClass = await schema.updateClass(\n          name,\n          transformToParse(schemaFields, existingParseClass.fields),\n          undefined,\n          undefined,\n          config.database\n        );\n        return {\n          class: {\n            name: parseClass.className,\n            schemaFields: transformToGraphQL(parseClass.fields),\n          },\n        };\n      } catch (e) {\n        parseGraphQLSchema.handleError(e);\n      }\n    },\n  });\n\n  parseGraphQLSchema.addGraphQLType(updateClassMutation.args.input.type.ofType, true, true);\n  parseGraphQLSchema.addGraphQLType(updateClassMutation.type, true, true);\n  parseGraphQLSchema.addGraphQLMutation('updateClass', updateClassMutation, true, true);\n\n  const deleteClassMutation = mutationWithClientMutationId({\n    name: 'DeleteClass',\n    description: 'The deleteClass mutation can be used to delete an existing object class.',\n    inputFields: {\n      name: schemaTypes.CLASS_NAME_ATT,\n    },\n    outputFields: {\n      class: {\n        description: 'This is the deleted class.',\n        type: new GraphQLNonNull(schemaTypes.CLASS),\n      },\n    },\n    mutateAndGetPayload: async (args, context) => {\n      try {\n        const { name } = cloneArgs(args);\n        const { config, auth } = context;\n\n        enforceMasterKeyAccess(auth, config);\n\n        if (auth.isReadOnly) {\n          throw createSanitizedError(\n            Parse.Error.OPERATION_FORBIDDEN,\n            \"read-only masterKey isn't allowed to delete a schema.\",\n            config\n          );\n        }\n\n        const schema = await config.database.loadSchema({ clearCache: true });\n        const existingParseClass = await getClass(name, schema);\n        await config.database.deleteSchema(name);\n        return {\n          class: {\n            name: existingParseClass.className,\n            schemaFields: transformToGraphQL(existingParseClass.fields),\n          },\n        };\n      } catch (e) {\n        parseGraphQLSchema.handleError(e);\n      }\n    },\n  });\n\n  parseGraphQLSchema.addGraphQLType(deleteClassMutation.args.input.type.ofType, true, true);\n  parseGraphQLSchema.addGraphQLType(deleteClassMutation.type, true, true);\n  parseGraphQLSchema.addGraphQLMutation('deleteClass', deleteClassMutation, true, true);\n};\n\nexport { load };\n"],"mappings":"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","ignoreList":[]}

package/lib/GraphQL/loaders/schemaQueries.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.load = exports.getClass = void 0;
+var _node = _interopRequireDefault(require("parse/node"));
+var _graphql = require("graphql");
+var _schemaFields = require("../transformers/schemaFields");
+var schemaTypes = _interopRequireWildcard(require("./schemaTypes"));
+var _parseGraphQLUtils = require("../parseGraphQLUtils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const getClass = async (name, schema) => {
+  try {
+    return await schema.getOneSchema(name, true);
+  } catch (e) {
+    if (e === undefined) {
+      throw new _node.default.Error(_node.default.Error.INVALID_CLASS_NAME, `Class ${name} does not exist.`);
+    } else {
+      throw new _node.default.Error(_node.default.Error.INTERNAL_SERVER_ERROR, 'Database adapter error.');
+    }
+  }
+};
+exports.getClass = getClass;
+const load = parseGraphQLSchema => {
+  parseGraphQLSchema.addGraphQLQuery('class', {
+    description: 'The class query can be used to retrieve an existing object class.',
+    args: {
+      name: schemaTypes.CLASS_NAME_ATT
+    },
+    type: new _graphql.GraphQLNonNull(schemaTypes.CLASS),
+    resolve: async (_source, args, context) => {
+      try {
+        const {
+          name
+        } = (0, _parseGraphQLUtils.cloneArgs)(args);
+        const {
+          config,
+          auth
+        } = context;
+        (0, _parseGraphQLUtils.enforceMasterKeyAccess)(auth, config);
+        const schema = await config.database.loadSchema({
+          clearCache: true
+        });
+        const parseClass = await getClass(name, schema);
+        return {
+          name: parseClass.className,
+          schemaFields: (0, _schemaFields.transformToGraphQL)(parseClass.fields)
+        };
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  }, true, true);
+  parseGraphQLSchema.addGraphQLQuery('classes', {
+    description: 'The classes query can be used to retrieve the existing object classes.',
+    type: new _graphql.GraphQLNonNull(new _graphql.GraphQLList(new _graphql.GraphQLNonNull(schemaTypes.CLASS))),
+    resolve: async (_source, _args, context) => {
+      try {
+        const {
+          config,
+          auth
+        } = context;
+        (0, _parseGraphQLUtils.enforceMasterKeyAccess)(auth, config);
+        const schema = await config.database.loadSchema({
+          clearCache: true
+        });
+        return (await schema.getAllClasses(true)).map(parseClass => ({
+          name: parseClass.className,
+          schemaFields: (0, _schemaFields.transformToGraphQL)(parseClass.fields)
+        }));
+      } catch (e) {
+        parseGraphQLSchema.handleError(e);
+      }
+    }
+  }, true, true);
+};
+exports.load = load;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","_interopRequireDefault","require","_graphql","_schemaFields","schemaTypes","_interopRequireWildcard","_parseGraphQLUtils","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","getClass","name","schema","getOneSchema","undefined","Parse","Error","INVALID_CLASS_NAME","INTERNAL_SERVER_ERROR","exports","load","parseGraphQLSchema","addGraphQLQuery","description","args","CLASS_NAME_ATT","type","GraphQLNonNull","CLASS","resolve","_source","context","cloneArgs","config","auth","enforceMasterKeyAccess","database","loadSchema","clearCache","parseClass","className","schemaFields","transformToGraphQL","fields","handleError","GraphQLList","_args","getAllClasses","map"],"sources":["../../../src/GraphQL/loaders/schemaQueries.js"],"sourcesContent":["import Parse from 'parse/node';\n\nimport { GraphQLNonNull, GraphQLList } from 'graphql';\nimport { transformToGraphQL } from '../transformers/schemaFields';\nimport * as schemaTypes from './schemaTypes';\nimport { enforceMasterKeyAccess, cloneArgs } from '../parseGraphQLUtils';\n\nconst getClass = async (name, schema) => {\n  try {\n    return await schema.getOneSchema(name, true);\n  } catch (e) {\n    if (e === undefined) {\n      throw new Parse.Error(Parse.Error.INVALID_CLASS_NAME, `Class ${name} does not exist.`);\n    } else {\n      throw new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'Database adapter error.');\n    }\n  }\n};\n\nconst load = parseGraphQLSchema => {\n  parseGraphQLSchema.addGraphQLQuery(\n    'class',\n    {\n      description: 'The class query can be used to retrieve an existing object class.',\n      args: {\n        name: schemaTypes.CLASS_NAME_ATT,\n      },\n      type: new GraphQLNonNull(schemaTypes.CLASS),\n      resolve: async (_source, args, context) => {\n        try {\n          const { name } = cloneArgs(args);\n          const { config, auth } = context;\n\n          enforceMasterKeyAccess(auth, config);\n\n          const schema = await config.database.loadSchema({ clearCache: true });\n          const parseClass = await getClass(name, schema);\n          return {\n            name: parseClass.className,\n            schemaFields: transformToGraphQL(parseClass.fields),\n          };\n        } catch (e) {\n          parseGraphQLSchema.handleError(e);\n        }\n      },\n    },\n    true,\n    true\n  );\n\n  parseGraphQLSchema.addGraphQLQuery(\n    'classes',\n    {\n      description: 'The classes query can be used to retrieve the existing object classes.',\n      type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(schemaTypes.CLASS))),\n      resolve: async (_source, _args, context) => {\n        try {\n          const { config, auth } = context;\n\n          enforceMasterKeyAccess(auth, config);\n\n          const schema = await config.database.loadSchema({ clearCache: true });\n          return (await schema.getAllClasses(true)).map(parseClass => ({\n            name: parseClass.className,\n            schemaFields: transformToGraphQL(parseClass.fields),\n          }));\n        } catch (e) {\n          parseGraphQLSchema.handleError(e);\n        }\n      },\n    },\n    true,\n    true\n  );\n};\n\nexport { getClass, load };\n"],"mappings":"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","ignoreList":[]}