@apollo/client-ai-apps 0.5.3 → 0.6.0

package/src/vite/__tests__/utilities/build.ts

@@ -33,7 +33,6 @@ export async function buildApp(
     ...config,
     build: {
       emptyOutDir: false,
-      outDir: "dist",
       ...config.build,
       rollupOptions: {
         input: config.build?.rollupOptions?.input ?? "virtual:entry",

package/src/vite/apolloClientAiApps.ts

@@ -14,7 +14,7 @@ import { glob } from "glob";
 import { print } from "@apollo/client/utilities";
 import { removeDirectivesFromDocument } from "@apollo/client/utilities/internal";
 import { of } from "rxjs";
-import { Kind, parse, type OperationDefinitionNode } from "graphql";
+import { Kind, OperationTypeNode, parse } from "graphql";
 import {
   getArgumentValue,
   getDirectiveArgument,
@@ -30,6 +30,7 @@ import { explorer } from "./utilities/config.js";
 import type { ApolloClientAiAppsConfig } from "../config/index.js";
 import { ApolloClientAiAppsConfigSchema } from "../config/schema.js";
 import { z } from "zod";
+import { createFragmentRegistry } from "@apollo/client/cache";
 
 export declare namespace apolloClientAiApps {
   export type Target = ApolloClientAiAppsConfig.AppTarget;
@@ -37,6 +38,7 @@ export declare namespace apolloClientAiApps {
   export interface Options {
     targets: Target[];
     devTarget?: Target | undefined;
+    appsOutDir: string;
   }
 }
 
@@ -66,19 +68,23 @@ export function devTarget(target: string | undefined) {
 interface FileCache {
   file: string;
   hash: string;
-  operations: ManifestOperation[];
+  sources: DocumentNode[];
 }
 
 export function apolloClientAiApps(
   options: apolloClientAiApps.Options
 ): Plugin {
   const targets = Array.from(new Set(options.targets));
-  const { devTarget = targets.length === 1 ? targets[0] : undefined } = options;
+  const {
+    devTarget = targets.length === 1 ? targets[0] : undefined,
+    appsOutDir,
+  } = options;
   const cache = new Map<string, FileCache>();
 
-  let packageJson!: Record<string, any>;
   let config!: ResolvedConfig;
 
+  const fragments = createFragmentRegistry();
+
   invariant(
     Array.isArray(targets) && targets.length > 0,
     "The `targets` option must be a non-empty array"
@@ -89,8 +95,13 @@ export function apolloClientAiApps(
     `All targets must be one of: ${VALID_TARGETS.join(", ")}`
   );
 
+  invariant(
+    path.basename(path.normalize(appsOutDir)) === "apps",
+    "`appsOutDir` must end with `apps` as the final path segment (e.g. `path/to/apps`)."
+  );
+
   const client = new ApolloClient({
-    cache: new InMemoryCache(),
+    cache: new InMemoryCache({ fragments }),
     link: processQueryLink,
   });
 
@@ -106,52 +117,57 @@ export function apolloClientAiApps(
         { name: "graphql-tag", identifier: "gql" },
         { name: "@apollo/client", identifier: "gql" },
       ],
-    }).map((source) => ({
-      node: parse(source.body),
-      file,
-      location: source.locationOffset,
-    }));
+    }).map((source) => parse(source.body));
 
-    const operations: ManifestOperation[] = [];
-    for (const source of sources) {
-      const type = (
-        source.node.definitions.find(
-          (d) => d.kind === "OperationDefinition"
-        ) as OperationDefinitionNode
-      ).operation;
-
-      let result;
-      if (type === "query") {
-        result = await client.query({
-          query: source.node,
-          fetchPolicy: "no-cache",
-        });
-      } else if (type === "mutation") {
-        result = await client.mutate({
-          mutation: source.node,
-          fetchPolicy: "no-cache",
-        });
-      } else {
-        throw new Error(
-          "Found an unsupported operation type. Only Query and Mutation are supported."
-        );
-      }
-      operations.push(result.data as ManifestOperation);
-    }
+    fragments.register(...sources);
 
     cache.set(file, {
       file: file,
       hash: fileHash,
-      operations,
+      sources,
     });
   }
 
   async function generateManifest(environment?: Environment) {
     const appsConfig = await getAppsConfig();
-    const operations = Array.from(cache.values()).flatMap(
-      (entry) => entry.operations
+    const sources = Array.from(cache.values()).flatMap(
+      (entry) => entry.sources
     );
 
+    const operations: ManifestOperation[] = [];
+    for (const source of sources) {
+      const operationDef = source.definitions.find(
+        (d) => d.kind === Kind.OPERATION_DEFINITION
+      );
+
+      if (!operationDef) continue;
+
+      switch (operationDef.operation) {
+        case OperationTypeNode.QUERY: {
+          const result = await client.query<ManifestOperation>({
+            query: source,
+            fetchPolicy: "no-cache",
+          });
+
+          operations.push(result.data!);
+          break;
+        }
+        case OperationTypeNode.MUTATION: {
+          const result = await client.mutate<ManifestOperation>({
+            mutation: source,
+            fetchPolicy: "no-cache",
+          });
+
+          operations.push(result.data!);
+          break;
+        }
+        default:
+          throw new Error(
+            `Found unsupported operation type '${operationDef.operation}'. Only queries and mutations are supported.`
+          );
+      }
+    }
+
     invariant(
       operations.filter((o) => o.prefetch).length <= 1,
       "Found multiple operations marked as `@prefetch`. You can only mark 1 operation with `@prefetch`."
@@ -185,6 +201,14 @@ export function apolloClientAiApps(
       ) as { mcp?: string; openai?: string };
     }
 
+    const packageJson = readPackageJson();
+    const appName = appsConfig.name ?? packageJson.name;
+
+    invariant(
+      appName,
+      "Error generating application manifest. Could not determine app name. Set `name` in your apollo-client-ai-apps config or `package.json`."
+    );
+
     const manifest: ApplicationManifest = {
       format: "apollo-ai-app-manifest",
       version: "1",
@@ -192,11 +216,10 @@ export function apolloClientAiApps(
       name: appsConfig.name ?? packageJson.name,
       description: appsConfig.description ?? packageJson.description,
       hash: createHash("sha256").update(Date.now().toString()).digest("hex"),
-      operations: Array.from(cache.values()).flatMap(
-        (entry) => entry.operations
-      ),
+      operations,
       resource,
       csp: {
+        baseUriDomains: appsConfig.csp?.baseUriDomains ?? [],
         connectDomains: appsConfig.csp?.connectDomains ?? [],
         frameDomains: appsConfig.csp?.frameDomains ?? [],
         redirectDomains: appsConfig.csp?.redirectDomains ?? [],
@@ -212,14 +235,7 @@ export function apolloClientAiApps(
       manifest.labels = appsConfig.labels;
     }
 
-    // We create mcp and openai environments in order to write to
-    // subdirectories, but we want the manifest to be in the root outDir. If we
-    // are running in a different environment, we'll put it in the configured
-    // outDir directly instead.
-    const outDir =
-      environment?.name === "mcp" || environment?.name === "openai" ?
-        path.resolve(config.build.outDir, "../")
-      : config.build.outDir;
+    const outDir = path.join(appsOutDir, appName);
 
     // Always write to build directory so the MCP server picks it up
     const dest = path.resolve(root, outDir, ".application-manifest.json");
@@ -233,9 +249,6 @@ export function apolloClientAiApps(
   return {
     name: "@apollo/client-ai-apps/vite",
     async buildStart() {
-      // Read package.json on start
-      packageJson = JSON.parse(fs.readFileSync("package.json", "utf-8"));
-
       // Scan all files on startup
       const files = await glob("./src/**/*.{ts,tsx,js,jsx}", { fs });
 
@@ -252,19 +265,27 @@ export function apolloClientAiApps(
     configResolved(resolvedConfig) {
       config = resolvedConfig;
     },
-    configEnvironment(name, { build }) {
+    async configEnvironment(name, { build }) {
       if (!targets.includes(name as any)) return;
 
+      const appsConfig = await getAppsConfig();
+      const appName = appsConfig.name ?? readPackageJson().name;
+
+      invariant(
+        appName,
+        "Could not determine app name. Set `name` in your apollo-client-ai-apps config or `package.json`."
+      );
+
       return {
         build: {
-          outDir: path.join(build?.outDir ?? "dist", name),
+          outDir: path.join(appsOutDir, appName, name),
         },
       };
     },
     configureServer(server) {
       server.watcher.on("change", async (file) => {
         if (file.endsWith("package.json")) {
-          packageJson = JSON.parse(fs.readFileSync("package.json", "utf-8"));
+          readPackageJson.resetCache();
           await generateManifest();
         } else if (file.match(/\.?apollo-client-ai-apps\.config\.\w+$/)) {
           explorer.clearCaches();
@@ -276,7 +297,14 @@ export function apolloClientAiApps(
       });
     },
 
-    config(_, { command }) {
+    config(userConfig, { command }) {
+      if (userConfig.build?.outDir) {
+        console.warn(
+          "[@apollo/client-ai-apps/vite] `build.outDir` is set in your Vite config but will be " +
+            "ignored. Use `appsOutDir` in the plugin options to control the output location."
+        );
+      }
+
       if (command === "serve") {
         invariant(
           isValidTarget(devTarget) || targets.length === 1,
@@ -497,6 +525,21 @@ function getResourceFromConfig(
   return typeof config === "string" ? config : config[target];
 }
 
+function readPackageJson(): Record<string, any> {
+  if (readPackageJson.cache) {
+    return readPackageJson.cache;
+  }
+
+  return (readPackageJson.cache = JSON.parse(
+    fs.readFileSync("package.json", "utf-8")
+  ));
+}
+
+readPackageJson.cache = undefined as Record<string, any> | undefined;
+readPackageJson.resetCache = () => {
+  readPackageJson.cache = undefined;
+};
+
 const ToolDirectiveSchema = z.strictObject({
   name: z.stringFormat("toolName", (value) => value.indexOf(" ") === -1, {
     error: (iss) => `Tool with name "${iss.input}" must not contain spaces`,