@vtex/api 6.48.1-beta → 6.48.1-beta.3

package/lib/clients/Workspaces.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
-const HttpClient_1 = require("../HttpClient");
-const routes = {
-    Account: (account) => `/${account}`,
-    Promote: (account) => `${routes.Workspace(account, constants_1.DEFAULT_WORKSPACE)}/_promote`,
-    Workspace: (account, workspace) => `${routes.Account(account)}/${workspace}`,
-};
-class Workspaces extends HttpClient_1.InfraClient {
-    constructor(context, options) {
-        super('router', context, options, true);
-        this.list = (account) => {
-            return this.http.get(routes.Account(account), { metric: 'workspaces-list' });
-        };
-        this.get = (account, workspace) => {
-            return this.http.get(routes.Workspace(account, workspace), { metric: 'workspaces-get' });
-        };
-        this.set = (account, workspace, metadata) => {
-            return this.http.put(routes.Workspace(account, workspace), metadata, { metric: 'workspaces-set' });
-        };
-        this.create = (account, workspace, production) => {
-            return this.http.post(routes.Account(account), { name: workspace, production }, { metric: 'workspaces-create' });
-        };
-        this.delete = (account, workspace) => {
-            return this.http.delete(routes.Workspace(account, workspace), { metric: 'workspaces-delete' });
-        };
-        this.reset = (account, workspace, metadata = {}) => {
-            const params = { reset: true };
-            const metric = 'workspaces-reset';
-            return this.http.put(routes.Workspace(account, workspace), metadata, { params, metric });
-        };
-        this.promote = (account, workspace, conflictResolutionStrategy) => {
-            return this.http.put(routes.Promote(account), { workspace, conflictResolutionStrategy }, { metric: 'workspaces-promote' });
-        };
-    }
-}
-exports.Workspaces = Workspaces;

package/lib/service/Runtime.d.ts

@@ -1,18 +0,0 @@
-import { IOClients } from '../clients/IOClients';
-import { EnvMetric, MetricsAccumulator } from '../metrics/MetricsAccumulator';
-import { Service } from './Service';
-import { RouteHandler, ServiceDescriptor } from './typings';
-export declare class Runtime<ClientsT extends IOClients = IOClients, StateT = void, CustomT = void> {
-    routes: Record<string, RouteHandler<ClientsT, StateT, CustomT>>;
-    events: any;
-    statusTrack?: () => EnvMetric[];
-    __is_service: true;
-    constructor(service: Service<ClientsT, StateT, CustomT>, descriptor: ServiceDescriptor);
-}
-declare global {
-    namespace NodeJS {
-        interface Global {
-            metrics: MetricsAccumulator;
-        }
-    }
-}

package/lib/service/Runtime.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ramda_1 = require("ramda");
-const IOClients_1 = require("../clients/IOClients");
-const MetricsAccumulator_1 = require("../metrics/MetricsAccumulator");
-const unhandled_1 = require("../utils/unhandled");
-const events_1 = require("./events");
-const graphql_1 = require("./graphql");
-const http_1 = require("./http");
-const linked = !!process.env.VTEX_APP_LINK;
-const noop = () => [];
-const defaultClients = {
-    options: {
-        messages: {
-            concurrency: 10,
-            retries: 2,
-            timeout: 1000,
-        },
-        messagesGraphQL: {
-            concurrency: 10,
-            retries: 2,
-            timeout: 1000,
-        },
-    },
-};
-class Runtime {
-    constructor(service, 
-    // tslint:disable-next-line
-    descriptor) {
-        this.__is_service = true; // tslint:disable-line
-        const { config } = service;
-        const clients = {
-            implementation: config.clients && config.clients.implementation || IOClients_1.IOClients,
-            options: Object.assign({}, defaultClients.options, config.clients ? config.clients.options : null),
-        };
-        const Clients = clients.implementation;
-        this.routes = config.routes
-            ? ramda_1.map(http_1.createHttpRoute(Clients, clients.options), config.routes)
-            : {};
-        if (config.graphql) {
-            let graphqlRoute = graphql_1.GRAPHQL_ROUTE;
-            if (descriptor.routes && descriptor.routes[graphql_1.GRAPHQL_ROUTE_LEGACY]) {
-                console.warn('Using legacy graphql route id', graphql_1.GRAPHQL_ROUTE_LEGACY);
-                graphqlRoute = graphql_1.GRAPHQL_ROUTE_LEGACY;
-            }
-            this.routes[graphqlRoute] = graphql_1.createGraphQLRoute(config.graphql, Clients, clients.options);
-        }
-        this.events = config.events
-            ? ramda_1.map(events_1.createEventHandler(Clients, clients.options), config.events)
-            : {};
-        this.statusTrack = linked ? noop : global.metrics.statusTrack;
-        unhandled_1.addProcessListeners();
-    }
-}
-exports.Runtime = Runtime;
-global.metrics = new MetricsAccumulator_1.MetricsAccumulator();
-metrics.trackCache('graphql-runtime', graphql_1.graphqlRuntimeCacheStorage);

