plugin-ai-api 1.1.0 → 1.1.2

package/src/server/__tests__/response-record-resource.test.ts

@@ -0,0 +1,50 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import type { Context, Next } from '@nocobase/actions';
+import { describe, expect, it, vi } from 'vitest';
+import { blockResponseRecordResource, targetsResponseRecordCollection } from '../middleware/response-record-resource';
+
+function context(resourceName: string, params: Record<string, unknown> = {}, targetCollection?: string): Context {
+  return {
+    action: { resourceName, actionName: 'list', params },
+    getCurrentRepository: targetCollection ? () => ({ targetCollection: { name: targetCollection } }) : undefined,
+    throw(status: number, message: string) {
+      throw Object.assign(new Error(message), { status });
+    },
+  } as unknown as Context;
+}
+
+describe('Responses API private storage resource', () => {
+  it.each([
+    context('aiApiResponseRecords'),
+    context('users.responses', { associatedName: 'aiApiResponseRecords' }),
+    context('generic', { targetCollection: 'aiApiResponseRecords' }),
+    context('generic', {}, 'aiApiResponseRecords'),
+  ])('detects every generic route to the response record collection', (ctx) => {
+    expect(targetsResponseRecordCollection(ctx)).toBe(true);
+  });
+
+  it('returns 404 before generic CRUD can expose stored prompts', async () => {
+    const next = vi.fn() as unknown as Next;
+
+    await expect(blockResponseRecordResource()(context('aiApiResponseRecords'), next)).rejects.toMatchObject({
+      status: 404,
+    });
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  it('does not affect unrelated resources', async () => {
+    const next = vi.fn().mockResolvedValue(undefined) as unknown as Next;
+
+    await blockResponseRecordResource()(context('users'), next);
+
+    expect(next).toHaveBeenCalledOnce();
+  });
+});

package/src/server/__tests__/response-store-integration.test.ts

@@ -0,0 +1,341 @@
+/**
+ * Database integration tests for the aiApiResponseRecords collection and response store.
+ *
+ * Uses createMockDatabase (SQLite in-memory) to validate:
+ * - Collection schema creation with correct field types
+ * - CRUD operations on response records
+ * - Owner-scoped retrieval and deletion
+ * - Expiry enforcement
+ * - Batch cleanup of expired records
+ * - Chain loading with previous_response_id
+ */
+
+import type { Context } from '@nocobase/actions';
+import { createMockDatabase, type Database } from '@nocobase/database';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import responseRecordsCollection from '../collections/ai-api-response-records';
+import SeedSampleResponseRecords from '../migrations/20260903000000-seed-sample-response-records';
+import {
+  cleanupExpiredResponseRecords,
+  deleteResponseRecord,
+  getResponseRecord,
+  loadConversationChain,
+  RESPONSE_RETENTION_MS,
+  storeResponseRecord,
+} from '../utils/response-store';
+
+describe('aiApiResponseRecords database integration', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = await createMockDatabase();
+    // Register the actual collection definition so schema drift between the plugin and this
+    // test fails here instead of silently passing against a hand-duplicated schema.
+    db.collection(responseRecordsCollection);
+    await db.sync({ force: true });
+  });
+
+  afterEach(async () => {
+    // Truncate to avoid unique constraint collisions across tests (shared SQLite file).
+    try {
+      await db.getRepository('aiApiResponseRecords').destroy({ filter: {} });
+    } catch {
+      // Table may not exist in some edge cases.
+    }
+    await db.close();
+  });
+
+  function makeCtx(): Pick<Context, 'db'> {
+    return { db } as Pick<Context, 'db'>;
+  }
+
+  function makeResponse(id: string, model = 'test-service/gpt-4o') {
+    return {
+      id,
+      object: 'response' as const,
+      created_at: Math.floor(Date.now() / 1000),
+      completed_at: Math.floor(Date.now() / 1000),
+      status: 'completed' as const,
+      error: null,
+      incomplete_details: null,
+      instructions: null,
+      model,
+      output: [],
+      output_text: `Response ${id}`,
+      parallel_tool_calls: true,
+      service_tier: 'default' as const,
+      temperature: null,
+      tool_choice: 'auto',
+      tools: [],
+      top_p: null,
+      truncation: 'disabled' as const,
+      usage: {
+        input_tokens: 10,
+        input_tokens_details: { cached_tokens: 0 },
+        output_tokens: 5,
+        output_tokens_details: { reasoning_tokens: 0 },
+        total_tokens: 15,
+      },
+      metadata: null,
+    };
+  }
+
+  it('stores and retrieves a response record by responseId + userId', async () => {
+    const ctx = makeCtx();
+    const response = makeResponse('resp_store_1');
+
+    await storeResponseRecord(ctx, response, { input: 'Hello', store: true }, 42);
+
+    const record = await getResponseRecord(ctx, 'resp_store_1', 42);
+    expect(record).toMatchObject({
+      responseId: 'resp_store_1',
+      userId: 42,
+      model: 'test-service/gpt-4o',
+    });
+    expect((record?.output as Record<string, unknown> | undefined)?.id).toBe('resp_store_1');
+  });
+
+  it('does not store when store=false', async () => {
+    const ctx = makeCtx();
+    const response = makeResponse('resp_no_store');
+
+    await storeResponseRecord(ctx, response, { input: 'Hello', store: false }, 42);
+
+    const record = await getResponseRecord(ctx, 'resp_no_store', 42);
+    expect(record).toBeNull();
+  });
+
+  it('scopes retrieval by userId — cross-user access returns null', async () => {
+    const ctx = makeCtx();
+    const response = makeResponse('resp_private');
+
+    await storeResponseRecord(ctx, response, { input: 'Secret', store: true }, 42);
+
+    // Same user can retrieve
+    expect(await getResponseRecord(ctx, 'resp_private', 42)).not.toBeNull();
+    // Different user cannot
+    expect(await getResponseRecord(ctx, 'resp_private', 99)).toBeNull();
+  });
+
+  it('treats expired records as missing', async () => {
+    const ctx = makeCtx();
+    const response = makeResponse('resp_expired');
+
+    // Manually insert with past expiry
+    await db.getRepository('aiApiResponseRecords').create({
+      values: {
+        responseId: 'resp_expired',
+        userId: 42,
+        model: 'test-service/gpt-4o',
+        input: 'Old',
+        output: response,
+        expiresAt: new Date(Date.now() - 1000),
+      },
+    });
+
+    const record = await getResponseRecord(ctx, 'resp_expired', 42);
+    expect(record).toBeNull();
+  });
+
+  it('deletes only an owner-scoped record', async () => {
+    const ctx = makeCtx();
+    const response = makeResponse('resp_delete');
+
+    await storeResponseRecord(ctx, response, { input: 'Delete me', store: true }, 42);
+
+    // Wrong user cannot delete
+    const deletedWrong = await deleteResponseRecord(ctx, 'resp_delete', 99);
+    expect(deletedWrong).toBe(false);
+
+    // Correct user can delete
+    const deletedRight = await deleteResponseRecord(ctx, 'resp_delete', 42);
+    expect(deletedRight).toBe(true);
+
+    // After deletion, retrieval returns null
+    expect(await getResponseRecord(ctx, 'resp_delete', 42)).toBeNull();
+  });
+
+  it('cleans up expired records in batches', async () => {
+    const ctx = makeCtx();
+
+    // Insert 3 expired and 2 unexpired records
+    for (let i = 0; i < 3; i++) {
+      await db.getRepository('aiApiResponseRecords').create({
+        values: {
+          responseId: `resp_cleanup_${i}`,
+          userId: 42,
+          model: 'test-service/gpt-4o',
+          input: 'Expired',
+          output: makeResponse(`resp_cleanup_${i}`),
+          expiresAt: new Date(Date.now() - 1000),
+        },
+      });
+    }
+    for (let i = 0; i < 2; i++) {
+      await db.getRepository('aiApiResponseRecords').create({
+        values: {
+          responseId: `resp_keep_${i}`,
+          userId: 42,
+          model: 'test-service/gpt-4o',
+          input: 'Keep',
+          output: makeResponse(`resp_keep_${i}`),
+          expiresAt: new Date(Date.now() + RESPONSE_RETENTION_MS),
+        },
+      });
+    }
+
+    const deleted = await cleanupExpiredResponseRecords(ctx);
+    expect(deleted).toBeGreaterThanOrEqual(3);
+
+    // Unexpired records remain
+    expect(await getResponseRecord(ctx, 'resp_keep_0', 42)).not.toBeNull();
+    expect(await getResponseRecord(ctx, 'resp_keep_1', 42)).not.toBeNull();
+  });
+
+  it('loads a conversation chain via previousResponseId', async () => {
+    const ctx = makeCtx();
+
+    // Create a chain: resp_chain_1 → resp_chain_2 → resp_chain_3
+    const r1 = makeResponse('resp_chain_1');
+    const r2 = { ...makeResponse('resp_chain_2'), previous_response_id: 'resp_chain_1' };
+    const r3 = { ...makeResponse('resp_chain_3'), previous_response_id: 'resp_chain_2' };
+
+    await storeResponseRecord(ctx, r1, { input: 'First question', store: true }, 42);
+    await storeResponseRecord(ctx, r2, { input: 'Follow up', store: true, previous_response_id: 'resp_chain_1' }, 42);
+    await storeResponseRecord(ctx, r3, { input: 'And then?', store: true, previous_response_id: 'resp_chain_2' }, 42);
+
+    const messages = await loadConversationChain(ctx, 'resp_chain_2', 42);
+    expect(messages).not.toBeNull();
+    // Should contain: first question input + first response output + follow up input + follow up output
+    // String input produces 1 user message per record; chain of 2 records = 2 messages minimum
+    expect(messages?.length ?? 0).toBeGreaterThanOrEqual(2);
+  });
+
+  it('returns null for a broken chain (missing link)', async () => {
+    const ctx = makeCtx();
+
+    // Only store the second response pointing to a non-existent first
+    const r2 = { ...makeResponse('resp_broken'), previous_response_id: 'resp_missing' };
+    await storeResponseRecord(ctx, r2, { input: 'Orphan', store: true, previous_response_id: 'resp_missing' }, 42);
+
+    const messages = await loadConversationChain(ctx, 'resp_broken', 42);
+    expect(messages).toBeNull();
+  });
+
+  it('returns null for a cyclic chain', async () => {
+    const ctx = makeCtx();
+
+    // Create a cycle: A → B → A
+    const rA = { ...makeResponse('resp_cycle_a'), previous_response_id: 'resp_cycle_b' };
+    const rB = { ...makeResponse('resp_cycle_b'), previous_response_id: 'resp_cycle_a' };
+
+    await storeResponseRecord(ctx, rA, { input: 'A', store: true, previous_response_id: 'resp_cycle_b' }, 42);
+    await storeResponseRecord(ctx, rB, { input: 'B', store: true, previous_response_id: 'resp_cycle_a' }, 42);
+
+    const messages = await loadConversationChain(ctx, 'resp_cycle_a', 42);
+    expect(messages).toBeNull();
+  });
+
+  it('handles BIGINT userId correctly', async () => {
+    const ctx = makeCtx();
+    const bigUserId = BigInt('9007199254740991'); // Within safe integer range for SQLite compatibility
+    const response = makeResponse('resp_bigint');
+
+    await storeResponseRecord(ctx, response, { input: 'BigInt test', store: true }, bigUserId);
+
+    const record = await getResponseRecord(ctx, 'resp_bigint', bigUserId);
+    expect(record?.userId.toString()).toBe(bigUserId.toString());
+  });
+
+  it('preserves metadata through store and retrieve', async () => {
+    const ctx = makeCtx();
+    const response = { ...makeResponse('resp_meta'), metadata: { env: 'test', version: '1.0' } };
+
+    await storeResponseRecord(
+      ctx,
+      response,
+      { input: 'Meta test', store: true, metadata: { env: 'test', version: '1.0' } },
+      42,
+    );
+
+    const record = await getResponseRecord(ctx, 'resp_meta', 42);
+    expect(record).not.toBeNull();
+    expect(record?.metadata).toEqual({ env: 'test', version: '1.0' });
+  });
+
+  it('uses the runtime data category so records are excluded from backups', () => {
+    const collection = db.getCollection('aiApiResponseRecords');
+    expect(collection.options.dataCategory).toBe('runtime');
+  });
+
+  describe('seed sample response records migration', () => {
+    function makeMigration() {
+      const rootUser = { get: (key: string) => (key === 'id' ? 42 : undefined) };
+      const usersRepo = { findOne: async () => rootUser };
+      const app = { logger: { info: vi.fn(), warn: vi.fn() } };
+      db.getRepository = ((original) =>
+        vi.fn((name: string) => (name === 'users' ? usersRepo : original.call(db, name))))(
+        db.getRepository.bind(db),
+      ) as Database['getRepository'];
+      const MigrationClass = SeedSampleResponseRecords as unknown as new (context: { db: Database; app: unknown }) => {
+        up: () => Promise<void>;
+        down: () => Promise<void>;
+      };
+      return { migration: new MigrationClass({ db, app }), app };
+    }
+
+    it('seeds both samples, is idempotent, and recovers partial execution', async () => {
+      const { migration } = makeMigration();
+
+      await migration.up();
+      const repo = db.getRepository('aiApiResponseRecords');
+      const countWelcome = await repo.count({ filter: { responseId: 'resp_sample_welcome' } });
+      const countFollowup = await repo.count({ filter: { responseId: 'resp_sample_followup' } });
+      if (countWelcome !== 1 || countFollowup !== 1) {
+        throw new Error(`after up: welcome=${countWelcome} followup=${countFollowup}`);
+      }
+
+      // Rerun: no duplicates.
+      await migration.up();
+      expect(await repo.count({ filter: { responseId: 'resp_sample_welcome' } })).toBe(1);
+      expect(await repo.count({ filter: { responseId: 'resp_sample_followup' } })).toBe(1);
+
+      // Partial execution: first sample exists, second was lost — rerun must create the missing one.
+      await repo.destroy({ filter: { responseId: 'resp_sample_followup' } });
+      await migration.up();
+      expect(await repo.count({ filter: { responseId: 'resp_sample_followup' } })).toBe(1);
+    });
+
+    it('down() removes exactly the two sample records', async () => {
+      const { migration } = makeMigration();
+
+      await migration.up();
+      await storeResponseRecord(makeCtx(), makeResponse('resp_user_owned'), { input: 'Keep me', store: true }, 42);
+
+      await migration.down();
+
+      const repo = db.getRepository('aiApiResponseRecords');
+      expect(await repo.count({ filter: { responseId: 'resp_sample_welcome' } })).toBe(0);
+      expect(await repo.count({ filter: { responseId: 'resp_sample_followup' } })).toBe(0);
+      // Unrelated records are untouched.
+      expect(await repo.count({ filter: { responseId: 'resp_user_owned' } })).toBe(1);
+    });
+
+    it('skips seeding when no root user exists', async () => {
+      const originalGetRepository = db.getRepository.bind(db);
+      db.getRepository = vi.fn((name: string) => {
+        if (name === 'users') return { findOne: async () => null };
+        return originalGetRepository(name);
+      }) as Database['getRepository'];
+      const app = { logger: { info: vi.fn(), warn: vi.fn() } };
+      const MigrationClass = SeedSampleResponseRecords as unknown as new (context: { db: Database; app: unknown }) => {
+        up: () => Promise<void>;
+      };
+      const migration = new MigrationClass({ db, app });
+
+      await migration.up();
+
+      expect(await originalGetRepository('aiApiResponseRecords').count()).toBe(0);
+    });
+  });
+});

