sofa-api 0.11.2 → 0.12.0

package/index.js

@@ -6,14 +6,12 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau
 
 const tslib = require('tslib');
 const graphql = require('graphql');
-const Trouter = _interopDefault(require('trouter'));
+const ittyRouter = require('itty-router');
 const utils = require('@graphql-tools/utils');
 const paramCase = require('param-case');
-const uuid = require('uuid');
-const crossUndiciFetch = require('cross-undici-fetch');
+const fetch = require('@whatwg-node/fetch');
 const colors = _interopDefault(require('ansi-colors'));
-const jsYaml = require('js-yaml');
-const fs = require('fs');
+const server = require('@whatwg-node/server');
 const titleCase = require('title-case');
 
 function getOperationInfo(doc) {
@@ -62,7 +60,7 @@ function resolveVariable({ value, type, schema, }) {
         return value;
     }
     if (type.kind === graphql.Kind.LIST_TYPE) {
-        return (Array.isArray(value) ? value : [value]).map(val => resolveVariable({
+        return (Array.isArray(value) ? value : [value]).map((val) => resolveVariable({
             value: val,
             type: type.type,
             schema,
@@ -115,20 +113,17 @@ class SubscriptionManager {
     }
     start(event, contextValue) {
         return tslib.__awaiter(this, void 0, void 0, function* () {
-            const id = uuid.v4();
+            const id = fetch.crypto.randomUUID();
             const name = event.subscription;
             if (!this.operations.has(name)) {
                 throw new Error(`Subscription '${name}' is not available`);
             }
-            const { document, operationName, variables } = this.operations.get(name);
             logger.info(`[Subscription] Start ${id}`, event);
             const result = yield this.execute({
                 id,
                 name,
                 url: event.url,
-                document,
-                operationName,
-                variables,
+                variables: event.variables,
                 contextValue,
             });
             if (typeof result !== 'undefined') {
@@ -167,9 +162,9 @@ class SubscriptionManager {
             }, contextValue);
         });
     }
-    execute({ id, document, name, url, operationName, variables, contextValue, }) {
+    execute({ id, name, url, variables, contextValue, }) {
         return tslib.__awaiter(this, void 0, void 0, function* () {
-            const variableNodes = this.operations.get(name).variables;
+            const { document, operationName, variables: variableNodes } = this.operations.get(name);
             const variableValues = variableNodes.reduce((values, variable) => {
                 const value = parseVariable({
                     value: variables[variable.variable.name.value],
@@ -179,9 +174,9 @@ class SubscriptionManager {
                 if (typeof value === 'undefined') {
                     return values;
                 }
-                return Object.assign(Object.assign({}, values), { [name]: value });
+                return Object.assign(Object.assign({}, values), { [variable.variable.name.value]: value });
             }, {});
-            const execution = yield graphql.subscribe({
+            const execution = yield this.sofa.subscribe({
                 schema: this.sofa.schema,
                 document,
                 operationName,
@@ -236,12 +231,12 @@ class SubscriptionManager {
             }
             const { url } = this.clients.get(id);
             logger.info(`[Subscription] Trigger ${id}`);
-            const response = yield crossUndiciFetch.fetch(url, {
+            const response = yield fetch.fetch(url, {
                 method: 'POST',
                 body: JSON.stringify(result),
                 headers: {
                     'Content-Type': 'application/json',
-                }
+                },
             });
             yield response.text();
         });
@@ -277,7 +272,9 @@ class SubscriptionManager {
 
 function createRouter(sofa) {
     logger.debug('[Sofa] Creating router');
-    const router = new Trouter();
+    const router = ittyRouter.Router({
+        base: sofa.basePath,
+    });
     const queryType = sofa.schema.getQueryType();
     const mutationType = sofa.schema.getMutationType();
     const subscriptionManager = new SubscriptionManager(sofa);
@@ -297,95 +294,80 @@ function createRouter(sofa) {
             }
         });
     }
-    router.post('/webhook', ({ body, contextValue }) => tslib.__awaiter(this, void 0, void 0, function* () {
-        const { subscription, variables, url } = body;
+    router.post('/webhook', (request, serverContext) => tslib.__awaiter(this, void 0, void 0, function* () {
+        const { subscription, variables, url } = yield request.json();
         try {
+            const contextValue = yield sofa.contextFactory(serverContext);
             const result = yield subscriptionManager.start({
                 subscription,
                 variables,
                 url,
             }, contextValue);
-            return {
-                type: 'result',
+            return new fetch.Response(JSON.stringify(result), {
                 status: 200,
-                statusMessage: 'OK',
-                body: result,
-            };
+                statusText: 'OK',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
         }
         catch (error) {
-            return {
-                type: 'error',
+            return new fetch.Response(JSON.stringify(error), {
                 status: 500,
-                statusMessage: 'Subscription failed',
-                error,
-            };
+                statusText: 'Subscription failed',
+            });
         }
     }));
-    router.post('/webhook/:id', ({ body, params, contextValue }) => tslib.__awaiter(this, void 0, void 0, function* () {
-        const id = params.id;
+    router.post('/webhook/:id', (request, serverContext) => tslib.__awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const id = (_a = request.params) === null || _a === void 0 ? void 0 : _a.id;
+        const body = yield request.json();
         const variables = body.variables;
         try {
+            const contextValue = yield sofa.contextFactory(serverContext);
             const result = yield subscriptionManager.update({
                 id,
                 variables,
             }, contextValue);
-            return {
-                type: 'result',
+            return new fetch.Response(JSON.stringify(result), {
                 status: 200,
-                statusMessage: 'OK',
-                body: result,
-            };
+                statusText: 'OK',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
         }
         catch (error) {
-            return {
-                type: 'error',
+            return new fetch.Response(JSON.stringify(error), {
                 status: 500,
-                statusMessage: 'Subscription failed to update',
-                error,
-            };
+                statusText: 'Subscription failed to update',
+            });
         }
     }));
-    router.delete('/webhook/:id', ({ params }) => tslib.__awaiter(this, void 0, void 0, function* () {
-        const id = params.id;
+    router.delete('/webhook/:id', (request) => tslib.__awaiter(this, void 0, void 0, function* () {
+        var _b;
+        const id = (_b = request.params) === null || _b === void 0 ? void 0 : _b.id;
         try {
             const result = yield subscriptionManager.stop(id);
-            return {
-                type: 'result',
+            return new fetch.Response(JSON.stringify(result), {
                 status: 200,
-                statusMessage: 'OK',
-                body: result,
-            };
+                statusText: 'OK',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
         }
         catch (error) {
-            return {
-                type: 'error',
+            return new fetch.Response(JSON.stringify(error), {
                 status: 500,
-                statusMessage: 'Subscription failed to stop',
-                error,
-            };
-        }
-    }));
-    return ({ method, url, body, contextValue }) => tslib.__awaiter(this, void 0, void 0, function* () {
-        if (!url.startsWith(sofa.basePath)) {
-            return null;
-        }
-        // trim base path and search
-        const [slicedUrl] = url.slice(sofa.basePath.length).split('?');
-        const trouterMethod = method.toUpperCase();
-        const obj = router.find(trouterMethod, slicedUrl);
-        for (const handler of obj.handlers) {
-            return yield handler({
-                url,
-                body,
-                params: obj.params,
-                contextValue,
+                statusText: 'Subscription failed to stop',
             });
         }
-        return null;
-    });
+    }));
+    return router;
 }
 function createQueryRoute({ sofa, router, fieldName, }) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     logger.debug(`[Router] Creating ${fieldName} query`);
     const queryType = sofa.schema.getQueryType();
     const operationNode = utils.buildOperationNodeForField({
@@ -413,12 +395,14 @@ function createQueryRoute({ sofa, router, fieldName, }) {
         path: (_c = routeConfig === null || routeConfig === void 0 ? void 0 : routeConfig.path) !== null && _c !== void 0 ? _c : getPath(fieldName, isSingle && hasIdArgument),
         responseStatus: (_d = routeConfig === null || routeConfig === void 0 ? void 0 : routeConfig.responseStatus) !== null && _d !== void 0 ? _d : 200,
     };
-    router[route.method.toLocaleLowerCase()](route.path, useHandler({ info, route, fieldName, sofa, operation }));
+    router[route.method](route.path, useHandler({ info, route, fieldName, sofa, operation }));
     logger.debug(`[Router] ${fieldName} query available at ${route.method} ${route.path}`);
     return {
         document: operation,
         path: route.path,
         method: route.method.toUpperCase(),
+        tags: (_e = routeConfig === null || routeConfig === void 0 ? void 0 : routeConfig.tags) !== null && _e !== void 0 ? _e : [],
+        description: (_f = routeConfig === null || routeConfig === void 0 ? void 0 : routeConfig.description) !== null && _f !== void 0 ? _f : '',
     };
 }
 function createMutationRoute({ sofa, router, fieldName, }) {
@@ -446,22 +430,37 @@ function createMutationRoute({ sofa, router, fieldName, }) {
         responseStatus: (_d = routeConfig === null || routeConfig === void 0 ? void 0 : routeConfig.responseStatus) !== null && _d !== void 0 ? _d : 200,
     };
     const { method, path } = route;
-    router[method.toLowerCase()](path, useHandler({ info, route, fieldName, sofa, operation }));
+    router[method](path, useHandler({ info, route, fieldName, sofa, operation }));
     logger.debug(`[Router] ${fieldName} mutation available at ${method} ${path}`);
     return {
         document: operation,
         path,
         method,
+        tags: (routeConfig === null || routeConfig === void 0 ? void 0 : routeConfig.tags) || [],
+        description: (routeConfig === null || routeConfig === void 0 ? void 0 : routeConfig.description) || '',
     };
 }
 function useHandler(config) {
     const { sofa, operation, fieldName } = config;
     const info = config.info;
-    return ({ url, body, params, contextValue }) => tslib.__awaiter(this, void 0, void 0, function* () {
+    return (request, serverContext) => tslib.__awaiter(this, void 0, void 0, function* () {
+        var _a;
+        let body = {};
+        if (request.body != null) {
+            const strBody = yield request.text();
+            if (strBody) {
+                body = JSON.parse(strBody);
+            }
+        }
         const variableValues = info.variables.reduce((variables, variable) => {
             const name = variable.variable.name.value;
             const value = parseVariable({
-                value: pickParam({ url, body, params, name }),
+                value: pickParam({
+                    url: request.url,
+                    body,
+                    params: request.params || {},
+                    name,
+                }),
                 variable,
                 schema: sofa.schema,
             });
@@ -470,36 +469,36 @@ function useHandler(config) {
             }
             return Object.assign(Object.assign({}, variables), { [name]: value });
         }, {});
+        const contextValue = yield sofa.contextFactory(serverContext);
         const result = yield sofa.execute({
             schema: sofa.schema,
-            source: graphql.print(operation),
+            document: operation,
             contextValue,
             variableValues,
             operationName: info.operation.name && info.operation.name.value,
         });
         if (result.errors) {
             const defaultErrorHandler = (errors) => {
-                return {
-                    type: 'error',
+                return new fetch.Response(errors[0], {
                     status: 500,
-                    error: errors[0],
-                };
+                });
             };
             const errorHandler = sofa.errorHandler || defaultErrorHandler;
             return errorHandler(result.errors);
         }
-        return {
-            type: 'result',
+        return new fetch.Response(JSON.stringify((_a = result.data) === null || _a === void 0 ? void 0 : _a[fieldName]), {
             status: config.route.responseStatus,
-            body: result.data && result.data[fieldName],
-        };
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
     });
 }
 function getPath(fieldName, hasId = false) {
     return `/${convertName(fieldName)}${hasId ? '/:id' : ''}`;
 }
 function pickParam({ name, url, params, body, }) {
-    if (params && params.hasOwnProperty(name)) {
+    if (name in params) {
         return params[name];
     }
     const searchParams = new URLSearchParams(url.split('?')[1]);
@@ -519,9 +518,25 @@ function createSofa(config) {
     const depthLimit = config.depthLimit || 1;
     logger.debug(`[Sofa] models: ${models.join(', ')}`);
     logger.debug(`[Sofa] ignore: ${ignore.join(', ')}`);
-    return Object.assign({ execute: graphql.graphql, models,
+    return Object.assign({ execute: graphql.execute,
+        subscribe: graphql.subscribe,
+        models,
         ignore,
-        depthLimit }, config);
+        depthLimit,
+        contextFactory(serverContext) {
+            if (config.context != null) {
+                if (isContextFn(config.context)) {
+                    return config.context(serverContext);
+                }
+                else {
+                    return config.context;
+                }
+            }
+            return serverContext;
+        } }, config);
+}
+function isContextFn(context) {
+    return typeof context === 'function';
 }
 // Objects and Unions are the only things that are used to define return types
 // and both might contain an ID
@@ -604,7 +619,7 @@ function mapToRef(type) {
     return `#/components/schemas/${type}`;
 }
 
-function buildSchemaObjectFromType(type) {
+function buildSchemaObjectFromType(type, opts) {
     const required = [];
     const properties = {};
     const fields = type.getFields();
@@ -613,28 +628,27 @@ function buildSchemaObjectFromType(type) {
         if (graphql.isNonNullType(field.type)) {
             required.push(field.name);
         }
-        properties[fieldName] = resolveField(field);
+        properties[fieldName] = resolveField(field, opts);
         if (field.description) {
             properties[fieldName].description = field.description;
         }
     }
     return Object.assign(Object.assign(Object.assign({ type: 'object' }, (required.length ? { required } : {})), { properties }), (type.description ? { description: type.description } : {}));
 }
-function resolveField(field) {
-    return resolveFieldType(field.type);
+function resolveField(field, opts) {
+    return resolveFieldType(field.type, opts);
 }
 // array -> [type]
 // type -> $ref
 // scalar -> swagger primitive
-function resolveFieldType(type) {
-    var _a, _b;
+function resolveFieldType(type, opts) {
     if (graphql.isNonNullType(type)) {
-        return resolveFieldType(type.ofType);
+        return resolveFieldType(type.ofType, opts);
     }
     if (graphql.isListType(type)) {
         return {
             type: 'array',
-            items: resolveFieldType(type.ofType),
+            items: resolveFieldType(type.ofType, opts),
         };
     }
     if (graphql.isObjectType(type)) {
@@ -643,14 +657,15 @@ function resolveFieldType(type) {
         };
     }
     if (graphql.isScalarType(type)) {
-        return (mapToPrimitive(type.name) || {
+        return (mapToPrimitive(type.name) ||
+            opts.customScalars[type.name] || {
             type: 'object',
         });
     }
     if (graphql.isEnumType(type)) {
         return {
             type: 'string',
-            enum: (_b = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.values) === null || _b === void 0 ? void 0 : _b.map((value) => value.name.value),
+            enum: type.getValues().map((value) => value.name),
         };
     }
     return {
@@ -658,10 +673,12 @@ function resolveFieldType(type) {
     };
 }
 
-function buildPathFromOperation({ url, schema, operation, useRequestBody, }) {
+function buildPathFromOperation({ url, schema, operation, useRequestBody, tags, description, customScalars, }) {
     const info = getOperationInfo(operation);
-    const description = resolveDescription(schema, info.operation);
-    return Object.assign(Object.assign({ operationId: info.name }, (useRequestBody
+    const summary = resolveSummary(schema, info.operation);
+    return Object.assign(Object.assign({ tags,
+        description,
+        summary, operationId: info.name }, (useRequestBody
         ? {
             requestBody: {
                 content: {
@@ -675,12 +692,13 @@ function buildPathFromOperation({ url, schema, operation, useRequestBody, }) {
             parameters: resolveParameters(url, info.operation.variableDefinitions),
         })), { responses: {
             200: {
-                description,
+                description: summary,
                 content: {
                     'application/json': {
                         schema: resolveResponse({
                             schema,
                             operation: info.operation,
+                            customScalars,
                         }),
                     },
                 },
@@ -706,7 +724,7 @@ function resolveRequestBody(variables) {
     }
     const properties = {};
     const required = [];
-    variables.forEach(variable => {
+    variables.forEach((variable) => {
         if (variable.type.kind === graphql.Kind.NON_NULL_TYPE) {
             required.push(variable.variable.name.value);
         }
@@ -732,26 +750,26 @@ function resolveParamSchema(type) {
         $ref: mapToRef(type.name.value),
     });
 }
-function resolveResponse({ schema, operation, }) {
+function resolveResponse({ schema, operation, customScalars, }) {
     const operationType = operation.operation;
     const rootField = operation.selectionSet.selections[0];
     if (rootField.kind === graphql.Kind.FIELD) {
         if (operationType === 'query') {
             const queryType = schema.getQueryType();
             const field = queryType.getFields()[rootField.name.value];
-            return resolveFieldType(field.type);
+            return resolveFieldType(field.type, { customScalars });
         }
         if (operationType === 'mutation') {
             const mutationType = schema.getMutationType();
             const field = mutationType.getFields()[rootField.name.value];
-            return resolveFieldType(field.type);
+            return resolveFieldType(field.type, { customScalars });
         }
     }
 }
 function isInPath(url, param) {
     return url.indexOf(`{${param}}`) !== -1;
 }
-function resolveDescription(schema, operation) {
+function resolveSummary(schema, operation) {
     const selection = operation.selectionSet.selections[0];
     const fieldName = selection.name.value;
     const typeDefinition = schema.getType(titleCase.titleCase(operation.operation));
@@ -762,7 +780,7 @@ function resolveDescription(schema, operation) {
     if (!isObjectTypeDefinitionNode(definitionNode)) {
         return '';
     }
-    const fieldNode = definitionNode.fields.find(field => field.name.value === fieldName);
+    const fieldNode = definitionNode.fields.find((field) => field.name.value === fieldName);
     const descriptionDefinition = fieldNode && fieldNode.description;
     return descriptionDefinition && descriptionDefinition.value
         ? descriptionDefinition.value
@@ -772,13 +790,13 @@ function isObjectTypeDefinitionNode(node) {
     return node.kind === graphql.Kind.OBJECT_TYPE_DEFINITION;
 }
 
-function OpenAPI({ schema, info, servers, components, security, tags, }) {
+function OpenAPI({ schema, info, servers, components, security, tags, customScalars = {}, }) {
     const types = schema.getTypeMap();
     const swagger = {
         openapi: '3.0.0',
         info,
         servers,
-        tags,
+        tags: [],
         paths: {},
         components: {
             schemas: {},
@@ -788,7 +806,9 @@ function OpenAPI({ schema, info, servers, components, security, tags, }) {
         const type = types[typeName];
         if ((graphql.isObjectType(type) || graphql.isInputObjectType(type)) &&
             !graphql.isIntrospectionType(type)) {
-            swagger.components.schemas[typeName] = buildSchemaObjectFromType(type);
+            swagger.components.schemas[typeName] = buildSchemaObjectFromType(type, {
+                customScalars,
+            });
         }
     }
     if (components) {
@@ -797,6 +817,9 @@ function OpenAPI({ schema, info, servers, components, security, tags, }) {
     if (security) {
         swagger.security = security;
     }
+    if (tags) {
+        swagger.tags = tags;
+    }
     return {
         addRoute(info, config) {
             const basePath = (config === null || config === void 0 ? void 0 : config.basePath) || '';
@@ -805,94 +828,26 @@ function OpenAPI({ schema, info, servers, components, security, tags, }) {
             if (!swagger.paths[path]) {
                 swagger.paths[path] = {};
             }
-            swagger.paths[path][info.method.toLowerCase()] = buildPathFromOperation({
+            const pathsObj = swagger.paths[path];
+            pathsObj[info.method.toLowerCase()] = buildPathFromOperation({
                 url: path,
                 operation: info.document,
                 schema,
                 useRequestBody: ['POST', 'PUT', 'PATCH'].includes(info.method),
+                tags: info.tags || [],
+                description: info.description || '',
+                customScalars,
             });
         },
         get() {
             return swagger;
         },
-        save(filepath) {
-            const isJSON = /\.json$/i;
-            const isYAML = /.ya?ml$/i;
-            if (isJSON.test(filepath)) {
-                writeOutput(filepath, JSON.stringify(swagger, null, 2));
-            }
-            else if (isYAML.test(filepath)) {
-                writeOutput(filepath, jsYaml.dump(swagger));
-            }
-            else {
-                throw new Error('We only support JSON and YAML files');
-            }
-        },
     };
-}
-function writeOutput(filepath, contents) {
-    fs.writeFileSync(filepath, contents, {
-        encoding: 'utf-8',
-    });
 }
 
-function isContextFn(context) {
-    return typeof context === 'function';
-}
-function useSofa(_a) {
-    var { context } = _a, config = tslib.__rest(_a, ["context"]);
-    const invokeSofa = createSofaRouter(config);
-    return (req, res, next) => tslib.__awaiter(this, void 0, void 0, function* () {
-        var _b;
-        try {
-            let contextValue = { req };
-            if (context) {
-                if (typeof context === 'function') {
-                    contextValue = yield context({ req, res });
-                }
-                else {
-                    contextValue = context;
-                }
-            }
-            const response = yield invokeSofa({
-                method: req.method,
-                url: (_b = req.originalUrl) !== null && _b !== void 0 ? _b : req.url,
-                body: req.body,
-                contextValue,
-            });
-            if (response == null) {
-                next();
-            }
-            else {
-                const headers = {
-                    'Content-Type': 'application/json',
-                };
-                if (response.statusMessage) {
-                    res.writeHead(response.status, response.statusMessage, headers);
-                }
-                else {
-                    res.writeHead(response.status, headers);
-                }
-                if (response.type === 'result') {
-                    res.end(JSON.stringify(response.body));
-                }
-                if (response.type === 'error') {
-                    res.end(JSON.stringify(response.error));
-                }
-            }
-        }
-        catch (error) {
-            next(error);
-        }
-    });
-}
-function createSofaRouter(config) {
-    const sofa = createSofa(config);
-    const router = createRouter(sofa);
-    return router;
+function useSofa(config) {
+    return server.createServerAdapter(createRouter(createSofa(config)));
 }
 
 exports.OpenAPI = OpenAPI;
-exports.createSofaRouter = createSofaRouter;
-exports.isContextFn = isContextFn;
 exports.useSofa = useSofa;