package/lib/service/events/index.d.ts

@@ -1,3 +0,0 @@
-import { ClientsImplementation, IOClients } from '../../clients/IOClients';
-import { InstanceOptions } from '../../HttpClient';
-export declare const createEventHandler: <ClientsT extends IOClients, StateT, CustomT>(Clients: ClientsImplementation<ClientsT>, options: Record<string, InstanceOptions>) => (handler: import("koa-compose").Middleware<import("../typings").EventContext<ClientsT, StateT>> | import("koa-compose").Middleware<import("../typings").EventContext<ClientsT, StateT>>[]) => import("koa-compose").ComposedMiddleware<import("../typings").EventContext<IOClients, {}>>;

package/lib/service/events/index.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ramda_1 = require("ramda");
-const clients_1 = require("../http/middlewares/clients");
-const error_1 = require("../http/middlewares/error");
-const timings_1 = require("../http/middlewares/timings");
-const compose_1 = require("../utils/compose");
-exports.createEventHandler = (Clients, options) => {
-    return (handler) => {
-        const middlewares = Array.isArray(handler) ? handler : [handler];
-        const pipeline = [clients_1.clients(Clients, options), timings_1.timings, error_1.error, contextAdapter(middlewares)];
-        return compose_1.composeForEvents(pipeline);
-    };
-};
-function contextAdapter(middlewares) {
-    return async function middlewareCascade(ctx) {
-        const ctxEvent = ramda_1.merge(ramda_1.pick(['clients', 'state', 'vtex', 'timings', 'metrics'], ctx), Object.assign({}, ctx.vtex, { body: ctx.state.body, key: ctx.vtex.eventInfo ? ctx.vtex.eventInfo.key : '', sender: ctx.vtex.eventInfo ? ctx.vtex.eventInfo.sender : '', subject: ctx.vtex.eventInfo ? ctx.vtex.eventInfo.subject : '' }));
-        await compose_1.composeForEvents(middlewares)(ctxEvent);
-        ctx.status = 204;
-    };
-}

package/lib/service/graphql/index.d.ts

@@ -1,7 +0,0 @@
-import { ClientsImplementation, IOClients } from '../../clients/IOClients';
-import { InstanceOptions } from '../../HttpClient';
-import { GraphQLOptions } from '../typings';
-export declare const GRAPHQL_ROUTE_LEGACY = "__graphql";
-export declare const GRAPHQL_ROUTE = "graphql";
-export declare const createGraphQLRoute: <ClientsT extends IOClients, StateT, CustomT>(graphql: GraphQLOptions<ClientsT, StateT, CustomT>, Clients: ClientsImplementation<ClientsT>, options: Record<string, InstanceOptions>) => import("koa-compose").Middleware<import("../typings").ServiceContext<ClientsT, StateT, CustomT>>;
-export { graphqlRuntimeCacheStorage } from './middlewares/run';

