create-auto-app 0.1.0 → 0.1.2

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

@@ -0,0 +1,178 @@
+import type { State, Integration } from '@auto-engineer/flowlang';
+import axios from 'axios';
+import { z } from '@auto-engineer/ai-gateway';
+
+export const CartItemSchema = z.object({
+  productId: z.string(),
+  name: z.string(),
+  price: z.number(),
+  quantity: z.number(),
+});
+
+export const CartSessionSchema = z.object({
+  sessionId: z.string(),
+  items: z.array(CartItemSchema),
+  total: z.number(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+export type CartItem = {
+  productId: string;
+  name: string;
+  price: number;
+  quantity: number;
+};
+
+export type CartSession = {
+  sessionId: string;
+  items: CartItem[];
+  total: number;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type CartState = State<'Cart', CartSession>;
+
+export type CartAddedState = State<'CartAdded', CartSession>;
+
+export type CartRemovedState = State<'CartRemoved', CartSession>;
+
+export type CartClearedState = State<'CartCleared', CartSession>;
+
+const client = axios.create({
+  baseURL: 'http://localhost:3002',
+  timeout: 10000,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+type CartQueries = {
+  Cart: (params: { sessionId: string }) => Promise<CartState>;
+};
+
+type CartCommands = {
+  AddToCart: (params: {
+    sessionId: string;
+    productId: string;
+    name: string;
+    price: number;
+    quantity: number;
+  }) => Promise<CartAddedState>;
+  RemoveFromCart: (params: { sessionId: string; productId: string; quantity?: number }) => Promise<CartRemovedState>;
+  ClearCart: (params: { sessionId: string }) => Promise<CartClearedState>;
+};
+
+export const Cart: Integration<'cart', CartQueries, CartCommands> = {
+  __brand: 'Integration' as const,
+  type: 'cart' as const,
+  name: 'cart',
+  Queries: {
+    schema: {
+      Cart: z.object({
+        sessionId: z.string(),
+      }),
+    },
+    Cart: async (params: { sessionId: string }): Promise<CartState> => {
+      try {
+        const cartSession = (await client.get<CartSession>(`/api/cart/${params.sessionId}`)).data;
+        return {
+          type: 'Cart',
+          data: cartSession,
+        };
+      } catch (error) {
+        console.error(`Failed to fetch cart for session ${params.sessionId}:`, error);
+        return {
+          type: 'Cart',
+          data: {
+            sessionId: params.sessionId,
+            items: [],
+            total: 0,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+          },
+        };
+      }
+    },
+  },
+  Commands: {
+    schema: {
+      AddToCart: z.object({
+        sessionId: z.string(),
+        productId: z.string(),
+        name: z.string(),
+        price: z.number(),
+        quantity: z.number(),
+      }),
+      RemoveFromCart: z.object({
+        sessionId: z.string(),
+        productId: z.string(),
+        quantity: z.number().optional(),
+      }),
+      ClearCart: z.object({
+        sessionId: z.string(),
+      }),
+    },
+    AddToCart: async (params: {
+      sessionId: string;
+      productId: string;
+      name: string;
+      price: number;
+      quantity: number;
+    }): Promise<CartAddedState> => {
+      try {
+        const cartSession = (
+          await client.post<CartSession>(`/api/cart/${params.sessionId}/add`, {
+            productId: params.productId,
+            name: params.name,
+            price: params.price,
+            quantity: params.quantity,
+          })
+        ).data;
+        return {
+          type: 'CartAdded',
+          data: cartSession,
+        };
+      } catch (error) {
+        console.error(`Failed to add item to cart for session ${params.sessionId}:`, error);
+        throw error;
+      }
+    },
+    RemoveFromCart: async (params: {
+      sessionId: string;
+      productId: string;
+      quantity?: number;
+    }): Promise<CartRemovedState> => {
+      try {
+        const requestBody: { productId: string; quantity?: number } = {
+          productId: params.productId,
+        };
+        if (params.quantity !== undefined) {
+          requestBody.quantity = params.quantity;
+        }
+
+        const cartSession = (await client.post<CartSession>(`/api/cart/${params.sessionId}/remove`, requestBody)).data;
+        return {
+          type: 'CartRemoved',
+          data: cartSession,
+        };
+      } catch (error) {
+        console.error(`Failed to remove item from cart for session ${params.sessionId}:`, error);
+        throw error;
+      }
+    },
+    ClearCart: async (params: { sessionId: string }): Promise<CartClearedState> => {
+      try {
+        const cartSession = (await client.post<CartSession>(`/api/cart/${params.sessionId}/clear`)).data;
+        return {
+          type: 'CartCleared',
+          data: cartSession,
+        };
+      } catch (error) {
+        console.error(`Failed to clear cart for session ${params.sessionId}:`, error);
+        throw error;
+      }
+    },
+  },
+};

package/templates/shopping-app/server/src/integrations/index.ts

@@ -0,0 +1,3 @@
+export * from './ai-integration';
+export * from './cart-integration';
+export * from './product-catalogue-integration';

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

@@ -0,0 +1,363 @@
+import type { State, Integration } from '@auto-engineer/flowlang';
+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),
+        },
+      ],
+    };
+  },
+);

