graphql-typed-apollo-client
Version:
A tool that generates a strongly typed client library for any GraphQL endpoint. The client allows writing GraphQL queries as plain JS objects (with type safety, awesome code completion experience, custom scalar type mapping, type guards and more)
175 lines • 9.36 kB
JavaScript
;
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
return cooked;
};
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __rest = (this && this.__rest) || function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
var __spreadArrays = (this && this.__spreadArrays) || function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
require("isomorphic-fetch");
var qs_1 = __importDefault(require("qs"));
var rxjs_1 = require("rxjs");
var lodash_1 = require("lodash");
var operators_1 = require("rxjs/operators");
var client_1 = require("@apollo/client");
var graphql_tag_1 = __importDefault(require("graphql-tag"));
var applyTypeMapperToResponse_1 = require("./applyTypeMapperToResponse");
var chain_1 = require("./chain");
var requestToGql_1 = require("./requestToGql");
var getSubscriptionCreator_1 = require("./getSubscriptionCreator");
var ClientError = /** @class */ (function (_super) {
__extends(ClientError, _super);
function ClientError(message, errors) {
var _newTarget = this.constructor;
var _this = _super.call(this, errors ? message + "\n" + errors.map(function (error) { return JSON.stringify(error, null, 2); }).join('\n') : message) || this;
_this.errors = errors;
_newTarget.prototype.name = _newTarget.name;
Object.setPrototypeOf(_this, _newTarget.prototype);
if (Error.captureStackTrace)
Error.captureStackTrace(_this, ClientError);
return _this;
}
return ClientError;
}(Error));
exports.ClientError = ClientError;
var dummyMutation = graphql_tag_1.default(templateObject_1 || (templateObject_1 = __makeTemplateObject(["\n mutation dummy {\n dummy {\n id\n }\n }\n"], ["\n mutation dummy {\n dummy {\n id\n }\n }\n"])));
exports.createClient = function (_a) {
var fetcher = _a.fetcher, subscriptionCreatorOptions = _a.subscriptionCreatorOptions, queryRoot = _a.queryRoot, mutationRoot = _a.mutationRoot, subscriptionRoot = _a.subscriptionRoot, typeMapper = _a.typeMapper;
var createSubscription = subscriptionCreatorOptions ? getSubscriptionCreator_1.getSubscriptionCreator(subscriptionCreatorOptions) : function () { return rxjs_1.NEVER; };
function apolloQuery(apolloContext, request, options) {
var _a;
if (!queryRoot)
throw new Error('queryRoot argument is missing');
var _b = requestToGql_1.requestToGql('query', queryRoot, request, typeMapper), query = _b.query, variables = _b.variables;
return (_a = apolloContext.client) === null || _a === void 0 ? void 0 : _a.query(__assign({ query: graphql_tag_1.default(query), variables: variables }, options));
}
function useQuery(request, options) {
if (!queryRoot)
throw new Error('queryRoot argument is missing');
var gqlQuery, gqlVars;
if (request) {
var _a = requestToGql_1.requestToGql('query', queryRoot, request, typeMapper), query_1 = _a.query, variables = _a.variables;
gqlQuery = graphql_tag_1.default(query_1);
gqlVars = variables;
}
else {
gqlQuery = graphql_tag_1.default(templateObject_2 || (templateObject_2 = __makeTemplateObject(["query {}"], ["query {}"])));
gqlVars = {};
}
var result = client_1.useQuery(gqlQuery, __assign({ variables: gqlVars }, options));
return result;
}
function useMutation(request, options) {
if (!mutationRoot)
throw new Error('mutationRoot argument is missing');
// use a trick here to delay the evaluation of actual mutation query function
var _a = client_1.useMutation(dummyMutation, options), _executeMutation = _a[0], mutateState = _a[1];
var executeMutation = function (executeOptions) {
if (executeOptions === void 0) { executeOptions = {}; }
var executeVariables = executeOptions.variables, otherOptions = __rest(executeOptions, ["variables"]);
var _a = requestToGql_1.requestToGql('mutation', mutationRoot, request(executeVariables), typeMapper), query = _a.query, variables = _a.variables;
var gqlQuery = graphql_tag_1.default(query);
var overrideExecuteOptions = __assign(__assign({}, otherOptions), { mutation: gqlQuery, variables: variables });
return _executeMutation(overrideExecuteOptions);
};
return [executeMutation, mutateState];
}
var query = function (request) {
if (!fetcher)
throw new Error('fetcher argument is missing');
if (!queryRoot)
throw new Error('queryRoot argument is missing');
var resultPromise = fetcher(requestToGql_1.requestToGql('query', queryRoot, request, typeMapper), fetch, qs_1.default);
return typeMapper
? resultPromise.then(function (result) { return applyTypeMapperToResponse_1.applyTypeMapperToResponse(queryRoot, result, typeMapper); })
: resultPromise;
};
var mutation = function (request) {
if (!fetcher)
throw new Error('fetcher argument is missing');
if (!mutationRoot)
throw new Error('mutationRoot argument is missing');
var resultPromise = fetcher(requestToGql_1.requestToGql('mutation', mutationRoot, request, typeMapper), fetch, qs_1.default);
return typeMapper
? resultPromise.then(function (result) { return applyTypeMapperToResponse_1.applyTypeMapperToResponse(mutationRoot, result, typeMapper); })
: resultPromise;
};
var subscription = function (request) {
if (!subscriptionCreatorOptions)
throw new Error('subscriptionClientOptions argument is missing');
if (!subscriptionRoot)
throw new Error('subscriptionRoot argument is missing');
var resultObservable = createSubscription(requestToGql_1.requestToGql('subscription', subscriptionRoot, request, typeMapper));
return typeMapper
? resultObservable.pipe(operators_1.map(function (result) { return applyTypeMapperToResponse_1.applyTypeMapperToResponse(subscriptionRoot, result, typeMapper); }))
: resultObservable;
};
var mapResponse = function (path, defaultValue) { return function (response) {
if (response.errors)
throw new ClientError("Response contains errors", response.errors);
if (!response.data)
throw new ClientError('Response data is empty');
var result = lodash_1.get(response, __spreadArrays(['data'], path), defaultValue);
if (result === undefined)
throw new ClientError("Response path `" + path.join('.') + "` is empty");
return result;
}; };
return {
apolloQuery: apolloQuery,
useQuery: useQuery,
useMutation: useMutation,
query: query,
mutation: mutation,
subscription: subscription,
chain: {
query: chain_1.chain(function (path, request, defaultValue) { return query(request).then(mapResponse(path, defaultValue)); }),
mutation: chain_1.chain(function (path, request, defaultValue) { return mutation(request).then(mapResponse(path, defaultValue)); }),
subscription: (chain_1.chain(function (path, request, defaultValue) { return subscription(request).pipe(operators_1.map(mapResponse(path, defaultValue))); })),
},
};
};
var templateObject_1, templateObject_2;
//# sourceMappingURL=createClient.js.map