package/src/server/__tests__/response-store.test.ts

@@ -0,0 +1,195 @@
+import type { Context } from '@nocobase/actions';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  deleteResponseRecord,
+  getResponseRecord,
+  loadConversationChain,
+  cleanupExpiredResponseRecords,
+  RESPONSE_RETENTION_MS,
+  storeResponseRecord,
+} from '../utils/response-store';
+import { chatResultToResponse } from '../utils/responses-format';
+
+function row(values: Record<string, unknown>) {
+  return { get: (key: string) => values[key] };
+}
+
+function context(findOne: ReturnType<typeof vi.fn>, create = vi.fn()) {
+  return {
+    db: {
+      getRepository: vi.fn().mockReturnValue({ findOne, create }),
+    },
+  } as unknown as Context;
+}
+
+describe('Responses API response store', () => {
+  it('scopes response retrieval by both response ID and user ID', async () => {
+    const findOne = vi.fn().mockResolvedValue(null);
+    const ctx = context(findOne);
+
+    await getResponseRecord(ctx, 'resp_private', 42);
+
+    expect(findOne).toHaveBeenCalledWith({ filter: { responseId: 'resp_private', userId: 42 } });
+  });
+
+  it('treats expired records as missing', async () => {
+    const findOne = vi.fn().mockResolvedValue(
+      row({
+        id: 1,
+        responseId: 'resp_expired',
+        userId: 42,
+        model: 'service/model',
+        input: 'Hi',
+        output: {},
+        expiresAt: new Date(Date.now() - 1000),
+      }),
+    );
+
+    await expect(getResponseRecord(context(findOne), 'resp_expired', 42)).resolves.toBeNull();
+  });
+
+  it('treats missing or malformed expiry timestamps as missing', async () => {
+    for (const expiresAt of [undefined, 'not-a-date']) {
+      const findOne = vi.fn().mockResolvedValue(
+        row({
+          id: 1,
+          responseId: 'resp_invalid_expiry',
+          userId: 42,
+          model: 'service/model',
+          input: 'Hi',
+          output: {},
+          expiresAt,
+        }),
+      );
+      await expect(getResponseRecord(context(findOne), 'resp_invalid_expiry', 42)).resolves.toBeNull();
+    }
+  });
+
+  it('loads a chain in chronological input/output order', async () => {
+    const first = chatResultToResponse({
+      id: 'resp_first',
+      model: 'service/model',
+      content: 'First answer',
+      requestBody: { input: 'First question' },
+    });
+    const second = chatResultToResponse({
+      id: 'resp_second',
+      model: 'service/model',
+      content: 'Second answer',
+      requestBody: { input: 'Second question', previous_response_id: 'resp_first' },
+    });
+    const records: Record<string, unknown> = {
+      resp_first: row({
+        id: 1,
+        responseId: 'resp_first',
+        userId: 42,
+        model: 'service/model',
+        input: 'First question',
+        output: first,
+        expiresAt: new Date(Date.now() + 10_000),
+      }),
+      resp_second: row({
+        id: 2,
+        responseId: 'resp_second',
+        userId: 42,
+        model: 'service/model',
+        input: 'Second question',
+        output: second,
+        previousResponseId: 'resp_first',
+        expiresAt: new Date(Date.now() + 10_000),
+      }),
+    };
+    const findOne = vi.fn().mockImplementation(({ filter }) => records[filter.responseId] ?? null);
+
+    await expect(loadConversationChain(context(findOne), 'resp_second', 42)).resolves.toEqual([
+      { role: 'user', content: 'First question' },
+      { role: 'assistant', content: [{ type: 'text', text: 'First answer' }] },
+      { role: 'user', content: 'Second question' },
+      { role: 'assistant', content: [{ type: 'text', text: 'Second answer' }] },
+    ]);
+  });
+
+  it('returns null for a broken or cyclic chain', async () => {
+    const output = chatResultToResponse({
+      id: 'resp_cycle',
+      model: 'service/model',
+      content: 'Loop',
+      requestBody: { input: 'Loop' },
+    });
+    const findOne = vi.fn().mockResolvedValue(
+      row({
+        id: 1,
+        responseId: 'resp_cycle',
+        userId: 42,
+        model: 'service/model',
+        input: 'Loop',
+        output,
+        previousResponseId: 'resp_cycle',
+        expiresAt: new Date(Date.now() + 10_000),
+      }),
+    );
+
+    await expect(loadConversationChain(context(findOne), 'resp_cycle', 42)).resolves.toBeNull();
+  });
+
+  it('deletes by an owner-scoped primary key lookup', async () => {
+    const destroy = vi.fn().mockResolvedValue(undefined);
+    const record = row({
+      id: 9,
+      responseId: 'resp_delete',
+      userId: 42,
+      model: 'service/model',
+      input: 'Delete',
+      output: {},
+      expiresAt: new Date(Date.now() + 10_000),
+    });
+    const ctx = {
+      db: { getRepository: vi.fn().mockReturnValue({ findOne: vi.fn().mockResolvedValue(record), destroy }) },
+    } as unknown as Context;
+
+    await expect(deleteResponseRecord(ctx, 'resp_delete', 42)).resolves.toBe(true);
+    expect(destroy).toHaveBeenCalledWith({ filterByTk: 9 });
+  });
+  it('stores by default with a 30-day expiry and honors store=false', async () => {
+    const create = vi.fn().mockResolvedValue(undefined);
+    const ctx = context(vi.fn(), create);
+    const response = chatResultToResponse({
+      id: 'resp_store',
+      model: 'service/model',
+      content: 'Stored',
+      requestBody: { input: 'Store me' },
+    });
+    const startedAt = Date.now();
+
+    await storeResponseRecord(ctx, response, { input: 'Store me' }, 42);
+    const expiresAt = create.mock.calls[0][0].values.expiresAt as Date;
+
+    expect(expiresAt.getTime()).toBeGreaterThanOrEqual(startedAt + RESPONSE_RETENTION_MS);
+    expect(create).toHaveBeenCalledWith({
+      values: expect.objectContaining({ responseId: 'resp_store', userId: 42, input: 'Store me' }),
+    });
+
+    create.mockClear();
+    await storeResponseRecord(ctx, response, { input: 'Do not store', store: false }, 42);
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  it('cleans expired records in bounded batches', async () => {
+    const firstBatch = Array.from({ length: 1000 }, (_, id) => row({ id: id + 1 }));
+    const secondBatch = [row({ id: 1001 })];
+    const find = vi.fn().mockResolvedValueOnce(firstBatch).mockResolvedValueOnce(secondBatch).mockResolvedValueOnce([]);
+    const destroy = vi.fn().mockImplementation(async ({ filterByTk }) => filterByTk.length);
+    const ctx = {
+      db: { getRepository: vi.fn().mockReturnValue({ find, destroy }) },
+    } as unknown as Context;
+
+    await expect(cleanupExpiredResponseRecords(ctx)).resolves.toBe(1001);
+    expect(find).toHaveBeenCalledTimes(3);
+    expect(find).toHaveBeenCalledWith(expect.objectContaining({ fields: ['id'], limit: 1000, sort: 'id' }));
+    expect(destroy).toHaveBeenNthCalledWith(1, {
+      filterByTk: Array.from({ length: 1000 }, (_, index) => index + 1),
+      individualHooks: false,
+    });
+    expect(destroy).toHaveBeenNthCalledWith(2, { filterByTk: [1001], individualHooks: false });
+  });
+});