package/lib/service/graphql/index.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const http_1 = require("../http");
-const error_1 = require("./middlewares/error");
-const formatters_1 = require("./middlewares/formatters");
-const query_1 = require("./middlewares/query");
-const response_1 = require("./middlewares/response");
-const run_1 = require("./middlewares/run");
-const schema_1 = require("./middlewares/schema");
-const timings_1 = require("./middlewares/timings");
-const upload_1 = require("./middlewares/upload");
-exports.GRAPHQL_ROUTE_LEGACY = '__graphql';
-exports.GRAPHQL_ROUTE = 'graphql';
-exports.createGraphQLRoute = (graphql, Clients, options) => {
-    const injectGraphql = async (ctx, next) => {
-        ctx.graphql = Object.assign({}, graphql);
-        await next();
-        delete ctx.graphql;
-    };
-    return http_1.createHttpRoute(Clients, options)([
-        injectGraphql,
-        timings_1.graphqlTimings,
-        error_1.graphqlError,
-        upload_1.upload,
-        query_1.parseQuery,
-        formatters_1.createFormatters,
-        schema_1.injectSchema,
-        run_1.run,
-        response_1.response,
-    ]);
-};
-var run_2 = require("./middlewares/run");
-exports.graphqlRuntimeCacheStorage = run_2.graphqlRuntimeCacheStorage;

package/lib/service/graphql/middlewares/error.js

@@ -1,107 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ramda_1 = require("ramda");
-const Logger_1 = require("../../../clients/Logger");
-const constants_1 = require("../../../constants");
-const RequestCancelledError_1 = require("../../../errors/RequestCancelledError");
-const array_1 = require("../utils/array");
-const pathname_1 = require("../utils/pathname");
-const CACHE_CONTROL_HEADER = 'cache-control';
-const META_HEADER = 'x-vtex-meta';
-const ETAG_HEADER = 'etag';
-const TWO_SECONDS_S = 2;
-const arrayHasError = ramda_1.any(ramda_1.has('errors'));
-const filterErrors = ramda_1.filter(ramda_1.has('errors'));
-const chainErrors = ramda_1.chain(ramda_1.prop('errors'));
-const hasError = ramda_1.compose(arrayHasError, array_1.toArray);
-const parseError = ramda_1.compose(chainErrors, filterErrors, array_1.toArray);
-const parseErrorResponse = (response) => {
-    if (hasError(response)) {
-        return parseError(response);
-    }
-    return null;
-};
-async function graphqlError(ctx, next) {
-    const { vtex: { production, route: { id, }, }, } = ctx;
-    let graphQLErrors = null;
-    try {
-        await next();
-        graphQLErrors = parseErrorResponse(ctx.graphql.graphqlResponse || {});
-    }
-    catch (e) {
-        if (e.code === RequestCancelledError_1.cancelledErrorCode) {
-            ctx.status = RequestCancelledError_1.cancelledRequestStatus;
-            return;
-        }
-        const formatError = ctx.graphql.formatters.formatError;
-        if (e.isGraphQLError) {
-            const response = JSON.parse(e.message);
-            graphQLErrors = parseError(response);
-            ctx.body = response;
-        }
-        else {
-            graphQLErrors = [formatError(e)];
-            ctx.body = { errors: graphQLErrors };
-        }
-        // Add response
-        ctx.status = e.statusCode || 500;
-        if (e.headers) {
-            ctx.set(e.headers);
-        }
-    }
-    finally {
-        if (graphQLErrors) {
-            const uniqueErrors = ramda_1.uniqBy((e) => {
-                if (e.extensions.exception && e.extensions.exception.request) {
-                    return e.extensions.exception.request.path;
-                }
-                return e;
-            }, graphQLErrors);
-            // Reduce size of `variables` prop in the errors.
-            ramda_1.map((e) => {
-                if (e.query && e.query.variables) {
-                    const stringifiedVariables = JSON.stringify(e.query.variables);
-                    e.query.variables = stringifiedVariables.length <= 1024 ? stringifiedVariables : '[variables too long]';
-                }
-            }, uniqueErrors);
-            console.error(`[node-vtex-api graphql errors] total=${graphQLErrors.length} unique=${uniqueErrors.length}`, uniqueErrors);
-            ctx.graphql.status = 'error';
-            // Do not generate etag for errors
-            ctx.remove(META_HEADER);
-            ctx.remove(ETAG_HEADER);
-            // In production errors, add two second cache
-            if (production) {
-                ctx.set(CACHE_CONTROL_HEADER, `public, max-age=${TWO_SECONDS_S}`);
-            }
-            else {
-                ctx.set(CACHE_CONTROL_HEADER, `no-cache, no-store`);
-            }
-            // Log each error to splunk individually
-            ramda_1.forEach((err) => {
-                // Prevent logging cancellation error (it's not an error)
-                if (!err.extensions.exception || err.extensions.exception.code !== RequestCancelledError_1.cancelledErrorCode) {
-                    // Add pathName to each error
-                    if (err.path) {
-                        err.pathName = pathname_1.generatePathName(err.path);
-                    }
-                    const log = Object.assign({}, err, { routeId: id });
-                    // Grab level from originalError, default to "error" level.
-                    let level = err.extensions.exception && err.extensions.exception.level;
-                    if (!level || !(level === Logger_1.LogLevel.Error || level === Logger_1.LogLevel.Warn)) {
-                        level = Logger_1.LogLevel.Error;
-                    }
-                    ctx.vtex.logger.log(log, level);
-                }
-                if (!constants_1.LINKED && err.extensions.exception && err.extensions.exception.sensitive) {
-                    delete err.extensions.exception.sensitive;
-                }
-            }, uniqueErrors);
-            // Expose graphQLErrors with pathNames to timings middleware
-            ctx.graphql.graphQLErrors = uniqueErrors;
-        }
-        else {
-            ctx.graphql.status = 'success';
-        }
-    }
-}
-exports.graphqlError = graphqlError;

