Merge branch 'master' into fix/link-checker-tab-visibility-reload-es-524

Author: harikakondur

apps/ai-content-generator/.npmrc

@@ -0,0 +1 @@
+@contentful:registry=https://registry.npmjs.org/

apps/ai-content-generator/contentful-app-manifest.json

@@ -0,0 +1,40 @@
+{
+  "functions": [
+    {
+      "id": "openaiProxyFunction",
+      "name": "OpenAI proxy function",
+      "description": "Calls OpenAI chat completions using the secret API key stored server-side.",
+      "path": "functions/openai-proxy.js",
+      "entryFile": "functions/openai-proxy.ts",
+      "allowNetworks": [
+        "https://api.openai.com"
+      ],
+      "accepts": [
+        "appaction.call"
+      ]
+    }
+  ],
+  "actions": [
+    {
+      "id": "openaiProxyAction",
+      "name": "OpenAI proxy action",
+      "type": "function-invocation",
+      "functionId": "openaiProxyFunction",
+      "category": "Custom",
+      "parameters": [
+        {
+          "id": "messages",
+          "name": "Messages",
+          "type": "Symbol",
+          "required": true
+        },
+        {
+          "id": "model",
+          "name": "Model",
+          "type": "Symbol",
+          "required": true
+        }
+      ]
+    }
+  ]
+}

apps/ai-content-generator/functions/openai-proxy.spec.ts

@@ -0,0 +1,106 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { handler, OpenAiProxyParameters } from './openai-proxy';
+
+type HandlerEvent = Parameters<typeof handler>[0];
+type HandlerContext = Parameters<typeof handler>[1];
+
+// The proxy only reads `key` off the installation params and `messages`/`model`
+// off the action body — build the smallest shapes the handler actually touches.
+const makeEvent = (body: OpenAiProxyParameters): HandlerEvent =>
+  ({ body } as unknown as HandlerEvent);
+
+const makeContext = (key?: string): HandlerContext =>
+  ({ appInstallationParameters: key ? { key } : {} } as unknown as HandlerContext);
+
+const validBody: OpenAiProxyParameters = {
+  messages: JSON.stringify([{ role: 'user', content: 'hi' }]),
+  model: 'gpt-4',
+};
+
+describe('openai-proxy handler', () => {
+  beforeEach(() => {
+    vi.stubGlobal('fetch', vi.fn());
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it('throws when no API key is configured', async () => {
+    await expect(handler(makeEvent(validBody), makeContext())).rejects.toThrow(
+      'OpenAI API key is not configured'
+    );
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('throws when messages is not valid JSON', async () => {
+    const event = makeEvent({ messages: 'not json', model: 'gpt-4' });
+
+    await expect(handler(event, makeContext('sk-test'))).rejects.toThrow(
+      'Invalid messages parameter: must be a JSON-encoded array'
+    );
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('calls OpenAI with the key and parsed messages, returning the completion text', async () => {
+    vi.mocked(fetch).mockResolvedValue({
+      ok: true,
+      json: async () => ({ choices: [{ message: { content: 'generated' } }] }),
+    } as Response);
+
+    const result = await handler(makeEvent(validBody), makeContext('sk-test'));
+
+    expect(result).toEqual({ text: 'generated' });
+    expect(fetch).toHaveBeenCalledWith(
+      'https://api.openai.com/v1/chat/completions',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({ Authorization: 'Bearer sk-test' }),
+        body: JSON.stringify({
+          model: 'gpt-4',
+          messages: [{ role: 'user', content: 'hi' }],
+        }),
+      })
+    );
+  });
+
+  it('returns empty text when the completion has no content', async () => {
+    vi.mocked(fetch).mockResolvedValue({
+      ok: true,
+      json: async () => ({ choices: [] }),
+    } as Response);
+
+    const result = await handler(makeEvent(validBody), makeContext('sk-test'));
+
+    expect(result).toEqual({ text: '' });
+  });
+
+  it('surfaces the OpenAI error message on a non-ok response', async () => {
+    vi.mocked(fetch).mockResolvedValue({
+      ok: false,
+      status: 401,
+      statusText: 'Unauthorized',
+      json: async () => ({ error: { message: 'Invalid API key' } }),
+    } as Response);
+
+    await expect(handler(makeEvent(validBody), makeContext('sk-test'))).rejects.toThrow(
+      'OpenAI request failed: 401 Invalid API key'
+    );
+  });
+
+  it('falls back to statusText when the error body has no message', async () => {
+    vi.mocked(fetch).mockResolvedValue({
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error',
+      json: async () => {
+        throw new Error('not json');
+      },
+    } as unknown as Response);
+
+    await expect(handler(makeEvent(validBody), makeContext('sk-test'))).rejects.toThrow(
+      'OpenAI request failed: 500 Internal Server Error'
+    );
+  });
+});

apps/ai-content-generator/functions/openai-proxy.ts

@@ -0,0 +1,70 @@
+import type {
+  FunctionEventHandler,
+  FunctionTypeEnum,
+  AppActionRequest,
+  FunctionEventContext,
+} from '@contentful/node-apps-toolkit';
+
+export type OpenAiProxyParameters = {
+  messages: string;
+  model: string;
+};
+
+type OpenAiProxyResponse = {
+  text: string;
+};
+
+// Installation parameters are persisted as a flat scalar object (see the app's
+// PersistedInstallationParameters). The proxy only needs the Secret `key`.
+type InstallationParameters = {
+  key?: string;
+};
+
+export const handler: FunctionEventHandler<
+  FunctionTypeEnum.AppActionCall,
+  OpenAiProxyParameters
+> = async (
+  event: AppActionRequest<'Custom', OpenAiProxyParameters>,
+  context: FunctionEventContext
+): Promise<OpenAiProxyResponse> => {
+  const { key } = context.appInstallationParameters as InstallationParameters;
+
+  if (!key) {
+    throw new Error('OpenAI API key is not configured');
+  }
+
+  const { messages, model } = event.body;
+
+  let parsedMessages: unknown;
+  try {
+    parsedMessages = JSON.parse(messages);
+  } catch {
+    throw new Error('Invalid messages parameter: must be a JSON-encoded array');
+  }
+
+  const response = await fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${key}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      model,
+      messages: parsedMessages,
+    }),
+  });
+
+  if (!response.ok) {
+    const errorBody = await response.json().catch(() => ({}));
+    throw new Error(
+      `OpenAI request failed: ${response.status} ${
+        errorBody?.error?.message ?? response.statusText
+      }`
+    );
+  }
+
+  const data = await response.json();
+  const text: string = data.choices?.[0]?.message?.content ?? '';
+
+  return { text };
+};

apps/ai-content-generator/functions/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "@tsconfig/recommended/tsconfig.json",
+  "compilerOptions": {},
+  "include": ["./**/*.ts"]
+}