attio 0.0.1-experimental.20240920 → 0.0.1-experimental.20240926

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

@@ -0,0 +1,32 @@
+import { graphqlServer } from "@hono/graphql-server";
+import { serve } from "@hono/node-server";
+import fs from "fs";
+import { buildSchema } from "graphql";
+import { Hono } from "hono";
+import path, { dirname } from "path";
+import { fileURLToPath } from "url";
+import { findAvailablePort } from "../util/find-available-port.js";
+export function startGraphqlServer(sendBack) {
+    let server = null;
+    const startServer = async () => {
+        const currentFilePath = fileURLToPath(import.meta.url);
+        const currentDirPath = dirname(currentFilePath);
+        const schemaPath = path.resolve(currentDirPath, "..", "schema.graphql");
+        const schemaString = fs.readFileSync(schemaPath, "utf8");
+        const port = await findAvailablePort(8700);
+        const schema = buildSchema(schemaString);
+        const app = new Hono();
+        const rootResolver = () => {
+            return {};
+        };
+        app.use("/graphql", graphqlServer({ schema, rootResolver, graphiql: true }));
+        server = serve({ fetch: app.fetch, port });
+        sendBack({ type: "GraphQL Server Started", port });
+    };
+    startServer();
+    return () => {
+        if (!server)
+            return;
+        server.close();
+    };
+}

package/lib/build/server/generate-server-entry.js

@@ -1,8 +1,8 @@
 import { glob } from "glob";
 import path from "path";
 import { getModuleHash } from "../get-module-hash.js";
