@apollo/client-ai-apps 0.3.0 → 0.3.2

package/src/react/hooks/useToolResponseMetadata.ts

@@ -0,0 +1,5 @@
+import { useOpenAiGlobal } from "./useOpenAiGlobal";
+
+export function useToolResponseMetadata() {
+  return useOpenAiGlobal("toolResponseMetadata") ?? null;
+}

package/src/react/hooks/useWidgetState.ts

@@ -0,0 +1,48 @@
+import { SetStateAction, useCallback, useState } from "react";
+import { UnknownObject } from "../../types/openai";
+import { useOpenAiGlobal } from "./useOpenAiGlobal";
+
+export function useWidgetState<T extends UnknownObject>(
+  defaultState: T | (() => T)
+): readonly [T, (state: SetStateAction<T>) => void];
+
+export function useWidgetState<T extends UnknownObject>(
+  defaultState?: T | (() => T | null) | null
+): readonly [T | null, (state: SetStateAction<T | null>) => void];
+
+export function useWidgetState<T extends UnknownObject>(
+  defaultState?: T | (() => T | null) | null
+): readonly [T | null, (state: SetStateAction<T | null>) => void] {
+  const widgetStateFromWindow = useOpenAiGlobal("widgetState") as T;
+  const [previousWidgetStateFromWindow, setPreviousWidgetStateFromWindow] =
+    useState(widgetStateFromWindow);
+
+  let [widgetState, _setWidgetState] = useState<T | null>(() => {
+    if (widgetStateFromWindow != null) {
+      return widgetStateFromWindow;
+    }
+
+    return typeof defaultState === "function" ? defaultState() : (
+        (defaultState ?? null)
+      );
+  });
+
+  if (previousWidgetStateFromWindow !== widgetStateFromWindow) {
+    _setWidgetState((widgetState = widgetStateFromWindow));
+    setPreviousWidgetStateFromWindow(widgetStateFromWindow);
+  }
+
+  const setWidgetState = useCallback((state: SetStateAction<T | null>) => {
+    _setWidgetState((prevState) => {
+      const newState = typeof state === "function" ? state(prevState) : state;
+
+      if (newState != null && typeof window !== "undefined") {
+        void window.openai?.setWidgetState?.(newState);
+      }
+
+      return newState;
+    });
+  }, []);
+
+  return [widgetState, setWidgetState];
+}

package/src/testing/internal/index.ts

@@ -0,0 +1,2 @@
+export { dispatchStateChange } from "./openai/dispatchStateChange";
+export { stubOpenAiGlobals } from "./openai/stubOpenAiGlobals";

package/src/testing/internal/matchers/index.d.ts

@@ -0,0 +1,9 @@
+import { NextRenderOptions } from "@testing-library/react-render-stream";
+
+interface CustomMatchers<R = unknown> {
+  toRerender: (options?: NextRenderOptions) => Promise<R>;
+}
+
+declare module "vitest" {
+  interface Assertion<T = any> extends CustomMatchers<T> {}
+}

package/src/testing/internal/matchers/index.ts

@@ -0,0 +1 @@
+import "./toRerender";

package/src/testing/internal/matchers/toRerender.ts

@@ -0,0 +1,49 @@
+// Vitest port of toRerender from
+// https://github.com/testing-library/react-render-stream-testing-library/blob/main/src/expect/renderStreamMatchers.ts
+import {
+  Assertable,
+  NextRenderOptions,
+  RenderStream,
+  WaitForRenderTimeoutError,
+} from "@testing-library/react-render-stream";
+
+import { expect } from "vitest";
+
+const assertableSymbol = Symbol.for(
+  "@testing-library/react-render-stream:assertable"
+);
+
+expect.extend({
+  async toRerender(actual, options: NextRenderOptions) {
+    const _stream = actual as RenderStream<any> | Assertable;
+    const stream = (
+      assertableSymbol in _stream ?
+        _stream[assertableSymbol]
+      : _stream) as RenderStream<any>;
+    const hint = this.utils.matcherHint("toRerender", undefined, undefined, {
+      isNot: this.isNot,
+    });
+
+    let pass = true;
+
+    try {
+      await stream.peekRender({ timeout: 100, ...options });
+    } catch (e) {
+      if (e instanceof WaitForRenderTimeoutError) {
+        pass = false;
+      } else {
+        throw e;
+      }
+    }
+
+    return {
+      pass,
+      message() {
+        return (
+          `${hint}\n\nExpected component to${pass ? " not" : ""} rerender, ` +
+          `but it did${pass ? "" : " not"}.`
+        );
+      },
+    };
+  },
+});

package/src/testing/internal/openai/dispatchStateChange.ts

@@ -0,0 +1,9 @@
+import { SET_GLOBALS_EVENT_TYPE } from "../../../types/openai";
+
+export function dispatchStateChange() {
+  window.dispatchEvent(
+    new CustomEvent(SET_GLOBALS_EVENT_TYPE, {
+      detail: { globals: window.openai },
+    })
+  );
+}

package/src/testing/internal/openai/stubOpenAiGlobals.ts

