houdini 0.15.8 → 0.15.9

package/.prettierignore

@@ -1,3 +1,4 @@
 .yarn/
 **/build/**
 README.md
+.github/**

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # houdini
 
+## 0.15.9
+
+### Patch Changes
+
+-   [#443](https://github.com/HoudiniGraphql/houdini/pull/443) [`801d7e8`](https://github.com/HoudiniGraphql/houdini/commit/801d7e87f5199cb5e352001826d8f2d4c454bcc3) Thanks [@jycouet](https://github.com/jycouet)! - warn user when Node interface is not properly defined and throw an error on Node usage (when not properly defined)
+
 ## 0.15.8
 
 ### Patch Changes

package/build/cmd/transforms/paginate.js

@@ -25,12 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pageInfoSelection = void 0;
 // externals
-const graphql = __importStar(require("graphql"));
 const common_1 = require("../../common");
 const types_1 = require("../../runtime/lib/types");
 // locals
 const types_2 = require("../types");
 const utils_1 = require("../utils");
+const graphql = __importStar(require("graphql"));
 // paginate transform adds the necessary fields for a paginated field
 async function paginate(config, documents) {
     // we're going to have to add documents to the list so collect them here and we'll add them when we're done

package/build/cmd/validators/typeCheck.d.ts

@@ -1,3 +1,5 @@
 import { Config } from '../../common';
 import { CollectedGraphQLDocument } from '../types';
+import * as graphql from 'graphql';
 export default function typeCheck(config: Config, docs: CollectedGraphQLDocument[]): Promise<void>;
+export declare function getAndVerifyNodeInterface(config: Config): graphql.GraphQLInterfaceType | null;

package/build/cmd/validators/typeCheck.js

@@ -23,26 +23,20 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAndVerifyNodeInterface = void 0;
 // externals
-const graphql = __importStar(require("graphql"));
 // locals
 const common_1 = require("../../common");
-const types_1 = require("../types");
 const fragmentVariables_1 = require("../transforms/fragmentVariables");
-const utils_1 = require("../utils");
 const list_1 = require("../transforms/list");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const graphql = __importStar(require("graphql"));
 // typeCheck verifies that the documents are valid instead of waiting
 // for the compiler to fail later down the line.
 async function typeCheck(config, docs) {
     // wrap the errors we run into in a HoudiniError
     const errors = [];
-    // verify the node interface (if it exists)
-    try {
-        verifyNodeInterface(config);
-    }
-    catch (e) {
-        throw (0, types_1.HoudiniErrorTodo)("There is a problem with your project's schema: " + e.message);
-    }
     // we need to catch errors in the list API. this means that a user
     // must provide parentID if they are using a list that is not all-objects
     // from root. figure out which lists are "free" (ie, can be applied without a parentID arg)
@@ -580,7 +574,7 @@ function nodeDirectives(config, directives) {
     let possibleNodes = [queryType?.name || ''];
     const customTypes = Object.keys(config.typeConfig || {});
     // check if there's a node interface
-    const nodeInterface = config.schema.getType('Node');
+    const nodeInterface = getAndVerifyNodeInterface(config);
     if (nodeInterface) {
         const { objects, interfaces } = config.schema.getImplementations(nodeInterface);
         possibleNodes.push(...objects.map((object) => object.name), ...interfaces.map((object) => object.name));
@@ -619,52 +613,74 @@ function nodeDirectives(config, directives) {
         };
     };
 }
-function verifyNodeInterface(config) {
+function getAndVerifyNodeInterface(config) {
     const { schema } = config;
     // look for Node
     const nodeInterface = schema.getType('Node');
     // if there is no node interface don't do anything else
     if (!nodeInterface) {
-        return;
+        return null;
     }
     // make sure its an interface
     if (!graphql.isInterfaceType(nodeInterface)) {
-        throw new Error(invalidNodeFieldMessage);
+        displayInvalidNodeFieldMessage(config.logLevel);
+        return null;
     }
     // look for a field on the query type to look up a node by id
     const queryType = schema.getQueryType();
     if (!queryType) {
-        throw new Error(invalidNodeFieldMessage);
+        displayInvalidNodeFieldMessage(config.logLevel);
+        return null;
     }
     // look for a node field
     const nodeField = queryType.getFields()['node'];
     if (!nodeField) {
-        throw new Error(invalidNodeFieldMessage);
+        displayInvalidNodeFieldMessage(config.logLevel);
+        return null;
     }
     // there needs to be an arg on the field called id
     const args = nodeField.args;
     if (args.length === 0) {
-        throw new Error(invalidNodeFieldMessage);
+        displayInvalidNodeFieldMessage(config.logLevel);
+        return null;
     }
     // look for the id arg
     const idArg = args.find((arg) => arg.name === 'id');
     if (!idArg) {
-        throw new Error(invalidNodeFieldMessage);
+        displayInvalidNodeFieldMessage(config.logLevel);
+        return null;
     }
     // make sure that the id arg takes an ID
     const idType = (0, utils_1.unwrapType)(config, idArg.type);
     // make sure its an ID
     if (idType.type.name !== 'ID') {
-        throw new Error(invalidNodeFieldMessage);
+        displayInvalidNodeFieldMessage(config.logLevel);
+        return null;
     }
     // make sure that the node field returns a Node
     const fieldReturnType = (0, utils_1.unwrapType)(config, nodeField.type);
     if (fieldReturnType.type.name !== 'Node') {
-        throw new Error(invalidNodeFieldMessage);
+        displayInvalidNodeFieldMessage(config.logLevel);
+        return null;
+    }
+    return nodeInterface;
+}
+exports.getAndVerifyNodeInterface = getAndVerifyNodeInterface;
+let nbInvalidNodeFieldMessageDisplayed = 0;
+function displayInvalidNodeFieldMessage(logLevel) {
+    // We want to display the message only once.
+    if (nbInvalidNodeFieldMessageDisplayed === 0) {
+        if (logLevel === common_1.LogLevel.Full) {
+            console.warn(invalidNodeFieldMessage);
+        }
+        else {
+            console.warn(invalidNodeFieldMessageLight);
+        }
     }
+    nbInvalidNodeFieldMessageDisplayed++;
 }
-const invalidNodeFieldMessage = `
-Your project defines a Node interface but it does not conform to the Global Identification Spec.
+const invalidNodeFieldMessageLight = `⚠️  Your Node interface is not properly defined, please fix your schema to be able to use this interface. (For more info, add flag "-l full")`;
+const invalidNodeFieldMessage = `⚠️  Your project defines a Node interface but it does not conform to the Global Identification Spec.
 
 If you are trying to provide the Node interface and its field, they must look like the following: