create-auto-app 0.2.0 → 0.2.2

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

@@ -0,0 +1,198 @@
+import type { State, Integration } from '@auto-engineer/flow';
+import { registerTool, z } from '@auto-engineer/ai-gateway';
+
+import { createClient as createCartClient } from './generated/cart/client';
+import type {
+  CartSession,
+  GetApiCartBySessionIdResponses,
+  PostApiCartBySessionIdAddResponses,
+  PostApiCartBySessionIdAddErrors,
+  PostApiCartBySessionIdRemoveResponses,
+  PostApiCartBySessionIdRemoveErrors,
+  PostApiCartBySessionIdClearResponses,
+} from './generated/cart';
+import {
+  zGetApiCartBySessionIdResponse,
+  zPostApiCartBySessionIdAddResponse,
+  zPostApiCartBySessionIdRemoveResponse,
+  zPostApiCartBySessionIdClearResponse,
+} from './generated/cart/zod.gen';
+
+// ---------- State ----------
+export type CartState = State<'Cart', { cart: CartSession }>;
+
+// ---------- Client ----------
+const cartClient = createCartClient({ baseUrl: 'http://localhost:3002' });
+
+// ---------- Integration facade ----------
+type CartQueries = {
+  GetCart: (p: { sessionId: string }) => Promise<CartState>;
+};
+type CartCommands = {
+  AddItem: (p: {
+    sessionId: string;
+    productId: string;
+    name: string;
+    price: number;
+    quantity: number;
+  }) => Promise<CartState>;
+  RemoveItem: (p: { sessionId: string; productId: string; quantity: number }) => Promise<CartState>;
+  Clear: (p: { sessionId: string }) => Promise<CartState>;
+};
+
+export const Cart: Integration<'cart', CartQueries, CartCommands> = {
+  __brand: 'Integration' as const,
+  type: 'cart',
+  name: 'cart',
+
+  Queries: {
+    // GET /api/cart/{sessionId}
+    GetCart: async ({ sessionId }) => {
+      const res = await cartClient.get<GetApiCartBySessionIdResponses, unknown, false>({
+        url: '/api/cart/{sessionId}',
+        path: { sessionId },
+      });
+      if (res.error !== undefined) {
+        console.error(`GetCart error for "${sessionId}":`, res.error);
+        const now = new Date().toISOString();
+        return { type: 'Cart', data: { cart: { sessionId, items: [], total: 0, createdAt: now, updatedAt: now } } };
+      }
+      return { type: 'Cart', data: { cart: res.data! } };
+    },
+  },
+
+  Commands: {
+    // POST /api/cart/{sessionId}/add
+    AddItem: async ({ sessionId, productId, name, price, quantity }) => {
+      const res = await cartClient.post<PostApiCartBySessionIdAddResponses, PostApiCartBySessionIdAddErrors, false>({
+        url: '/api/cart/{sessionId}/add',
+        path: { sessionId },
+        body: { productId, name, price, quantity },
+      });
+      if (res.error !== undefined) {
+        console.error(`AddItem error for "${sessionId}":`, res.error);
+        // fall back to current cart
+        const fallback = await cartClient.get<GetApiCartBySessionIdResponses, unknown, false>({
+          url: '/api/cart/{sessionId}',
+          path: { sessionId },
+        });
+        return { type: 'Cart', data: { cart: fallback.data! } };
+      }
+      return { type: 'Cart', data: { cart: res.data! } };
+    },
+
+    // POST /api/cart/{sessionId}/remove
+    RemoveItem: async ({ sessionId, productId, quantity }) => {
+      const res = await cartClient.post<
+        PostApiCartBySessionIdRemoveResponses,
+        PostApiCartBySessionIdRemoveErrors,
+        false
+      >({
+        url: '/api/cart/{sessionId}/remove',
+        path: { sessionId },
+        body: { productId, quantity },
+      });
+      if (res.error !== undefined) {
+        console.error(`RemoveItem error for "${sessionId}":`, res.error);
+        const fallback = await cartClient.get<GetApiCartBySessionIdResponses, unknown, false>({
+          url: '/api/cart/{sessionId}',
+          path: { sessionId },
+        });
+        return { type: 'Cart', data: { cart: fallback.data! } };
+      }
+      return { type: 'Cart', data: { cart: res.data! } };
+    },
+
+    // POST /api/cart/{sessionId}/clear
+    Clear: async ({ sessionId }) => {
+      const res = await cartClient.post<PostApiCartBySessionIdClearResponses, unknown, false>({
+        url: '/api/cart/{sessionId}/clear',
+        path: { sessionId },
+      });
+      if (res.error !== undefined) {
+        console.error(`Clear error for "${sessionId}":`, res.error);
+        const fallback = await cartClient.get<GetApiCartBySessionIdResponses, unknown, false>({
+          url: '/api/cart/{sessionId}',
+          path: { sessionId },
+        });
+        return { type: 'Cart', data: { cart: fallback.data! } };
+      }
+      return { type: 'Cart', data: { cart: res.data! } };
+    },
+  },
+};
+
+// ---------- MCP tools  ----------
+registerTool<{ sessionId: string }>(
+  'CART_GET',
+  {
+    title: 'Get Cart',
+    description: 'Fetch a cart session by ID',
+    inputSchema: { sessionId: z.string().min(1) },
+    schema: zGetApiCartBySessionIdResponse,
+    schemaName: 'CartSession',
+    schemaDescription: 'Cart session details',
+  },
+  async ({ sessionId }) => {
+    const res = await Cart.Queries!.GetCart({ sessionId });
+    return { content: [{ type: 'text' as const, text: JSON.stringify(res.data.cart, null, 2) }] };
+  },
+);
+
+registerTool<{ sessionId: string; productId: string; name: string; price: number; quantity: number }>(
+  'CART_ADD',
+  {
+    title: 'Add Item to Cart',
+    description: 'Add an item to the cart',
+    inputSchema: {
+      sessionId: z.string().min(1),
+      productId: z.string().min(1),
+      name: z.string().min(1),
+      price: z.number(),
+      quantity: z.number().int().positive(),
+    },
+    schema: zPostApiCartBySessionIdAddResponse,
+    schemaName: 'CartSession',
+    schemaDescription: 'Updated cart',
+  },
+  async (args) => {
+    const res = await Cart.Commands!.AddItem(args);
+    return { content: [{ type: 'text' as const, text: JSON.stringify(res.data.cart, null, 2) }] };
+  },
+);
+
+registerTool<{ sessionId: string; productId: string; quantity: number }>(
+  'CART_REMOVE',
+  {
+    title: 'Remove Item from Cart',
+    description: 'Remove or decrement an item in the cart',
+    inputSchema: {
+      sessionId: z.string().min(1),
+      productId: z.string().min(1),
+      quantity: z.number().int().positive(),
+    },
+    schema: zPostApiCartBySessionIdRemoveResponse,
+    schemaName: 'CartSession',
+    schemaDescription: 'Updated cart',
+  },
+  async (args) => {
+    const res = await Cart.Commands!.RemoveItem(args);
+    return { content: [{ type: 'text' as const, text: JSON.stringify(res.data.cart, null, 2) }] };
+  },
+);
+
+registerTool<{ sessionId: string }>(
+  'CART_CLEAR',
+  {
+    title: 'Clear Cart',
+    description: 'Remove all items from the cart',
+    inputSchema: { sessionId: z.string().min(1) },
+    schema: zPostApiCartBySessionIdClearResponse,
+    schemaName: 'CartSession',
+    schemaDescription: 'Updated cart',
+  },
+  async ({ sessionId }) => {
+    const res = await Cart.Commands!.Clear({ sessionId });
+    return { content: [{ type: 'text' as const, text: JSON.stringify(res.data.cart, null, 2) }] };
+  },
+);

package/templates/shopping-app/example-integrations/cart/src/generated/cart/client/client.gen.ts

@@ -0,0 +1,199 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Client, Config, ResolvedRequestOptions } from './types.gen';
+import {
+  buildUrl,
+  createConfig,
+  createInterceptors,
+  getParseAs,
+  mergeConfigs,
+  mergeHeaders,
+  setAuthParams,
+} from './utils.gen';
+
+type ReqInit = Omit<RequestInit, 'body' | 'headers'> & {
+  body?: any;
+  headers: ReturnType<typeof mergeHeaders>;
+};
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config);
+
+  const getConfig = (): Config => ({ ..._config });
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config);
+    return getConfig();
+  };
+
+  const interceptors = createInterceptors<
+    Request,
+    Response,
+    unknown,
+    ResolvedRequestOptions
+  >();
+
+  const request: Client['request'] = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined,
+    };
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      });
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    if (opts.body && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.serializedBody === undefined || opts.serializedBody === '') {
+      opts.headers.delete('Content-Type');
+    }
+
+    const url = buildUrl(opts);
+    const requestInit: ReqInit = {
+      redirect: 'follow',
+      ...opts,
+      body: opts.serializedBody,
+    };
+
+    let request = new Request(url, requestInit);
+
+    for (const fn of interceptors.request._fns) {
+      if (fn) {
+        request = await fn(request, opts);
+      }
+    }
+
+    // fetch must be assigned here, otherwise it would throw the error:
+    // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+    const _fetch = opts.fetch!;
+    let response = await _fetch(request);
+
+    for (const fn of interceptors.response._fns) {
+      if (fn) {
+        response = await fn(response, request, opts);
+      }
+    }
+
+    const result = {
+      request,
+      response,
+    };
+
+    if (response.ok) {
+      if (
+        response.status === 204 ||
+        response.headers.get('Content-Length') === '0'
+      ) {
+        return opts.responseStyle === 'data'
+          ? {}
+          : {
+              data: {},
+              ...result,
+            };
+      }
+
+      const parseAs =
+        (opts.parseAs === 'auto'
+          ? getParseAs(response.headers.get('Content-Type'))
+          : opts.parseAs) ?? 'json';
+
+      let data: any;
+      switch (parseAs) {
+        case 'arrayBuffer':
+        case 'blob':
+        case 'formData':
+        case 'json':
+        case 'text':
+          data = await response[parseAs]();
+          break;
+        case 'stream':
+          return opts.responseStyle === 'data'
+            ? response.body
+            : {
+                data: response.body,
+                ...result,
+              };
+      }
+
+      if (parseAs === 'json') {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+
+      return opts.responseStyle === 'data'
+        ? data
+        : {
+            data,
+            ...result,
+          };
+    }
+
+    const textError = await response.text();
+    let jsonError: unknown;
+
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {
+      // noop
+    }
+
+    const error = jsonError ?? textError;
+    let finalError = error;
+
+    for (const fn of interceptors.error._fns) {
+      if (fn) {
+        finalError = (await fn(error, response, request, opts)) as string;
+      }
+    }
+
+    finalError = finalError || ({} as string);
+
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+
+    // TODO: we probably want to return error and improve types
+    return opts.responseStyle === 'data'
+      ? undefined
+      : {
+          error: finalError,
+          ...result,
+        };
+  };
+
+  return {
+    buildUrl,
+    connect: (options) => request({ ...options, method: 'CONNECT' }),
+    delete: (options) => request({ ...options, method: 'DELETE' }),
+    get: (options) => request({ ...options, method: 'GET' }),
+    getConfig,
+    head: (options) => request({ ...options, method: 'HEAD' }),
+    interceptors,
+    options: (options) => request({ ...options, method: 'OPTIONS' }),
+    patch: (options) => request({ ...options, method: 'PATCH' }),
+    post: (options) => request({ ...options, method: 'POST' }),
+    put: (options) => request({ ...options, method: 'PUT' }),
+    request,
+    setConfig,
+    trace: (options) => request({ ...options, method: 'TRACE' }),
+  };
+};