package/templates/shopping-app/server/src/server.ts

@@ -0,0 +1,43 @@
+import 'reflect-metadata';
+import { ApolloServer } from 'apollo-server';
+import { buildSchema } from 'type-graphql';
+import { loadProjections, loadRegisterFiles, loadResolvers } from './utils';
+import {
+  getInMemoryEventStore,
+  getInMemoryMessageBus,
+  projections,
+  forwardToMessageBus,
+} from '@event-driven-io/emmett';
+
+async function start() {
+  const loadedProjections = await loadProjections('src/domain/flows/**/projection.{ts,js}');
+  const registrations = await loadRegisterFiles('src/domain/flows/**/register.{ts,js}');
+
+  const messageBus = getInMemoryMessageBus();
+
+  const eventStore = getInMemoryEventStore({
+    projections: projections.inline(loadedProjections),
+    hooks: {
+      onAfterCommit: forwardToMessageBus(messageBus),
+    },
+  });
+
+  await Promise.all(registrations.map((r) => r.register(messageBus, eventStore)));
+
+  const resolvers = await loadResolvers('src/domain/flows/**/*.resolver.{ts,js}');
+  const schema = await buildSchema({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    resolvers: resolvers as unknown as [(...args: any[]) => any, ...Array<(...args: any[]) => any>],
+  });
+  const server = new ApolloServer({
+    schema,
+    context: () => ({
+      eventStore,
+      messageBus,
+    }),
+  });
+  const { url } = await server.listen({ port: 4000 });
+  console.log(`🚀 GraphQL server ready at ${url}`);
+}
+
+void start();

package/templates/shopping-app/server/src/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './loadResolvers';
+export * from './loadRegisterFiles';
+export * from './loadProjections';
+//# sourceMappingURL=index.d.ts.map

package/templates/shopping-app/server/src/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}

package/templates/shopping-app/server/src/utils/index.js

@@ -0,0 +1,4 @@
+export * from './loadResolvers.js';
+export * from './loadRegisterFiles.js';
+export * from './loadProjections.js';
+//# sourceMappingURL=index.js.map

package/templates/shopping-app/server/src/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}

package/templates/shopping-app/server/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './loadResolvers';
+export * from './loadRegisterFiles';
+export * from './loadProjections';

package/templates/shopping-app/server/src/utils/loadProjections.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectionDefinition } from '@event-driven-io/emmett';
+export declare function loadProjections(source: string): Promise<ProjectionDefinition[]>;
+//# sourceMappingURL=loadProjections.d.ts.map

package/templates/shopping-app/server/src/utils/loadProjections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadProjections.d.ts","sourceRoot":"","sources":["../../src/utils/loadProjections.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAoBrF"}

package/templates/shopping-app/server/src/utils/loadProjections.js

