@graphql-mesh/thrift 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/{index.mjs → esm/index.js}

@@ -1,44 +1,55 @@
-import { parse, SyntaxType } from '@creditkarma/thrift-parser';
-import { readFileOrUrl } from '@graphql-mesh/utils';
-import { GraphQLID, GraphQLNonNull, GraphQLObjectType, GraphQLInputObjectType, GraphQLEnumType, GraphQLSchema, GraphQLList, GraphQLInt, GraphQLBoolean, GraphQLFloat, GraphQLString } from 'graphql';
-import { GraphQLJSON, GraphQLBigInt, GraphQLByte, GraphQLVoid } from 'graphql-scalars';
-import { createHttpClient } from '@creditkarma/thrift-client';
-import { TType, ThriftClient, MessageType, TApplicationExceptionCodec, TApplicationException, TApplicationExceptionType } from '@creditkarma/thrift-server-core';
+import { GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLSchema, GraphQLString, } from 'graphql';
+import { GraphQLBigInt, GraphQLByte, GraphQLJSON, GraphQLVoid } from 'graphql-scalars';
 import { pascalCase } from 'pascal-case';
+import { createHttpClient } from '@creditkarma/thrift-client';
+import { parse, SyntaxType, } from '@creditkarma/thrift-parser';
+import { MessageType, TApplicationException, TApplicationExceptionCodec, TApplicationExceptionType, ThriftClient, TType, } from '@creditkarma/thrift-server-core';
+import { path, process, util } from '@graphql-mesh/cross-helpers';
 import { PredefinedProxyOptions } from '@graphql-mesh/store';
+import { getInterpolatedHeadersFactory, parseInterpolationStrings, } from '@graphql-mesh/string-interpolation';
+import { readFileOrUrl } from '@graphql-mesh/utils';
 import { AggregateError } from '@graphql-tools/utils';
