sofa-api 0.11.2 → 0.12.0

package/index.mjs

@@ -1,13 +1,11 @@
-import { __awaiter, __asyncValues, __rest } from 'tslib';
-import { getOperationAST, Kind, isScalarType, isEqualType, GraphQLBoolean, isInputObjectType, subscribe, isObjectType, isNonNullType, print, graphql, getNamedType, isListType, isEnumType, parse, printType, isIntrospectionType } from 'graphql';
-import Trouter from 'trouter';
+import { __awaiter, __asyncValues } from 'tslib';
+import { getOperationAST, Kind, isScalarType, isEqualType, GraphQLBoolean, isInputObjectType, isObjectType, isNonNullType, execute, subscribe, getNamedType, isListType, isEnumType, parse, printType, isIntrospectionType } from 'graphql';
+import { Router } from 'itty-router';
 import { buildOperationNodeForField } from '@graphql-tools/utils';
 import { paramCase } from 'param-case';
-import { v4 } from 'uuid';
-import { fetch } from 'cross-undici-fetch';
+import { crypto, fetch, Response } from '@whatwg-node/fetch';
 import colors from 'ansi-colors';
-import { dump } from 'js-yaml';
-import { writeFileSync } from 'fs';
+import { createServerAdapter } from '@whatwg-node/server';
 import { titleCase } from 'title-case';
 
 function getOperationInfo(doc) {
@@ -56,7 +54,7 @@ function resolveVariable({ value, type, schema, }) {
         return value;
     }
     if (type.kind === 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,
@@ -109,20 +107,17 @@ class SubscriptionManager {
     }
     start(event, contextValue) {
         return __awaiter(this, void 0, void 0, function* () {
-            const id = v4();
+            const id = 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') {
@@ -161,9 +156,9 @@ class SubscriptionManager {
             }, contextValue);
         });
     }
-    execute({ id, document, name, url, operationName, variables, contextValue, }) {
+    execute({ id, name, url, variables, contextValue, }) {
         return __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],
@@ -173,9 +168,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 subscribe({
+            const execution = yield this.sofa.subscribe({
                 schema: this.sofa.schema,
                 document,
                 operationName,
@@ -235,7 +230,7 @@ class SubscriptionManager {
                 body: JSON.stringify(result),
                 headers: {
                     'Content-Type': 'application/json',
-                }
+                },
             });
             yield response.text();
         });
@@ -271,7 +266,9 @@ class SubscriptionManager {
 
 function createRouter(sofa) {
     logger.debug('[Sofa] Creating router');
-    const router = new Trouter();
+    const router = Router({
+        base: sofa.basePath,
+    });
     const queryType = sofa.schema.getQueryType();
     const mutationType = sofa.schema.getMutationType();
     const subscriptionManager = new SubscriptionManager(sofa);
@@ -291,95 +288,80 @@ function createRouter(sofa) {
             }
         });
     }
-    router.post('/webhook', ({ body, contextValue }) => __awaiter(this, void 0, void 0, function* () {
-        const { subscription, variables, url } = body;
+    router.post('/webhook', (request, serverContext) => __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 Response(JSON.stringify(result), {
                 status: 200,
-                statusMessage: 'OK',
-                body: result,
-            };
+                statusText: 'OK',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
         }
         catch (error) {
-            return {
-                type: 'error',
+            return new Response(JSON.stringify(error), {
                 status: 500,
-                statusMessage: 'Subscription failed',
-                error,
-            };
+                statusText: 'Subscription failed',
+            });
         }
     }));
-    router.post('/webhook/:id', ({ body, params, contextValue }) => __awaiter(this, void 0, void 0, function* () {
-        const id = params.id;
+    router.post('/webhook/:id', (request, serverContext) => __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 Response(JSON.stringify(result), {
                 status: 200,
-                statusMessage: 'OK',
-                body: result,
-            };
+                statusText: 'OK',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
         }
         catch (error) {
-            return {
-                type: 'error',
+            return new Response(JSON.stringify(error), {
                 status: 500,
-                statusMessage: 'Subscription failed to update',
-                error,
-            };
+                statusText: 'Subscription failed to update',
+            });
         }
     }));
-    router.delete('/webhook/:id', ({ params }) => __awaiter(this, void 0, void 0, function* () {
-        const id = params.id;
+    router.delete('/webhook/:id', (request) => __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 Response(JSON.stringify(result), {
                 status: 200,
-                statusMessage: 'OK',
-                body: result,
-            };
+                statusText: 'OK',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
         }
         catch (error) {
-            return {
-                type: 'error',
+            return new Response(JSON.stringify(error), {
                 status: 500,
-                statusMessage: 'Subscription failed to stop',
-                error,
-            };
-        }
-    }));
-    return ({ method, url, body, contextValue }) => __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 = buildOperationNodeForField({
@@ -407,12 +389,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, }) {
@@ -440,22 +424,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 }) => __awaiter(this, void 0, void 0, function* () {
+    return (request, serverContext) => __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,
             });
@@ -464,36 +463,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: 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 Response(errors[0], {
                     status: 500,
-                    error: errors[0],
-                };
+                });
             };
             const errorHandler = sofa.errorHandler || defaultErrorHandler;
             return errorHandler(result.errors);
         }
-        return {
-            type: 'result',
+        return new 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]);
@@ -513,9 +512,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, models,
+    return Object.assign({ execute,
+        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
@@ -598,7 +613,7 @@ function mapToRef(type) {
     return `#/components/schemas/${type}`;
 }
 
-function buildSchemaObjectFromType(type) {
+function buildSchemaObjectFromType(type, opts) {
     const required = [];
     const properties = {};
     const fields = type.getFields();
@@ -607,28 +622,27 @@ function buildSchemaObjectFromType(type) {
         if (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 (isNonNullType(type)) {
-        return resolveFieldType(type.ofType);
+        return resolveFieldType(type.ofType, opts);
     }
     if (isListType(type)) {
         return {
             type: 'array',
-            items: resolveFieldType(type.ofType),
+            items: resolveFieldType(type.ofType, opts),
         };
     }
     if (isObjectType(type)) {
@@ -637,14 +651,15 @@ function resolveFieldType(type) {
         };
     }
     if (isScalarType(type)) {
-        return (mapToPrimitive(type.name) || {
+        return (mapToPrimitive(type.name) ||
+            opts.customScalars[type.name] || {
             type: 'object',
         });
     }
     if (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 {
@@ -652,10 +667,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: {
@@ -669,12 +686,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,
                         }),
                     },
                 },
@@ -700,7 +718,7 @@ function resolveRequestBody(variables) {
     }
     const properties = {};
     const required = [];
-    variables.forEach(variable => {
+    variables.forEach((variable) => {
         if (variable.type.kind === Kind.NON_NULL_TYPE) {
             required.push(variable.variable.name.value);
         }
@@ -726,26 +744,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 === 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(operation.operation));
@@ -756,7 +774,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
@@ -766,13 +784,13 @@ function isObjectTypeDefinitionNode(node) {
     return node.kind === 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: {},
@@ -782,7 +800,9 @@ function OpenAPI({ schema, info, servers, components, security, tags, }) {
         const type = types[typeName];
         if ((isObjectType(type) || isInputObjectType(type)) &&
             !isIntrospectionType(type)) {
-            swagger.components.schemas[typeName] = buildSchemaObjectFromType(type);
+            swagger.components.schemas[typeName] = buildSchemaObjectFromType(type, {
+                customScalars,
+            });
         }
     }
     if (components) {
@@ -791,6 +811,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) || '';
@@ -799,91 +822,25 @@ 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, dump(swagger));
-            }
-            else {
-                throw new Error('We only support JSON and YAML files');
-            }
-        },
     };
-}
-function writeOutput(filepath, contents) {
-    writeFileSync(filepath, contents, {
-        encoding: 'utf-8',
-    });
 }
 
-function isContextFn(context) {
-    return typeof context === 'function';
-}
-function useSofa(_a) {
-    var { context } = _a, config = __rest(_a, ["context"]);
-    const invokeSofa = createSofaRouter(config);
-    return (req, res, next) => __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 createServerAdapter(createRouter(createSofa(config)));
 }
 
-export { OpenAPI, createSofaRouter, isContextFn, useSofa };
+export { OpenAPI, useSofa };

package/open-api/index.d.ts

@@ -1,16 +1,26 @@
 import { GraphQLSchema } from 'graphql';
 import { RouteInfo } from '../types';
-export declare function OpenAPI({ schema, info, servers, components, security, tags, }: {
+import { OpenAPIV3 } from 'openapi-types';
+export declare function OpenAPI({ schema, info, servers, components, security, tags, customScalars, }: {
     schema: GraphQLSchema;
-    info: Record<string, any>;
-    servers?: Record<string, any>[];
+    info: OpenAPIV3.InfoObject;
+    servers?: OpenAPIV3.ServerObject[];
     components?: Record<string, any>;
-    security?: Record<string, any>[];
-    tags?: Record<string, any>[];
+    security?: OpenAPIV3.SecurityRequirementObject[];
+    tags?: OpenAPIV3.TagObject[];
+    /**
+     * Override mapping of custom scalars to OpenAPI
+     * @example
+     * ```js
+     * {
+     *   Date: { type: "string",  format: "date" }
+     * }
+     * ```
+     */
+    customScalars?: Record<string, any>;
 }): {
     addRoute(info: RouteInfo, config?: {
-        basePath?: string | undefined;
-    } | undefined): void;
-    get(): any;
-    save(filepath: string): void;
+        basePath?: string;
+    }): void;
+    get(): OpenAPIV3.Document<{}>;
 };

package/open-api/operations.d.ts

@@ -1,7 +1,11 @@
 import { DocumentNode, GraphQLSchema } from 'graphql';
-export declare function buildPathFromOperation({ url, schema, operation, useRequestBody, }: {
+import { OpenAPIV3 } from 'openapi-types';
+export declare function buildPathFromOperation({ url, schema, operation, useRequestBody, tags, description, customScalars, }: {
     url: string;
     schema: GraphQLSchema;
     operation: DocumentNode;
     useRequestBody: boolean;
-}): any;
+    tags?: string[];
+    description?: string;
+    customScalars: Record<string, any>;
+}): OpenAPIV3.OperationObject;