New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

graphql-query-factory

Package Overview
Dependencies
Maintainers
1
Versions
24
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

graphql-query-factory - npm Package Compare versions

Comparing version 1.0.12 to 1.0.13

project.graphcool
yarn.lock

56

dist/batcher.js

@@ -1,5 +0,8 @@

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
"use strict";
const { GraphQLClient } = require('graphql-request');
const chalk = require('chalk');
const fetch = require("node-fetch");
global.fetch = fetch;
const { ApolloClient, createNetworkInterface } = require("apollo-client");
const gql = require("graphql-tag");
const chalk = require("chalk");
const log = console.log;

@@ -12,2 +15,3 @@

}
class QueryBatcher {

@@ -34,21 +38,35 @@ constructor(queries, concurrent) {

let sliced = this.sliceQueryArray(queries, concurrent);
return sliced;
// let target = sliced.target;
// let original = sliced.original; //TODO: refactor "original" to "remaining"
// if (target !== undefined) {
// for (let query in target) {
// client.query({});
// }
// } else {
// return sliced;
// }
}
queryExecute(query) {
return _asyncToGenerator(function* () {
let endpoint = String(process && process.env && process.env.GQL_SIMPLE_ENDPOINT || 'https://api.graph.cool/simple/v1/cj6qq63wr0mrv0187fq2xdf0u');
let token = String(process && process.env && process.env.GQL_AUTH_TOKEN || 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE1MDM2MDY5NTUsImNsaWVudElkIjoiY2oxYzRqZ3Axa2lwdzAxMDV4MDVmZTRuNSIsInByb2plY3RJZCI6ImNqNnFxNjN3cjBtcnYwMTg3ZnEyeGRmMHUiLCJwZXJtYW5lbnRBdXRoVG9rZW5JZCI6ImNqNnF3cmNhajB2bHIwMTg3eHg2N2ZvdW0ifQ.vN6R2A-lMv_gVPWwoZlf0JbkBNsX8YSpZUA_Xq9u_K4');
const client = new GraphQLClient(endpoint, {
headers: {
'Authorization': `Bearer ${token}`
async queryExecute(query) {
const client = new ApolloClient({
networkInterface: createNetworkInterface({
uri: process && process.env && process.env.GQL_SIMPLE_ENDPOINT || "https://api.graph.cool/simple/v1/cj7rzel6x02b40143fhkupzik",
opts: {
headers: { Authorization: process && process.env && process.env.GQL_AUTH_TOKEN || "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE1MDU4NDkxNTIsImNsaWVudElkIjoiY2oxYzRqZ3Axa2lwdzAxMDV4MDVmZTRuNSIsInByb2plY3RJZCI6ImNqN3J6ZWw2eDAyYjQwMTQzZmhrdXB6aWsiLCJwZXJtYW5lbnRBdXRoVG9rZW5JZCI6ImNqN3J6cGVidDAyeTQwMTU1cG9odnllNGgifQ.ZA2zNCIvzrkUrASxkuZbX26rvHfsbKHK2V53J5CwQi4" }
}
});
try {
let data = yield client.request(query);
return data;
} catch (error) {
log(`queryExecute failed. Error: ${error}`);
}
})();
})
});
// let gqlQuery = this.strToGql(query);
// log(`gqlQuery: ${String(gqlQuery)}`);
let endpoint = String(process && process.env && process.env.GQL_SIMPLE_ENDPOINT || "https://api.graph.cool/simple/v1/cj7rzel6x02b40143fhkupzik");
let token = String(process && process.env && process.env.GQL_AUTH_TOKEN || "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE1MDU4NDkxNTIsImNsaWVudElkIjoiY2oxYzRqZ3Axa2lwdzAxMDV4MDVmZTRuNSIsInByb2plY3RJZCI6ImNqN3J6ZWw2eDAyYjQwMTQzZmhrdXB6aWsiLCJwZXJtYW5lbnRBdXRoVG9rZW5JZCI6ImNqN3J6cGVidDAyeTQwMTU1cG9odnllNGgifQ.ZA2zNCIvzrkUrASxkuZbX26rvHfsbKHK2V53J5CwQi4");
log(`${query}`);
log(`Endpoint: ${endpoint}`);
try {
let data = await client.mutate({ mutation: gql`${query}` });
log(`Data inside queryExecute: ${data}`);
return data;
} catch (error) {
log(`\n${chalk.red("queryExecute() in " + this.constructor.name + " failed.")} ${chalk.red(error)}\n`);
}
}

@@ -55,0 +73,0 @@ sliceQueryArray() {

57

dist/builder.js

@@ -1,10 +0,13 @@

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
"use strict";
const chalk = require('chalk'); //https://www.npmjs.com/package/chalk
const chalk = require("chalk"); //https://www.npmjs.com/package/chalk
const gql = require("graphql-tag");
const log = console.log;
function builder(query, variables) {
let queryStringsPromise = new QueryBuilder(query, variables);
return queryStringsPromise;
let qb = new QueryBuilder(query, variables);
let queries = qb.buildQueries();
return queries;
}
class QueryBuilder {

@@ -14,4 +17,2 @@ constructor(queryTemplate, queryVariables) {

this.vars = queryVariables;
let queries = this.buildQueries();
return queries;
}

@@ -32,8 +33,8 @@ getQuery() {

/* We already have getVariables to define the variables being passed in explicitly.
The purpose of this function is to extract the parameters from the query call signature.
The regex used here works for single line and multiline call signatures alike.
e.g. query nameOfQuery($param: String!, $param2: String!) { }
e.g. query nameOfQuery($param: String!,
$param2: String!) { }
*/
The purpose of this function is to extract the parameters from the query call signature.
The regex used here works for single line and multiline call signatures alike.
e.g. query nameOfQuery($param: String!, $param2: String!) { }
e.g. query nameOfQuery($param: String!,
$param2: String!) { }
*/
let regex = /\$\w+(?=[\):])/g;

@@ -57,3 +58,3 @@ try {

// split object into key value pairs and iterate over for each key
let regexp = new RegExp(`\\$${key}`, 'g');
let regexp = new RegExp(`\\$${key}`, "g");
let matchIncrementor = 0;

@@ -78,18 +79,18 @@ let newQuery = query.replace(regexp, (match, pos, original) => {

}
buildQueries() {
var _this = this;
return _asyncToGenerator(function* () {
let q = _this.getQuery();
let qVars = _this.getVariables();
try {
let qParams = yield _this.extractQueryParams(q);
let qWithArguments = yield _this.injectQueryArguments(q, qParams, qVars);
return qWithArguments;
} catch (error) {
log(`buildQuery error: ${error}`);
}
})();
async buildQueries() {
let q = this.getQuery();
let qVars = this.getVariables();
try {
let qParams = await this.extractQueryParams(q);
let qWithArguments = await this.injectQueryArguments(q, qParams, qVars);
return qWithArguments;
} catch (error) {
log(`buildQuery error: ${error}`);
}
}
}
module.exports = builder;
module.exports = {
QueryBuilder,
builder
};

2

dist/index.js

@@ -0,1 +1,3 @@

'use strict';
const builder = require('./builder.js');

@@ -2,0 +4,0 @@ const batcher = require('./batcher.js');

54

dist/tests/batch-queries.js

@@ -1,6 +0,6 @@

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
"use strict";
const { QueryBatcher, batcher } = require('../batcher.js');
const test = require('ava');
const chalk = require('chalk');
const { QueryBatcher, batcher } = require("../batcher.js");
const test = require("ava");
const chalk = require("chalk");
const log = console.log;

@@ -83,8 +83,17 @@

}`];
test('slice query array', t => {
const singleQuery = `mutation {
createContent(
markup: "markup1"
raw: "raw1"
) {
markup
raw
}
}`;
test("slice query array", t => {
log(`${chalk.blue("\nSliced Array from Original Query Array\n-------------------------------------\n")}`);
let q = new QueryBatcher(sampleQueries, 2);
let sliced = q.sliceQueryArray();
let target = sliced.target;
log(`${chalk.yellow('\nSliced Array from Original Query Array\n-------------------------------------\n')} ${String(target)}`);
log(` ${String(chalk.grey(target))}`);
// log(`${chalk.yellow('\nExpected Slice\n-------------------------------------\n')} ${String(expectedSlice)}`);

@@ -94,25 +103,10 @@ t.is(String(target), String(expectedSlice));

test('execute single query', (() => {
var _ref = _asyncToGenerator(function* (t) {
let q = new QueryBatcher(sampleQueries, 2);
let sliced = q.sliceQueryArray();
let stringified = String(sliced.target);
let target = sliced.target;
log(`Target vanilla: ${target}`);
log(`Target parsed: ${String(target)}`);
Object.entries(sliced).forEach(function ([key, val]) {
for (let query of val) {
q.queryExecute(String(query)).then(function (data) {
log(`Data from queryExecute inside batch-queries test: ${data}`);
});
}
log(`\nK[${key}]\t\tV[${typeof val}]\n\n`);
});
log(`${chalk.blue('\nExecuting Target\n------------------------------------\n')} ${stringified}`);
t.pass();
});
test("execute single query", async t => {
log(`${chalk.yellow("\nExecuting Target\n------------------------------------\n")} `);
let q = new QueryBatcher();
let res = await q.queryExecute(singleQuery);
return function (_x) {
return _ref.apply(this, arguments);
};
})());
t.pass();
});
//

38

dist/tests/build-queries.js

@@ -1,6 +0,6 @@

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
"use strict";
const builder = require('../builder.js');
const test = require('ava');
const chalk = require('chalk');
const { builder } = require("../builder.js");
const test = require("ava");
const chalk = require("chalk");
const log = console.log;

@@ -19,10 +19,10 @@

const queryVariablesArray = [{
"markup": "markup1",
"raw": "raw1"
markup: "markup1",
raw: "raw1"
}, {
"markup": "markup2",
"raw": "raw2"
markup: "markup2",
raw: "raw2"
}, {
"markup": "markup3",
"raw": "raw3"
markup: "markup3",
raw: "raw3"
}];

@@ -56,13 +56,7 @@

test('queries build', (() => {
var _ref = _asyncToGenerator(function* (t) {
let qs = yield builder(sampleMutation, queryVariablesArray);
let queries = String(qs);
log(`${chalk.blue('\nQueries\n------------------------------------\n')} ${queries}`);
t.is(queries, expectedQueries);
});
return function (_x) {
return _ref.apply(this, arguments);
};
})());
test("queries build", async t => {
let qs = await builder(sampleMutation, queryVariablesArray);
let queries = String(qs);
log(`${chalk.blue("\nQueries\n------------------------------------\n")} ${chalk.grey(queries)}`);
t.is(queries, expectedQueries);
});

9

package.json
{
"name": "graphql-query-factory",
"version": "1.0.12",
"version": "1.0.13",
"description": "",

@@ -26,5 +26,8 @@ "main": "index.js",

"license": "ISC",
"repository": "https://github.com/alechp/graphql-query-factory.git",
"dependencies": {
"apollo-client": "^1.9.2",
"dotenv": "^4.0.0",
"graphql-request": "^1.3.4"
"graphql-tag": "^2.4.2",
"node-fetch": "^1.7.3"
},

@@ -36,3 +39,3 @@ "devDependencies": {

"babel-plugin-transform-flow-strip-types": "^6.22.0",
"babel-preset-es2017": "^6.24.1",
"babel-preset-env": "^1.6.0",
"babel-preset-flow": "^6.23.0",

@@ -39,0 +42,0 @@ "chalk": "^2.1.0",

15

readme.md

@@ -110,3 +110,5 @@ # GraphQL Query Batcher

* [x] Ensure that output is formatted as an array
* [ ] Add typechecking for variable types
* [ ] Wrap variables in strings
* [ ] Automatically sort queries into queries or mutations
##### Batcher

@@ -116,3 +118,3 @@ * [ ] tests

* [ ] execute all queries
* [ ]
* [ ] Add type switcher for the query type
##### Flow Types

@@ -138,2 +140,9 @@ * [x] Add Flow types to QueryBuilder

##### Schema
* [x] Update Graphcool instance to random staging
* [x] Update .env with correct EP & Auth
* [x] Update Travis
* [x] Update Schema
##### Finishing Touches

@@ -144,3 +153,3 @@ * [ ] Create walkthrough video on usage

* [ ] Add repository field to Package
* [ ] Add [apollo-codegen](https://github.com/apollographql/apollo-codegen) [apollo tutorial](http://dev.apollodata.com/react/using-with-types.html)
* [ ] Add [apollo-codegen](https://github.com/apollographql/apollo-codegen) from [apollo tutorial](http://dev.apollodata.com/react/using-with-types.html)
* [ ] Add contribution section below

@@ -147,0 +156,0 @@ * [ ] Remove Flow Errors below

65

src/batcher.js
//@flow
const { GraphQLClient } = require('graphql-request')
const chalk = require('chalk');
const fetch = require("node-fetch");
global.fetch = fetch;
const { ApolloClient, createNetworkInterface } = require("apollo-client");
const gql = require("graphql-tag");
const chalk = require("chalk");
const log = console.log;

@@ -12,2 +14,3 @@

}
class QueryBatcher {

@@ -20,3 +23,3 @@ queries: Array<string>;

}
getQueries(){
getQueries() {
return this.queries;

@@ -27,7 +30,7 @@ }

}
getConcurrent(){
getConcurrent() {
return this.concurrent;
}
setConcurrent(numberOfConcurrentConnections: number){
this.concurrent=numberOfConcurrentConnections;
setConcurrent(numberOfConcurrentConnections: number) {
this.concurrent = numberOfConcurrentConnections;
}

@@ -38,17 +41,39 @@ batchQueryExecute(): mixed {

let sliced = this.sliceQueryArray(queries, concurrent);
return sliced;
// let target = sliced.target;
// let original = sliced.original; //TODO: refactor "original" to "remaining"
// if (target !== undefined) {
// for (let query in target) {
// client.query({});
// }
// } else {
// return sliced;
// }
}
async queryExecute(query: string): mixed {
let endpoint: string = String(process.env.GQL_SIMPLE_ENDPOINT)
let token: string = String(process.env.GQL_AUTH_TOKEN)
const client = new GraphQLClient(endpoint, {
headers: {
'Authorization': `Bearer ${token}`
}
const client = new ApolloClient({
networkInterface: createNetworkInterface({
uri: process.env.GQL_SIMPLE_ENDPOINT,
opts: {
headers: { Authorization: process.env.GQL_AUTH_TOKEN }
}
})
});
// let gqlQuery = this.strToGql(query);
// log(`gqlQuery: ${String(gqlQuery)}`);
let endpoint: string = String(process.env.GQL_SIMPLE_ENDPOINT);
let token: string = String(process.env.GQL_AUTH_TOKEN);
log(`${query}`);
log(`Endpoint: ${endpoint}`);
try {
let data: mixed = await client.request(query);
let data = await client.mutate({ mutation: gql`${query}` });
log(`Data inside queryExecute: ${data}`);
return data;
} catch(error) { log(`queryExecute failed. Error: ${error}`); }
} catch (error) {
log(
`\n${chalk.red(
"queryExecute() in " + this.constructor.name + " failed."
)} ${chalk.red(error)}\n`
);
}
}

@@ -63,5 +88,5 @@ sliceQueryArray(): mixed {

let queries = {
target: [...target],
original: [...original]
}
target: [...target],
original: [...original]
};
return queries;

@@ -74,2 +99,2 @@ }

QueryBatcher
}
};

83

src/builder.js
//@flow
const chalk = require('chalk'); //https://www.npmjs.com/package/chalk
const chalk = require("chalk"); //https://www.npmjs.com/package/chalk
const gql = require("graphql-tag");
const log = console.log;
function builder(query: string, variables: Array<mixed>): mixed {
let queryStringsPromise = new QueryBuilder(query, variables);
return queryStringsPromise;
let qb = new QueryBuilder(query, variables);
let queries = qb.buildQueries();
return queries;
}
class QueryBuilder {

@@ -16,19 +19,17 @@ query: string;

this.vars = queryVariables;
let queries = this.buildQueries();
return queries;
}
getQuery(): string{
getQuery(): string {
return this.query;
}
setQuery(query){
setQuery(query) {
this.query = query;
}
getVariables(): Array<mixed>{
getVariables(): Array<mixed> {
return this.vars;
}
setVariables(vars){
setVariables(vars) {
this.vars = vars;
}
extractQueryParams(query: string): ?Array<string> {
/* We already have getVariables to define the variables being passed in explicitly.
/* We already have getVariables to define the variables being passed in explicitly.
The purpose of this function is to extract the parameters from the query call signature.

@@ -44,32 +45,40 @@ The regex used here works for single line and multiline call signatures alike.

return queryParams;
} catch(error) {
log(`queryFactory::query Error: ${chalk.red(error)}`)
} catch (error) {
log(`queryFactory::query Error: ${chalk.red(error)}`);
}
}
injectQueryArguments(queryTemplate: string, queryParams: Array<string>, queryVariables: mixed): Array<string>{
let query: string = queryTemplate, queryOriginal: string = queryTemplate;
injectQueryArguments(
queryTemplate: string,
queryParams: Array<string>,
queryVariables: mixed
): Array<string> {
let query: string = queryTemplate,
queryOriginal: string = queryTemplate;
let queries: Array<string> = [];
// let queryOriginal = queryTemplate;
try {
for(let varObj of queryVariables){
//grab first object...
for(let [key, value] of Object.entries(varObj)) {
// split object into key value pairs and iterate over for each key
let regexp = new RegExp(`\\$${key}`, 'g');
for (let varObj of queryVariables) {
//grab first object...
for (let [key, value] of Object.entries(varObj)) {
// split object into key value pairs and iterate over for each key
let regexp = new RegExp(`\\$${key}`, "g");
let matchIncrementor: number = 0;
let newQuery: string = query.replace(regexp, (match, pos, original) => {
matchIncrementor++;
return (matchIncrementor == 2) ? value : match;
//replace the second instance of the query.
// 1st instance = query parameter in query signature
// 2nd instance (replace) = query argument
});
let newQuery: string = query.replace(
regexp,
(match, pos, original) => {
matchIncrementor++;
return matchIncrementor == 2 ? value : match;
//replace the second instance of the query.
// 1st instance = query parameter in query signature
// 2nd instance (replace) = query argument
}
);
query = newQuery;
// we asssign this query so that the next replace will already have the previous argument passed in
}
queries.push(query); // begin building array of queries
queries.push(query); // begin building array of queries
query = queryOriginal; //reset query to the original query passed into this function so that we can perform same parsing on next set of variables
}
}
return queries;
} catch(error) {
} catch (error) {
log(`Error: ${error}`);

@@ -82,6 +91,10 @@ }

try {
let qParams: ?Array<string> = await this.extractQueryParams(q);
let qWithArguments: Array<string> = await this.injectQueryArguments(q, qParams, qVars);
let qParams: ?Array<string> = await this.extractQueryParams(q);
let qWithArguments: Array<string> = await this.injectQueryArguments(
q,
qParams,
qVars
);
return qWithArguments;
} catch(error) {
} catch (error) {
log(`buildQuery error: ${error}`);

@@ -91,2 +104,6 @@ }

}
module.exports = builder;
module.exports = {
QueryBuilder,
builder
};

80

src/tests/batch-queries.js

@@ -1,7 +0,8 @@

const {QueryBatcher, batcher } = require('../batcher.js')
const test = require('ava');
const chalk = require('chalk');
const { QueryBatcher, batcher } = require("../batcher.js");
const test = require("ava");
const chalk = require("chalk");
const log = console.log;
const sampleQueries = [`mutation addMarkup($markup:String!, $raw: String!) {
const sampleQueries = [
`mutation addMarkup($markup:String!, $raw: String!) {
createContent(

@@ -15,3 +16,3 @@ markup: markup1

}`,
`mutation addMarkup($markup:String!, $raw: String!) {
`mutation addMarkup($markup:String!, $raw: String!) {
createContent(

@@ -25,3 +26,3 @@ markup: markup2

}`,
`mutation addMarkup($markup:String!, $raw: String!) {
`mutation addMarkup($markup:String!, $raw: String!) {
createContent(

@@ -35,3 +36,3 @@ markup: markup3

}`,
`mutation addMarkup($markup:String!, $raw: String!) {
`mutation addMarkup($markup:String!, $raw: String!) {
createContent(

@@ -45,3 +46,3 @@ markup: markup4

}`,
`mutation addMarkup($markup:String!, $raw: String!) {
`mutation addMarkup($markup:String!, $raw: String!) {
createContent(

@@ -55,3 +56,3 @@ markup: markup5

}`,
`mutation addMarkup($markup:String!, $raw: String!) {
`mutation addMarkup($markup:String!, $raw: String!) {
createContent(

@@ -65,3 +66,3 @@ markup: markup6

}`,
`mutation addMarkup($markup:String!, $raw: String!) {
`mutation addMarkup($markup:String!, $raw: String!) {
createContent(

@@ -74,6 +75,7 @@ markup: markup7

}
}`];
}`
];
const expectedSlice = [`mutation addMarkup($markup:String!, $raw: String!) {
const expectedSlice = [
`mutation addMarkup($markup:String!, $raw: String!) {
createContent(

@@ -87,3 +89,3 @@ markup: markup1

}`,
`mutation addMarkup($markup:String!, $raw: String!) {
`mutation addMarkup($markup:String!, $raw: String!) {
createContent(

@@ -96,9 +98,23 @@ markup: markup2

}
}`];
test('slice query array', t => {
}`
];
const singleQuery = `mutation {
createContent(
markup: "markup1"
raw: "raw1"
) {
markup
raw
}
}`;
test("slice query array", t => {
log(
`${chalk.blue(
"\nSliced Array from Original Query Array\n-------------------------------------\n"
)}`
);
let q = new QueryBatcher(sampleQueries, 2);
let sliced = q.sliceQueryArray();
let target = sliced.target;
log(`${chalk.yellow('\nSliced Array from Original Query Array\n-------------------------------------\n')} ${String(target)}`);
log(` ${String(chalk.grey(target))}`);
// log(`${chalk.yellow('\nExpected Slice\n-------------------------------------\n')} ${String(expectedSlice)}`);

@@ -108,20 +124,14 @@ t.is(String(target), String(expectedSlice));

test('execute single query', async t => {
let q = new QueryBatcher(sampleQueries, 2);
let sliced: mixed = q.sliceQueryArray();
let stringified: string = String(sliced.target);
let target = sliced.target;
log(`Target vanilla: ${target}`);
log(`Target parsed: ${String(target)}`);
Object.entries(sliced).forEach( ([key, val]) => {
for(let query of val) {
q.queryExecute(String(query))
.then(data => {
log(`Data from queryExecute inside batch-queries test: ${data}`);
});
}
log(`\nK[${key}]\t\tV[${typeof val}]\n\n`);
});
log(`${chalk.blue('\nExecuting Target\n------------------------------------\n')} ${stringified}`);
test("execute single query", async t => {
log(
`${chalk.yellow(
"\nExecuting Target\n------------------------------------\n"
)} `
);
let q = new QueryBatcher();
let res = await q.queryExecute(singleQuery);
t.pass();
});
//

28

src/tests/build-queries.js

@@ -1,4 +0,4 @@

const builder = require('../builder.js');
const test = require('ava');
const chalk = require('chalk');
const { builder } = require("../builder.js");
const test = require("ava");
const chalk = require("chalk");
const log = console.log;

@@ -18,12 +18,12 @@

{
"markup": "markup1",
"raw": "raw1"
markup: "markup1",
raw: "raw1"
},
{
"markup": "markup2",
"raw": "raw2"
markup: "markup2",
raw: "raw2"
},
{
"markup": "markup3",
"raw": "raw3"
markup: "markup3",
raw: "raw3"
}

@@ -58,7 +58,11 @@ ];

test('queries build', async t => {
test("queries build", async t => {
let qs = await builder(sampleMutation, queryVariablesArray);
let queries = String(qs);
log(`${chalk.blue('\nQueries\n------------------------------------\n')} ${queries}`);
t.is(queries, expectedQueries)
log(
`${chalk.blue(
"\nQueries\n------------------------------------\n"
)} ${chalk.grey(queries)}`
);
t.is(queries, expectedQueries);
});
.babelrc

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc