@devticon-os/graphql-codegen-axios 0.0.4 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devticon-os/graphql-codegen-axios",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "license": "MIT",
   "main": "src/index.js",
   "files": [

package/src/helpers.ts

@@ -1,45 +1,64 @@
-import { AxiosResponse, AxiosInstance, AxiosRequestConfig } from 'axios';
-import { GraphQLError } from 'graphql';
+import { AxiosResponse, AxiosInstance, AxiosRequestConfig } from "axios";
+import { GraphQLError } from "graphql";
 
 type GraphqlResponse<T> = {
   data: T;
   errors?: GraphQLError[];
 };
 
+type GraphqlRequestParams = {
+  query: string;
+  variables: any;
+};
 const first = <T>(data: T[]) => data[0];
 
-const firstOrFail = <T>(data: T[]) => {
-  const row = data[0];
-  if (!row) {
-    throw new Error('Not found');
-  }
-  return row;
-};
+const firstOrFail =
+  <T>(reqParams: GraphqlRequestParams) =>
+    (data: T[]) => {
+      const row = data[0];
+      if (!row) {
+        throw new QueryNoResultsError(reqParams);
+      }
+      return row;
+    };
 
-const nonNullable = <T>(data: T) => {
-  const row = data;
-  if (!row) {
-    throw new Error('Not found');
-  }
-  return row;
-};
+const nonNullable =
+  <T>(reqParams: GraphqlRequestParams) =>
+    (data: T) => {
+      const row = data;
+      if (!row) {
+        throw new QueryNoResultsError(reqParams);
+      }
+      return row;
+    };
 
-export const handleResponse = <T>({ data }: AxiosResponse<GraphqlResponse<T>>) => {
+export const handleResponse = <T>({
+                                    data,
+                                  }: AxiosResponse<GraphqlResponse<T>>) => {
   const errors = data.errors;
   if (errors && errors.length > 0) {
-    throw new GraphqlError('Request failed', errors);
+    throw new GraphqlError("Request failed", errors);
   }
   return data.data;
 };
-
 export const unpackSingleResults =
   <T extends Object, K extends keyof T>(key: K) =>
-  (data: T) =>
-    data[key];
+    (data: T) =>
+      data[key];
 
 export class GraphqlError extends Error {
   constructor(message: string, public gqlErrors: GraphQLError[]) {
-    const msg = `${message} ${gqlErrors.map(e => e.message).join('\n')}`;
+    const msg = `${message} ${gqlErrors.map((e) => e.message).join("\n")}`;
     super(msg);
   }
 }
+
+export class QueryNoResultsError extends Error {
+  query: string;
+  variables: any;
+  constructor(params: GraphqlRequestParams) {
+    super(`Query has no results`);
+    this.query = params.query;
+    this.variables = params.variables;
+  }
+}

package/src/index.js

@@ -1,31 +1,32 @@
-const fs = require('fs');
-const path = require('path');
-const { print } = require('graphql');
+const fs = require("fs");
+const path = require("path");
+const { print } = require("graphql");
 
 const getType = (name, operationType, type) => {
   name = name.charAt(0).toUpperCase() + name.slice(1);
-  operationType = operationType.charAt(0).toUpperCase() + operationType.slice(1);
+  operationType =
+    operationType.charAt(0).toUpperCase() + operationType.slice(1);
   switch (type) {
-    case 'variables':
+    case "variables":
       return `${name}${operationType}Variables`;
-    case 'results':
+    case "results":
       return `${name}${operationType}`;
   }
 };
 
-const functionsToString = functions => {
-  let str = '{';
+const functionsToString = (functions) => {
+  let str = "{";
   for (let [name, body] of Object.entries(functions)) {
     str += `${name}: ${body},\n`;
   }
-  str += '}';
+  str += "}";
   return str;
 };
 
 const getUsedFragments = (raw, allFragments, results = []) => {
   const fragments = [...raw.matchAll(/\.\.\.(\w*)$/gm)]
     .map(([_, name]) => name)
-    .map(name => allFragments.find(d => d.name.value === name));
+    .map((name) => allFragments.find((d) => d.name.value === name));
 
   for (let fragment of fragments) {
     getUsedFragments(print(fragment), allFragments, results);
@@ -33,19 +34,22 @@ const getUsedFragments = (raw, allFragments, results = []) => {
   results.push(...fragments);
   return results;
 };
-
 const printOperation = (ast, allFragments) => {
-  ast.directives = ast.directives.filter(d => !['first', 'firstOrFail'].includes(d.name.value));
-  const raw = print(ast).replace('@firstOrFail', '').replace('@first', '').replace('@nonNullable', '');
+  ast.directives = ast.directives.filter(
+    (d) => !["first", "firstOrFail"].includes(d.name.value)
+  );
+  const raw = print(ast)
+    .replace("@firstOrFail", "")
+    .replace("@first", "")
+    .replace("@nonNullable", "");
 
   let fragments = getUsedFragments(raw, allFragments);
-  fragments = [...new Set(fragments)].map(f => print(f));
+  fragments = [...new Set(fragments)].map((f) => print(f));
 
-  return fragments.join('\n') + '\n' + raw;
+  return fragments.join("\n") + "\n" + raw;
 };
 
-const helpers = fs.readFileSync(path.join(__dirname, 'helpers.ts'), 'utf-8');
-
+const helpers = fs.readFileSync(path.join(__dirname, "helpers.ts"), "utf-8");
 module.exports = {
   plugin(schema, documents, config) {
     const functions = {};
@@ -54,7 +58,7 @@ module.exports = {
 
     for (let { document } of documents) {
       for (const definition of document.definitions) {
-        if (definition.kind === 'FragmentDefinition') {
+        if (definition.kind === "FragmentDefinition") {
           fragments.push(definition);
         }
       }
@@ -64,33 +68,44 @@ module.exports = {
       for (const definition of document.definitions) {
         const name = definition.name.value;
 
-        if (definition.kind !== 'OperationDefinition') {
+        if (definition.kind !== "OperationDefinition") {
           continue;
         }
-        const variablesType = getType(name, definition.operation, 'variables');
-        const resultsType = getType(name, definition.operation, 'results');
+        const variablesType = getType(name, definition.operation, "variables");
+        const resultsType = getType(name, definition.operation, "results");
 
-        queries.push(`const ${name}RawQuery = \`${printOperation(definition, fragments)}\`;`);
+        queries.push(
+          `const ${name}RawQuery = \`${printOperation(
+            definition,
+            fragments
+          )}\`;`
+        );
         let func = `(variables: ${variablesType}, config?: AxiosRequestConfig) => client.post<GraphqlResponse<${resultsType}>>("", {variables, query: ${name}RawQuery}, config).then(handleResponse)`;
 
         if (definition.selectionSet.selections.length === 1) {
-          if (!['query', 'mutation'].includes(definition.operation)) {
+          if (!["query", "mutation"].includes(definition.operation)) {
             continue;
           }
           const selection = definition.selectionSet.selections[0];
-          const directives = selection.directives.map(d => d.name.value);
+          const directives = selection.directives.map((d) => d.name.value);
           const propertyName = selection.name.value;
           func += `.then(unpackSingleResults("${propertyName}"))\n`;
           for (let directive of directives) {
-            func += `.then(${directive})\n`;
+            if (directive === "nonNullable" || directive === "firstOrFail") {
+              func += `.then(${directive}({variables, query: ${name}RawQuery}))\n`;
+            } else {
+              func += `.then(${directive})\n`;
+            }
           }
         }
         functions[name] = func;
       }
     }
 
-    const sdk = `export const getSdk = (client: AxiosInstance) => (${functionsToString(functions)})`;
-    return [...queries, helpers, sdk].join('\n');
+    const sdk = `export const getSdk = (client: AxiosInstance) => (${functionsToString(
+      functions
+    )})`;
+    return [...queries, helpers, sdk].join("\n");
   },
   addToSchema: /* GraphQL */ `
     directive @first on OBJECT