houdini 0.14.8 → 0.15.0-next.2

package/.changeset/empty-socks-design.md

@@ -0,0 +1,5 @@
+---
+'houdini': minor
+---
+
+parentID directive and arguments are now relative to object containing the decorated field

package/.changeset/few-donkeys-teach.md

@@ -0,0 +1,5 @@
+---
+'houdini': minor
+---
+
+Added store-based APIs :tada:

package/.changeset/forty-geckos-grin.md

@@ -0,0 +1,5 @@
+---
+'houdini': patch
+---
+
+Fixed return type of inline mutation

package/.changeset/pre.json

@@ -0,0 +1,16 @@
+{
+	"mode": "pre",
+	"tag": "next",
+	"initialVersions": {
+		"houdini": "0.14.7",
+		"example-kit": "0.13.0",
+		"integration": "0.0.1"
+	},
+	"changesets": [
+		"empty-socks-design",
+		"few-donkeys-teach",
+		"forty-geckos-grin",
+		"thin-readers-matter",
+		"wicked-lamps-smoke"
+	]
+}

package/.changeset/thin-readers-matter.md

@@ -0,0 +1,5 @@
+---
+'houdini': patch
+---
+
+config.schemaPath can be a glob pointing to multiple files

package/.changeset/wicked-lamps-smoke.md

@@ -0,0 +1,5 @@
+---
+'houdini': patch
+---
+
+Fixed type generated for mutation results

package/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+open_collective: houdini

package/.github/workflows/tests.yml

@@ -62,8 +62,8 @@ jobs:
             - name: Tests
               run: yarn tests
 
-    generate:
-        name: Generate runtime for example application
+    integration:
+        name: Integration Tests
         runs-on: ubuntu-latest
 
         steps:
@@ -85,5 +85,15 @@ jobs:
             - name: Build packages
               run: yarn build
 
-            - name: Generate runtime
-              run: cd example && yarn generate
+            - name: Install Playwright
+              run: npx playwright install --with-deps
+
+            - name: Integration Tests
+              run: yarn tests:integration
+
+            - name: Upload test results
+              if: always()
+              uses: actions/upload-artifact@v2
+              with:
+                  name: playwright-report
+                  path: integration/playwright-report

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # houdini
 