@@ -0,0 +1,23 @@
+import fg from 'fast-glob';
+import path from 'path';
+export async function loadProjections(source) {
+    const files = await fg(source, { absolute: true });
+    const modules = await Promise.all(files.map(async (file) => {
+        const mod = await import(pathToFileUrl(file).href);
+        if (typeof mod === 'object' && mod !== null && 'projection' in mod) {
+            const projectionModule = mod;
+            if (projectionModule.projection == null) {
+                console.warn(`⚠️ Projection file "${file}" does not export "projection"`);
+            }
+            return projectionModule.projection;
+        }
+        console.warn(`⚠️ Projection file "${file}" does not export "projection"`);
+        return undefined;
+    }));
+    return modules.filter((p) => p != null);
+}
+function pathToFileUrl(filePath) {
+    const resolved = path.resolve(filePath);
+    return new URL(`file://${resolved}`);
+}
+//# sourceMappingURL=loadProjections.js.map

package/templates/shopping-app/server/src/utils/loadProjections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadProjections.js","sourceRoot":"","sources":["../../src/utils/loadProjections.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,WAAW,CAAC;AAC3B,OAAO,IAAI,MAAM,MAAM,CAAC;AAGxB,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,MAAc;IAClD,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IAEnD,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QACvB,MAAM,GAAG,GAAY,MAAM,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;QAE5D,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,IAAI,YAAY,IAAI,GAAG,EAAE,CAAC;YACnE,MAAM,gBAAgB,GAAG,GAA4C,CAAC;YACtE,IAAI,gBAAgB,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;gBACxC,OAAO,CAAC,IAAI,CAAC,uBAAuB,IAAI,gCAAgC,CAAC,CAAC;YAC5E,CAAC;YACD,OAAO,gBAAgB,CAAC,UAAU,CAAC;QACrC,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,uBAAuB,IAAI,gCAAgC,CAAC,CAAC;QAC1E,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC,CACH,CAAC;IAEF,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAA6B,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;AACrE,CAAC;AAED,SAAS,aAAa,CAAC,QAAgB;IACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACxC,OAAO,IAAI,GAAG,CAAC,UAAU,QAAQ,EAAE,CAAC,CAAC;AACvC,CAAC"}

package/templates/shopping-app/server/src/utils/loadProjections.ts

@@ -0,0 +1,30 @@
+import fg from 'fast-glob';
+import path from 'path';
+import type { ProjectionDefinition } from '@event-driven-io/emmett';
+
+export async function loadProjections(source: string): Promise<ProjectionDefinition[]> {
+  const files = await fg(source, { absolute: true });
+
+  const modules = await Promise.all(
+    files.map(async (file) => {
+      const mod: unknown = await import(pathToFileUrl(file).href);
+
+      if (typeof mod === 'object' && mod !== null && 'projection' in mod) {
+        const projectionModule = mod as { projection?: ProjectionDefinition };
+        if (projectionModule.projection == null) {
+          console.warn(`⚠️ Projection file "${file}" does not export "projection"`);
+        }
+        return projectionModule.projection;
+      }
+      console.warn(`⚠️ Projection file "${file}" does not export "projection"`);
+      return undefined;
+    }),
+  );
+
+  return modules.filter((p): p is ProjectionDefinition => p != null);
+}
+
+function pathToFileUrl(filePath: string): URL {
+  const resolved = path.resolve(filePath);
+  return new URL(`file://${resolved}`);
+}

package/templates/shopping-app/server/src/utils/loadRegisterFiles.d.ts

@@ -0,0 +1,6 @@
+import type { CommandProcessor, EventStore } from '@event-driven-io/emmett';
+export interface SliceRegistration {
+    register: (messageBus: CommandProcessor, eventStore: EventStore) => Promise<unknown> | void;
+}
+export declare function loadRegisterFiles(source: string): Promise<SliceRegistration[]>;
+//# sourceMappingURL=loadRegisterFiles.d.ts.map

package/templates/shopping-app/server/src/utils/loadRegisterFiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadRegisterFiles.d.ts","sourceRoot":"","sources":["../../src/utils/loadRegisterFiles.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE5E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,CAAC,UAAU,EAAE,gBAAgB,EAAE,UAAU,EAAE,UAAU,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;CAC7F;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA2BpF"}