package/templates/shopping-app/example-integrations/cart/src/generated/cart/client/index.ts

@@ -0,0 +1,25 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from '../core/auth.gen';
+export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from '../core/bodySerializer.gen';
+export { buildClientParams } from '../core/params.gen';
+export { createClient } from './client.gen';
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  OptionsLegacyParser,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape,
+} from './types.gen';
+export { createConfig, mergeHeaders } from './utils.gen';

package/templates/shopping-app/example-integrations/cart/src/generated/cart/client/types.gen.ts

@@ -0,0 +1,232 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Auth } from '../core/auth.gen';
+import type {
+  Client as CoreClient,
+  Config as CoreConfig,
+} from '../core/types.gen';
+import type { Middleware } from './utils.gen';
+
+export type ResponseStyle = 'data' | 'fields';
+
+export interface Config<T extends ClientOptions = ClientOptions>
+  extends Omit<RequestInit, 'body' | 'headers' | 'method'>,
+    CoreConfig {
+  /**
+   * Base URL for all requests made by this client.
+   */
+  baseUrl?: T['baseUrl'];
+  /**
+   * Fetch API implementation. You can use this option to provide a custom
+   * fetch instance.
+   *
+   * @default globalThis.fetch
+   */
+  fetch?: (request: Request) => ReturnType<typeof fetch>;
+  /**
+   * Please don't use the Fetch client for Next.js applications. The `next`
+   * options won't have any effect.
+   *
+   * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+   */
+  next?: never;
+  /**
+   * Return the response data parsed in a specified format. By default, `auto`
+   * will infer the appropriate method from the `Content-Type` response header.
+   * You can override this behavior with any of the {@link Body} methods.
+   * Select `stream` if you don't want to parse response data at all.
+   *
+   * @default 'auto'
+   */
+  parseAs?:
+    | 'arrayBuffer'
+    | 'auto'
+    | 'blob'
+    | 'formData'
+    | 'json'
+    | 'stream'
+    | 'text';
+  /**
+   * Should we return only data or multiple fields (data, error, response, etc.)?
+   *
+   * @default 'fields'
+   */
+  responseStyle?: ResponseStyle;
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: T['throwOnError'];
+}
+
+export interface RequestOptions<
+  TResponseStyle extends ResponseStyle = 'fields',
+  ThrowOnError extends boolean = boolean,
+  Url extends string = string,
+> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+  }> {
+  /**
+   * Any body that you want to add to your request.
+   *
+   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+   */
+  body?: unknown;
+  path?: Record<string, unknown>;
+  query?: Record<string, unknown>;
+  /**
+   * Security mechanism(s) to use for the request.
+   */
+  security?: ReadonlyArray<Auth>;
+  url: Url;
+}
+
+export interface ResolvedRequestOptions<
+  TResponseStyle extends ResponseStyle = 'fields',
+  ThrowOnError extends boolean = boolean,
+  Url extends string = string,
+> extends RequestOptions<TResponseStyle, ThrowOnError, Url> {
+  serializedBody?: string;
+}
+
+export type RequestResult<
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = boolean,
+  TResponseStyle extends ResponseStyle = 'fields',
+> = ThrowOnError extends true
+  ? Promise<
+      TResponseStyle extends 'data'
+        ? TData extends Record<string, unknown>
+          ? TData[keyof TData]
+          : TData
+        : {
+            data: TData extends Record<string, unknown>
+              ? TData[keyof TData]
+              : TData;
+            request: Request;
+            response: Response;
+          }
+    >
+  : Promise<
+      TResponseStyle extends 'data'
+        ?
+            | (TData extends Record<string, unknown>
+                ? TData[keyof TData]
+                : TData)
+            | undefined
+        : (
+            | {
+                data: TData extends Record<string, unknown>
+                  ? TData[keyof TData]
+                  : TData;
+                error: undefined;
+              }
+            | {
+                data: undefined;
+                error: TError extends Record<string, unknown>
+                  ? TError[keyof TError]
+                  : TError;
+              }
+          ) & {
+            request: Request;
+            response: Response;
+          }
+    >;
+
+export interface ClientOptions {
+  baseUrl?: string;
+  responseStyle?: ResponseStyle;
+  throwOnError?: boolean;
+}
+
+type MethodFn = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+  TResponseStyle extends ResponseStyle = 'fields',
+>(
+  options: Omit<RequestOptions<TResponseStyle, ThrowOnError>, 'method'>,
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+
+type RequestFn = <
+  TData = unknown,
+  TError = unknown,
+  ThrowOnError extends boolean = false,
+  TResponseStyle extends ResponseStyle = 'fields',
+>(
+  options: Omit<RequestOptions<TResponseStyle, ThrowOnError>, 'method'> &
+    Pick<Required<RequestOptions<TResponseStyle, ThrowOnError>>, 'method'>,
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+
+type BuildUrlFn = <
+  TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+  },
+>(
+  options: Pick<TData, 'url'> & Options<TData>,
+) => string;
+
+export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn> & {
+  interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (
+  override?: Config<ClientOptions & T>,
+) => Config<Required<ClientOptions> & T>;
+
+export interface TDataShape {
+  body?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
+  url: string;
+}
+
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+
+export type Options<
+  TData extends TDataShape = TDataShape,
+  ThrowOnError extends boolean = boolean,
+  TResponseStyle extends ResponseStyle = 'fields',
+> = OmitKeys<
+  RequestOptions<TResponseStyle, ThrowOnError>,
+  'body' | 'path' | 'query' | 'url'
+> &
+  Omit<TData, 'url'>;
+
+export type OptionsLegacyParser<
+  TData = unknown,
+  ThrowOnError extends boolean = boolean,
+  TResponseStyle extends ResponseStyle = 'fields',
+> = TData extends { body?: any }
+  ? TData extends { headers?: any }
+    ? OmitKeys<
+        RequestOptions<TResponseStyle, ThrowOnError>,
+        'body' | 'headers' | 'url'
+      > &
+        TData
+    : OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, 'body' | 'url'> &
+        TData &
+        Pick<RequestOptions<TResponseStyle, ThrowOnError>, 'headers'>
+  : TData extends { headers?: any }
+    ? OmitKeys<
+        RequestOptions<TResponseStyle, ThrowOnError>,
+        'headers' | 'url'
+      > &
+        TData &
+        Pick<RequestOptions<TResponseStyle, ThrowOnError>, 'body'>
+    : OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, 'url'> & TData;