attio 0.0.1-experimental.20241002.1 → 0.0.1-experimental.20241003.1

package/lib/build.js

@@ -13,6 +13,6 @@ const buildErrorSchema = z.object({
     }),
 });
 export const errorSchema = z.object({
-    errors: z.array(buildErrorSchema),
-    warnings: z.array(buildErrorSchema),
+    errors: z.array(buildErrorSchema).optional(),
+    warnings: z.array(buildErrorSchema).optional(),
 });

package/lib/commands/dev.js

@@ -5,6 +5,7 @@ import { option } from "pastel";
 import React from "react";
 import { z } from "zod";
 import { renderBuildErrors } from "../components/BuildError.js";
+import { CodeGenError } from "../components/CodeGenErrors.js";
 import { InitialInstructions } from "../components/InitialInstructions.js";
 import { ScrollBox } from "../components/ScrollBox.js";
 import { renderTypeScriptErrors } from "../components/TypeScriptErrors.js";
@@ -28,7 +29,8 @@ export default function Dev({ options: { debug } }) {
     const jsTime = snapshot.children.javascript?.getSnapshot().context.time;
     const tsErrors = snapshot.children.typescript?.getSnapshot().context.errors;
     const tsTime = snapshot.children.typescript?.getSnapshot().context.time;
-    const hasErrors = Boolean(jsError || tsErrors);
+    const codeGenError = snapshot.children["code-gen"]?.getSnapshot().context.error;
+    const hasErrors = Boolean(jsError || tsErrors || codeGenError);
     const isNoConfig = snapshot.matches("No Config");
     React.useEffect(() => {
         if (isNoConfig) {
@@ -57,10 +59,7 @@ export default function Dev({ options: { debug } }) {
                     React.createElement(Text, null,
                         "Code Gen:",
                         " ",
-                        JSON.stringify(snapshot.children["code-gen"]?.getSnapshot()?.value),
-                        " ",
-                        snapshot.children["code-gen"]?.getSnapshot().context.error
-                            ?.message)),
+                        JSON.stringify(snapshot.children["code-gen"]?.getSnapshot()?.value))),
                 snapshot.context.devVersion?.app_id && (React.createElement(Box, null,
                     React.createElement(Text, null,
                         "App ID: ",
@@ -101,5 +100,6 @@ export default function Dev({ options: { debug } }) {
                 React.createElement(Text, null, "Press \"o\" to open GraphQL Explorer")))),
         hasErrors && (React.createElement(ScrollBox, { borderStyle: "round", padding: 1 },
             jsError && renderBuildErrors(jsError),
-            tsErrors && renderTypeScriptErrors(tsErrors)))));
+            tsErrors && renderTypeScriptErrors(tsErrors),
+            codeGenError && React.createElement(CodeGenError, { error: codeGenError })))));
 }

package/lib/components/BuildError.js

@@ -34,7 +34,7 @@ const Error = React.forwardRef(({ message, level }, ref) => (React.createElement
                         React.createElement(Text, { color: "greenBright" }, "^")))))))));
 export function renderBuildErrors({ errors, warnings }) {
     return [
-        ...errors.map((error, index) => (React.createElement(Error, { key: `BuildError-${index}`, message: error, level: "error" }))),
-        ...warnings.map((error, index) => (React.createElement(Error, { key: `BuildError-${index}`, message: error, level: "warning" }))),
+        ...(errors ?? []).map((error, index) => (React.createElement(Error, { key: `BuildError-${index}`, message: error, level: "error" }))),
+        ...(warnings ?? []).map((error, index) => (React.createElement(Error, { key: `BuildError-${index}`, message: error, level: "warning" }))),
     ];
 }

package/lib/components/CodeGenErrors.js

@@ -0,0 +1,22 @@
+import { codeFrameColumns } from "@babel/code-frame";
+import { Box, Text } from "ink";
+import React from "react";
+export const CodeGenError = React.forwardRef(({ error }, ref) => {
+    return (React.createElement(Box, { flexDirection: "column", ref: ref },
+        React.createElement(Box, null,
+            React.createElement(Text, { color: "red" },
+                React.createElement(Text, { backgroundColor: "red", color: "white" },
+                    " ",
+                    "GRAPHQL ERROR",
+                    " "),
+                " ",
+                React.createElement(Text, null, error.message))),
+        React.createElement(Box, { paddingTop: 1, flexDirection: "column" },
+            React.createElement(Box, null,
+                React.createElement(Text, null, codeFrameColumns(error.source, {
+                    start: {
+                        line: error.locations[0].line,
+                        column: error.locations[0].column,
+                    },
+                }))))));
+});

package/lib/graphql/generate-operations.js

@@ -1,7 +1,8 @@
 import fs from "fs";
