houdini 0.12.0-alpha.0 → 0.12.4

package/README.md

@@ -42,7 +42,7 @@ for the generation of an incredibly lean GraphQL abstraction for your applicatio
 1. [Fetching Data](#fetching-data)
     1. [Query variables and page data](#query-variables-and-page-data)
     1. [Loading State](#loading-state)
-    1. [Additional Logic](#additional-logic)
+    1. [Hooks](#load-hooks)
     1. [Refetching Data](#refetching-data)
     1. [Cache policy](#cache-policy)
         1. [Data Retention](#data-retention)
@@ -69,7 +69,7 @@ for the generation of an incredibly lean GraphQL abstraction for your applicatio
 1. [Persisted Queries](#persisted-queries)
 1. [Notes, Constraints, and Conventions](#%EF%B8%8Fnotes-constraints-and-conventions)
 
-## 🕹️  Example
+## 🕹  Example
 
 A demo can be found in the <a href='./example'>example directory</a>.
 
@@ -123,7 +123,12 @@ import houdini from 'houdini-preprocess'
                 alias: {
                     $houdini: path.resolve('.', '$houdini')
                 }
-            }
+            },
+	    server: {
+                fs: {
+                    allow: ['.'],
+                },
+            },
         }
     }
 }
@@ -327,23 +332,30 @@ the result of query:
 {/if}
 ```
 
-### Additional logic
+### Load Hooks
 
 Sometimes you will need to add additional logic to a component's query. For example, you might want to
 check if the current session is valid before a query is sent to the server. In order to support this,
-houdini will look for a function called `onLoad` defined in the module context which can be used to perform
-any logic you need. If you return a value from this function, it will be passed as props to your component:
+houdini will look for hook functions defined in the module context which can be used to perform
+any logic you need.
+
+#### `beforeLoad`
+
+Called before Houdini executes load queries against the server. You can expect the same
+arguments as SvelteKit's [`load`](https://kit.svelte.dev/docs#loading) hook.
+
+If you return a value from this function, it will be passed as props to your component.
 
 ```svelte
 <script context="module">
     // It has access to the same arguments and this.error this.redirect as the variable functions
-    export function onLoad({page, session}){
+    export function beforeLoad({page, session}){
         if(!session.authenticated){
             return this.redirect(302, '/login')
         }
 
-	return {
-	    message: "There are this many items"
+    	return {
+    	    message: "There are this many items"
         }
     }
 </script>
@@ -366,6 +378,42 @@ any logic you need. If you return a value from this function, it will be passed
 {message}: {$data.items.length}
 ```
 
+#### `afterLoad`
+
+Called after Houdini executes load queries against the server. You can expect the same
+arguments as SvelteKit's [`load`](https://kit.svelte.dev/docs#loading) hook, plus an additional
+`data` property referencing query result data.
+
+If you return a value from this function, it will be passed as props to your component.
+
+```svelte
+<script context="module">
+    export function MyProfileVariables({ page: { params: { id } } }) {
+        return { id }
+    }
+    export function afterLoad({ data }){
+        if(!data.MyProfile){
+            return this.error(404)
+        }
+    }
+</script>
+
+<script>
+    import { query, graphql } from '$houdini'
+
+    // load the items
+    const { data } = query(graphql`
+        query MyProfile {
+            profile(id) {
+                name
+            }
+        }
+    `)
+</script>
+
+Hello I'm {$data.profile.name}
+```
+
 ### Refetching Data
 
 Refetching data is done with the `refetch` function provided from the result of a query:
@@ -572,6 +620,8 @@ query AllUsers {
     }
 }
 ```
+> Keep in mind, if you are using fragment variables inside of a field flagged for 
+> list operations, you'll have to pass a value for the variable when performing the operation 
 
 ## 📝&nbsp;&nbsp;Mutations
 

package/build/cmd/generate.js

@@ -107,13 +107,17 @@ exports.runPipeline = function (config, docs) { return __awaiter(void 0, void 0,
                 // we need to create the runtime folder structure
                 _a.sent();
                 return [4 /*yield*/, houdini_common_1.runPipeline(config, [
-                        transforms.internalSchema,
-                        transforms.list,
-                        transforms.addID,
                         validators.typeCheck,
-                        transforms.typename,
                         validators.uniqueNames,
                         validators.noIDAlias,
+                        transforms.internalSchema,
+                        transforms.addID,
+                        transforms.typename,
+                        // list transform must go before fragment variables
+                        // so that the mutation fragments are defined before they get mixed in
+                        transforms.list,
+                        // paginate transform needs to go before fragmentVariables
+                        // so that the variable definitions get hashed
                         transforms.paginate,
                         transforms.fragmentVariables,
                         transforms.composeQueries,

package/build/cmd/generators/artifacts/selection.js

@@ -65,7 +65,7 @@ function selection(_a) {
             // look up the fragment definition
             var fragmentDefinition = document.document.definitions.find(function (defn) { return defn.kind === 'FragmentDefinition' && defn.name.value === field.name.value; });
             if (!fragmentDefinition) {
-                throw new Error('Could not find definition for fragment ' + field.name.value);
+                throw new Error('selection: could not find definition for fragment ' + field.name.value);
             }
             // merge the fragments selection into ours
             object = utils_1.deepMerge(object, selection({

package/build/cmd/generators/typescript/index.js

@@ -191,7 +191,10 @@ function generateOperationTypeDefs(config, body, definition, selections, visited
                 types_1.readonlyProperty(AST.tsPropertySignature(AST.stringLiteral('input'), AST.tsTypeAnnotation(hasInputs
                     ? AST.tsTypeReference(AST.identifier(inputTypeName))
                     : AST.tsNullKeyword()))),
-                types_1.readonlyProperty(AST.tsPropertySignature(AST.stringLiteral('result'), AST.tsTypeAnnotation(AST.tsTypeReference(AST.identifier(shapeTypeName))))),
+                types_1.readonlyProperty(AST.tsPropertySignature(AST.stringLiteral('result'), AST.tsTypeAnnotation(AST.tsUnionType([
+                    AST.tsTypeReference(AST.identifier(shapeTypeName)),
+                    AST.tsUndefinedKeyword(),
+                ])))),
             ]))), 
             // export the type that describes the result
             AST.exportNamedDeclaration(AST.tsTypeAliasDeclaration(AST.identifier(shapeTypeName), inlineType_1.inlineType({

package/build/cmd/transforms/composeQueries.d.ts

@@ -8,10 +8,3 @@ export declare type FragmentDependency = {
 };
 export default function includeFragmentDefinitions(config: Config, documents: CollectedGraphQLDocument[]): Promise<void>;
 export declare function collectFragments(config: Config, docs: CollectedGraphQLDocument[]): Record<string, FragmentDependency>;
-export declare function flattenFragments(operation: {
-    requiredFragments: Array<string>;
-}, fragments: {
-    [name: string]: {
-        requiredFragments: Array<string>;
-    };
-}): Array<string>;

package/build/cmd/transforms/composeQueries.js

@@ -78,7 +78,7 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flattenFragments = exports.collectFragments = void 0;
+exports.collectFragments = void 0;
 // externals
 var graphql_1 = require("graphql");
 // includeFragmentDefinitions adds any referenced fragments to operations
@@ -199,7 +199,7 @@ function flattenFragments(operation, fragments) {
         // grab the referenced fragment
         var targetFragment = fragments[nextFragment];
         if (!targetFragment) {
-            throw new Error('Could not find definition for fragment ' + nextFragment);
+            throw new Error('compose: could not find definition for fragment ' + nextFragment);
         }
         // add this fragments dependents to the pile
         remaining.push.apply(remaining, __spread(targetFragment.requiredFragments));
@@ -207,4 +207,3 @@ function flattenFragments(operation, fragments) {
     // we're done
     return __spread(frags);
 }
-exports.flattenFragments = flattenFragments;

package/build/cmd/transforms/fragmentVariables.d.ts

@@ -1,7 +1,18 @@
 import { Config } from 'houdini-common';
 import * as graphql from 'graphql';
 import { CollectedGraphQLDocument } from '../types';
+import { FragmentDependency } from './composeQueries';
 export default function fragmentVariables(config: Config, documents: CollectedGraphQLDocument[]): Promise<void>;
+declare type ValueMap = Record<string, graphql.ValueNode>;
+export declare function inlineFragmentArgs({ config, fragmentDefinitions, document, generatedFragments, visitedFragments, scope, newName, }: {
+    config: Config;
+    fragmentDefinitions: Record<string, FragmentDependency>;
+    document: graphql.ASTNode;
+    generatedFragments: Record<string, graphql.FragmentDefinitionNode>;
+    visitedFragments: Set<string>;
+    scope: ValueMap | undefined | null;
+    newName?: string;
+}): any;
 export declare function withArguments(config: Config, node: graphql.FragmentSpreadNode): graphql.ArgumentNode[];
 export declare type FragmentArgument = {
     name: string;
@@ -10,3 +21,8 @@ export declare type FragmentArgument = {
     defaultValue: graphql.ValueNode | null;
 };
 export declare function fragmentArguments(config: Config, definition: graphql.FragmentDefinitionNode): FragmentArgument[];
+export declare function collectWithArguments(config: Config, node: graphql.FragmentSpreadNode, scope?: ValueMap | null): {
+    args: ValueMap | null;
+    hash: string;
+};
+export {};

package/build/cmd/transforms/fragmentVariables.js

@@ -97,7 +97,7 @@ var __spread = (this && this.__spread) || function () {
     return ar;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fragmentArguments = exports.withArguments = void 0;
+exports.collectWithArguments = exports.fragmentArguments = exports.withArguments = exports.inlineFragmentArgs = void 0;
 var graphql = __importStar(require("graphql"));
 var composeQueries_1 = require("./composeQueries");
 var utils_1 = require("../utils");
@@ -105,11 +105,10 @@ var types_1 = require("../../runtime/types");
 var GraphqlKinds = graphql.Kind;
 // fragmentVariables transforms fragment spreads with variables into something the server can use
 function fragmentVariables(config, documents) {
-    var _a;
     return __awaiter(this, void 0, void 0, function () {
-        var fragments, generatedFragments, visitedFragments, documents_1, documents_1_1, doc_1, operation, rootScope, doc;
-        var e_1, _b;
-        return __generator(this, function (_c) {
+        var fragments, generatedFragments, visitedFragments, documents_1, documents_1_1, doc_1, operation, doc;
+        var e_1, _a;
+        return __generator(this, function (_b) {
             fragments = composeQueries_1.collectFragments(config, documents);
             generatedFragments = {};
             visitedFragments = new Set();
@@ -125,16 +124,6 @@ function fragmentVariables(config, documents) {
                     if (!operation) {
                         continue;
                     }
-                    rootScope = ((_a = operation.variableDefinitions) === null || _a === void 0 ? void 0 : _a.reduce(function (scope, definition) {
-                        var _a;
-                        return (__assign(__assign({}, scope), (_a = {}, _a[definition.variable.name.value] = {
-                            kind: 'Variable',
-                            name: {
-                                kind: 'Name',
-                                value: definition.variable.name.value,
-                            },
-                        }, _a)));
-                    }, {})) || {};
                     // inline any fragment arguments in the document
                     doc_1.document = inlineFragmentArgs({
                         config: config,
@@ -142,14 +131,14 @@ function fragmentVariables(config, documents) {
                         document: doc_1.document,
                         generatedFragments: generatedFragments,
                         visitedFragments: visitedFragments,
-                        scope: rootScope,
+                        scope: null,
                     });
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (documents_1_1 && !documents_1_1.done && (_b = documents_1.return)) _b.call(documents_1);
+                    if (documents_1_1 && !documents_1_1.done && (_a = documents_1.return)) _a.call(documents_1);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
@@ -172,37 +161,22 @@ function fragmentVariables(config, documents) {
 exports.default = fragmentVariables;
 function inlineFragmentArgs(_a) {
     var config = _a.config, fragmentDefinitions = _a.fragmentDefinitions, document = _a.document, generatedFragments = _a.generatedFragments, visitedFragments = _a.visitedFragments, scope = _a.scope, newName = _a.newName;
+    // if the scope is null, use the root-level scope defined by the document's
+    // operation definition
+    if (!scope) {
+        scope = operationScope(document.definitions.find(function (_a) {
+            var kind = _a.kind;
+            return kind === GraphqlKinds.OPERATION_DEFINITION;
+        }));
+    }
     // look up the arguments for the fragment
     var definitionArgs = fragmentArguments(config, document).reduce(function (acc, arg) {
         var _a;
         return (__assign(__assign({}, acc), (_a = {}, _a[arg.name] = arg, _a)));
     }, {});
     var result = graphql.visit(document, {
-        Argument: function (node) {
-            // look at the arguments value to see if its a variable
-            var value = node.value;
-            if (value.kind !== 'Variable') {
-                return;
-            }
-            // if there's no scope we can't evaluate it
-            if (!scope) {
-                throw new Error(node.name.value +
-                    ' is not defined in the current scope: ' +
-                    JSON.stringify(scope));
-            }
-            // is the variable in scope
-            var newValue = scope[value.name.value];
-            // if it is just use it
-            if (newValue) {
-                return __assign(__assign({}, node), { value: newValue });
-            }
-            // if the argument is required
-            if (definitionArgs[value.name.value] && definitionArgs[value.name.value].required) {
-                throw new Error('Missing value for required arg: ' + value.name.value);
-            }
-            // if we got this far, theres no value for a non-required arg, remove the node
-            return null;
-        },
+        // every time we run into a fragment spread we might need to replace it
+        // with a version that incorporates the current scope's variable values
         FragmentSpread: function (node) {
             var e_2, _a;
             // look at the fragment spread to see if there are any default arguments
@@ -257,7 +231,8 @@ function inlineFragmentArgs(_a) {
                         return definition.kind === 'FragmentDefinition' &&
                             definition.name.value === node.name.value;
                     });
-                    // remove the element from the list
+                    // keep walking down the referenced fragment's selection
+                    // and replace the definition in the document
                     var localDefinitions = __spread(doc.document.definitions);
                     localDefinitions.splice(definitionIndex, 1);
                     localDefinitions.push(inlineFragmentArgs({
@@ -281,8 +256,35 @@ function inlineFragmentArgs(_a) {
                 }
             }
         },
+        // look at every time something is used as an argument
+        Argument: function (node) {
+            // if the argument is a variable we need to expand it to its value (passed from the parent)
+            var value = node.value;
+            if (value.kind !== 'Variable') {
+                return;
+            }
+            // if there's no scope we can't evaluate it
+            if (!scope) {
+                throw new Error(node.name.value +
+                    ' is not defined in the current scope: ' +
+                    JSON.stringify(scope));
+            }
+            // is the variable in scope
+            var newValue = scope[value.name.value];
+            // if it is just use it
+            if (newValue) {
+                return __assign(__assign({}, node), { value: newValue });
+            }
+            // if the argument is required
+            if (definitionArgs[value.name.value] && definitionArgs[value.name.value].required) {
+                throw new Error('Missing value for required arg: ' + value.name.value);
+            }
+            // if we got this far, theres no value for a non-required arg, remove the node
+            return null;
+        },
     });
-    // if we are supposed to change the name
+    // if we computed a new name for the fragment (because we got here as part of analyzing a fragment
+    // spread with @with), we need to change the name of the fragment
     if (newName) {
         // the new name for the document
         result.name = {
@@ -292,6 +294,7 @@ function inlineFragmentArgs(_a) {
     }
     return result;
 }
+exports.inlineFragmentArgs = inlineFragmentArgs;
 function withArguments(config, node) {
     var _a;
     var withDirectives = (_a = node.directives) === null || _a === void 0 ? void 0 : _a.filter(function (directive) { return directive.name.value === config.withDirective; });
@@ -407,3 +410,17 @@ function collectWithArguments(config, node, scope) {
         hash: '_' + utils_1.murmurHash(JSON.stringify(args)),
     };
 }
+exports.collectWithArguments = collectWithArguments;
+function operationScope(operation) {
+    var _a;
+    return (((_a = operation.variableDefinitions) === null || _a === void 0 ? void 0 : _a.reduce(function (scope, definition) {
+        var _a;
+        return (__assign(__assign({}, scope), (_a = {}, _a[definition.variable.name.value] = {
+            kind: 'Variable',
+            name: {
+                kind: 'Name',
+                value: definition.variable.name.value,
+            },
+        }, _a)));
+    }, {})) || {});
+}

package/build/cmd/transforms/list.js

@@ -105,7 +105,6 @@ var graphql = __importStar(require("graphql"));
 var types_1 = require("../types");
 var utils_1 = require("../utils");
 var types_2 = require("../../runtime/types");
-var paginate_1 = require("./paginate");
 // addListFragments adds fragments for the fields tagged with @list
 function addListFragments(config, documents) {
     return __awaiter(this, void 0, void 0, function () {
@@ -118,7 +117,7 @@ function addListFragments(config, documents) {
                 doc.document = graphql.visit(doc.document, {
                     Directive: function (node, key, parent, path, ancestors) {
                         var _a;
-                        // if we found a @list applied (old applications will call this @connection)
+                        // if we found a @list applied (or a @paginate which implies a @list )
                         if ([config.listDirective, config.paginateDirective].includes(node.name.value)) {
                             // look up the name passed to the directive
                             var nameArg = (_a = node.arguments) === null || _a === void 0 ? void 0 : _a.find(function (arg) { return arg.name.value === 'name'; });
@@ -178,27 +177,6 @@ function addListFragments(config, documents) {
                             }
                         }
                     },
-                    Field: function (node, key, parent, path, ancestors) {
-                        var _a;
-                        // if the is marked with @list and is a connection, we need to make sure that we ask for
-                        // the cursor fields
-                        if (!((_a = node.directives) === null || _a === void 0 ? void 0 : _a.find(function (directive) { return directive.name.value === config.listDirective; }))) {
-                            return;
-                        }
-                        // the field is a list, is it a connection?
-                        // look up the parent's type
-                        var parentType = houdini_common_1.parentTypeFromAncestors(config.schema, ancestors);
-                        // a non-connection list can just use the selection set of the tagged field
-                        // but if this is a connection tagged with list we need to use the selection
-                        // of the edges.node field
-                        var targetField = node;
-                        var targetFieldDefinition = parentType.getFields()[targetField.name.value];
-                        var connection = connectionSelection(config, targetFieldDefinition, houdini_common_1.parentTypeFromAncestors(config.schema, ancestors), node.selectionSet).connection;
-                        // if the field is a connection, add the cursor
-                        if (connection) {
-                            return __assign(__assign({}, node), { selectionSet: __assign(__assign({}, node.selectionSet), { selections: __spread(node.selectionSet.selections, paginate_1.pageInfoSelection) }) });
-                        }
-                    },
                 });
             };
             try {

package/build/cmd/transforms/paginate.d.ts

@@ -1,37 +1,3 @@
 import { Config } from 'houdini-common';
 import { CollectedGraphQLDocument } from '../types';
 export default function paginate(config: Config, documents: CollectedGraphQLDocument[]): Promise<void>;
-export declare const pageInfoSelection: {
-    kind: string;
-    name: {
-        kind: string;
-        value: string;
-    };
-    selectionSet: {
-        kind: string;
-        selections: ({
-            kind: string;
-            name: {
-                kind: string;
-                value: string;
-            };
-            selectionSet?: undefined;
-        } | {
-            kind: string;
-            name: {
-                kind: string;
-                value: string;
-            };
-            selectionSet: {
-                kind: string;
-                selections: {
-                    kind: string;
-                    name: {
-                        kind: string;
-                        value: string;
-                    };
-                }[];
-            };
-        })[];
-    };
-}[];

package/build/cmd/transforms/paginate.js

@@ -97,7 +97,6 @@ var __values = (this && this.__values) || function(o) {
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pageInfoSelection = void 0;
 // externals
 var graphql = __importStar(require("graphql"));
 var houdini_common_1 = require("houdini-common");
@@ -192,7 +191,7 @@ function paginate(config, documents) {
                                 ? // no need to add any fields to the selection if we're dealing with offset pagination
                                     node.selectionSet
                                 : // add the page info if we are dealing with cursor-based pagination
-                                 __assign(__assign({}, node.selectionSet), { selections: __spread(node.selectionSet.selections, exports.pageInfoSelection) }) });
+                                 __assign(__assign({}, node.selectionSet), { selections: __spread(node.selectionSet.selections, pageInfoSelection) }) });
                     },
                 });
                 // if we saw the paginate directive we need to add arguments to the fragment or query that contain the
@@ -611,7 +610,7 @@ function objectNode(_a) {
     }
     return node;
 }
-exports.pageInfoSelection = [
+var pageInfoSelection = [
     {
         kind: 'Field',
         name: {

package/build/cmd/validators/typeCheck.js

@@ -247,6 +247,11 @@ function typeCheck(config, docs) {
                             var targetField = ancestors[ancestors.length - 1];
                             var targetFieldDefinition = parentType.getFields()[targetField.name.value];
                             var type = list_1.connectionSelection(config, targetFieldDefinition, houdini_common_1.parentTypeFromAncestors(config.schema, ancestors), targetField.selectionSet).type;
+                            // make sure there is an id field
+                            if (!type.getFields()['id']) {
+                                errors.push(new types_1.HoudiniErrorTodo("@" + config.listDirective + " can only be applied to types with an id field."));
+                                return;
+                            }
                             // add the list to the list
                             lists.push(listName);
                             listTypes.push(type.name);
@@ -265,6 +270,10 @@ function typeCheck(config, docs) {
                 }
                 finally { if (e_1) throw e_1.error; }
             }
+            // if we got errors
+            if (errors.length > 0) {
+                throw errors;
+            }
             rules = __spread(graphql.specifiedRules).filter(
             // remove rules that conflict with houdini
             function (rule) {
@@ -302,7 +311,9 @@ function typeCheck(config, docs) {
             // validate any fragment arguments
             validateFragmentArguments(config, fragments), 
             // make sure there are pagination args on fields marked with @paginate
-            paginateArgs(config));
+            paginateArgs(config), 
+            // make sure every argument defined in a fragment is used
+            noUnusedFragmentArguments(config));
             try {
                 for (docs_2 = __values(docs), docs_2_1 = docs_2.next(); !docs_2_1.done; docs_2_1 = docs_2.next()) {
                     _a = docs_2_1.value, filename = _a.filename, parsed = _a.document;
@@ -659,6 +670,46 @@ function paginateArgs(config) {
         };
     };
 }
+function noUnusedFragmentArguments(config) {
+    return function (ctx) {
+        // if we run into a fragment definition with arguments we need to make sure every argument is used
+        var args = new Set();
+        return {
+            // when we first see a fragment definition
+            enter: {
+                FragmentDefinition: function (node) {
+                    var e_7, _a;
+                    var _b;
+                    var definitionArguments = (_b = node.directives) === null || _b === void 0 ? void 0 : _b.filter(function (directive) { return directive.name.value === config.argumentsDirective; }).flatMap(function (directive) { return directive.arguments; });
+                    try {
+                        for (var _c = __values((definitionArguments === null || definitionArguments === void 0 ? void 0 : definitionArguments.map(function (arg) { return arg === null || arg === void 0 ? void 0 : arg.name.value; })) || []), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var arg = _d.value;
+                            args.add(arg);
+                        }
+                    }
+                    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                    }
+                },
+                Variable: function (node) {
+                    args.delete(node.name.value);
+                },
+            },
+            leave: {
+                // once we're done with the definition make sure we used everything
+                FragmentDefinition: function (node) {
+                    if (args.size > 0) {
+                        ctx.reportError(new graphql.GraphQLError('Encountered unused fragment arguments: ' + __spread(args).join(',')));
+                    }
+                },
+            },
+        };
+    };
+}
 function nodeDirectives(config, directives) {
     var queryType = config.schema.getQueryType();
     var possibleNodes = [(queryType === null || queryType === void 0 ? void 0 : queryType.name) || ''];