create-auto-app 0.8.4 → 0.8.5

package/templates/shopping-app/server/src/integrations/product-catalogue/product-catalogue-integration.ts

@@ -0,0 +1,232 @@
+import type { State, Integration } from '@auto-engineer/flow';
+import { registerTool, z } from '@auto-engineer/ai-gateway';
+
+import { createClient } from './generated/product-catalog/client';
+import type {
+  ProductCatalogItem,
+  GetApiProductsResponses,
+  GetApiProductsSearchResponses,
+  GetApiProductsSearchErrors,
+  GetApiProductsCategoryByCategoryResponses,
+  GetApiProductsByIdResponses,
+  GetApiProductsByIdErrors,
+} from './generated/product-catalog';
+import {
+  zGetApiProductsResponse,
+  zGetApiProductsSearchResponse,
+  zGetApiProductsCategoryByCategoryResponse,
+  zGetApiProductsByIdResponse,
+} from './generated/product-catalog/zod.gen';
+
+export type Product = ProductCatalogItem;
+
+export type Products = State<'Products', { products: Product[] }>;
+export type ProductsByCategory = State<'ProductsByCategory', { category: string; products: Product[] }>;
+export type ProductSearchResults = State<'ProductSearchResults', { query: string; products: Product[] }>;
+export type ProductDetails = State<'ProductDetails', { product: Product | null }>;
+
+// ---------- Generated client instance ----------
+const productClient = createClient({
+  baseUrl: 'http://localhost:3001',
+});
+
+// ---------- Integration facade ----------
+type ProductCatalogQueries = {
+  Products: () => Promise<Products>;
+  ProductsByCategory: (params: { category: string }) => Promise<ProductsByCategory>;
+  ProductSearchResults: (params: { query: string }) => Promise<ProductSearchResults>;
+  ProductDetails: (params: { id: string }) => Promise<ProductDetails>;
+};
+
+const _ProductCatalog: Integration<'product-catalog', ProductCatalogQueries> = {
+  __brand: 'Integration' as const,
+  type: 'product-catalog' as const,
+  name: 'product-catalog',
+
+  Queries: {
+    // GET /api/products
+    Products: async (): Promise<Products> => {
+      try {
+        const res = await productClient.get<GetApiProductsResponses, unknown, false>({ url: '/api/products' });
+        if (res.error !== undefined) console.error('Failed to fetch products:', res.error);
+        return { type: 'Products', data: { products: (res.data as Product[]) ?? [] } };
+      } catch (err) {
+        console.error('Failed to fetch products:', err);
+        return { type: 'Products', data: { products: [] as Product[] } };
+      }
+    },
+
+    // GET /api/products/category/{category}
+    ProductsByCategory: async ({ category }): Promise<ProductsByCategory> => {
+      try {
+        const res = await productClient.get<GetApiProductsCategoryByCategoryResponses, unknown, false>({
+          url: '/api/products/category/{category}',
+          path: { category },
+        });
+        if (res.error !== undefined) console.error(`Category "${category}" error:`, res.error);
+        return { type: 'ProductsByCategory', data: { category, products: (res.data as Product[]) ?? [] } };
+      } catch (err) {
+        console.error(`Failed to fetch products for category ${category}:`, err);
+        return { type: 'ProductsByCategory', data: { category, products: [] as Product[] } };
+      }
+    },
+
+    // GET /api/products/search?q=...
+    ProductSearchResults: async ({ query }): Promise<ProductSearchResults> => {
+      try {
+        const res = await productClient.get<GetApiProductsSearchResponses, GetApiProductsSearchErrors, false>({
+          url: '/api/products/search',
+          query: { q: query },
+        });
+        if (res.error !== undefined) console.error(`Search "${query}" error:`, res.error);
+        return { type: 'ProductSearchResults', data: { query, products: (res.data as Product[]) ?? [] } };
+      } catch (err) {
+        console.error(`Failed to search products with query "${query}":`, err);
+        return { type: 'ProductSearchResults', data: { query, products: [] as Product[] } };
+      }
+    },
+
+    // GET /api/products/{id}
+    ProductDetails: async ({ id }): Promise<ProductDetails> => {
+      try {
+        const res = await productClient.get<GetApiProductsByIdResponses, GetApiProductsByIdErrors, false>({
+          url: '/api/products/{id}',
+          path: { id },
+        });
+        if (res.response.status === 404 || res.error !== undefined) {
+          if (res.response.status !== 404) console.error(`Error fetching product "${id}":`, res.error);
+          return { type: 'ProductDetails', data: { product: null } };
+        }
+        return { type: 'ProductDetails', data: { product: res.data ?? null } };
+      } catch (err) {
+        console.error(`Failed to fetch product details for ID ${id}:`, err);
+        return { type: 'ProductDetails', data: { product: null } };
+      }
+    },
+  },
+};
+
+// ---------- Lazy MCP tool registration  ----------
+let _toolsRegistered = false;
+
+function registerProductCatalogToolsOnce(): void {
+  if (_toolsRegistered) return;
+  _toolsRegistered = true;
+
+  // All products
+  registerTool<Record<string, unknown>>(
+    'PRODUCT_CATALOGUE_PRODUCTS',
+    {
+      title: 'Get All Products',
+      description: 'Fetches all products from the product catalog',
+      inputSchema: {},
+      schema: zGetApiProductsResponse,
+      schemaName: 'GetApiProductsResponse',
+      schemaDescription: 'Array of ProductCatalogItem',
+    },
+    async () => {
+      const queries = _ProductCatalog.Queries as ProductCatalogQueries;
+      if (!queries?.Products) {
+        return {
+          content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.Products is not available' }],
+          isError: true,
+        };
+      }
+      const result = await queries.Products();
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.products, null, 2) }] };
+    },
+  );
+
+  // By category
+  interface ProductsByCategoryParams extends Record<string, unknown> {
+    category: string;
+  }
+  registerTool<ProductsByCategoryParams>(
+    'PRODUCT_CATALOGUE_PRODUCTS_BY_CATEGORY',
+    {
+      title: 'Get Products by Category',
+      description: 'Fetches products from a specific category',
+      inputSchema: { category: z.string().min(1, 'Category is required') },
+      schema: zGetApiProductsCategoryByCategoryResponse,
+      schemaName: 'GetApiProductsCategoryByCategoryResponse',
+      schemaDescription: 'Array of ProductCatalogItem',
+    },
+    async ({ category }) => {
+      const queries = _ProductCatalog.Queries as ProductCatalogQueries;
+      if (!queries?.ProductsByCategory) {
+        return {
+          content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.ProductsByCategory is not available' }],
+          isError: true,
+        };
+      }
+      const result = await queries.ProductsByCategory({ category });
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.products, null, 2) }] };
+    },
+  );
+
+  // Search
+  interface ProductSearchParams extends Record<string, unknown> {
+    query: string;
+  }
+  registerTool<ProductSearchParams>(
+    'PRODUCT_CATALOGUE_SEARCH',
+    {
+      title: 'Search Products',
+      description: 'Search for products using a query string',
+      inputSchema: { query: z.string().min(1, 'Search query is required') },
+      schema: zGetApiProductsSearchResponse,
+      schemaName: 'GetApiProductsSearchResponse',
+      schemaDescription: 'Array of ProductCatalogItem',
+    },
+    async ({ query }) => {
+      const queries = _ProductCatalog.Queries as ProductCatalogQueries;
+      if (!queries?.ProductSearchResults) {
+        return {
+          content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.ProductSearchResults is not available' }],
+          isError: true,
+        };
+      }
+      const result = await queries.ProductSearchResults({ query });
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.products, null, 2) }] };
+    },
+  );
+
+  // Details
+  interface ProductDetailsParams extends Record<string, unknown> {
+    id: string;
+  }
+  registerTool<ProductDetailsParams>(
+    'PRODUCT_CATALOGUE_PRODUCT_DETAILS',
+    {
+      title: 'Get Product Details',
+      description: 'Fetches detailed information about a specific product',
+      inputSchema: { id: z.string().min(1, 'Product ID is required') },
+      schema: zGetApiProductsByIdResponse,
+      schemaName: 'GetApiProductsByIdResponse',
+      schemaDescription: 'Single ProductCatalogItem',
+    },
+    async ({ id }) => {
+      const queries = _ProductCatalog.Queries as ProductCatalogQueries;
+      if (!queries?.ProductDetails) {
+        return {
+          content: [{ type: 'text' as const, text: 'ProductCatalog.Queries.ProductDetails is not available' }],
+          isError: true,
+        };
+      }
+      const result = await queries.ProductDetails({ id });
+      if (result.data.product === null) {
+        return { content: [{ type: 'text' as const, text: `Product with ID "${id}" not found` }], isError: true };
+      }
+      return { content: [{ type: 'text' as const, text: JSON.stringify(result.data.product, null, 2) }] };
+    },
+  );
+}
+
+// registers tools on *first usage* of the integration
+export const ProductCatalog: Integration<'product-catalog', ProductCatalogQueries> = new Proxy(_ProductCatalog, {
+  get(target, prop, receiver) {
+    // First touch of ProductCatalog triggers tool registration
+    registerProductCatalogToolsOnce();
+    return Reflect.get(target, prop, receiver);
+  },
+});

