attio 0.0.1-experimental.20240927 → 0.0.1-experimental.20241002

package/lib/api/start-graphql-server.js

@@ -11,7 +11,7 @@ export function startGraphqlServer(sendBack) {
     const startServer = async () => {
         const currentFilePath = fileURLToPath(import.meta.url);
         const currentDirPath = dirname(currentFilePath);
-        const schemaPath = path.resolve(currentDirPath, "..", "schema.graphql");
+        const schemaPath = path.resolve(currentDirPath, "..", "..", "schema.graphql");
         const schemaString = fs.readFileSync(schemaPath, "utf8");
         const port = await findAvailablePort(8700);
         const schema = buildSchema(schemaString);

package/lib/client/components/action.d.ts

@@ -1,10 +1,11 @@
 import React from "react";
+import { Icon } from "../icon";
 /**
  * Action Button
  */
 export declare function Action(props: {
     onTrigger: () => void;
-    icon?: string;
+    icon?: Icon;
     disabled?: boolean;
     children: React.ReactNode;
 }): React.JSX.Element;

package/lib/client/hooks/index.d.ts

@@ -1,5 +1,4 @@
 export { useDialog } from "./use-dialog.js";
-export { useGraphQL } from "./use-graphql.js";
 export { useAsyncCache, AsyncCacheConfig, AsyncFunction } from "./use-async-cache.js";
 export { useQuery } from "./use-query.js";
 export { useRecord } from "./use-record.js";

package/lib/client/hooks/use-query.d.ts

@@ -1,5 +1,6 @@
-export declare function useQuery<T>(
+import { Query } from "../run-query";
+export declare function useQuery<Variables, Result>(
 /** GraphQL query */
-query: string, 
+query: Query<Variables, Result>, 
 /** GraphQL query variables */
-variableValues?: Record<string, any>): T;
+variableValues?: Variables): Result;

package/lib/client/icon.d.ts

@@ -0,0 +1,2 @@
+export type Icon = AttioIcon | `${string}.png`;
+export type AttioIcon = "Activity" | "AlignArrowUp" | "AlignBlockCenter" | "AlignBlockLeft" | "AlignBlockRight" | "AlignCenter" | "AlignLeft" | "AlignRight" | "Apps" | "Archive" | "ArrowDown" | "ArrowDownLeft" | "ArrowDownRight" | "ArrowLeft" | "ArrowLeftRight" | "ArrowRight" | "ArrowsRefresh" | "ArrowUp" | "ArrowUpDown" | "ArrowUpLeft" | "ArrowUpRight" | "ArrowUpRightCircle" | "At" | "Attachment" | "Attributes" | "AttributesPlus" | "Automation" | "Bank" | "BarChart" | "Bold" | "BracketsCross" | "Breakpoint" | "BrowserExtension" | "BulletList" | "CalendarArrowLeft" | "CalendarArrowRight" | "CalendarClock" | "Calendar" | "CalendarArrowLeft" | "CalendarArrowRight" | "CalendarClock" | "CalendarDate" | "CalendarMinus" | "CalendarPlus" | "Caption" | "Change" | "Changelog" | "Check" | "CheckCircle" | "CheckDouble" | "CheckSquare" | "CheckSquarePlus" | "ChevronDown" | "ChevronDownChevronUp" | "ChevronLeft" | "ChevronRight" | "ChevronRightDouble" | "ChevronUp" | "ChevronUpChevronDown" | "CircleEmpty" | "CircleFilled" | "ClassifyRecord" | "ClassifyText" | "Clock" | "ClockDelay" | "Code" | "Collapse" | "Collapsed" | "CollapsedHover" | "CollapseHover" | "CollapseScreen" | "Collection" | "CollectionPlus" | "ColumnPlus" | "Columns" | "ColumnsPlus" | "Command" | "Comment" | "CommentPlus" | "Comments" | "Companies" | "Company" | "CompanyPlus" | "ConditionDown" | "Confetti" | "Copy" | "CreditCard" | "Cross" | "CrossCircle" | "Currency" | "CustomForms" | "CustomFormsCog" | "CustomFormsEdit" | "CustomFormsPlus" | "Dashboard" | "DashboardPlus" | "Data" | "DataText" | "Deal" | "Description" | "Desktop" | "Dollar" | "DollarArrowUp" | "DotsHorizontal" | "DotsVertical" | "Download" | "DragHandle" | "Duplicate" | "Edit" | "EditDisabled" | "Education" | "Email" | "EmailArrowLeft" | "EmailArrowRight" | "EmailDraft" | "EmailMass" | "EmailMassPlus" | "EmailMinus" | "EmailPlus" | "EmailTemplate" | "EmailTemplatePlus" | "EmojiAdd" | "EmptyCircle" | "Enter" | "Equals" | "EstimatedArr" | "Euro" | "EverythingBagel" | "ExpandScreen" | "Eye" | "EyeHide" | "Feedback" | "FileCsv" | "Filter" | "FilterAdd" | "FilterFunnel" | "Flash" | "Folder" | "FolderPlus" | "Forbid" | "FunnelChart" | "FunnelStepsChart" | "GalleryView" | "Gbp" | "GitBranch" | "Globe" | "GlobeHemisphereEast" | "Grid" | "Growth" | "Hand" | "Handshake" | "Hashtag" | "HelpCircle" | "Image" | "ImportExport" | "Inbox" | "InboxCross" | "InboxNotification" | "InfoCircle" | "Input" | "Italic" | "Key" | "KeyboardKey" | "LineChart" | "Link" | "List" | "ListArrowLeft" | "ListEdit" | "ListFlash" | "ListMinus" | "ListPlus" | "ListSearch" | "ListView" | "Location" | "Locked" | "LogOut" | "MapChart" | "Maximise" | "Merge" | "Message" | "Minimise" | "Minus" | "MinusSquare" | "MobilePhone" | "Moon" | "More" | "Move" | "MultiSelect" | "Name" | "None" | "Note" | "NotePlus" | "NoteTemplate" | "NoteTemplateArrowRight" | "NoteTemplatePlus" | "NumberList" | "ObjectIcon" | "ObjectPlaceholder" | "ObjectPlus" | "PanelLeft" | "PanelRight" | "Paste" | "Pause" | "Percentage" | "Phone" | "PhoneArrowLeft" | "PhoneArrowRight" | "PhoneBusy" | "PhoneCancel" | "PhoneCheck" | "PhoneCross" | "PhoneMissed" | "PhoneNoAnswer" | "PieChart" | "Pin" | "Pinned" | "Placeholder" | "Play" | "Plus" | "PlusSquare" | "Pointer" | "PromptCompletion" | "Record" | "RecordDetailEdit" | "RecordEdit" | "RecordFlash" | "RecordPlus" | "RecordSearch" | "Reference" | "RelationshipConnect" | "RemoveCircle" | "Rename" | "Repeat" | "Replace" | "Reply" | "Report" | "ReportPlus" | "Reset" | "RingBell" | "Robot" | "Rocket" | "Rows" | "RowsPlus" | "Sales" | "Search" | "SearchMinus" | "SearchPlus" | "SectionArrowDown" | "SectionArrowUp" | "Select" | "SelfServed" | "Send" | "SendAdd" | "SendEdit" | "ServiceBell" | "Sessions" | "Settings" | "SettingsArrowRight" | "SettingsCheck" | "SettingsMinus" | "Share" | "ShieldLocker" | "Shortcut" | "ShortcutMinus" | "ShortcutPlus" | "ShowRightSidebar" | "Signature" | "SingleMetricChart" | "SnapGrid" | "SortAscending" | "SortDescending" | "SortPlus" | "Spreadsheet" | "SquareEmpty" | "SquareFilled" | "SquareStrength" | "StageChanged" | "Star" | "StarCross" | "Status" | "Strength" | "Subscription" | "SummariseRecord" | "Sun" | "Switch" | "Table" | "Tag" | "Templates" | "TestTube" | "Text" | "TextIndentLeft" | "TextIndentRight" | "ThumbsDown" | "ThumbsUp" | "TidyUp" | "TimeChart" | "TimeInStatus" | "Timestamp" | "Trash" | "Trigger" | "TriggerPlus" | "Undo" | "Unlink" | "Upload" | "User" | "UserArrowLeft" | "UserArrowRight" | "UserFlash" | "UserHeart" | "UserKey" | "UserMinus" | "UserPhone" | "UserPlaceholder" | "UserPlus" | "Users" | "VideoCamera" | "View" | "ViewPlus" | "Voicemail" | "WarningCircle" | "WarningTriangle" | "Webhooks" | "WorkflowCredit" | "WorkflowRun" | "WorkflowsEdit" | "WorkflowsPlaceholder" | "WorkflowsPlus" | "Workspace";

package/lib/client/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./hooks/index.js";
 export * from "./components/index.js";
+export { runQuery, Query } from "./run-query.js";
 export * as Forms from "./forms/index.js";
 export { FormArray } from "./forms/array.js";
 export { FormNumber } from "./forms/number.js";
@@ -7,3 +8,4 @@ export { FormString } from "./forms/string.js";
 export { FormConnection, Connection } from "./forms/connection.js";
 export * from "./forms/path.js";
 export { Form } from "./forms/build.js";
+export { Icon, AttioIcon } from "./icon.js";

package/lib/client/run-query.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Imperatively runs a GraphQL query.
+ */
+export declare function runQuery(query: string, variableValues?: Record<string, any>): Promise<any>;
+export type Query<Variables, Result> = {
+    __data: Result;
+    __variables: Variables;
+} & string;

package/lib/commands/connection/add.js

@@ -84,12 +84,12 @@ export default function AddConnection({ options: { slug, label, description, typ
             snapshot.matches("Ask for slug") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
                     React.createElement(Text, null, "Unique Slug: "),
-                    React.createElement(TextInput, { value: snapshot.context.slug ?? "", placeholder: "my-access-token", onChange: (slug) => send({ type: "Update Slug", slug }), onSubmit: () => send({ type: "Submit" }) })))),
+                    React.createElement(TextInput, { value: snapshot.context.slug ?? "", onChange: (slug) => send({ type: "Update Slug", slug }), onSubmit: () => send({ type: "Submit" }) })))),
             snapshot.matches("Ask for label") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
                     React.createElement(Text, null, "Provide a label for your connection. This will be displayed to users. (You can edit this later)")),
                 React.createElement(Box, null,
-                    React.createElement(TextInput, { value: snapshot.context.label ?? "", placeholder: "My Awesome Connection", onChange: (label) => send({ type: "Update Label", label }), onSubmit: () => send({ type: "Submit" }) })))),
+                    React.createElement(TextInput, { value: snapshot.context.label ?? "", onChange: (label) => send({ type: "Update Label", label }), onSubmit: () => send({ type: "Submit" }) })))),
             snapshot.matches("Ask for description") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
                     React.createElement(Text, null, "Provide an optional detailed description for your connection. This will be displayed to users. (You can edit this later)")),
