dhaivatpandya

persistgraphql

Object.defineProperty(exports, "__esModule", { value: true });

var extractFromAST_1 = require("./extractFromAST");

var extractFromJS_1 = require("./extractFromJS");

var queryTransformers_1 = require("./queryTransformers");

        var inputFilePath = _a.inputFilePath, _b = _a.outputFilePath, outputFilePath = _b === void 0 ? 'extracted_queries.json' : _b, _c = _a.queryTransformers, queryTransformers = _c === void 0 ? [] : _c, _d = _a.extension, extension = _d === void 0 ? 'graphql' : _d, _e = _a.inJsCode, inJsCode = _e === void 0 ? false : _e;

        this.inputFilePath = inputFilePath;

        this.outputFilePath = outputFilePath;

        this.queryTransformers = queryTransformers;

    ExtractGQL.getFileExtension = function (filePath) {

        var pieces = path.basename(filePath).split('.');

        return pieces[pieces.length - 1];

    ExtractGQL.readFile = function (filePath) {

        return new Promise(function (resolve, reject) {

            fs.readFile(filePath, 'utf8', function (err, data) {

    ExtractGQL.isDirectory = function (path) {

            fs.stat(path, function (err, stats) {

                    resolve(stats.isDirectory());

    ExtractGQL.prototype.addQueryTransformer = function (queryTransformer) {

        this.queryTransformers.push(queryTransformer);

    ExtractGQL.prototype.applyQueryTransformers = function (document) {

        return common_1.applyQueryTransformers(document, this.queryTransformers);

    ExtractGQL.prototype.getQueryKey = function (definition) {

        return common_1.getQueryKey(definition, this.queryTransformers);

    ExtractGQL.prototype.getQueryDocumentKey = function (document) {

        return common_1.getQueryDocumentKey(document, this.queryTransformers);

    ExtractGQL.prototype.createMapFromDocument = function (document) {

        var transformedDocument = this.applyQueryTransformers(document);

        var queryDefinitions = extractFromAST_1.getOperationDefinitions(transformedDocument);

        queryDefinitions.forEach(function (transformedDefinition) {

            var transformedQueryWithFragments = _this.getQueryFragments(transformedDocument, transformedDefinition);

            transformedQueryWithFragments.definitions.unshift(transformedDefinition);

            var docQueryKey = _this.getQueryDocumentKey(transformedQueryWithFragments);

            result[docQueryKey] = _this.getQueryId();

    ExtractGQL.prototype.processGraphQLFile = function (graphQLFile) {

            ExtractGQL.readFile(graphQLFile).then(function (fileContents) {

                var graphQLDocument = graphql_1.parse(fileContents);

                resolve(_this.createMapFromDocument(graphQLDocument));

    ExtractGQL.prototype.createOutputMapFromString = function (docString) {

        var doc = graphql_1.parse(docString);

        var docMap = graphql_1.separateOperations(doc);

        var resultMaps = Object.keys(docMap).map(function (operationName) {

            var document = docMap[operationName];

            return _this.createMapFromDocument(document);

        return _.merge.apply(_, [{}].concat(resultMaps));

                        Promise.all(promises).then(function (queryStrings) {

                            resolve(queryStrings.reduce(function (x, y) { return x + y; }));

                            resolve(queryStrings.reduce(function (x, y) { return x + y; }, ''));

                    _this.readInputFile(inputPath).then(function (result) {

                    }).catch(function (err) {

                        console.log("Error occurred in processing path " + inputPath + ": ");

                        console.log(err.message);

    ExtractGQL.prototype.getQueryFragments = function (document, queryDefinition) {

        var queryFragmentNames = extractFromAST_1.getFragmentNames(queryDefinition.selectionSet, document);

        var reduceQueryDefinitions = function (carry, definition) {

            var definitionName = definition.name;

            if ((extractFromAST_1.isFragmentDefinition(definition) && queryFragmentNames[definitionName.value] === 1)) {

                var definitionExists = carry.findIndex(function (value) { return value.name.value === definitionName.value; }) !== -1;

                    return carry.concat([definition]);

        retDocument.definitions = document.definitions.reduce(reduceQueryDefinitions, []).sort(common_1.sortFragmentsByName);

    ExtractGQL.prototype.getQueryId = function () {

    ExtractGQL.prototype.writeOutputMap = function (outputMap, outputFilePath) {

            fs.open(outputFilePath, 'w+', function (openErr, fd) {

                fs.write(fd, JSON.stringify(outputMap), function (writeErr, written, str) {

                        reject(writeErr);

    ExtractGQL.prototype.extract = function () {

        this.processInputPath(this.inputFilePath).then(function (outputMap) {

            _this.writeOutputMap(outputMap, _this.outputFilePath).then(function () {

                console.log("Wrote output file to " + _this.outputFilePath + ".");

                console.log("Unable to process ouput path " + _this.outputFilePath + ". Error message: ");

                console.log("" + err.message);

            console.log("Unable to process input path " + _this.inputFilePath + ". Error message: ");

            console.log("" + err.message);

        console.log('Usage: persistgraphql input_file [output_file]');

        console.log('Using the add-typename query transformer.');

        queryTransformers.push(queryTransformers_1.addTypenameTransformer);

        queryTransformers: queryTransformers,

        options.extension = argv['extension'];

var extractFromAST_1 = require("../src/extractFromAST");

var ExtractGQL_1 = require("../src/ExtractGQL");

var queryTransformers_1 = require("../src/queryTransformers");

var graphql_tag_1 = require("graphql-tag");

    var queries = (_a = ["\n    query {\n      author {\n        firstName\n        lastName\n      }\n    }\n\n    query otherQuery {\n      person {\n        firstName\n        lastName\n      }\n    }"], _a.raw = ["\n    query {\n      author {\n        firstName\n        lastName\n      }\n    }\n\n    query otherQuery {\n      person {\n        firstName\n        lastName\n      }\n    }"], graphql_tag_1.default(_a));

    var egql = new ExtractGQL_1.ExtractGQL({ inputFilePath: 'not-real' });

        egql.getQueryKey(queries.definitions[0]),

        egql.getQueryKey(queries.definitions[1]),

    it('should be able to construct an instance', function () {

        assert.doesNotThrow(function () {

            new ExtractGQL_1.ExtractGQL({

                inputFilePath: 'queries.graphql',

                outputFilePath: 'output.json',

    describe('isDirectory', function () {

        it('should return true on a directory', function (done) {

            ExtractGQL_1.ExtractGQL.isDirectory('./test/fixtures').then(function (result) {

        it('should return false on a file', function (done) {

            ExtractGQL_1.ExtractGQL.isDirectory('./test/fixtures/single_query/queries.graphql').then(function (result) {

    describe('getFileExtension', function () {

        it('should return the correct extension on a file with an extension', function () {

            assert.equal(ExtractGQL_1.ExtractGQL.getFileExtension('../../path/source.graphql'), 'graphql');

            assert.equal(ExtractGQL_1.ExtractGQL.getFileExtension('/some/complicated/path.with.dots/dots../view.js'), 'js');

        it('should return an empty string if the file has no extension', function () {

            assert.equal(ExtractGQL_1.ExtractGQL.getFileExtension('/redherring.graphql/file'), '');

            assert.equal(ExtractGQL_1.ExtractGQL.getFileExtension('file'), '');

        it('should be able to read a file into a string', function (done) {

            var filePath = 'test/fixtures/single_query/queries.graphql';

            ExtractGQL_1.ExtractGQL.readFile(filePath).then(function (result) {

                var graphQLString = graphql_1.print(graphql_1.parse(result));

                assert.deepEqual(graphQLString, graphql_1.print(queries));

    describe('createMapFromDocument', function () {

        it('should be able to handle a document with no queries', function () {

            var document = (_a = ["fragment something on Type { otherThing }"], _a.raw = ["fragment something on Type { otherThing }"], graphql_tag_1.default(_a));

            var map = egql.createMapFromDocument(document);

        it('should be able to handle a document with a single query', function () {

            var myegql = new ExtractGQL_1.ExtractGQL({ inputFilePath: 'nothing' });

            var document = (_a = ["query author {\n        name\n      }"], _a.raw = ["query author {\n        name\n      }"], graphql_tag_1.default(_a));

            var map = myegql.createMapFromDocument(document);

            var key = egql.getQueryDocumentKey(document);

            assert.equal(Object.keys(map).length, 1);

        it('should be able to handle a document with a fragment', function () {

            var myegql = new ExtractGQL_1.ExtractGQL({ inputFilePath: 'empty' });

            var document = (_a = ["\n        query authorList {\n          author {\n            ...authorDetails\n          }\n        }\n        fragment authorDetails on Author {\n          firstName\n          lastName\n        }\n      "], _a.raw = ["\n        query authorList {\n          author {\n            ...authorDetails\n          }\n        }\n        fragment authorDetails on Author {\n          firstName\n          lastName\n        }\n      "], graphql_tag_1.default(_a));

            var key = myegql.getQueryDocumentKey(document);

        it('should be able to handle a document with multiple fragments', function () {

            var document = (_a = ["\n        query authorList {\n          author {\n            ...authorDetails\n            ...otherDetails\n          }\n        }\n        fragment authorDetails on Author {\n          firstName\n          lastName\n        }\n        fragment otherDetails on Author {\n          author\n        }"], _a.raw = ["\n        query authorList {\n          author {\n            ...authorDetails\n            ...otherDetails\n          }\n        }\n        fragment authorDetails on Author {\n          firstName\n          lastName\n        }\n        fragment otherDetails on Author {\n          author\n        }"], graphql_tag_1.default(_a));

            assert.equal(Object.keys(map)[0], graphql_1.print(document));

        it('should be able to handle a document with unused fragments', function () {

            var document = (_a = ["\n        query authorList {\n          author {\n            firstName\n            lastName\n          }\n        }\n        fragment pointlessFragment on Author {\n          firstName\n          lastName\n        }\n      "], _a.raw = ["\n        query authorList {\n          author {\n            firstName\n            lastName\n          }\n        }\n        fragment pointlessFragment on Author {\n          firstName\n          lastName\n        }\n      "], graphql_tag_1.default(_a));

            assert.equal(Object.keys(map)[0], graphql_1.print(extractFromAST_1.createDocumentFromQuery(document.definitions[0])));

        it('should be able to handle a document with multiple queries sharing a fragment', function () {

            var document = (_a = ["\n        query authorList {\n          author {\n            ...authorDetails\n          }\n        }\n        query authorInfo {\n          author {\n            ...authorDetails\n          }\n        }\n        fragment authorDetails on Author {\n          firstName\n          lastName\n        }\n      "], _a.raw = ["\n        query authorList {\n          author {\n            ...authorDetails\n          }\n        }\n        query authorInfo {\n          author {\n            ...authorDetails\n          }\n        }\n        fragment authorDetails on Author {\n          firstName\n          lastName\n        }\n      "], graphql_tag_1.default(_a));

        it('should process a directory with no graphql files', function (done) {

            egql.processInputPath('./test/fixtures/no_queries').then(function (result) {

                assert.equal(Object.keys(result).length, 2);

        it('should process a file with a fragment reference to a different file', function () {

            var expectedQuery = (_a = ["\n        query {\n          author {\n            ...details\n          }\n        }\n        fragment details on Author {\n          firstName\n          lastName\n        }\n        "], _a.raw = ["\n        query {\n          author {\n            ...details\n          }\n        }\n        fragment details on Author {\n          firstName\n          lastName\n        }\n        "], graphql_tag_1.default(_a));

            return egql.processInputPath('./test/fixtures/single_fragment').then(function (result) {

                var keys = Object.keys(result);

                assert.equal(keys.length, 1);

                assert.include(Object.keys(result), graphql_1.print(expectedQuery));

        it('should process a JS file with queries', function () {

            var jsEgql = new ExtractGQL_1.ExtractGQL({

            return jsEgql.processInputPath('./test/fixtures/single_fragment_js')

                .then(function (result) {

                assert.equal(keys[0], graphql_1.print(expectedQuery));

    describe('writeOutputMap', function () {

        it('should be able to write an OutputMap to a file', function (done) {

            var outputMap = egql.createMapFromDocument(queries);

            egql.writeOutputMap(outputMap, './test/output_tests/output.graphql').then(function () {

    describe('getQueryKey', function () {

        it('should apply query transformers before returning the query key', function () {

            var query = (_a = ["\n        query {\n          author {\n            firstName\n            lastName\n          }\n        }"], _a.raw = ["\n        query {\n          author {\n            firstName\n            lastName\n          }\n        }"], graphql_tag_1.default(_a));

            var transformedQuery = (_b = ["\n        query {\n          author {\n            firstName\n            lastName\n            __typename\n          }\n        }"], _b.raw = ["\n        query {\n          author {\n            firstName\n            lastName\n            __typename\n          }\n        }"], graphql_tag_1.default(_b));

            var myegql = new ExtractGQL_1.ExtractGQL({

                queryTransformers: [queryTransformers_1.addTypenameTransformer],

            assert.equal(myegql.getQueryKey(query.definitions[0]), graphql_1.print(transformedQuery.definitions[0]));

  "description": "A build tool for GraphQL projects.",

    "test": "mocha --reporter spec --full-trace lib/test/tests.js",

    "lint": "tslint -c tslint.json test/**/*.ts; tslint src/**/*.ts"

    "url": "git+https://github.com/Poincare/apollo-query-whitelisting.git"

    "url": "https://github.com/Poincare/persistgraphql/issues"

  "homepage": "https://github.com/Poincare/persistgraphql#readme",

    "persistgraphql": "./bin/persistgraphql"

		{
		"name": "persistgraphql",
		"version": "0.3.9",
		"version": "0.3.10",
		"description": "A build tool for GraphQL projects.",
		@@ -5,0 +5,0 @@ "main": "lib/index.js",

		@@ -150,3 +150,3 @@ "use strict";
		Promise.all(promises).then(function (queryStrings) {
		resolve(queryStrings.reduce(function (x, y) { return x + y; }));
		resolve(queryStrings.reduce(function (x, y) { return x + y; }, ''));
		});
		@@ -153,0 +153,0 @@ });

		@@ -216,2 +216,8 @@ "use strict";
		});
		it('should process a directory with no graphql files', function (done) {
		egql.processInputPath('./test/fixtures/no_queries').then(function (result) {
		assert.equal(Object.keys(result).length, 2);
		done();
		});
		});
		it('should process a file with a fragment reference to a different file', function () {
		@@ -218,0 +224,0 @@ var expectedQuery = (_a = ["\n query {\n author {\n ...details\n }\n }\n fragment details on Author {\n firstName\n lastName\n }\n "], _a.raw = ["\n query {\n author {\n ...details\n }\n }\n fragment details on Author {\n firstName\n lastName\n }\n "], graphql_tag_1.default(_a));

Improved metrics