package/lib/service/graphql/middlewares/formatters.d.ts

@@ -1,2 +0,0 @@
-import { GraphQLServiceContext } from '../typings';
-export declare function createFormatters(ctx: GraphQLServiceContext, next: () => Promise<void>): Promise<void>;

package/lib/service/graphql/middlewares/formatters.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const apollo_server_errors_1 = require("apollo-server-errors");
-const ramda_1 = require("ramda");
-const error_1 = require("../../../utils/error");
-const ERROR_FIELD_WHITELIST = ['message', 'path', 'stack', 'extensions', 'statusCode', 'name', 'headers', 'originalError', 'code'];
-// formatError overrides the default option in runHttpQuery, which
-// does not keep track of the error stack. All non-enumerable
-// properties of Error (including stack) need to be returned
-// explicitly, otherwise will not show up after a JSON.stringify call
-const createFormatError = (details) => (error) => {
-    const formattedError = ramda_1.pick(ERROR_FIELD_WHITELIST, error);
-    if (!formattedError.extensions) {
-        formattedError.extensions = {
-            code: 'INTERNAL_SERVER_ERROR',
-        };
-    }
-    if (formattedError.originalError) {
-        formattedError.originalError = error_1.cleanError(formattedError.originalError);
-        if (formattedError.stack === formattedError.originalError.stack) {
-            delete formattedError.originalError.stack;
-        }
-        if (!formattedError.extensions.exception) {
-            formattedError.extensions.exception = Object.assign({ message: formattedError.originalError.message, name: formattedError.originalError.name }, ramda_1.omit(error_1.SENSITIVE_EXCEPTION_FIELDS, formattedError.originalError), { sensitive: ramda_1.pick(error_1.SENSITIVE_EXCEPTION_FIELDS, formattedError.originalError) });
-        }
-        else {
-            const mergedExceptions = Object.assign({}, formattedError.originalError, formattedError.extensions.exception);
-            const extendedException = Object.assign({ message: formattedError.originalError.message, name: formattedError.originalError.name }, ramda_1.omit(error_1.SENSITIVE_EXCEPTION_FIELDS, mergedExceptions), { sensitive: ramda_1.pick(error_1.SENSITIVE_EXCEPTION_FIELDS, mergedExceptions) });
-            formattedError.extensions.exception = error_1.cleanError(extendedException);
-        }
-        // Make originalError not enumerable to prevent duplicated log and response information
-        Object.defineProperty(formattedError, 'originalError', { enumerable: false });
-    }
-    Object.assign(formattedError, details);
-    return formattedError;
-};
-const createFormatResponse = (formatter) => (response) => {
-    const { errors = null } = response || {};
-    return Object.assign({}, response, { errors: Array.isArray(errors) ? apollo_server_errors_1.formatApolloErrors(errors, { formatter }) : undefined });
-};
-async function createFormatters(ctx, next) {
-    const { headers: { 'x-forwarded-host': forwardedHost, 'x-forwarded-proto': forwardedProto, 'x-vtex-platform': platform, }, vtex: { operationId, requestId, }, } = ctx;
-    // Do not log variables for file uploads
-    const variables = ctx.request.is('multipart/form-data')
-        ? '[GraphQL Upload]'
-        : ctx.graphql.query && ctx.graphql.query.variables;
-    const query = Object.assign({}, ctx.graphql.query, { variables });
-    const details = {
-        forwardedHost,
-        forwardedProto,
-        operationId,
-        platform,
-        query,
-        requestId,
-    };
-    const formatError = createFormatError(details);
-    const formatResponse = createFormatResponse(formatError);
-    ctx.graphql.formatters = {
-        formatError,
-        formatResponse,
-    };
-    await next();
-}
-exports.createFormatters = createFormatters;