@@ -0,0 +1,13 @@
+import { vi } from "vitest";
+import { API, OpenAiGlobals, UnknownObject } from "../../../types/openai";
+import { dispatchStateChange } from "./dispatchStateChange";
+
+export function stubOpenAiGlobals(globals?: Partial<API<any> & OpenAiGlobals>) {
+  vi.stubGlobal("openai", {
+    setWidgetState: (state: UnknownObject) => {
+      window.openai.widgetState = state;
+      dispatchStateChange();
+    },
+    ...globals,
+  });
+}

package/src/types/openai.ts

@@ -1,4 +1,4 @@
-type UnknownObject = any;
+export type UnknownObject = Record<string, unknown>;
 
 declare global {
   interface Window {

package/src/vite/{absolute_asset_imports_plugin.test.ts → __tests__/absolute_asset_imports_plugin.test.ts}

@@ -1,5 +1,5 @@
 import { expect, test, vi, describe, beforeEach, Mock } from "vitest";
-import { AbsoluteAssetImportsPlugin } from "./absolute_asset_imports_plugin";
+import { AbsoluteAssetImportsPlugin } from "../absolute_asset_imports_plugin";
 
 test("Should replace root relative scripts with full url when origin is provided", () => {
   const ctx = {

package/src/vite/{application_manifest_plugin.test.ts → __tests__/application_manifest_plugin.test.ts}

@@ -1,5 +1,5 @@
 import { expect, test, vi, describe, beforeEach, Mock } from "vitest";
-import { ApplicationManifestPlugin } from "./application_manifest_plugin";
+import { ApplicationManifestPlugin } from "../application_manifest_plugin";
 import fs from "fs";
 import * as glob from "glob";
 import path from "path";
@@ -562,6 +562,32 @@ describe("buildStart", () => {
     );
   });
 
+  test("Should error when tool name contains spaces", async () => {
+    vi.spyOn(fs, "readFileSync").mockImplementation((path) => {
+      if (path === "package.json") {
+        return JSON.stringify({});
+      } else if (path === "my-component.tsx") {
+        return `
+            const MY_QUERY = gql\`query HelloWorldQuery @tool(name: "hello world", description: "A tool") { helloWorld }\`;
+        `;
+      }
+    });
+    vi.spyOn(glob, "glob").mockImplementation(() =>
+      Promise.resolve(["my-component.tsx"])
+    );
+    vi.spyOn(path, "resolve").mockImplementation((_, file) => file);
+    vi.spyOn(fs, "writeFileSync");
+
+    const plugin = ApplicationManifestPlugin();
+    plugin.configResolved({ command: "serve", server: {} });
+
+    await expect(
+      async () => await plugin.buildStart()
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Error: Tool with name "hello world" contains spaces which is not allowed.]`
+    );
+  });
+
   test("Should error when tool name is not a string", async () => {
     vi.spyOn(fs, "readFileSync").mockImplementation((path) => {
       if (path === "package.json") {
@@ -675,16 +701,16 @@ describe("buildStart", () => {
       } else if (path === root + "/my-component.tsx") {
         return `
             const MY_QUERY = gql\`
-              fragment A on User { firstName } 
-              fragment B on User { lastName } 
-              query HelloWorldQuery @tool(name: "hello-world", description: "This is an awesome tool!") { 
+              fragment A on User { firstName }
+              fragment B on User { lastName }
+              query HelloWorldQuery @tool(name: "hello-world", description: "This is an awesome tool!") {
                 helloWorld {
                   ...B
                   ...A
                   ...C
-                } 
-              
-              fragment C on User { middleName } 
+                }
+
+              fragment C on User { middleName }
               }\`;
         `;
       }

package/src/vite/application_manifest_plugin.ts

@@ -140,6 +140,12 @@ export const ApplicationManifestPlugin = () => {
             throw new Error("'name' argument must be supplied for @tool");
           }
 
+          if (name.indexOf(" ") > -1) {
+            throw new Error(
+              `Tool with name "${name}" contains spaces which is not allowed.`
+            );
+          }
+
           if (!description) {
             throw new Error(
               "'description' argument must be supplied for @tool"

package/vitest-setup.ts

@@ -1 +1,2 @@
 import "@testing-library/jest-dom/vitest";
+import "./src/testing/internal/matchers";

package/dist/apollo_client/client.d.ts

@@ -1,13 +0,0 @@
-import { ApolloClient } from "@apollo/client";
-import "../types/openai";
-import { ApplicationManifest } from "../types/application-manifest";
-type ExtendedApolloClientOptions = Omit<ApolloClient.Options, "link"> & {
-    link?: ApolloClient.Options["link"];
-    manifest: ApplicationManifest;
-};
-export declare class ExtendedApolloClient extends ApolloClient {
-    manifest: ApplicationManifest;
-    constructor(options: ExtendedApolloClientOptions);
-    prefetchData(): Promise<void>;
-}
-export {};

package/dist/apollo_client/provider.d.ts

@@ -1,5 +0,0 @@
-import React from "react";
-import { ExtendedApolloClient } from "./client";
-export declare const ExtendedApolloProvider: ({ children, client, }: React.PropsWithChildren<{
-    client: ExtendedApolloClient;
-}>) => React.JSX.Element;