package/templates/shopping-app/server/src/integrations/product-catalogue-integration.ts

@@ -1,363 +0,0 @@
-import type { State, Integration } from '@auto-engineer/flow';
-import axios from 'axios';
-import { registerTool, z } from '@auto-engineer/ai-gateway';
-
-export const ProductSchema = z.object({
-  productId: z.string(),
-  name: z.string(),
-  category: z.string(),
-  price: z.number(),
-  tags: z.array(z.string()),
-  imageUrl: z.string().url(),
-});
-
-const ProductsSchema = z.object({
-  type: z.literal('Products'),
-  data: z.object({
-    products: z.array(ProductSchema),
-  }),
-});
-
-export type Product = {
-  productId: string;
-  name: string;
-  category: string;
-  price: number;
-  tags: string[];
-  imageUrl: string;
-};
-
-export type Products = State<
-  'Products',
-  {
-    products: Product[];
-  }
->;
-
-export type ProductsByCategory = State<
-  'ProductsByCategory',
-  {
-    category: string;
-    products: Product[];
-  }
->;
-
-export type ProductSearchResults = State<
-  'ProductSearchResults',
-  {
-    query: string;
-    products: Product[];
-  }
->;
-
-export type ProductDetails = State<
-  'ProductDetails',
-  {
-    product: Product | null;
-  }
->;
-
-const client = axios.create({
-  baseURL: 'http://localhost:3001',
-  timeout: 10000,
-  headers: {
-    'Content-Type': 'application/json',
-  },
-});
-
-type ProductCatalogQueries = {
-  Products: () => Promise<Products>;
-  ProductsByCategory: (params: { category: string }) => Promise<ProductsByCategory>;
-  ProductSearchResults: (params: { query: string }) => Promise<ProductSearchResults>;
-  ProductDetails: (params: { id: string }) => Promise<ProductDetails>;
-};
-
-export const ProductCatalog: Integration<'product-catalog', ProductCatalogQueries> = {
-  __brand: 'Integration' as const,
-  type: 'product-catalog' as const,
-  name: 'product-catalog',
-  Queries: {
-    schema: {
-      Products: ProductsSchema,
-      // ProductsByCategory: z.object({
-      //   category: z.string(),
-      //   products: z.array(ProductSchema),
-      // }),
-      // ProductSearchResults: z.object({
-      //   query: z.string(),
-      //   products: z.array(ProductSchema),
-      // }),
-      // ProductDetails: z.object({
-      //   product: ProductSchema.nullable(),
-      // }),
-    },
-    Products: async (): Promise<Products> => {
-      try {
-        const products = (await client.get<Product[]>('/api/products')).data;
-        return {
-          type: 'Products',
-          data: {
-            products,
-          },
-        };
-      } catch (error) {
-        console.error('Failed to fetch products:', error);
-        return {
-          type: 'Products',
-          data: {
-            products: [],
-          },
-        };
-      }
-    },
-    ProductsByCategory: async (params: { category: string }): Promise<ProductsByCategory> => {
-      try {
-        const products = (await client.get<Product[]>(`/api/products/category/${params.category}`)).data;
-        return {
-          type: 'ProductsByCategory',
-          data: {
-            category: params.category,
-            products,
-          },
-        };
-      } catch (error) {
-        console.error(`Failed to fetch products for category ${params.category}:`, error);
-        return {
-          type: 'ProductsByCategory',
-          data: {
-            category: params.category,
-            products: [],
-          },
-        };
-      }
-    },
-    ProductSearchResults: async (params: { query: string }): Promise<ProductSearchResults> => {
-      try {
-        const products = (
-          await client.get<Product[]>('/api/products/search', {
-            params: { q: params.query },
-          })
-        ).data;
-        return {
-          type: 'ProductSearchResults',
-          data: {
-            query: params.query,
-            products,
-          },
-        };
-      } catch (error) {
-        console.error(`Failed to search products with query "${params.query}":`, error);
-        return {
-          type: 'ProductSearchResults',
-          data: {
-            query: params.query,
-            products: [],
-          },
-        };
-      }
-    },
-    ProductDetails: async (params: { id: string }): Promise<ProductDetails> => {
-      try {
-        const product = (await client.get<Product>(`/api/products/${params.id}`)).data;
-        return {
-          type: 'ProductDetails',
-          data: {
-            product,
-          },
-        };
-      } catch (error) {
-        if (axios.isAxiosError(error) && error.response?.status === 404) {
-          return {
-            type: 'ProductDetails',
-            data: {
-              product: null,
-            },
-          };
-        }
-        console.error(`Failed to fetch product details for ID ${params.id}:`, error);
-        return {
-          type: 'ProductDetails',
-          data: {
-            product: null,
-          },
-        };
-      }
-    },
-  },
-};
-
-// Register MCP tools for ProductCatalog queries
-
-// Type definitions for query functions
-type ProductsQuery = () => Promise<Products>;
-type ProductsByCategoryQuery = (params: { category: string }) => Promise<ProductsByCategory>;
-type ProductSearchQuery = (params: { query: string }) => Promise<ProductSearchResults>;
-type ProductDetailsQuery = (params: { id: string }) => Promise<ProductDetails>;
-
-// Tool for fetching all products
-registerTool<Record<string, unknown>>(
-  'PRODUCT_CATALOGUE_PRODUCTS',
-  {
-    title: 'Get All Products',
-    description: 'Fetches all products from the product catalog',
-    inputSchema: {},
-    schema: ProductsSchema,
-    schemaName: 'Products',
-    schemaDescription: 'A list of products with id, name, category, price, tags, and imageUrl',
-  },
-  async () => {
-    const queries = ProductCatalog.Queries;
-    if (!queries?.Products) {
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: 'ProductCatalog.Queries.Products is not available',
-          },
-        ],
-        isError: true,
-      };
-    }
-    const productsQuery = queries.Products as ProductsQuery;
-    const result = await productsQuery();
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify(result.data, null, 2),
-        },
-      ],
-    };
-  },
-);
-
-// Tool for fetching products by category
-interface ProductsByCategoryParams extends Record<string, unknown> {
-  category: string;
-}
-
-registerTool<ProductsByCategoryParams>(
-  'PRODUCT_CATALOGUE_PRODUCTS_BY_CATEGORY',
-  {
-    title: 'Get Products by Category',
-    description: 'Fetches products from a specific category',
-    inputSchema: {
-      category: z.string().min(1, 'Category is required'),
-    },
-  },
-  async ({ category }) => {
-    const queries = ProductCatalog.Queries;
-    if (!queries?.ProductsByCategory) {
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: 'ProductCatalog.Queries.ProductsByCategory is not available',
-          },
-        ],
-        isError: true,
-      };
-    }
-    const categoryQuery = queries.ProductsByCategory as ProductsByCategoryQuery;
-    const result = await categoryQuery({ category });
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify(result.data, null, 2),
-        },
-      ],
-    };
-  },
-);
-
-// Tool for searching products
-interface ProductSearchParams extends Record<string, unknown> {
-  query: string;
-}
-
-registerTool<ProductSearchParams>(
-  'PRODUCT_CATALOGUE_SEARCH',
-  {
-    title: 'Search Products',
-    description: 'Search for products using a query string',
-    inputSchema: {
-      query: z.string().min(1, 'Search query is required'),
-    },
-  },
-  async ({ query }) => {
-    const queries = ProductCatalog.Queries;
-    if (!queries?.ProductSearchResults) {
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: 'ProductCatalog.Queries.ProductSearchResults is not available',
-          },
-        ],
-        isError: true,
-      };
-    }
-    const searchQuery = queries.ProductSearchResults as ProductSearchQuery;
-    const result = await searchQuery({ query });
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify(result.data, null, 2),
-        },
-      ],
-    };
-  },
-);
-
-// Tool for getting product details
-interface ProductDetailsParams extends Record<string, unknown> {
-  id: string;
-}
-
-registerTool<ProductDetailsParams>(
-  'PRODUCT_CATALOGUE_PRODUCT_DETAILS',
-  {
-    title: 'Get Product Details',
-    description: 'Fetches detailed information about a specific product',
-    inputSchema: {
-      id: z.string().min(1, 'Product ID is required'),
-    },
-  },
-  async ({ id }) => {
-    const queries = ProductCatalog.Queries;
-    if (!queries?.ProductDetails) {
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: 'ProductCatalog.Queries.ProductDetails is not available',
-          },
-        ],
-        isError: true,
-      };
-    }
-    const detailsQuery = queries.ProductDetails as ProductDetailsQuery;
-    const result = await detailsQuery({ id });
-    if (result.data.product === null) {
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: `Product with ID "${id}" not found`,
-          },
-        ],
-        isError: true,
-      };
-    }
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify(result.data, null, 2),
-        },
-      ],
-    };
-  },
-);