-import { parse, visit, validate, print, OperationTypeNode, isObjectType, isListType, isNonNullType, isInputObjectType, isEnumType, getNamedType, validateSchema, } from "graphql";
+import { parse, visit, validate, print, OperationTypeNode, GraphQLError as OfficialGraphQLError, isObjectType, isListType, isNonNullType, isInputObjectType, isEnumType, getNamedType, validateSchema, } from "graphql";
 import path from "path";
 import { format } from "prettier";
+import { getLineAndColumn, GraphQLError } from "./parse-schema.js";
 function findGraphQLFiles(dir) {
     const files = [];
     const entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -10,7 +11,22 @@ function findGraphQLFiles(dir) {
         if (entry.isDirectory()) {
             files.push(...findGraphQLFiles(fullPath));
         }
-        else if (entry.isFile() && path.extname(entry.name) === ".graphql") {
+        else if (entry.isFile() &&
+            (path.extname(entry.name) === ".graphql" || path.extname(entry.name) === ".gql")) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function findGeneratedFiles(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.d.ts") {
             files.push(fullPath);
         }
     }
@@ -113,34 +129,69 @@ declare module "./${graphqlFileName}" {
 `;
 }
 export async function generateOperationFromQuery(graphqlFileName, query, schema) {
-    const ast = parse(query);
-    let operations = "";
+    let ast;
+    try {
+        ast = parse(query);
+    }
+    catch (e) {
+        if (e instanceof OfficialGraphQLError) {
+            throw new GraphQLError(e.message, e.locations ?? [{ line: 1, column: 1 }], query, graphqlFileName);
+        }
+        throw e;
+    }
+    let operation = "";
     const schemaErrors = validateSchema(schema);
     if (schemaErrors.length > 0) {
         throw new Error(`Schema validation errors: ${schemaErrors.map((e) => e.message).join("\n")}`);
     }
     const validationErrors = validate(schema, ast);
     const filteredErrors = validationErrors.filter((error) => !error.message.includes("is not executable"));
-    if (filteredErrors.length > 0) {
-        throw new Error(`Validation errors: ${filteredErrors.map((e) => e.message).join("\n")}`);
+    const firstError = filteredErrors[0];
+    if (firstError) {
+        throw new GraphQLError(firstError.message, firstError.locations ?? [{ line: 1, column: 1 }], query, graphqlFileName);
     }
     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);
+            if (node.name) {
+                switch (node.operation) {
+                    case OperationTypeNode.MUTATION:
+                    case OperationTypeNode.SUBSCRIPTION:
+                        throw new GraphQLError(`Only queries are supported, found ${node.operation}`, node.loc ? [getLineAndColumn(query, node.loc)] : [{ line: 1, column: 1 }], query, graphqlFileName);
+                    case OperationTypeNode.QUERY:
+                        if (operation) {
+                            throw new GraphQLError(`Only one query is allowed per .graphql file`, node.loc
+                                ? [getLineAndColumn(query, node.loc)]
+                                : [{ line: 1, column: 1 }], query, graphqlFileName);
+                        }
+                        const operationName = node.name.value;
+                        const variableDefinitions = node.variableDefinitions || [];
+                        operation = generateOperationFunction(graphqlFileName, operationName, variableDefinitions, schema, node.selectionSet);
+                        break;
+                    default:
+                        return node.operation;
+                }
             }
         },
     });
-    return format(operations, { parser: "typescript" });
+    return format(operation, { parser: "typescript" });
 }
 export async function generateOperations(rootDir, schema) {
+    await Promise.all(findGeneratedFiles(rootDir).map(async (file) => fs.promises.unlink(file)));
     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" });
+    await Promise.all(graphqlFiles.map(async (file) => {
+        const content = await fs.promises.readFile(file, "utf-8");
+        const operation = await generateOperationFromQuery(path.basename(file), content, schema);
+        const formattedOperation = await format(`/**
+ * ****************************************************
+ * THIS FILE IS AUTO-GENERATED AT DEVELOPMENT TIME.
+ *
+ * DO NOT EDIT DIRECTLY OR COMMIT IT TO SOURCE CONTROL.
+ * ****************************************************
+ */
+import {Query } from "attio/client"
+
+${operation}
+`, { parser: "typescript" });
+        await fs.promises.writeFile(`${file}.d.ts`, formattedOperation);
+    }));
 }

package/lib/graphql/parse-schema.js

@@ -2,27 +2,41 @@ 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, {
+export class GraphQLError extends Error {
+    constructor(message, locations, source, filename) {
+        super(message);
+        this.locations = locations;
+        this.source = source;
+        this.filename = filename;
+    }
+    toString() {
+        const { line, column } = this.locations[0];
+        return `${this.message}\n\n${this.filename}:${this.locations[0].line}\n\n${codeFrameColumns(this.source, {
             start: { line, column },
-        }))
-            .join(`\n\n`)}\n`;
+        })}\n`;
     }
-    else {
-        throw e;
+}
+export function getLineAndColumn(source, location) {
+    let line = 1;
+    let column = 1;
+    for (let i = 0; i < location.start; i++) {
+        if (source[i] === "\n") {
+            line++;
+            column = 1;
+        }
+        else {
+            column++;
+        }
     }
+    return { line, column };
 }
 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`,
-        });
+    catch (e) {
+        throw new GraphQLError(e.message, e.locations, schemaString, schemaPath);
     }
     parsedSchema = {
         ...parsedSchema,
@@ -42,16 +56,12 @@ export function parseSchemaString(schemaString, schemaPath) {
     };
     const sdlValidationErrors = validateSDL(parsedSchema);
     if (sdlValidationErrors.length) {
-        throw Object.assign(new Error(formatGraphQlError(sdlValidationErrors[0], schemaString, schemaPath)), {
-            code: `GRAPHQL_SCHEMA_ERROR`,
-        });
+        throw new GraphQLError(sdlValidationErrors[0].message, sdlValidationErrors[0].locations ?? [{ line: 1, column: 1 }], schemaString, schemaPath);
     }
     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`,
-        });
+        throw new GraphQLError(schemaValidationErrors[0].message, schemaValidationErrors[0].locations ?? [{ line: 1, column: 1 }], schemaString, schemaPath);
     }
     return {
         source: schemaString,

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

@@ -1,7 +1,7 @@
 import { sendTo, assign, setup, fromCallback } from "xstate";
+import { generateOperations } from "../graphql/generate-operations.js";
 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: {},
@@ -27,12 +27,15 @@ export const codeGenMachine = setup({
             loadSchema();
         }),
         generateOperations: fromCallback(({ sendBack, input }) => {
-            updateOperationTypes(input.schema)
+            generateOperations(".", input.schema)
                 .then(() => sendBack({ type: "Done" }))
                 .catch((error) => sendBack({ type: "Error", error }));
         }),
     },
     actions: {
+        clearError: assign({
+            error: () => undefined,
+        }),
         setError: assign({
             error: (_, params) => params.error,
         }),
@@ -72,6 +75,7 @@ export const codeGenMachine = setup({
             on: {
                 Done: {
                     target: "Done",
+                    actions: "clearError",
                 },
                 Error: {
                     target: "Errored",

package/lib/machines/dev-machine.js

@@ -117,13 +117,9 @@ export const devMachine = setup({
             upload().catch((error) => sendBack({ type: "Upload Error", error }));
         }),
         "watch": fromCallback(({ sendBack }) => {
-            const watcher = chokidar.watch([
-                "src/app",
-                "src/assets",
-                "src/webhooks",
-                "src/events",
-                ".env",
-            ]);
+            const watcher = chokidar.watch(["src/app", "src/assets", "src/webhooks", "src/events", ".env"], {
+                ignored: "**/*.graphql.d.ts",
+            });
             watcher.on("ready", () => watcher.on("all", () => {
                 sendBack({ type: "Change" });
             }));

package/lib/templates/typescript/tsconfig.json

@@ -35,12 +35,12 @@
     "strictNullChecks": true,
     "strictPropertyInitialization": true,
     "target": "ES2019",
-    "types": ["attio/client", "attio/global", "attio/graphql"],
+    "types": ["attio/client", "attio/global"],
   },
   "exclude": [
     "node_modules"
   ],
   "include": [
-    "src", "graphql.d.ts"
+    "src"
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attio",
-  "version": "0.0.1-experimental.20241002.1",
+  "version": "0.0.1-experimental.20241003.1",
   "bin": "lib/attio.js",
   "type": "module",
   "files": [
@@ -19,9 +19,6 @@
     "./global": {
       "types": "./global.d.ts"
     },
-    "./graphql": {
-      "types": "./lib/graphql.d.ts"
-    },
     "./server": {
       "types": "./server.d.ts"
     },

package/lib/graphql.d.ts

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

package/lib/templates/typescript/graphql.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="attio/graphql" />
-
-declare module "*.graphql" {
-  const content: string
-  export default content;
-}

package/lib/util/update-operation-types.js

@@ -1,13 +0,0 @@
-import { promises as fs } from "fs";
-import { format } from "prettier";
-import { generateOperations } from "../graphql/generate-operations.js";
-import { findNodeModulesPath } from "./find-node-modules-path.js";
-export async function updateOperationTypes(schema) {
-    const filePath = await findNodeModulesPath(["lib", "graphql.d.ts"]);
-    if (!filePath) {
-        return;
-    }
-    const unformattedTypescript = await generateOperations(".", schema);
-    const typescript = await format(unformattedTypescript, { parser: "typescript" });
-    await fs.writeFile(filePath, `import type { Query } from "./client/index.js";\n\n${typescript}`);
-}