package/lib/service/graphql/middlewares/query.d.ts

@@ -1,2 +0,0 @@
-import { GraphQLServiceContext } from '../typings';
-export declare function parseQuery(ctx: GraphQLServiceContext, next: () => Promise<void>): Promise<void>;

package/lib/service/graphql/middlewares/query.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const co_body_1 = require("co-body");
-const ramda_1 = require("ramda");
-const url_1 = require("url");
-const constants_1 = require("../../../constants");
-const parseVariables = (query) => {
-    if (query && query[constants_1.BODY_HASH]) {
-        return null;
-    }
-    if (query && typeof query.variables === 'string') {
-        query.variables = JSON.parse(query.variables);
-    }
-    return query;
-};
-const queryFromUrl = ramda_1.compose(parseVariables, ramda_1.prop('query'), ramda_1.partialRight(url_1.parse, [true]));
-async function parseQuery(ctx, next) {
-    const { request, req } = ctx;
-    let query;
-    if (request.is('multipart/form-data')) {
-        query = request.body;
-    }
-    else if (request.method.toUpperCase() === 'POST') {
-        query = await co_body_1.json(req);
-    }
-    else {
-        query = queryFromUrl(request.url) || await co_body_1.json(req);
-    }
-    ctx.graphql.query = query;
-    await next();
-}
-exports.parseQuery = parseQuery;

package/lib/service/graphql/middlewares/response.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ramda_1 = require("ramda");
-const constants_1 = require("../../../constants");
-const cacheControl_1 = require("../utils/cacheControl");
-const DEV_FIELDS = ['data', 'errors', 'extensions'];
-const PROD_FIELDS = ['data', 'errors'];
-function setVaryHeaders(ctx, scope, segment) {
-    ctx.vary(constants_1.FORWARDED_HOST_HEADER);
-    if (segment) {
-        ctx.vary(constants_1.SEGMENT_HEADER);
-    }
-    if (scope === 'private' || ctx.query.scope === 'private') {
-        ctx.vary(constants_1.SESSION_HEADER);
-    }
-    else if (ctx.vtex.sessionToken) {
-        ctx.vtex.logger.warn({
-            message: 'GraphQL resolver receiving session token without private scope',
-            userAgent: ctx.get('user-agent'),
-        });
-    }
-}
-async function response(ctx, next) {
-    const { responseInit, graphqlResponse } = ctx.graphql;
-    const { production } = ctx.vtex;
-    const { maxAge = '', scope = '', segment = null, } = graphqlResponse ? cacheControl_1.cacheControl(graphqlResponse, ctx) : {};
-    const cacheControlHeader = ramda_1.reject(ramda_1.isEmpty, [maxAge, scope]).join(',');
-    ctx.set(Object.assign({}, responseInit && responseInit.headers, { 'Cache-Control': cacheControlHeader }));
-    if (ctx.method.toUpperCase() === 'GET') {
-        setVaryHeaders(ctx, scope, segment);
-    }
-    const fields = production ? PROD_FIELDS : DEV_FIELDS;
-    ctx.body = ramda_1.pick(fields, graphqlResponse);
-    await next();
-}
-exports.response = response;

