@webiny/handler-graphql 0.0.0-mt-1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @webiny/handler-graphql
+[![](https://img.shields.io/npm/dw/@webiny/handler-graphql.svg)](https://www.npmjs.com/package/@webiny/handler-graphql) 
+[![](https://img.shields.io/npm/v/@webiny/handler-graphql.svg)](https://www.npmjs.com/package/@webiny/handler-graphql)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+A simple Apollo Server as a `handler` 

package/builtInTypes/AnyScalar.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from "graphql";
+export declare const Any: GraphQLScalarType;

package/builtInTypes/AnyScalar.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Any = void 0;
+
+var _graphql = require("graphql");
+
+const returnValue = value => {
+  return value;
+};
+
+const Any = new _graphql.GraphQLScalarType({
+  name: "Any",
+  description: `A scalar type that represents an ambiguous value.`,
+  serialize: returnValue,
+  parseValue: returnValue
+});
+exports.Any = Any;

package/builtInTypes/DateScalar.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from "graphql";
+export declare const DateScalar: GraphQLScalarType;

package/builtInTypes/DateScalar.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DateScalar = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _graphqlScalars = require("graphql-scalars");
+
+var _graphql = require("graphql");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const DateScalar = new _graphql.GraphQLScalarType(_objectSpread(_objectSpread({}, _graphqlScalars.DateResolver), {}, {
+  serialize: value => {
+    if (!value) {
+      return null;
+    }
+
+    try {
+      const date = new Date(value);
+      return date.toISOString().substr(0, 10);
+    } catch (ex) {
+      if (value.toISOString) {
+        return value.toISOString().substr(0, 10);
+      }
+
+      throw ex;
+    }
+  }
+}));
+exports.DateScalar = DateScalar;

package/builtInTypes/DateTimeScalar.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from "graphql";
+export declare const DateTimeScalar: GraphQLScalarType;

package/builtInTypes/DateTimeScalar.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DateTimeScalar = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _graphqlScalars = require("graphql-scalars");
+
+var _graphql = require("graphql");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const DateTimeScalar = new _graphql.GraphQLScalarType(_objectSpread(_objectSpread({}, _graphqlScalars.DateTimeResolver), {}, {
+  serialize: value => {
+    if (!value) {
+      return null;
+    }
+
+    try {
+      const date = new Date(value);
+      return date.toISOString();
+    } catch (ex) {
+      if (value.toISOString) {
+        return value.toISOString();
+      }
+
+      throw ex;
+    }
+  }
+}));
+exports.DateTimeScalar = DateTimeScalar;

package/builtInTypes/DateTimeZScalar.d.ts

@@ -0,0 +1,6 @@
+import { GraphQLScalarType } from "graphql";
+/**
+ * A custom type for dateTime with the timezone.
+ * Must be in format "YYYY-MM-ddTHH:mm:ss+HH:mm".
+ */
+export declare const DateTimeZScalar: GraphQLScalarType;

package/builtInTypes/DateTimeZScalar.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DateTimeZScalar = void 0;
+
+var _graphqlScalars = require("graphql-scalars");
+
+var _graphql = require("graphql");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const validateTimeZone = value => {
+  const timeWithTimezone = value.split("T")[1];
+
+  if (!timeWithTimezone) {
+    throw new _error.default("Could not extract time with timezone from value.", "DATE_TIME_TIMEZONE_ERROR", {
+      value
+    });
+  }
+
+  const separator = timeWithTimezone.includes("-") ? "-" : "+";
+  const zone = timeWithTimezone.split(separator)[1];
+
+  if (!zone) {
+    throw new _error.default("Could not extract timezone from value.", "DATE_TIME_TIMEZONE_ERROR", {
+      value: timeWithTimezone
+    });
+  }
+
+  const hoursMinutes = zone.split(":");
+  const [hours, minutes] = hoursMinutes;
+
+  if (hours === undefined || minutes === undefined || hoursMinutes.length !== 2) {
+    throw new _error.default("Could not extract hours or minutes from value.", "DATE_TIME_TIMEZONE_ERROR", {
+      value: zone
+    });
+  }
+};
+/**
+ * A custom type for dateTime with the timezone.
+ * Must be in format "YYYY-MM-ddTHH:mm:ss+HH:mm".
+ */
+
+
+const DateTimeZScalar = new _graphql.GraphQLScalarType({
+  name: "DateTimeZ",
+  description: "A custom type for dateTime with the timezone.",
+  parseValue: value => {
+    // this serves as validator
+    _graphqlScalars.DateTimeResolver.parseValue(value);
+
+    validateTimeZone(value);
+    return value;
+  },
+  serialize: value => {
+    return value;
+  }
+});
+exports.DateTimeZScalar = DateTimeZScalar;

package/builtInTypes/JsonScalar.d.ts

@@ -0,0 +1 @@
+export declare const JsonScalar: import("graphql").GraphQLScalarType;

package/builtInTypes/JsonScalar.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JsonScalar = void 0;
+
+var _graphqlScalars = require("graphql-scalars");
+
+const JsonScalar = _graphqlScalars.JSONResolver;
+exports.JsonScalar = JsonScalar;

package/builtInTypes/LongScalar.d.ts

@@ -0,0 +1 @@
+export declare const LongScalar: import("graphql").GraphQLScalarType;

package/builtInTypes/LongScalar.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LongScalar = void 0;
+
+var _graphqlScalars = require("graphql-scalars");
+
+const LongScalar = _graphqlScalars.LongResolver;
+exports.LongScalar = LongScalar;

package/builtInTypes/NumberScalar.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from "graphql";
+export declare const Number: GraphQLScalarType;

package/builtInTypes/NumberScalar.js

@@ -0,0 +1,60 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Number = void 0;
+
+var _graphql = require("graphql");
+
+var _language = require("graphql/language");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const parseValue = value => {
+  if (String(value).match(/^0x/) !== null) {
+    throw new _error.default("Value sent must be a non-hex number.", "INVALID_VALUE", {
+      value
+    });
+  } else if (typeof value === "number") {
+    return value;
+  } else if (value === null || value === undefined) {
+    return null;
+  } else if (isNaN(value) === true) {
+    throw new _error.default("Value sent must be a number.", "INVALID_VALUE", {
+      value
+    });
+  }
+
+  return parseFloat(value);
+};
+
+const Number = new _graphql.GraphQLScalarType({
+  name: "Number",
+  description: "A custom input type to be used with numbers. Supports Int and Float.",
+  serialize: value => {
+    try {
+      return parseValue(value);
+    } catch (ex) {
+      console.log({
+        message: "Value sent must be a number.",
+        code: "INVALID_VALUE",
+        data: {
+          value
+        }
+      });
+      return null;
+    }
+  },
+  parseValue,
+  parseLiteral: ast => {
+    if (ast.kind === _language.Kind.INT || ast.kind === _language.Kind.FLOAT) {
+      return ast.value;
+    }
+
+    throw new Error(`Expected type Number, found {${ast.value}}`);
+  }
+});
+exports.Number = Number;

package/builtInTypes/RefInputScalar.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from "graphql";
+export declare const RefInput: GraphQLScalarType;

package/builtInTypes/RefInputScalar.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RefInput = void 0;
+
+var _graphql = require("graphql");
+
+const isMongoId = value => {
+  if (/^[0-9a-fA-F]{24}$/.test(value)) {
+    return value;
+  }
+
+  throw new Error("Must be a valid Mongo ID!");
+};
+
+const RefInput = new _graphql.GraphQLScalarType({
+  name: "RefInput",
+  description: "A custom input type to be used with references. Supports plain ID and `{ id: ID }` Object literal.",
+  serialize: value => {
+    if (!value || value.id === null) {
+      return null;
+    }
+
+    return typeof value === "string" ? value : value.id;
+  },
+  parseValue: value => {
+    if (!value || value.id === null) {
+      return null;
+    }
+
+    if (typeof value === "string") {
+      return isMongoId(value);
+    }
+
+    if ("id" in value) {
+      return isMongoId(value.id);
+    }
+
+    throw new Error("Invalid RefInput value!");
+  },
+  parseLiteral: ast => {
+    if (ast.kind === "StringValue") {
+      return isMongoId(ast.value);
+    }
+
+    if (ast.kind === "ObjectValue") {
+      for (let i = 0; i < ast.fields.length; i++) {
+        const {
+          name,
+          value
+        } = ast.fields[i];
+
+        if (name.value === "id") {
+          // @ts-ignore
+          return isMongoId(value.value);
+        }
+      }
+    }
+
+    throw new Error("Invalid RefInput value!");
+  }
+});
+exports.RefInput = RefInput;

package/builtInTypes/TimeScalar.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from "graphql";
+export declare const TimeScalar: GraphQLScalarType;

package/builtInTypes/TimeScalar.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TimeScalar = void 0;
+
+var _graphql = require("graphql");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const re = /^([0-9]{2}):([0-9]{2})(:([0-9]{2}))?$/;
+
+const parseTime = value => {
+  if (!value || value.match(re) === null) {
+    throw new _error.default("Value does not look like time.", "TIME_VALIDATION_ERROR", {
+      value
+    });
+  }
+
+  const parsed = value.split(":").map(Number);
+
+  if (parsed.length < 2) {
+    throw new _error.default(`Could not parse the value.`, "TIME_VALIDATION_ERROR", {
+      value
+    });
+  }
+
+  const [hours, minutes, seconds = 0] = parsed;
+
+  if (hours >= 24) {
+    throw new _error.default(`There cannot be more than 24 hours.`, "TIME_VALIDATION_ERROR", {
+      value
+    });
+  } else if (minutes >= 60) {
+    throw new _error.default(`There cannot be more than 59 minutes.`, "TIME_VALIDATION_ERROR", {
+      value
+    });
+  } else if (seconds >= 60) {
+    throw new _error.default(`There cannot be more than 59 seconds.`, "TIME_VALIDATION_ERROR", {
+      value
+    });
+  }
+
+  return {
+    hours,
+    minutes,
+    seconds
+  };
+};
+
+const convertToTime = value => {
+  const {
+    hours,
+    minutes,
+    seconds
+  } = parseTime(value);
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+};
+
+const TimeScalar = new _graphql.GraphQLScalarType({
+  name: "Time",
+  description: "A custom type to support time-only input.",
+  // sending to client
+  serialize: convertToTime,
+  // received from client
+  parseValue: convertToTime
+});
+exports.TimeScalar = TimeScalar;

package/builtInTypes/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./AnyScalar";
+export * from "./DateScalar";
+export * from "./DateTimeScalar";
+export * from "./DateTimeZScalar";
+export * from "./JsonScalar";
+export * from "./LongScalar";
+export * from "./NumberScalar";
+export * from "./RefInputScalar";
+export * from "./TimeScalar";

package/builtInTypes/index.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _AnyScalar = require("./AnyScalar");
+
+Object.keys(_AnyScalar).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _AnyScalar[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _AnyScalar[key];
+    }
+  });
+});
+
+var _DateScalar = require("./DateScalar");
+
+Object.keys(_DateScalar).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _DateScalar[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _DateScalar[key];
+    }
+  });
+});
+
+var _DateTimeScalar = require("./DateTimeScalar");
+
+Object.keys(_DateTimeScalar).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _DateTimeScalar[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _DateTimeScalar[key];
+    }
+  });
+});
+
+var _DateTimeZScalar = require("./DateTimeZScalar");
+
+Object.keys(_DateTimeZScalar).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _DateTimeZScalar[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _DateTimeZScalar[key];
+    }
+  });
+});
+
+var _JsonScalar = require("./JsonScalar");
+
+Object.keys(_JsonScalar).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _JsonScalar[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _JsonScalar[key];
+    }
+  });
+});
+
+var _LongScalar = require("./LongScalar");
+
+Object.keys(_LongScalar).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _LongScalar[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _LongScalar[key];
+    }
+  });
+});
+
+var _NumberScalar = require("./NumberScalar");
+
+Object.keys(_NumberScalar).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _NumberScalar[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _NumberScalar[key];
+    }
+  });
+});
+
+var _RefInputScalar = require("./RefInputScalar");
+
+Object.keys(_RefInputScalar).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _RefInputScalar[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _RefInputScalar[key];
+    }
+  });
+});
+
+var _TimeScalar = require("./TimeScalar");
+
+Object.keys(_TimeScalar).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _TimeScalar[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _TimeScalar[key];
+    }
+  });
+});