-export async function generateServerEntry({ appDirAbsolute, webhooksDirAbsolute, log, }) {
-    const [serverFunctionConcretePaths, webhookConcretePaths] = await Promise.all([
+export async function generateServerEntry({ appDirAbsolute, webhooksDirAbsolute, eventDirAbsolute, log, }) {
+    const [serverFunctionConcretePaths, webhookConcretePaths, eventConcretePaths] = await Promise.all([
         Promise.all([
             glob("**/*.server.ts", { nodir: true, cwd: appDirAbsolute }),
             glob("**/*.server.js", { nodir: true, cwd: appDirAbsolute }),
@@ -11,6 +11,10 @@ export async function generateServerEntry({ appDirAbsolute, webhooksDirAbsolute,
             glob("**/*.webhook.ts", { nodir: true, cwd: webhooksDirAbsolute }),
             glob("**/*.webhook.js", { nodir: true, cwd: webhooksDirAbsolute }),
         ]).then((paths) => paths.flat()),
+        Promise.all([
+            glob("*.event.ts", { nodir: true, cwd: eventDirAbsolute }),
+            glob("*.event.js", { nodir: true, cwd: eventDirAbsolute }),
+        ]).then((paths) => paths.flat()),
     ]);
     const serverFunctionModules = serverFunctionConcretePaths.map((path) => ({
         path,
@@ -20,6 +24,10 @@ export async function generateServerEntry({ appDirAbsolute, webhooksDirAbsolute,
         path,
         id: path.replace(/\.webhook\.(js|ts)$/, ""),
     }));
+    const eventModules = eventConcretePaths.map((path) => ({
+        path,
+        id: path.replace(/\.event\.(js|ts)$/, ""),
+    }));
     for (const module of serverFunctionModules) {
         log?.(`🔎 Found server module "${module.path}"`);
     }
@@ -27,6 +35,7 @@ export async function generateServerEntry({ appDirAbsolute, webhooksDirAbsolute,
     
         const modules = new Map()
         const webhookModules = new Map()
+        const eventModules = new Map()
 
     
         ${serverFunctionModules
@@ -37,8 +46,13 @@ export async function generateServerEntry({ appDirAbsolute, webhooksDirAbsolute,
         .map((module) => `webhookModules.set("${module.id}", () => import(${JSON.stringify(path.join(webhooksDirAbsolute, module.path))}))`)
         .join("\n")}
 
+        ${eventModules
+        .map((module) => `eventModules.set("${module.id}", () => import(${JSON.stringify(path.join(eventDirAbsolute, module.path))}))`)
+        .join("\n")}
+
         var stdin_default;
         var stdin_webhooks_default;
+        var stdin_events_default;
         function main() {
             stdin_default = async function(moduleHash, args) {
                 const module = modules.get(moduleHash)
@@ -79,6 +93,26 @@ export async function generateServerEntry({ appDirAbsolute, webhooksDirAbsolute,
 
                 return func(...args)
             }
+
+            stdin_events_default = async function(eventModuleId, args) {
+                const module = eventModules.get(eventModuleId)
+
+                if (!module) {
+                    throw new Error("Event handler not found")
+                }
+
+                const func = (await module()).default
+
+                if (!func) {
+                    throw new Error(\`Default export not found in module \${eventModuleId}\`)
+                }
+
+                if (typeof func !== "function") {
+                    throw new Error(\`\${eventModuleId} does not export a function\`)
+                }
+
+                return func(...args)
+            }
         }
 
 

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

@@ -1,5 +1,5 @@
 export { useDialog } from "./use-dialog.js";
 export { useGraphQL } from "./use-graphql.js";
-export { useLoader } from "./use-loader.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-async-cache.d.ts

@@ -0,0 +1,23 @@
+/**
+ * An async function that returns data.
+ */
+export type AsyncFunction<Input extends Array<any>, Output> = (...args: Input) => Promise<Output>;
+/**
+ * A type-safe configuration object for multiple loaders.
+ *
+ * The key is used to cache the result of the loader.
+ * The value is a loader that takes an array of arguments and returns a promise.
+ */
+export interface AsyncCacheConfig {
+    [K: string]: AsyncFunction<Array<any>, any> | [AsyncFunction<Array<any>, any>, ...Array<any>];
+}
+/**
+ * A hook that returns, and caches, the results of calling multiple async functions,
+ * typically to load data.
+ */
+export declare function useAsyncCache<Config extends AsyncCacheConfig>(config: Config): {
+    values: {
+        [K in keyof Config]: Config[K] extends AsyncFunction<any, infer Output> ? Output : Config[K] extends [AsyncFunction<infer Input, infer Output>, ...infer Args] ? Args extends Input ? Output : never : never;
+    };
+    invalidate: (name: Extract<keyof Config, string>) => void;
+};

package/lib/commands/dev.js

@@ -88,7 +88,9 @@ export default function Dev({ options: { debug } }) {
                     React.createElement(Text, { color: "redBright" }, "\u274C Upload Error"),
                     React.createElement(Text, null,
                         "\u2013 ",
-                        snapshot.context.uploadError?.message))))),
+                        snapshot.context.uploadError?.message)))),
+            snapshot.matches({ Watching: { Graphql: "Started" } }) && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
+                React.createElement(Text, null, "Press \"o\" to open GraphQL Explorer")))),
         hasErrors && (React.createElement(ScrollBox, { borderStyle: "round", padding: 1 },
             jsError && renderBuildErrors(jsError),
             tsErrors && renderTypeScriptErrors(tsErrors)))));

package/lib/machines/dev-machine.js

@@ -1,7 +1,10 @@
 import chokidar from "chokidar";
+import open from "open";
+import readline from "readline";
 import { assign, fromCallback, setup, enqueueActions } from "xstate";
 import { completeBundleUpload } from "../api/complete-bundle-upload.js";
 import { createDevVersion } from "../api/create-dev-version.js";
+import { startGraphqlServer } from "../api/start-graphql-server.js";
 import { startUpload } from "../api/start-upload.js";
 import { loadAppConfigFile } from "../util/app-config.js";
 import { loadDeveloperConfig, loadInitialDeveloperConfig, } from "../util/load-developer-config.js";
@@ -30,6 +33,24 @@ export const devMachine = setup({
             }
             sendBack({ type: "Initialized", config });
         }),
+        listenForGraphqlOpen: fromCallback(({ input }) => {
+            readline.emitKeypressEvents(process.stdin);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(true);
+            }
+            const handleKeyPress = (str, key) => {
+                if (key.name?.toLowerCase() === "o") {
+                    open(`http://localhost:${input.graphqlPort}/graphql`);
+                }
+            };
+            process.stdin.on("keypress", handleKeyPress);
+            return () => {
+                process.stdin.removeListener("keypress", handleKeyPress);
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+            };
+        }),
         prepareUpload: fromCallback(({ sendBack }) => {
             const prepareUpload = async () => {
                 const config = await loadDeveloperConfig();
@@ -94,7 +115,13 @@ 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", ".env"]);
+            const watcher = chokidar.watch([
+                "src/app",
+                "src/assets",
+                "src/webhooks",
+                "src/events",
+                ".env",
+            ]);
             watcher.on("ready", () => watcher.on("all", () => {
                 sendBack({ type: "Change" });
             }));
@@ -102,6 +129,7 @@ export const devMachine = setup({
                 watcher.close();
             };
         }),
+        graphql: fromCallback(({ sendBack }) => startGraphqlServer(sendBack)),
     },
     actions: {
         clearUploadError: assign({ uploadError: undefined }),
@@ -119,6 +147,9 @@ export const devMachine = setup({
         setDevVersion: assign({
             devVersion: (_, params) => params.devVersion,
         }),
+        setGraphqlPort: assign({
+            graphqlPort: (_, params) => params.port,
+        }),
         setSuccess: assign({
             jsContents: (_, params) => params.contents,
             lastSuccessfulJavaScriptBuild: (_, params) => params.time,
@@ -246,6 +277,31 @@ export const devMachine = setup({
                     },
                     initial: "Validating",
                 },
+                Graphql: {
+                    invoke: {
+                        src: "graphql",
+                    },
+                    states: {
+                        "Not Started": {
+                            on: {
+                                "GraphQL Server Started": {
+                                    target: "Started",
+                                    actions: {
+                                        type: "setGraphqlPort",
+                                        params: ({ event }) => event,
+                                    },
+                                },
+                            },
+                        },
+                        "Started": {
+                            invoke: {
+                                src: "listenForGraphqlOpen",
+                                input: ({ context }) => ({ graphqlPort: context.graphqlPort }),
+                            },
+                        },
+                    },
+                    initial: "Not Started",
+                },
             },
             type: "parallel",
         },

package/lib/machines/js-machine.js

@@ -24,6 +24,7 @@ export const jsMachine = setup({
                 const appDir = "src/app";
                 const assetsDir = "src/assets";
                 const webhooksDir = "src/webhooks";
+                const eventsDir = "src/events";
                 const log = (message) => {
                     sendBack({ type: "Log", message });
                 };
@@ -72,6 +73,7 @@ export const jsMachine = setup({
                             const js = await generateServerEntry({
                                 appDirAbsolute: path.resolve(appDir),
                                 webhooksDirAbsolute: path.resolve(webhooksDir),
+                                eventDirAbsolute: path.resolve(eventsDir),
                                 log,
                             });
                             if (js === lastJS) {