package/lib/service/graphql/middlewares/run.d.ts

@@ -1,4 +0,0 @@
-import { LRUCache } from '../../../caches';
-import { GraphQLServiceContext } from '../typings';
-export declare const graphqlRuntimeCacheStorage: LRUCache<string, string>;
-export declare function run(ctx: GraphQLServiceContext, next: () => Promise<void>): Promise<void>;

package/lib/service/graphql/middlewares/run.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const apollo_server_core_1 = require("apollo-server-core");
-const caches_1 = require("../../../caches");
-const maxAgeEnum_1 = require("../utils/maxAgeEnum");
-exports.graphqlRuntimeCacheStorage = new caches_1.LRUCache({
-    max: 100,
-});
-const persistedQueries = {
-    cache: exports.graphqlRuntimeCacheStorage,
-};
-const linked = !!process.env.VTEX_APP_LINK;
-async function run(ctx, next) {
-    const { method, graphql, request, } = ctx;
-    const { dataSources, formatters, query, schema, } = graphql;
-    const { formatError, formatResponse, } = formatters;
-    // We don't want resolvers to have access to the GraphQL context,
-    // so we delete it here and restore it after execution.
-    delete ctx.graphql;
-    try {
-        const { graphqlResponse, responseInit } = await apollo_server_core_1.runHttpQuery([], {
-            method,
-            options: {
-                cacheControl: {
-                    calculateHttpHeaders: true,
-                    defaultMaxAge: maxAgeEnum_1.defaultMaxAgeFromCtx(ctx),
-                    stripFormattedExtensions: false,
-                },
-                context: ctx,
-                dataSources,
-                debug: linked,
-                documentStore: exports.graphqlRuntimeCacheStorage,
-                formatError,
-                formatResponse,
-                parseOptions: {
-                    noLocation: !linked,
-                },
-                persistedQueries,
-                schema,
-                tracing: linked,
-            },
-            query: query,
-            request,
-        });
-        ctx.graphql = graphql;
-        ctx.graphql.responseInit = responseInit;
-        ctx.graphql.graphqlResponse = JSON.parse(graphqlResponse);
-    }
-    catch (err) {
-        ctx.graphql = graphql;
-        throw err;
-    }
-    await next();
-}
-exports.run = run;

package/lib/service/graphql/middlewares/schema.d.ts

@@ -1,2 +0,0 @@
-import { GraphQLServiceContext } from '../typings';
-export declare function injectSchema(ctx: GraphQLServiceContext, next: () => Promise<void>): Promise<void>;

package/lib/service/graphql/middlewares/schema.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const schema_1 = require("../schema");
-async function injectSchema(ctx, next) {
-    ctx.graphql.schema = schema_1.makeSchema(ctx);
-    await next();
-}
-exports.injectSchema = injectSchema;

package/lib/service/graphql/middlewares/timings.d.ts

@@ -1,2 +0,0 @@
-import { GraphQLServiceContext } from '../typings';
-export declare function graphqlTimings(ctx: GraphQLServiceContext, next: () => Promise<void>): Promise<void>;

package/lib/service/graphql/middlewares/timings.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-async function graphqlTimings(ctx, next) {
-    const start = process.hrtime();
-    // Errors will be caught by the next middleware so we don't have to catch.
-    await next();
-    // Batch success or error metric for entire operation
-    metrics.batch(`graphql-operation-${ctx.graphql.status}`, process.hrtime(start));
-}
-exports.graphqlTimings = graphqlTimings;

package/lib/service/graphql/middlewares/upload.d.ts