package/createGraphQLHandler.d.ts

@@ -0,0 +1,4 @@
+import { HandlerGraphQLOptions } from "./types";
+import { PluginCollection } from "@webiny/plugins/types";
+declare const _default: (options?: HandlerGraphQLOptions) => PluginCollection;
+export default _default;

package/createGraphQLHandler.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _boolean = require("boolean");
+
+var _createGraphQLSchema = require("./createGraphQLSchema");
+
+var _debugPlugins = _interopRequireDefault(require("./debugPlugins"));
+
+var _processRequestBody = _interopRequireDefault(require("./processRequestBody"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const DEFAULT_HEADERS = {
+  "Content-Type": "application/json",
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Headers": "*",
+  "Access-Control-Allow-Methods": "OPTIONS,POST"
+};
+const DEFAULT_CACHE_MAX_AGE = 30758400; // 1 year
+
+var _default = (options = {}) => {
+  let schema;
+  const debug = (0, _boolean.boolean)(options.debug);
+  return [...(debug ? (0, _debugPlugins.default)() : []), {
+    type: "handler",
+    name: "handler-graphql",
+
+    async handle(context, next) {
+      const {
+        http
+      } = context;
+
+      if (!http) {
+        return next();
+      }
+
+      if (http.request.method === "OPTIONS") {
+        return http.response({
+          statusCode: 204,
+          headers: _objectSpread(_objectSpread({}, DEFAULT_HEADERS), {}, {
+            "Cache-Control": "public, max-age=" + DEFAULT_CACHE_MAX_AGE
+          })
+        });
+      }
+
+      if (http.request.method !== "POST") {
+        return next();
+      }
+
+      if (!schema) {
+        schema = (0, _createGraphQLSchema.createGraphQLSchema)(context);
+      }
+
+      const body = JSON.parse(http.request.body);
+      const result = await (0, _processRequestBody.default)(body, schema, context);
+      return http.response({
+        body: JSON.stringify(result),
+        statusCode: 200,
+        headers: DEFAULT_HEADERS
+      });
+    }
+
+  }];
+};
+
+exports.default = _default;

package/createGraphQLSchema.d.ts

@@ -0,0 +1,3 @@
+import { Context } from "@webiny/handler/types";
+import { HttpContext } from "@webiny/handler-http/types";
+export declare const createGraphQLSchema: (context: Context<HttpContext>) => import("graphql").GraphQLSchema;