-import { parseInterpolationStrings, getInterpolatedHeadersFactory } from '@graphql-mesh/string-interpolation';
-import { util, process } from '@graphql-mesh/cross-helpers';
-
-class ThriftHandler {
-    constructor({ config, baseDir, store, fetchFn, importFn, logger }) {
+export default class ThriftHandler {
+    constructor({ config, baseDir, store, importFn, logger, }) {
         this.config = config;
         this.baseDir = baseDir;
         this.idl = store.proxy('idl.json', PredefinedProxyOptions.JsonWithoutValidation);
-        this.fetchFn = fetchFn;
         this.importFn = importFn;
         this.logger = logger;
     }
-    async getMeshSource() {
-        var _a, _b;
-        const { schemaHeaders, serviceName, operationHeaders } = this.config;
-        const thriftAST = await this.idl.getWithSet(async () => {
-            const rawThrift = await readFileOrUrl(this.config.idl, {
-                allowUnknownExtensions: true,
-                cwd: this.baseDir,
-                headers: schemaHeaders,
-                fetch: this.fetchFn,
-                logger: this.logger,
-                importFn: this.importFn,
-            });
-            const parseResult = parse(rawThrift, { organize: false });
-            if (parseResult.type === SyntaxType.ThriftErrors) {
-                if (parseResult.errors.length === 1) {
-                    throw parseResult.errors[0];
-                }
-                throw new AggregateError(parseResult.errors);
+    async parseWithIncludes(idlFilePath, includesMap) {
+        const rawThrift = await readFileOrUrl(idlFilePath, {
+            allowUnknownExtensions: true,
+            cwd: this.baseDir,
+            headers: this.config.schemaHeaders,
+            fetch: this.fetchFn,
+            logger: this.logger,
+            importFn: this.importFn,
+        });
+        const parseResult = parse(rawThrift, { organize: false });
+        const idlNamespace = path.basename(idlFilePath).split('.')[0];
+        if (parseResult.type === SyntaxType.ThriftErrors) {
+            if (parseResult.errors.length === 1) {
+                throw parseResult.errors[0];
             }
-            return parseResult;
+            throw new AggregateError(parseResult.errors);
+        }
+        includesMap[idlNamespace] = parseResult;
+        const includes = parseResult.body.filter((statement) => statement.type === SyntaxType.IncludeDefinition);
+        await Promise.all(includes.map(async (include) => {
+            const includePath = path.resolve(path.dirname(idlFilePath), include.path.value);
+            await this.parseWithIncludes(includePath, includesMap);
+        }));
+        return includesMap;
+    }
+    async getMeshSource({ fetchFn }) {
+        var _a, _b;
+        this.fetchFn = fetchFn;
+        const { serviceName, operationHeaders } = this.config;
+        const namespaceASTMap = await this.idl.getWithSet(async () => {
+            const includeMap = {};
+            await this.parseWithIncludes(this.config.idl, includeMap);
+            return includeMap;
         });
         const enumTypeMap = new Map();
         const outputTypeMap = new Map();
@@ -317,11 +328,15 @@ class ThriftHandler {
                     outputType = GraphQLJSON;
                     const ofTypeKey = getGraphQLFunctionType(functionType.keyType, id);
                     const ofTypeValue = getGraphQLFunctionType(functionType.valueType, id);
-                    typeVal = typeVal || { type: TType.MAP, keyType: ofTypeKey.typeVal, valType: ofTypeValue.typeVal };
+                    typeVal = typeVal || {
+                        type: TType.MAP,
+                        keyType: ofTypeKey.typeVal,
+                        valType: ofTypeValue.typeVal,
+                    };
                     break;
                 }
                 case SyntaxType.Identifier: {
-                    const typeName = functionType.value;
+                    const typeName = functionType.value.replace('.', '_');
                     if (enumTypeMap.has(typeName)) {
                         const enumType = enumTypeMap.get(typeName);
                         inputType = enumType;
@@ -350,114 +365,122 @@ class ThriftHandler {
         }
         const { args: commonArgs, contextVariables } = parseInterpolationStrings(Object.values(operationHeaders || {}));
         const headersFactory = getInterpolatedHeadersFactory(operationHeaders);
-        for (const statement of thriftAST.body) {
-            switch (statement.type) {
-                case SyntaxType.EnumDefinition:
-                    enumTypeMap.set(statement.name.value, new GraphQLEnumType({
-                        name: statement.name.value,
-                        description: processComments(statement.comments),
-                        values: statement.members.reduce((prev, curr) => ({
-                            ...prev,
-                            [curr.name.value]: {
-                                description: processComments(curr.comments),
-                                value: curr.name.value,
-                            },
-                        }), {}),
-                    }));
-                    break;
-                case SyntaxType.StructDefinition: {
-                    const structName = statement.name.value;
-                    const description = processComments(statement.comments);
-                    const objectFields = {};
-                    const inputObjectFields = {};
-                    const structTypeVal = {
-                        id: Math.random(),
-                        name: structName,
-                        type: TType.STRUCT,
-                        fields: {},
-                    };
-                    topTypeMap[structName] = structTypeVal;
-                    const structFieldTypeMap = structTypeVal.fields;
-                    for (const field of statement.fields) {
-                        const fieldName = field.name.value;
-                        let fieldOutputType;
-                        let fieldInputType;
-                        const description = processComments(field.comments);
-                        const processedFieldTypes = getGraphQLFunctionType(field.fieldType, (_a = field.fieldID) === null || _a === void 0 ? void 0 : _a.value);
-                        fieldOutputType = processedFieldTypes.outputType;
-                        fieldInputType = processedFieldTypes.inputType;
-                        if (field.requiredness === 'required') {
-                            fieldOutputType = new GraphQLNonNull(fieldOutputType);
-                            fieldInputType = new GraphQLNonNull(fieldInputType);
-                        }
-                        objectFields[fieldName] = {
-                            type: fieldOutputType,
-                            description,
-                        };
-                        inputObjectFields[fieldName] = {
-                            type: fieldInputType,
-                            description,
-                        };
-                        structFieldTypeMap[fieldName] = processedFieldTypes.typeVal;
-                    }
-                    outputTypeMap.set(structName, new GraphQLObjectType({
-                        name: structName,
-                        description,
-                        fields: objectFields,
-                    }));
-                    inputTypeMap.set(structName, new GraphQLInputObjectType({
-                        name: structName + 'Input',
-                        description,
-                        fields: inputObjectFields,
-                    }));
-                    break;
+        const baseNamespace = path.basename(this.config.idl, '.thrift');
+        for (const namespace of Object.keys(namespaceASTMap).reverse()) {
+            const thriftAST = namespaceASTMap[namespace];
+            for (const statement of thriftAST.body) {
+                let typeName = 'name' in statement ? statement.name.value : undefined;
+                if (namespace !== baseNamespace) {
+                    typeName = `${namespace}_${typeName}`;
                 }
-                case SyntaxType.ServiceDefinition:
-                    for (const fnIndex in statement.functions) {
-                        const fn = statement.functions[fnIndex];
-                        const fnName = fn.name.value;
-                        const description = processComments(fn.comments);
-                        const { outputType: returnType } = getGraphQLFunctionType(fn.returnType, Number(fnIndex) + 1);
-                        const args = {};
-                        for (const argName in commonArgs) {
-                            const typeNameOrType = commonArgs[argName].type;
-                            args[argName] = {
-                                type: typeof typeNameOrType === 'string' ? inputTypeMap.get(typeNameOrType) : typeNameOrType || GraphQLID,
-                            };
-                        }
-                        const fieldTypeMap = {};
-                        for (const field of fn.fields) {
+                switch (statement.type) {
+                    case SyntaxType.EnumDefinition:
+                        enumTypeMap.set(typeName, new GraphQLEnumType({
+                            name: typeName,
+                            description: processComments(statement.comments),
+                            values: statement.members.reduce((prev, curr) => ({
+                                ...prev,
+                                [curr.name.value]: {
+                                    description: processComments(curr.comments),
+                                    value: curr.name.value,
+                                },
+                            }), {}),
+                        }));
+                        break;
+                    case SyntaxType.StructDefinition: {
+                        const description = processComments(statement.comments);
+                        const objectFields = {};
+                        const inputObjectFields = {};
+                        const structTypeVal = {
+                            id: Math.random(),
+                            name: typeName,
+                            type: TType.STRUCT,
+                            fields: {},
+                        };
+                        topTypeMap[typeName] = structTypeVal;
+                        const structFieldTypeMap = structTypeVal.fields;
+                        for (const field of statement.fields) {
                             const fieldName = field.name.value;
-                            const fieldDescription = processComments(field.comments);
-                            let { inputType: fieldType, typeVal } = getGraphQLFunctionType(field.fieldType, (_b = field.fieldID) === null || _b === void 0 ? void 0 : _b.value);
+                            let fieldOutputType;
+                            let fieldInputType;
+                            const description = processComments(field.comments);
+                            const processedFieldTypes = getGraphQLFunctionType(field.fieldType, (_a = field.fieldID) === null || _a === void 0 ? void 0 : _a.value);
+                            fieldOutputType = processedFieldTypes.outputType;
+                            fieldInputType = processedFieldTypes.inputType;
                             if (field.requiredness === 'required') {
-                                fieldType = new GraphQLNonNull(fieldType);
+                                fieldOutputType = new GraphQLNonNull(fieldOutputType);
+                                fieldInputType = new GraphQLNonNull(fieldInputType);
                             }
-                            args[fieldName] = {
-                                type: fieldType,
-                                description: fieldDescription,
+                            objectFields[fieldName] = {
+                                type: fieldOutputType,
+                                description,
+                            };
+                            inputObjectFields[fieldName] = {
+                                type: fieldInputType,
+                                description,
                             };
-                            fieldTypeMap[fieldName] = typeVal;
+                            structFieldTypeMap[fieldName] = processedFieldTypes.typeVal;
                         }
-                        rootFields[fnName] = {
-                            type: returnType,
+                        outputTypeMap.set(typeName, new GraphQLObjectType({
+                            name: typeName,
                             description,
-                            args,
-                            resolve: async (root, args, context, info) => thriftHttpClient.doRequest(fnName, args, fieldTypeMap, {
-                                headers: headersFactory({ root, args, context, info, env: process.env }),
-                            }),
-                        };
-                        methodNames.push(fnName);
-                        methodAnnotations[fnName] = { annotations: {}, fieldAnnotations: {} };
-                        methodParameters[fnName] = fn.fields.length + 1;
+                            fields: objectFields,
+                        }));
+                        inputTypeMap.set(typeName, new GraphQLInputObjectType({
+                            name: typeName + 'Input',
+                            description,
+                            fields: inputObjectFields,
+                        }));
+                        break;
+                    }
+                    case SyntaxType.ServiceDefinition:
+                        for (const fnIndex in statement.functions) {
+                            const fn = statement.functions[fnIndex];
+                            const fnName = fn.name.value;
+                            const description = processComments(fn.comments);
+                            const { outputType: returnType } = getGraphQLFunctionType(fn.returnType, Number(fnIndex) + 1);
+                            const args = {};
+                            for (const argName in commonArgs) {
+                                const typeNameOrType = commonArgs[argName].type;
+                                args[argName] = {
+                                    type: typeof typeNameOrType === 'string'
+                                        ? inputTypeMap.get(typeNameOrType)
+                                        : typeNameOrType || GraphQLID,
+                                };
+                            }
+                            const fieldTypeMap = {};
+                            for (const field of fn.fields) {
+                                const fieldName = field.name.value;
+                                const fieldDescription = processComments(field.comments);
+                                let { inputType: fieldType, typeVal } = getGraphQLFunctionType(field.fieldType, (_b = field.fieldID) === null || _b === void 0 ? void 0 : _b.value);
+                                if (field.requiredness === 'required') {
+                                    fieldType = new GraphQLNonNull(fieldType);
+                                }
+                                args[fieldName] = {
+                                    type: fieldType,
+                                    description: fieldDescription,
+                                };
+                                fieldTypeMap[fieldName] = typeVal;
+                            }
+                            rootFields[fnName] = {
+                                type: returnType,
+                                description,
+                                args,
+                                resolve: async (root, args, context, info) => thriftHttpClient.doRequest(fnName, args, fieldTypeMap, {
+                                    headers: headersFactory({ root, args, context, info, env: process.env }),
+                                }),
+                            };
+                            methodNames.push(fnName);
+                            methodAnnotations[fnName] = { annotations: {}, fieldAnnotations: {} };
+                            methodParameters[fnName] = fn.fields.length + 1;
+                        }
+                        break;
+                    case SyntaxType.TypedefDefinition: {
+                        const { inputType, outputType } = getGraphQLFunctionType(statement.definitionType, Math.random());
+                        inputTypeMap.set(typeName, inputType);
+                        outputTypeMap.set(typeName, outputType);
+                        break;
                     }
-                    break;
-                case SyntaxType.TypedefDefinition: {
-                    const { inputType, outputType } = getGraphQLFunctionType(statement.definitionType, Math.random());
-                    const typeName = statement.name.value;
-                    inputTypeMap.set(typeName, inputType);
-                    outputTypeMap.set(typeName, outputType);
-                    break;
                 }
             }
         }
@@ -474,5 +497,3 @@ class ThriftHandler {
         };
     }
 }
-
-export default ThriftHandler;

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "@graphql-mesh/thrift",
-  "version": "1.0.0-alpha-3fc47d119.0",
+  "version": "1.0.0-alpha-20230420181317-a95037648",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/types": "0.79.0-alpha-3fc47d119.0",
-    "@graphql-mesh/utils": "1.0.0-alpha-3fc47d119.0",
-    "graphql": "*"
+    "@graphql-mesh/cross-helpers": "^0.3.4",
+    "@graphql-mesh/store": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-mesh/types": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-tools/utils": "^9.2.1",
+    "graphql": "*",
+    "tslib": "^2.4.0"
   },
   "dependencies": {
     "@creditkarma/thrift-client": "1.0.4",
     "@creditkarma/thrift-parser": "2.0.0",
     "@creditkarma/thrift-server-core": "1.0.4",
-    "@graphql-mesh/cross-helpers": "0.2.0",
-    "@graphql-mesh/store": "1.0.0-alpha-3fc47d119.0",
-    "@graphql-mesh/string-interpolation": "0.3.0",
-    "@graphql-tools/utils": "8.8.0",
-    "graphql-scalars": "1.17.0",
+    "@graphql-mesh/string-interpolation": "0.4.4",
+    "graphql-scalars": "^1.20.4",
     "pascal-case": "3.1.2",
-    "thrift": "0.16.0",
-    "tslib": "^2.4.0",
+    "thrift": "0.18.1",
     "url-join": "4.0.1"
   },
   "repository": {
@@ -27,21 +27,28 @@
     "directory": "packages/handlers/thrift"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/index.d.cts

@@ -0,0 +1,12 @@
+import { GetMeshSourcePayload, MeshHandler, MeshHandlerOptions, MeshSource, YamlConfig } from '@graphql-mesh/types';
+export default class ThriftHandler implements MeshHandler {
+    private config;
+    private baseDir;
+    private idl;
+    private fetchFn;
+    private importFn;
+    private logger;
+    constructor({ config, baseDir, store, importFn, logger, }: MeshHandlerOptions<YamlConfig.ThriftHandler>);
+    private parseWithIncludes;
+    getMeshSource({ fetchFn }: GetMeshSourcePayload): Promise<MeshSource>;
+}

package/typings/index.d.ts

@@ -0,0 +1,12 @@
+import { GetMeshSourcePayload, MeshHandler, MeshHandlerOptions, MeshSource, YamlConfig } from '@graphql-mesh/types';
+export default class ThriftHandler implements MeshHandler {
+    private config;
+    private baseDir;
+    private idl;
+    private fetchFn;
+    private importFn;
+    private logger;
+    constructor({ config, baseDir, store, importFn, logger, }: MeshHandlerOptions<YamlConfig.ThriftHandler>);
+    private parseWithIncludes;
+    getMeshSource({ fetchFn }: GetMeshSourcePayload): Promise<MeshSource>;
+}

package/index.d.ts

@@ -1,15 +0,0 @@
-import { GetMeshSourceOptions, MeshHandler, YamlConfig } from '@graphql-mesh/types';
-import { GraphQLSchema } from 'graphql';
-export default class ThriftHandler implements MeshHandler {
-    private config;
-    private baseDir;
-    private idl;
-    private fetchFn;
-    private importFn;
-    private logger;
-    constructor({ config, baseDir, store, fetchFn, importFn, logger }: GetMeshSourceOptions<YamlConfig.ThriftHandler>);
-    getMeshSource(): Promise<{
-        schema: GraphQLSchema;
-        contextVariables: Record<string, string>;
-    }>;
-}