@@ -119,11 +119,11 @@ export default function AddConnection({ options: { slug, label, description, typ
             snapshot.matches("Ask for Authorize URL") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
                     React.createElement(Text, null, "OAuth Authorize URL: "),
-                    React.createElement(TextInput, { value: snapshot.context.authorizeUrl ?? "", placeholder: "https://authorization-server.com/authorize", onChange: (authorizeUrl) => send({ type: "Update Authorize URL", authorizeUrl }), onSubmit: () => send({ type: "Submit" }) })))),
+                    React.createElement(TextInput, { value: snapshot.context.authorizeUrl ?? "", onChange: (authorizeUrl) => send({ type: "Update Authorize URL", authorizeUrl }), onSubmit: () => send({ type: "Submit" }) })))),
             snapshot.matches("Ask for Access Token URL") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
                     React.createElement(Text, null, "OAuth Access Token URL: "),
-                    React.createElement(TextInput, { value: snapshot.context.accessTokenUrl ?? "", placeholder: "https://authorization-server.com/token", onChange: (accessTokenUrl) => send({ type: "Update Access Token URL", accessTokenUrl }), onSubmit: () => send({ type: "Submit" }) })))),
+                    React.createElement(TextInput, { value: snapshot.context.accessTokenUrl ?? "", onChange: (accessTokenUrl) => send({ type: "Update Access Token URL", accessTokenUrl }), onSubmit: () => send({ type: "Submit" }) })))),
             snapshot.matches("Ask for Scopes") && (React.createElement(React.Fragment, null,
                 React.createElement(Box, null,
                     React.createElement(Text, null, "OAuth Scopes: (separated by commas) "),

package/lib/commands/dev.js

@@ -53,6 +53,14 @@ export default function Dev({ options: { debug } }) {
                     React.createElement(Text, null,
                         "Env: ",
                         JSON.stringify(snapshot.children.env?.getSnapshot().value))),
+                React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        "Code Gen:",
+                        " ",
+                        JSON.stringify(snapshot.children["code-gen"]?.getSnapshot()?.value),
+                        " ",
+                        snapshot.children["code-gen"]?.getSnapshot().context.error
+                            ?.message)),
                 snapshot.context.devVersion?.app_id && (React.createElement(Box, null,
                     React.createElement(Text, null,
                         "App ID: ",

package/lib/graphql/generate-operations.js

@@ -0,0 +1,151 @@
+import fs from "fs";
+import { parse, visit, validate, print, OperationTypeNode, isObjectType, isListType, isNonNullType, isInputObjectType, isEnumType, getNamedType, } from "graphql";
+import path from "path";
+import { format } from "prettier";
+function findGraphQLFiles(dir) {
+    const files = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...findGraphQLFiles(fullPath));
+        }
+        else if (entry.isFile() && path.extname(entry.name) === ".graphql") {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function generateEnumTypeDefinition(type) {
+    const values = type
+        .getValues()
+        .map((v) => `'${v.name}'`)
+        .join(" | ");
+    return values;
+}
+function generateTypeDefinition(type) {
+    if (isNonNullType(type)) {
+        return generateTypeDefinition(type.ofType);
+    }
+    if (isListType(type)) {
+        return `${generateTypeDefinition(type.ofType)}`;
+    }
+    if (isObjectType(type) || isInputObjectType(type)) {
+        return type.name;
+    }
+    if (isEnumType(type)) {
+        return generateEnumTypeDefinition(type);
+    }
+    switch (type.name) {
+        case "Int":
+        case "Float":
+            return "number";
+        case "String":
+        case "ID":
+            return "string";
+        case "Boolean":
+            return "boolean";
+        default:
+            return "any";
+    }
+}
+function generateInputObjectTypeDefinition(type) {
+    const fields = Object.values(type.getFields())
+        .map((field) => `${field.name}: ${generateTypeDefinition(field.type)}`)
+        .join(", ");
+    return `{ ${fields} }`;
+}
+function generateTypeDefinitionFromSelectionSet(selectionSet, parentType) {
+    const fieldDefinitions = selectionSet.selections
+        .map((selection) => {
+        if (selection.kind === "Field") {
+            const field = parentType.getFields()[selection.name.value];
+            if (!field) {
+                throw new Error(`Field ${selection.name.value} not found in type ${parentType.name}`);
+            }
+            let fieldType = field.type;
+            let fieldTypeDefinition = "";
+            if (selection.selectionSet) {
+                if (isObjectType(getNamedType(fieldType))) {
+                    fieldTypeDefinition = generateTypeDefinitionFromSelectionSet(selection.selectionSet, getNamedType(fieldType));
+                }
+            }
+            else {
+                fieldTypeDefinition = generateTypeDefinition(fieldType);
+            }
+            return `${selection.name.value}: ${fieldTypeDefinition}${isListType(fieldType) ? "[]" : ""}`;
+        }
+        return "";
+    })
+        .filter(Boolean);
+    return `{${fieldDefinitions.join(",")}}`;
+}
+function generateReturnType(selectionSet, schema) {
+    const queryType = schema.getQueryType();
+    if (!queryType) {
+        throw new Error("Query type not found in schema");
+    }
+    return generateTypeDefinitionFromSelectionSet(selectionSet, queryType);
+}
+function generateOperationFunction(graphqlFileName, operationName, variableDefinitions, schema, selectionSet) {
+    const typeName = `${operationName.charAt(0).toUpperCase() + operationName.slice(1)}`;
+    const returnType = generateReturnType(selectionSet, schema);
+    let input;
+    if (variableDefinitions.length === 1) {
+        const varDef = variableDefinitions[0];
+        const varType = schema.getType(print(varDef.type).replace(/[!]/g, ""));
+        const varTypeString = isInputObjectType(varType)
+            ? generateInputObjectTypeDefinition(varType)
+            : generateTypeDefinition(varType);
+        input = `export type ${typeName}Variables = ${varTypeString}`;
+    }
+    else {
+        const variables = variableDefinitions
+            .map((def) => {
+            const varType = schema.getType(print(def.type).replace(/[!]/g, ""));
+            const varTypeString = isInputObjectType(varType)
+                ? generateInputObjectTypeDefinition(varType)
+                : generateTypeDefinition(varType);
+            return `${def.variable.name.value}: ${varTypeString}`;
+        })
+            .join(", ");
+        input = `export interface ${typeName}Variables { ${variables} }`;
+    }
+    return `
+declare module "./${graphqlFileName}" {
+  ${input}
+
+  export interface ${typeName}Result ${returnType}
+
+  const value: Query<${typeName}Variables, ${typeName}Result>
+  export default value
+}
+`;
+}
+export async function generateOperationFromQuery(graphqlFileName, query, schema) {
+    const ast = parse(query);
+    let operations = "";
+    const validationErrors = validate(schema, ast);
+    if (validationErrors.length > 0) {
+        throw new Error(`Validation errors: ${validationErrors.map((e) => e.message).join("\n")}`);
+    }
+    visit(ast, {
+        OperationDefinition(node) {
+            if (node.name && node.operation === OperationTypeNode.QUERY) {
+                const operationName = node.name.value;
+                const variableDefinitions = node.variableDefinitions || [];
+                operations += generateOperationFunction(graphqlFileName, operationName, variableDefinitions, schema, node.selectionSet);
+            }
+        },
+    });
+    return format(operations, { parser: "typescript" });
+}
+export async function generateOperations(rootDir, schema) {
+    const graphqlFiles = findGraphQLFiles(rootDir);
+    let operations = "";
+    for (const file of graphqlFiles) {
+        const content = fs.readFileSync(file, "utf-8");
+        operations += await generateOperationFromQuery(path.basename(file), content, schema);
+    }
+    return format(operations, { parser: "typescript" });
+}

package/lib/graphql/generate-types.js

@@ -0,0 +1,109 @@
+import { isObjectType, isInputObjectType, isScalarType, isEnumType, isListType, isNonNullType, } from "graphql";
+import { format } from "prettier";
+function countTypeUsages(schema) {
+    const typeUsages = new Map();
+    Object.values(schema.getTypeMap()).forEach((type) => {
+        if ((isObjectType(type) || isInputObjectType(type)) && !type.name.startsWith("__")) {
+            Object.values(type.getFields()).forEach((field) => {
+                let fieldType = field.type;
+                while (isListType(fieldType) || isNonNullType(fieldType)) {
+                    fieldType = fieldType.ofType;
+                }
+                if (isObjectType(fieldType) || isInputObjectType(fieldType)) {
+                    const usage = typeUsages.get(fieldType.name) || { count: 0, type: fieldType };
+                    usage.count++;
+                    typeUsages.set(fieldType.name, usage);
+                }
+            });
+        }
+    });
+    return typeUsages;
+}
+function generateFieldType(type, schema, typeUsages, seenTypes = new Set()) {
+    if (isListType(type)) {
+        return `Array<${generateFieldType(type.ofType, schema, typeUsages, seenTypes)}>`;
+    }
+    if (isNonNullType(type)) {
+        return generateFieldType(type.ofType, schema, typeUsages, seenTypes);
+    }
+    if (isScalarType(type)) {
+        switch (type.name) {
+            case "ID":
+            case "String":
+                return "string";
+            case "Int":
+            case "Float":
+                return "number";
+            case "Boolean":
+                return "boolean";
+            default:
+                return "any";
+        }
+    }
+    if (isEnumType(type)) {
+        return type
+            .getValues()
+            .map((v) => `'${v.name}'`)
+            .join(" | ");
+    }
+    if (isObjectType(type) || isInputObjectType(type)) {
+        const usage = typeUsages.get(type.name);
+        if (usage && usage.count > 1) {
+            return type.name;
+        }
+        if (seenTypes.has(type.name)) {
+            return type.name;
+        }
+        seenTypes.add(type.name);
+        const fields = type.getFields();
+        let inlineType = "{";
+        Object.entries(fields).forEach(([fieldName, field]) => {
+            const fieldType = generateFieldType(field.type, schema, typeUsages, new Set(seenTypes));
+            inlineType += `${fieldName}: ${fieldType};`;
+        });
+        inlineType += "}";
+        return inlineType;
+    }
+    return "any";
+}
+function generateDocComment(description) {
+    if (!description)
+        return "";
+    const lines = description.split("\n");
+    if (lines.length === 1) {
+        return `/** ${description} */`;
+    }
+    return `/**\n * ${lines.join("\n * ")}\n */`;
+}
+function generateType(type, schema, typeUsages) {
+    let typeString = "";
+    const typeComment = generateDocComment(type.description ?? "");
+    if (typeComment) {
+        typeString += `${typeComment}\n`;
+    }
+    typeString += `export type ${type.name.charAt(0).toUpperCase() + type.name.slice(1)} = {`;
+    const fields = type.getFields();
+    Object.entries(fields).forEach(([fieldName, field]) => {
+        typeString += "\n";
+        const fieldComment = generateDocComment(field.description);
+        if (fieldComment) {
+            typeString += `${fieldComment}\n`;
+        }
+        const fieldType = generateFieldType(field.type, schema, typeUsages);
+        typeString += `${fieldName}: ${fieldType};`;
+    });
+    typeString += "\n};";
+    return typeString;
+}
+export async function generateTypesFromSchema(schema) {
+    const typeUsages = countTypeUsages(schema);
+    let types = "";
+    const typeMap = schema.getTypeMap();
+    Object.values(typeMap).forEach((type) => {
+        if ((isObjectType(type) || isInputObjectType(type)) && !type.name.startsWith("__")) {
+            types += generateType(type, schema, typeUsages);
+            types += "\n\n";
+        }
+    });
+    return await format(types, { parser: "typescript" });
+}

package/lib/graphql/parse-schema.js

@@ -0,0 +1,65 @@
+import { codeFrameColumns } from "@babel/code-frame";
+import fs from "fs";
+import { parse, validateSchema, buildASTSchema } from "graphql";
+import { validateSDL } from "graphql/validation/validate.js";
+function formatGraphQlError(e, source, filename) {
+    if (e.locations?.length) {
+        return `${e.message}\n\n${filename}:${e.locations[0].line}\n\n${e.locations
+            .map(({ line, column }) => codeFrameColumns(source, {
+            start: { line, column },
+        }))
+            .join(`\n\n`)}\n`;
+    }
+    else {
+        throw e;
+    }
+}
+export function parseSchemaString(schemaString, schemaPath) {
+    let parsedSchema;
+    try {
+        parsedSchema = parse(schemaString);
+    }
+    catch (ex) {
+        throw Object.assign(new Error(formatGraphQlError(ex, schemaString, schemaPath)), {
+            code: `GRAPHQL_SYNTAX_ERROR`,
+        });
+    }
+    parsedSchema = {
+        ...parsedSchema,
+        definitions: parsedSchema.definitions
+            .slice()
+            .sort((a, b) => {
+            if (!a.name)
+                return -1;
+            if (!b.name)
+                return 1;
+            if (a.name.value.toLowerCase() > b.name.value.toLowerCase())
+                return 1;
+            if (a.name.value.toLowerCase() < b.name.value.toLowerCase())
+                return -1;
+            return 0;
+        }),
+    };
+    const sdlValidationErrors = validateSDL(parsedSchema);
+    if (sdlValidationErrors.length) {
+        throw Object.assign(new Error(formatGraphQlError(sdlValidationErrors[0], schemaString, schemaPath)), {
+            code: `GRAPHQL_SCHEMA_ERROR`,
+        });
+    }
+    const schema = buildASTSchema(parsedSchema, { assumeValid: false, assumeValidSDL: false });
+    const schemaValidationErrors = validateSchema(schema);
+    if (schemaValidationErrors.length > 0) {
+        throw Object.assign(new Error(formatGraphQlError(schemaValidationErrors[0], schemaString, schemaPath)), {
+            code: `GRAPHQL_SCHEMA_ERROR`,
+        });
+    }
+    return {
+        source: schemaString,
+        documentNode: parsedSchema,
+        schema,
+    };
+}
+export function parseSchema(schemaPath) {
+    const schemaString = fs.readFileSync(schemaPath, "utf-8");
+    return parseSchemaString(schemaString, schemaPath);
+}

package/lib/graphql.d.ts

@@ -0,0 +1,4 @@
+declare module "*.graphql" {
+    const value: string
+    export default value
+}

package/lib/machines/code-gen-machine.js

@@ -0,0 +1,102 @@
+import { sendTo, assign, setup, fromCallback } from "xstate";
+import { parseSchema } from "../graphql/parse-schema.js";
+import { findNodeModulesPath } from "../util/find-node-modules-path.js";
+import { updateOperationTypes } from "../util/update-operation-types.js";
+export const codeGenMachine = setup({
+    types: {
+        context: {},
+        events: {},
+        input: {},
+    },
+    guards: {
+        "all finished": (_, params) => params.finished.length === 2,
+    },
+    actors: {
+        loadSchema: fromCallback(({ sendBack }) => {
+            const loadSchema = async () => {
+                try {
+                    const path = await findNodeModulesPath(["schema.graphql"]);
+                    if (!path) {
+                        sendBack({ type: "Error", error: new Error("No schema found") });
+                        return;
+                    }
+                    const { schema } = parseSchema(path);
+                    sendBack({ type: "Schema Loaded", schema });
+                }
+                catch (error) {
+                    sendBack({ type: "Error", error });
+                }
+            };
+            loadSchema();
+        }),
+        generateOperations: fromCallback(({ sendBack, input }) => {
+            updateOperationTypes(input.schema)
+                .then(() => sendBack({ type: "Done" }))
+                .catch((error) => sendBack({ type: "Error", error }));
+        }),
+    },
+    actions: {
+        clearFinished: assign({
+            finished: [],
+        }),
+        setOperationsFinished: assign({
+            finished: (_, params) => params.finished.concat("operations.ts"),
+        }),
+        setError: assign({
+            error: (_, params) => params.error,
+        }),
+        setSchema: assign({
+            schema: (_, params) => params.schema,
+        }),
+        raiseDone: sendTo(({ context }) => context.parentRef, { type: "Code Generation Done" }),
+    },
+}).createMachine({
+    id: "GraphQL Code Generation Machine",
+    context: ({ input }) => ({
+        schema: null,
+        finished: [],
+        parentRef: input.parentRef,
+    }),
+    states: {
+        "Load Schema": {
+            on: {
+                "Error": {
+                    target: "Errored",
+                    actions: { type: "setError", params: ({ event }) => event },
+                },
+                "Schema Loaded": {
+                    target: "Generating Operations",
+                    actions: { type: "setSchema", params: ({ event }) => event },
+                    reenter: true,
+                },
+            },
+            invoke: {
+                src: "loadSchema",
+            },
+        },
+        "Done": {
+            entry: "raiseDone",
+        },
+        "Errored": {},
+        "Generating Operations": {
+            on: {
+                Done: {
+                    target: "Done",
+                },
+                Error: {
+                    target: "Errored",
+                    actions: { type: "setError", params: ({ event }) => event },
+                },
+            },
+            invoke: {
+                src: "generateOperations",
+                input: ({ context }) => ({ schema: context.schema }),
+            },
+        },
+    },
+    initial: "Load Schema",
+    on: {
+        Change: ".Load Schema",
+    },
+    description: `Generates operations typescript types`,
+});