@@ -1,7 +0,0 @@
-import { GraphQLServiceContext } from '../typings';
-declare module 'graphql-upload' {
-    function graphqlUploadKoa(options: ApolloUploadOptions): (ctx: GraphQLServiceContext, next: () => Promise<any>) => Promise<void>;
-}
-declare function graphqlUploadKoaMiddleware(ctx: GraphQLServiceContext, next: () => Promise<any>): Promise<void>;
-export declare const upload: typeof graphqlUploadKoaMiddleware;
-export {};

package/lib/service/graphql/schema/index.d.ts

@@ -1,3 +0,0 @@
-import { GraphQLSchema } from 'graphql';
-export declare type SchemaMetaData = Record<string, boolean>;
-export declare const makeSchema: (ctx: import("../../typings").ServiceContext<import("../../..").IOClients, any, import("../typings").GraphQLContext>) => GraphQLSchema;

package/lib/service/graphql/schema/index.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_extra_1 = require("fs-extra");
-const graphql_tools_1 = require("graphql-tools");
-const ramda_1 = require("ramda");
-const messagesLoader_1 = require("./messagesLoader");
-const schemaDirectives_1 = require("./schemaDirectives");
-const typeDefs_1 = require("./typeDefs");
-const cache = {
-    executableSchema: null,
-    schemaMetaData: null,
-    typeDefs: null,
-};
-let appTypeDefs;
-try {
-    appTypeDefs = fs_extra_1.readFileSync('./service/schema.graphql', 'utf8');
-    // tslint:disable-next-line:no-empty
-}
-catch (err) { }
-exports.makeSchema = (ctx) => {
-    const { graphql: { resolvers: appResolvers, schemaDirectives: appDirectives, }, clients: { segment }, vtex: { locale }, } = ctx;
-    if (cache.executableSchema) {
-        return cache.executableSchema;
-    }
-    const schemaMetaData = extractSchemaMetaData(appTypeDefs);
-    // The target translation locale is only necessary if this GraphQL app uses the `IOMessage` resolver.
-    const getLocaleTo = async () => {
-        if (locale) {
-            return locale;
-        }
-        const { cultureInfo } = await segment.getSegment();
-        return cultureInfo;
-    };
-    const resolverContext = {
-        getLocaleTo,
-        translationsLoader: messagesLoader_1.messagesLoader(ctx.clients),
-    };
-    const executableSchema = graphql_tools_1.makeExecutableSchema({
-        resolvers: Object.assign({}, appResolvers, typeDefs_1.nativeResolvers(resolverContext)),
-        schemaDirectives: Object.assign({}, appDirectives, schemaDirectives_1.nativeSchemaDirectives),
-        typeDefs: getOrSetTypeDefs(schemaMetaData),
-    });
-    if (isSchemaCacheable(schemaMetaData)) {
-        cache.executableSchema = executableSchema;
-    }
-    return executableSchema;
-};
-const getOrSetTypeDefs = (schemaMetaData) => {
-    if (!cache.typeDefs) {
-        cache.typeDefs = [
-            appTypeDefs,
-            typeDefs_1.nativeTypeDefs(schemaMetaData),
-        ].join('\n\n');
-    }
-    return cache.typeDefs;
-};
-const hasScalar = (typeDefs) => (scalar) => new RegExp(`scalar(\\s)+${scalar}(\\s\\n)+`).test(typeDefs);
-const extractSchemaMetaData = (typeDefs) => {
-    if (!cache.schemaMetaData) {
-        const scalars = ramda_1.keys(typeDefs_1.scalarResolversMap);
-        const scalarsPresentInSchema = ramda_1.map(hasScalar(typeDefs), scalars);
-        cache.schemaMetaData = ramda_1.zipObj(scalars, scalarsPresentInSchema);
-    }
-    return cache.schemaMetaData;
-};
-const isSchemaCacheable = (schemaMetaData) => !ramda_1.any(scalar => schemaMetaData[scalar], typeDefs_1.shouldNotCacheWhenSchemaHas);

package/lib/service/graphql/schema/messagesLoader.d.ts

@@ -1,4 +0,0 @@
-import DataLoader from 'dataloader';
-import { IOClients } from '../../../clients/IOClients';
-import { IOMessage } from '../../../utils/message';
-export declare const messagesLoader: (clients: IOClients) => DataLoader<IOMessage, string>;