+## 0.15.0-next.2
+
+### Patch Changes
+
+-   [#331](https://github.com/HoudiniGraphql/houdini/pull/331) [`41cd95a`](https://github.com/HoudiniGraphql/houdini/commit/41cd95a577e418b6937039da963f82c95bd79854) Thanks [@AlecAivazis](https://github.com/AlecAivazis)! - Fixed return type of inline mutation
+
+## 0.15.0-next.1
+
+### Minor Changes
+
+-   [#291](https://github.com/HoudiniGraphql/houdini/pull/291) [`17cd57e`](https://github.com/HoudiniGraphql/houdini/commit/17cd57eac72596823d2a4dddec85b6ac1a1d09dd) Thanks [@jycouet](https://github.com/jycouet)! - Added store-based APIs :tada:
+
+### Patch Changes
+
+-   [#321](https://github.com/HoudiniGraphql/houdini/pull/321) [`47bb94e`](https://github.com/HoudiniGraphql/houdini/commit/47bb94ea4b6c36210f1d2b7812613287fbe82e61) Thanks [@AlecAivazis](https://github.com/AlecAivazis)! - config.schemaPath can be a glob pointing to multiple files
+
+*   [#326](https://github.com/HoudiniGraphql/houdini/pull/326) [`dc4bf44`](https://github.com/HoudiniGraphql/houdini/commit/dc4bf44ff7507f2a8c58b50c651e9ac155a3ad8c) Thanks [@AlecAivazis](https://github.com/AlecAivazis)! - Fixed type generated for mutation results
+
+## 0.15.0-next.0
+
+### Minor Changes
+
+-   [#315](https://github.com/HoudiniGraphql/houdini/pull/315) [`4cf4b7f`](https://github.com/HoudiniGraphql/houdini/commit/4cf4b7f93d893ede734c7a067f03b14499cc9773) Thanks [@AlecAivazis](https://github.com/AlecAivazis)! - parentID directive and arguments are now relative to object containing the decorated field
+
 ## 0.14.8
 
 ### Patch Changes

package/build/cmd/generate.d.ts

@@ -0,0 +1,4 @@
+import { Config } from '../common';
+import { CollectedGraphQLDocument } from './types';
+export default function compile(config: Config): Promise<void>;
+export declare function runPipeline(config: Config, docs: CollectedGraphQLDocument[]): Promise<void>;

package/build/cmd/generate.js

@@ -0,0 +1,441 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPipeline = void 0;
+// externals
+var glob_1 = __importDefault(require("glob"));
+var svelte = __importStar(require("svelte/compiler"));
+var promises_1 = __importDefault(require("fs/promises"));
+var graphql = __importStar(require("graphql"));
+var util_1 = require("util");
+// locals
+var common_1 = require("../common");
+var types_1 = require("./types");
+var transforms = __importStar(require("./transforms"));
+var generators = __importStar(require("./generators"));
+var validators = __importStar(require("./validators"));
+// the main entry point of the compile script
+function compile(config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var documents;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, collectDocuments(config)
+                    // push the documents through the pipeline
+                ];
+                case 1:
+                    documents = _a.sent();
+                    // push the documents through the pipeline
+                    return [4 /*yield*/, runPipeline(config, documents)];
+                case 2:
+                    // push the documents through the pipeline
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.default = compile;
+// the compiler's job can be broken down into a few different tasks after the documents have been collected:
+// - validate their structure
+// - perform a series of transformations
+// - write the corresponding artifacts to disk
+function runPipeline(config, docs) {
+    return __awaiter(this, void 0, void 0, function () {
+        var artifactStats, previousVersion, content, _a, _b, _c, versionChanged, unchanged, _d, _e, artifact, emoji;
+        var e_1, _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0: 
+                // we need to create the runtime folder structure
+                return [4 /*yield*/, config.createDirectories()
+                    // reset the newSchema accumulator
+                ];
+                case 1:
+                    // we need to create the runtime folder structure
+                    _g.sent();
+                    // reset the newSchema accumulator
+                    config.newSchema = '';
+                    artifactStats = {
+                        total: [],
+                        changed: [],
+                        new: [],
+                    };
+                    // notify the user we are starting the generation process
+                    if (config.logLevel !== common_1.LogLevel.Quiet) {
+                        console.log('🎩 Generating runtime...');
+                    }
+                    previousVersion = '';
+                    _g.label = 2;
+                case 2:
+                    _g.trys.push([2, 4, , 5]);
+                    _b = (_a = JSON).parse;
+                    return [4 /*yield*/, promises_1.default.readFile(config.metaFilePath, 'utf-8')];
+                case 3:
+                    content = _b.apply(_a, [_g.sent()]);
+                    previousVersion = content.version;
+                    return [3 /*break*/, 5];
+                case 4:
+                    _c = _g.sent();
+                    return [3 /*break*/, 5];
+                case 5:
+                    versionChanged = previousVersion !== 'HOUDINI_VERSION';
+                    return [4 /*yield*/, (0, common_1.runPipeline)(config, [
+                            validators.typeCheck,
+                            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,
+                            generators.artifacts(artifactStats),
+                            generators.runtime,
+                            generators.typescript,
+                            generators.persistOutput,
+                            generators.schema,
+                            generators.stores,
+                        ], docs)
+                        // don't log anything if its quiet
+                    ];
+                case 6:
+                    _g.sent();
+                    // don't log anything if its quiet
+                    if (config.logLevel === common_1.LogLevel.Quiet) {
+                    }
+                    else if (versionChanged) {
+                        console.log('ℹ️  Detected new version of Houdini. Regenerating all documents...');
+                        console.log('ℹ️  Welcome to the pre-release version for 0.15.0! Documentation can be found here: https://docs-git-0150-aaivazis.vercel.app/.');
+                        console.log("ℹ️  For a description of what's changed, visit this guide: https://docs-git-0150-aaivazis.vercel.app/guides/migrating-to-0.15.0");
+                    }
+                    else if ([common_1.LogLevel.Summary, common_1.LogLevel.ShortSummary].includes(config.logLevel)) {
+                        unchanged = artifactStats.total.length - artifactStats.changed.length - artifactStats.new.length;
+                        // if we have any unchanged artifacts
+                        if (unchanged > 0) {
+                            console.log("\uD83D\uDCC3 Unchanged: ".concat(unchanged));
+                        }
+                        if (artifactStats.changed.length > 0) {
+                            console.log("\u270F\uFE0F  Changed: ".concat(artifactStats.changed.length));
+                            if (config.logLevel === common_1.LogLevel.Summary) {
+                                logFirst5(artifactStats.changed);
+                            }
+                        }
+                        if (artifactStats.new.length > 0) {
+                            console.log("\u2728 New: ".concat(artifactStats.new.length));
+                            if (config.logLevel === common_1.LogLevel.Summary) {
+                                logFirst5(artifactStats.new);
+                            }
+                        }
+                    }
+                    else if (config.logLevel === common_1.LogLevel.Full) {
+                        try {
+                            for (_d = __values(artifactStats.total), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                artifact = _e.value;
+                                emoji = '📃';
+                                if (artifactStats.changed.includes(artifact)) {
+                                    emoji = '✏️ ';
+                                }
+                                else if (artifactStats.new.includes(artifact)) {
+                                    emoji = '✨';
+                                }
+                                // log the name
+                                console.log("".concat(emoji, " ").concat(artifact));
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.runPipeline = runPipeline;
+function collectDocuments(config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var sourceFiles, documents;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, util_1.promisify)(glob_1.default)(config.sourceGlob)
+                    // the list of documents we found
+                ];
+                case 1:
+                    sourceFiles = _a.sent();
+                    documents = [];
+                    // wait for every file to be processed
+                    return [4 /*yield*/, Promise.all(sourceFiles.map(function (filepath) { return __awaiter(_this, void 0, void 0, function () {
+                            var contents, _a, _b, _c, _d;
+                            return __generator(this, function (_e) {
+                                switch (_e.label) {
+                                    case 0: return [4 /*yield*/, promises_1.default.readFile(filepath, 'utf-8')
+                                        // if the file ends with .svelte, we need to look for graphql template tags
+                                    ];
+                                    case 1:
+                                        contents = _e.sent();
+                                        if (!filepath.endsWith('.svelte')) return [3 /*break*/, 3];
+                                        _b = (_a = documents.push).apply;
+                                        _c = [documents];
+                                        _d = [[]];
+                                        return [4 /*yield*/, findGraphQLTemplates(filepath, contents)];
+                                    case 2:
+                                        _b.apply(_a, _c.concat([__spreadArray.apply(void 0, _d.concat([__read.apply(void 0, [(_e.sent())]), false]))]));
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        documents.push({ filepath: filepath, document: contents });
+                                        _e.label = 4;
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                case 2:
+                    // wait for every file to be processed
+                    _a.sent();
+                    return [4 /*yield*/, Promise.all(documents.map(function (_a) {
+                            var document = _a.document, filepath = _a.filepath;
+                            return processGraphQLDocument(config, filepath, document);
+                        }))];
+                case 3: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+function findGraphQLTemplates(filepath, contents) {
+    return __awaiter(this, void 0, void 0, function () {
+        var documents, parsedFile, e_2, err, scripts;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    documents = [];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, (0, common_1.parseFile)(contents)];
+                case 2:
+                    parsedFile = _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    e_2 = _a.sent();
+                    err = e_2;
+                    // add the filepath to the error message
+                    throw new Error("Encountered error parsing ".concat(filepath, ": ") + err.message);
+                case 4:
+                    scripts = [parsedFile.instance, parsedFile.module]
+                        .map(function (script) { return (script ? script.content : null); })
+                        .filter(Boolean);
+                    return [4 /*yield*/, Promise.all(scripts.map(function (jsContent) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                // @ts-ignore
+                                // look for any template tag literals in the script body
+                                svelte.walk(jsContent, {
+                                    enter: function (node) {
+                                        // if we are looking at the graphql template tag
+                                        if (node.type === 'TaggedTemplateExpression' &&
+                                            // @ts-ignore
+                                            node.tag.name === 'graphql') {
+                                            // @ts-ignore
+                                            // parse the tag contents to get the info we need
+                                            var printedDoc = node.quasi.quasis[0].value.raw;
+                                            documents.push({ document: printedDoc, filepath: filepath });
+                                        }
+                                    },
+                                });
+                                return [2 /*return*/];
+                            });
+                        }); }))
+                        // we found every document in the file
+                    ];
+                case 5:
+                    _a.sent();
+                    // we found every document in the file
+                    return [2 /*return*/, documents];
+            }
+        });
+    });
+}
+function processGraphQLDocument(config, filepath, document) {
+    return __awaiter(this, void 0, void 0, function () {
+        var parsedDoc, operations, fragments, kind;
+        return __generator(this, function (_a) {
+            parsedDoc = graphql.parse(document);
+            operations = parsedDoc.definitions.filter(function (_a) {
+                var kind = _a.kind;
+                return kind === graphql.Kind.OPERATION_DEFINITION;
+            });
+            fragments = parsedDoc.definitions.filter(function (_a) {
+                var kind = _a.kind;
+                return kind === graphql.Kind.FRAGMENT_DEFINITION;
+            });
+            // if there is more than one operation, throw an error
+            if (operations.length > 1) {
+                throw new Error('Operation documents can only have one operation');
+            }
+            // we are looking at a fragment document
+            else {
+                // if there is more than one fragment, throw an error
+                if (fragments.length > 1) {
+                    throw new Error('Fragment documents can only have one fragment');
+                }
+            }
+            kind = types_1.ArtifactKind.Fragment;
+            if (operations.length === 1) {
+                // the document kind depends on the artifact
+                // query
+                if (operations[0].kind === 'OperationDefinition' && operations[0].operation === 'query') {
+                    kind = types_1.ArtifactKind.Query;
+                }
+                // mutation
+                else if (operations[0].kind === 'OperationDefinition' &&
+                    operations[0].operation === 'mutation') {
+                    kind = types_1.ArtifactKind.Mutation;
+                }
+                // subscription
+                else if (operations[0].kind === 'OperationDefinition' &&
+                    operations[0].operation === 'subscription') {
+                    kind = types_1.ArtifactKind.Subcription;
+                }
+            }
+            // add it to the list
+            return [2 /*return*/, {
+                    name: config.documentName(parsedDoc),
+                    kind: kind,
+                    document: parsedDoc,
+                    filename: filepath,
+                    originalDocument: parsedDoc,
+                    generateArtifact: true,
+                    generateStore: true,
+                    originalString: document,
+                }];
+        });
+    });
+}
+function logFirst5(values) {
+    var e_3, _a;
+    try {
+        // grab the first 5 changed documents
+        for (var _b = __values(values.slice(0, 5)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var artifact = _c.value;
+            console.log("    ".concat(artifact));
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    // if there are more than 5 just tell them how many
+    if (values.length > 5) {
+        console.log("    ... ".concat(values.length - 5, " more"));
+    }
+}

package/build/cmd/generators/artifacts/fieldKey.d.ts

@@ -0,0 +1,3 @@
+import * as graphql from 'graphql';
+import { Config } from '../../../common';
+export default function fieldKey(config: Config, field: graphql.FieldNode): string;

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

@@ -0,0 +1,83 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// external imports
+var graphql = __importStar(require("graphql"));
+// we need to generate a static key that we can use to index this field in the cache.
+// this needs to be a unique hash driven by the field's attribute and arguments
+// returns the key for a specific field
+function fieldKey(config, field) {
+    var _a, _b;
+    // we're going to hash a field by creating a json object and adding it
+    // to the attribute name
+    var attributeName = ((_a = field.alias) === null || _a === void 0 ? void 0 : _a.value) || field.name.value;
+    // field might not have a location so print and re-parse before we look at serialized values
+    var printed = graphql.print(field);
+    var secondParse = graphql.parse("{".concat(printed, "}"))
+        .definitions[0].selectionSet
+        .selections[0];
+    // if the field is paginated, we need to strip away any args
+    var paginated = !!((_b = field.directives) === null || _b === void 0 ? void 0 : _b.find(function (directive) { return directive.name.value === config.paginateDirective; }));
+    var paginationArgs = ['first', 'after', 'last', 'before', 'limit', 'offset'];
+    var argObj = (secondParse.arguments || []).reduce(function (acc, arg) {
+        var _a;
+        var _b, _c;
+        // the query already contains a serialized version of the argument so just pull it out of the
+        // document string
+        var start = (_b = arg.value.loc) === null || _b === void 0 ? void 0 : _b.start;
+        var end = (_c = arg.value.loc) === null || _c === void 0 ? void 0 : _c.end;
+        // if the field is paginated, ignore the pagination args in the key
+        if (paginated && paginationArgs.includes(arg.name.value)) {
+            return acc;
+        }
+        // if the argument is not in the query, life doesn't make sense
+        if (!start || !end) {
+            return acc;
+        }
+        return __assign(__assign({}, acc), (_a = {}, _a[arg.name.value] = printed.substring(start - 1, end - 1), _a));
+    }, {});
+    var key = Object.values(argObj).length > 0
+        ? "".concat(attributeName, "(").concat(Object.entries(argObj)
+            .map(function (entries) { return entries.join(': '); })
+            .join(', '), ")")
+        : attributeName;
+    // if the field is paginated, key it differently so other documents can ask for the non paginated value without conflict
+    if (paginated) {
+        key = key + '::paginated';
+    }
+    return key;
+}
+exports.default = fieldKey;

package/build/cmd/generators/artifacts/index.d.ts

@@ -0,0 +1,7 @@
+import { CollectedGraphQLDocument } from '../../types';
+import { Config } from '../../../common';
+export default function artifactGenerator(stats: {
+    total: string[];
+    new: string[];
+    changed: string[];
+}): (config: Config, docs: CollectedGraphQLDocument[]) => Promise<void>;