LibreChat/api/server/routes/prompts.test.js

2394 lines
76 KiB
JavaScript

const express = require('express');
const request = require('supertest');
const mongoose = require('mongoose');
const { ObjectId } = require('mongodb');
const { MongoMemoryServer } = require('mongodb-memory-server');
const {
SystemRoles,
ResourceType,
AccessRoleIds,
PrincipalType,
PrincipalModel,
PermissionBits,
} = require('librechat-data-provider');
const { SystemCapabilities, BASE_CONFIG_PRINCIPAL_ID } = require('@librechat/data-schemas');
let mockAppConfig = {};
// Mock modules before importing
jest.mock('~/server/services/Config', () => ({
getCachedTools: jest.fn().mockResolvedValue({}),
getAppConfig: jest.fn().mockResolvedValue({}),
}));
jest.mock('~/models', () => {
const mongoose = require('mongoose');
const { createMethods } = require('@librechat/data-schemas');
const methods = createMethods(mongoose, {
removeAllPermissions: async ({ resourceType, resourceId }) => {
const AclEntry = mongoose.models.AclEntry;
if (AclEntry) {
await AclEntry.deleteMany({ resourceType, resourceId });
}
},
});
return {
...methods,
getRoleByName: jest.fn(),
};
});
jest.mock('~/server/middleware', () => ({
requireJwtAuth: (req, res, next) => next(),
configMiddleware: jest.fn((req, res, next) => {
req.config = mockAppConfig;
next();
}),
promptUsageLimiter: (req, res, next) => next(),
promptResolveLimiter: (req, res, next) => next(),
canAccessPromptViaGroup: jest.requireActual('~/server/middleware').canAccessPromptViaGroup,
canAccessPromptGroupResource:
jest.requireActual('~/server/middleware').canAccessPromptGroupResource,
checkBan: (_req, _res, next) => next(),
uaParser: (_req, _res, next) => next(),
canAccessResource: jest.requireActual('~/server/middleware').canAccessResource,
}));
const { configMiddleware } = require('~/server/middleware');
let app;
let mongoServer;
let promptRoutes;
let accessPermissionsRoutes;
let Prompt, PromptGroup, AclEntry, AccessRole, User, SystemGrant, Config;
let testUsers, testRoles;
let grantPermission;
let db;
let currentTestUser; // Track current user for middleware
// Helper function to set user in middleware
function setTestUser(app, user) {
currentTestUser = user;
}
beforeAll(async () => {
mongoServer = await MongoMemoryServer.create();
const mongoUri = mongoServer.getUri();
await mongoose.connect(mongoUri);
// Initialize models
const dbModels = require('~/db/models');
Prompt = dbModels.Prompt;
PromptGroup = dbModels.PromptGroup;
AclEntry = dbModels.AclEntry;
AccessRole = dbModels.AccessRole;
User = dbModels.User;
SystemGrant = dbModels.SystemGrant;
Config = dbModels.Config;
db = require('~/models');
// Import permission service
const permissionService = require('~/server/services/PermissionService');
grantPermission = permissionService.grantPermission;
// Create test data
await setupTestData();
// Setup Express app
app = express();
app.use(express.json());
// Add user middleware before routes
app.use((req, res, next) => {
if (currentTestUser) {
req.user = {
...(currentTestUser.toObject ? currentTestUser.toObject() : currentTestUser),
id: currentTestUser._id.toString(),
_id: currentTestUser._id,
name: currentTestUser.name,
role: currentTestUser.role,
};
}
next();
});
// Set default user
currentTestUser = testUsers.owner;
// Import routes after middleware is set up
promptRoutes = require('./prompts');
app.use('/api/prompts', promptRoutes);
// Mounted so the sharing test below can call the real access-permissions router
// (and its real `updateResourcePermissions` controller) instead of the service layer.
accessPermissionsRoutes = require('./accessPermissions');
app.use('/api/permissions', accessPermissionsRoutes);
});
afterEach(() => {
mockAppConfig = {};
// Always reset to owner user after each test for isolation
if (currentTestUser !== testUsers.owner) {
currentTestUser = testUsers.owner;
}
});
afterAll(async () => {
await mongoose.disconnect();
await mongoServer?.stop();
jest.clearAllMocks();
});
async function setupTestData() {
// Create access roles for promptGroups
testRoles = {
viewer: await AccessRole.create({
accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
name: 'Viewer',
resourceType: ResourceType.PROMPTGROUP,
permBits: PermissionBits.VIEW,
}),
editor: await AccessRole.create({
accessRoleId: AccessRoleIds.PROMPTGROUP_EDITOR,
name: 'Editor',
resourceType: ResourceType.PROMPTGROUP,
permBits: PermissionBits.VIEW | PermissionBits.EDIT,
}),
owner: await AccessRole.create({
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
name: 'Owner',
resourceType: ResourceType.PROMPTGROUP,
permBits:
PermissionBits.VIEW | PermissionBits.EDIT | PermissionBits.DELETE | PermissionBits.SHARE,
}),
};
// Create test users
testUsers = {
owner: await User.create({
name: 'Prompt Owner',
email: 'owner@example.com',
role: SystemRoles.USER,
}),
viewer: await User.create({
name: 'Prompt Viewer',
email: 'viewer@example.com',
role: SystemRoles.USER,
}),
editor: await User.create({
name: 'Prompt Editor',
email: 'editor@example.com',
role: SystemRoles.USER,
}),
noAccess: await User.create({
name: 'No Access',
email: 'noaccess@example.com',
role: SystemRoles.USER,
}),
admin: await User.create({
name: 'Admin',
email: 'admin@example.com',
role: SystemRoles.ADMIN,
}),
};
// Seed capabilities for the ADMIN role
await SystemGrant.create([
{
principalType: PrincipalType.ROLE,
principalId: SystemRoles.ADMIN,
capability: SystemCapabilities.MANAGE_PROMPTS,
grantedAt: new Date(),
},
{
principalType: PrincipalType.ROLE,
principalId: SystemRoles.ADMIN,
capability: SystemCapabilities.READ_PROMPTS,
grantedAt: new Date(),
},
]);
// Mock getRoleByName
const { getRoleByName } = require('~/models');
getRoleByName.mockImplementation((roleName) => {
switch (roleName) {
case SystemRoles.USER:
return { permissions: { PROMPTS: { USE: true, CREATE: true, SHARE: true } } };
case SystemRoles.ADMIN:
return { permissions: { PROMPTS: { USE: true, CREATE: true, SHARE: true } } };
default:
return null;
}
});
}
async function createAccessiblePromptGroup({
name,
prompt,
production = true,
groupId,
type = 'text',
}) {
let group;
if (groupId) {
group = await PromptGroup.findById(groupId);
} else {
group = await PromptGroup.create({
name,
category: 'stored-filter-test',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
}
const promptRecord = await Prompt.create({
prompt,
author: testUsers.owner._id,
type,
groupId: group._id,
});
if (production) {
group.productionId = promptRecord._id;
await group.save();
}
return { group, prompt: promptRecord };
}
describe('Prompt Routes - ACL Permissions', () => {
let consoleErrorSpy;
beforeEach(() => {
consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
});
afterEach(() => {
consoleErrorSpy.mockRestore();
});
// Simple test to verify route is loaded
it('should have routes loaded', async () => {
// This should at least not crash
const response = await request(app).get('/api/prompts/test-404');
// We expect a 401 or 404, not 500
expect(response.status).not.toBe(500);
});
describe('POST /api/prompts - Create Prompt', () => {
afterEach(async () => {
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('should block configured prompt content before persistence', async () => {
mockAppConfig = {
filters: {
prompts: {
pii: {
starterPatterns: ['sk_prefix'],
},
},
},
};
const response = await request(app)
.post('/api/prompts')
.send({
prompt: {
prompt: 'Use sk-private-token for requests',
type: 'text',
},
group: {
name: 'Filtered Prompt Group',
},
});
expect(response.status).toBe(400);
expect(response.body).toEqual(
expect.objectContaining({
error: 'content_filter_block',
source: 'prompt',
field: 'text',
}),
);
await expect(Prompt.countDocuments()).resolves.toBe(0);
await expect(PromptGroup.countDocuments()).resolves.toBe(0);
});
it('should create a prompt and grant owner permissions', async () => {
const promptData = {
prompt: {
prompt: 'Test prompt content',
type: 'text',
},
group: {
name: 'Test Prompt Group',
},
};
const response = await request(app).post('/api/prompts').send(promptData);
expect(response.status).toBe(200);
expect(response.body.prompt).toBeDefined();
expect(response.body.prompt.prompt).toBe(promptData.prompt.prompt);
// Check ACL entry was created
const aclEntry = await AclEntry.findOne({
resourceType: ResourceType.PROMPTGROUP,
resourceId: response.body.prompt.groupId,
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
});
expect(aclEntry).toBeTruthy();
expect(aclEntry.roleId.toString()).toBe(testRoles.owner._id.toString());
});
it('should create a prompt group with prompt and grant owner permissions', async () => {
const promptData = {
prompt: {
prompt: 'Group prompt content',
type: 'text',
},
group: {
name: 'Test Group',
category: 'testing',
},
};
const response = await request(app).post('/api/prompts').send(promptData).expect(200);
expect(response.body.prompt).toBeDefined();
expect(response.body.group).toBeDefined();
expect(response.body.group.name).toBe(promptData.group.name);
// Check ACL entry was created for the promptGroup
const aclEntry = await AclEntry.findOne({
resourceType: ResourceType.PROMPTGROUP,
resourceId: response.body.group._id,
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
});
expect(aclEntry).toBeTruthy();
});
});
describe('GET /api/prompts/:promptId - Get Prompt', () => {
let testPrompt;
let testGroup;
beforeEach(async () => {
// Create a prompt group first
testGroup = await PromptGroup.create({
name: 'Test Group',
category: 'testing',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
});
// Create a prompt
testPrompt = await Prompt.create({
prompt: 'Test prompt for retrieval',
name: 'Get Test',
author: testUsers.owner._id,
type: 'text',
groupId: testGroup._id,
});
});
afterEach(async () => {
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('should retrieve prompt when user has view permissions', async () => {
// Grant view permissions on the promptGroup
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: testGroup._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
grantedBy: testUsers.owner._id,
});
const response = await request(app).get(`/api/prompts/${testPrompt._id}`);
expect(response.status).toBe(200);
expect(response.body._id).toBe(testPrompt._id.toString());
expect(response.body.prompt).toBe(testPrompt.prompt);
});
it('should deny access when user has no permissions', async () => {
// Change the user to one without access
setTestUser(app, testUsers.noAccess);
const response = await request(app).get(`/api/prompts/${testPrompt._id}`).expect(403);
// Verify error response
expect(response.body.error).toBe('Forbidden');
expect(response.body.message).toBe('Insufficient permissions to access this promptGroup');
});
it('should allow admin access without explicit permissions', async () => {
// Set admin user
setTestUser(app, testUsers.admin);
const response = await request(app).get(`/api/prompts/${testPrompt._id}`).expect(200);
expect(response.body._id).toBe(testPrompt._id.toString());
});
it('should re-inspect an older stored prompt under prompt-only policy', async () => {
const privateValue = 'sk-stored-prompt-value';
testPrompt.prompt = `Use ${privateValue} for this request`;
await testPrompt.save();
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: testGroup._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
grantedBy: testUsers.owner._id,
});
mockAppConfig = {
filters: {
prompts: {
pii: {
starterPatterns: ['sk_prefix'],
},
},
},
};
const response = await request(app).get(`/api/prompts/${testPrompt._id}`).expect(400);
expect(response.body).toEqual(
expect.objectContaining({
error: 'content_filter_block',
source: 'prompt',
field: 'text',
}),
);
expect(JSON.stringify(response.body)).not.toContain(privateValue);
});
});
describe('Stored prompt policy enforcement', () => {
afterEach(async () => {
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('should omit filtered variable and non-variable production prompts from reuse results', async () => {
const safe = await createAccessiblePromptGroup({
name: 'Safe prompt',
prompt: 'Summarize this document',
});
const blockedPlain = await createAccessiblePromptGroup({
name: 'Blocked plain prompt',
prompt: 'Use sk-plain-stored-value for the request',
});
const blockedVariable = await createAccessiblePromptGroup({
name: 'Blocked variable prompt',
prompt: 'Use sk-variable-stored-value for {{customer}}',
});
mockAppConfig = {
filters: {
prompts: {
pii: {
starterPatterns: ['sk_prefix'],
},
},
},
};
const response = await request(app).get('/api/prompts/all').expect(200);
const responseIds = response.body.map((group) => group._id);
expect(responseIds).toContain(safe.group._id.toString());
expect(responseIds).not.toContain(blockedPlain.group._id.toString());
expect(responseIds).not.toContain(blockedVariable.group._id.toString());
expect(JSON.stringify(response.body)).not.toContain('sk-plain-stored-value');
expect(JSON.stringify(response.body)).not.toContain('sk-variable-stored-value');
});
it('should keep prompt filtering disabled when the prompt scope is omitted', async () => {
const stored = await createAccessiblePromptGroup({
name: 'Stored prompt',
prompt: 'Use sk-allowed-by-omission for the request',
});
mockAppConfig = {
filters: {
messages: {
pii: {
starterPatterns: ['sk_prefix'],
},
},
},
};
const response = await request(app).get('/api/prompts/all').expect(200);
expect(response.body).toEqual(
expect.arrayContaining([
expect.objectContaining({
_id: stored.group._id.toString(),
productionPrompt: expect.objectContaining({
prompt: 'Use sk-allowed-by-omission for the request',
}),
}),
]),
);
});
it('should redact blocked versions while preserving safe records for remediation', async () => {
const blocked = await createAccessiblePromptGroup({
name: 'Prompt with history',
prompt: 'Use sk-blocked-version for this request',
});
const safe = await createAccessiblePromptGroup({
groupId: blocked.group._id,
prompt: 'A safe replacement prompt',
production: false,
});
mockAppConfig = {
filters: {
prompts: {
pii: {
starterPatterns: ['sk_prefix'],
},
},
},
};
const [groupResponse, groupsResponse, promptsResponse] = await Promise.all([
request(app).get(`/api/prompts/groups/${blocked.group._id}`).expect(200),
request(app).get('/api/prompts/groups').query({ limit: '10' }).expect(200),
request(app)
.get('/api/prompts')
.query({ groupId: blocked.group._id.toString() })
.expect(200),
]);
expect(groupResponse.body.productionPrompt).toEqual(
expect.objectContaining({
prompt: '',
contentFilterBlocked: true,
}),
);
const listedGroup = groupsResponse.body.promptGroups.find(
(group) => group._id === blocked.group._id.toString(),
);
expect(listedGroup.productionPrompt).toEqual(
expect.objectContaining({
prompt: '',
contentFilterBlocked: true,
}),
);
const blockedVersion = promptsResponse.body.find(
(prompt) => prompt._id === blocked.prompt._id.toString(),
);
const safeVersion = promptsResponse.body.find(
(prompt) => prompt._id === safe.prompt._id.toString(),
);
expect(blockedVersion).toEqual(
expect.objectContaining({
prompt: '',
contentFilterBlocked: true,
}),
);
expect(safeVersion.prompt).toBe('A safe replacement prompt');
expect(
JSON.stringify([groupResponse.body, groupsResponse.body, promptsResponse.body]),
).not.toContain('sk-blocked-version');
});
it('should reject promoting an older blocked prompt without changing production', async () => {
const safe = await createAccessiblePromptGroup({
name: 'Production prompt',
prompt: 'Current safe production prompt',
});
const blocked = await createAccessiblePromptGroup({
groupId: safe.group._id,
prompt: 'Use sk-blocked-production for this request',
production: false,
});
mockAppConfig = {
filters: {
prompts: {
pii: {
starterPatterns: ['sk_prefix'],
},
},
},
};
const response = await request(app)
.patch(`/api/prompts/${blocked.prompt._id}/tags/production`)
.expect(400);
expect(response.body).toEqual(
expect.objectContaining({
error: 'content_filter_block',
source: 'prompt',
field: 'text',
}),
);
expect(JSON.stringify(response.body)).not.toContain('sk-blocked-production');
const unchangedGroup = await PromptGroup.findById(safe.group._id).lean();
expect(unchangedGroup.productionId.toString()).toBe(safe.prompt._id.toString());
});
});
describe('DELETE /api/prompts/:promptId - Delete Prompt', () => {
let testPrompt;
let testGroup;
beforeEach(async () => {
// Create group with prompt
testGroup = await PromptGroup.create({
name: 'Delete Test Group',
category: 'testing',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
});
testPrompt = await Prompt.create({
prompt: 'Test prompt for deletion',
name: 'Delete Test',
author: testUsers.owner._id,
type: 'text',
groupId: testGroup._id,
});
// Add prompt to group
testGroup.productionId = testPrompt._id;
testGroup.promptIds = [testPrompt._id];
await testGroup.save();
// Grant owner permissions on the promptGroup
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: testGroup._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
});
afterEach(async () => {
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('should delete prompt when user has delete permissions', async () => {
const response = await request(app)
.delete(`/api/prompts/${testPrompt._id}`)
.query({ groupId: testGroup._id.toString() })
.expect(200);
expect(response.body.prompt).toBe('Prompt deleted successfully');
// Verify prompt was deleted
const deletedPrompt = await Prompt.findById(testPrompt._id);
expect(deletedPrompt).toBeNull();
// Verify ACL entries were removed
const aclEntries = await AclEntry.find({
resourceType: ResourceType.PROMPTGROUP,
resourceId: testGroup._id,
});
expect(aclEntries).toHaveLength(0);
});
it('should deny deletion when user lacks delete permissions', async () => {
// Create a prompt as a different user (not the one trying to delete)
const authorPrompt = await Prompt.create({
prompt: 'Test prompt by another user',
name: 'Another User Prompt',
author: testUsers.editor._id, // Different author
type: 'text',
groupId: testGroup._id,
});
// Grant only viewer permissions to viewer user on the promptGroup
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.viewer._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: testGroup._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
grantedBy: testUsers.editor._id,
});
// Set viewer user
setTestUser(app, testUsers.viewer);
await request(app)
.delete(`/api/prompts/${authorPrompt._id}`)
.query({ groupId: testGroup._id.toString() })
.expect(403);
// Verify prompt still exists
const prompt = await Prompt.findById(authorPrompt._id);
expect(prompt).toBeTruthy();
});
it('should run configMiddleware so the handler receives the configured value', async () => {
configMiddleware.mockClear();
await request(app)
.delete(`/api/prompts/${testPrompt._id}`)
.query({ groupId: testGroup._id.toString() })
.expect(200);
expect(configMiddleware).toHaveBeenCalledTimes(1);
});
});
describe('DELETE /api/prompts/groups/:groupId - Delete Prompt Group', () => {
let testGroup;
beforeEach(async () => {
testGroup = await PromptGroup.create({
name: 'Delete Group Test Group',
category: 'testing',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: testGroup._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
});
afterEach(async () => {
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('should run configMiddleware so the handler receives the configured value', async () => {
configMiddleware.mockClear();
await request(app).delete(`/api/prompts/groups/${testGroup._id}`).expect(200);
expect(configMiddleware).toHaveBeenCalledTimes(1);
});
});
describe('PATCH /api/prompts/:promptId/tags/production - Make Production', () => {
let testPrompt;
let testGroup;
beforeEach(async () => {
// Create group
testGroup = await PromptGroup.create({
name: 'Production Test Group',
category: 'testing',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
});
testPrompt = await Prompt.create({
prompt: 'Test prompt for production',
name: 'Production Test',
author: testUsers.owner._id,
type: 'text',
groupId: testGroup._id,
});
});
afterEach(async () => {
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('should make prompt production when user has edit permissions', async () => {
// Grant edit permissions on the promptGroup
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: testGroup._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_EDITOR,
grantedBy: testUsers.owner._id,
});
// Ensure owner user
setTestUser(app, testUsers.owner);
const response = await request(app)
.patch(`/api/prompts/${testPrompt._id}/tags/production`)
.expect(200);
expect(response.body.message).toBe('Prompt production made successfully');
// Verify the group was updated
const updatedGroup = await PromptGroup.findById(testGroup._id);
expect(updatedGroup.productionId.toString()).toBe(testPrompt._id.toString());
});
it('should deny making production when user lacks edit permissions', async () => {
// Grant only view permissions to viewer on the promptGroup
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.viewer._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: testGroup._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
grantedBy: testUsers.owner._id,
});
// Set viewer user
setTestUser(app, testUsers.viewer);
await request(app).patch(`/api/prompts/${testPrompt._id}/tags/production`).expect(403);
// Verify prompt hasn't changed
const unchangedGroup = await PromptGroup.findById(testGroup._id);
expect(unchangedGroup.productionId.toString()).not.toBe(testPrompt._id.toString());
});
});
describe('Public Access', () => {
let publicPrompt;
let publicGroup;
beforeEach(async () => {
// Create a prompt group
publicGroup = await PromptGroup.create({
name: 'Public Test Group',
category: 'testing',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
});
// Create a public prompt
publicPrompt = await Prompt.create({
prompt: 'Public prompt content',
name: 'Public Test',
author: testUsers.owner._id,
type: 'text',
groupId: publicGroup._id,
});
// Grant public viewer access on the promptGroup
await grantPermission({
principalType: PrincipalType.PUBLIC,
principalId: null,
resourceType: ResourceType.PROMPTGROUP,
resourceId: publicGroup._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
grantedBy: testUsers.owner._id,
});
});
afterEach(async () => {
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('should allow any user to view public prompts', async () => {
// Change user to someone without explicit permissions
setTestUser(app, testUsers.noAccess);
const response = await request(app).get(`/api/prompts/${publicPrompt._id}`).expect(200);
expect(response.body._id).toBe(publicPrompt._id.toString());
});
});
describe('PATCH /api/prompts/groups/:groupId - Update Prompt Group Security', () => {
let testGroup;
beforeEach(async () => {
// Create a prompt group
testGroup = await PromptGroup.create({
name: 'Security Test Group',
category: 'security-test',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
});
// Grant owner permissions
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: testGroup._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
});
afterEach(async () => {
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('should allow updating allowed fields (name, category, oneliner)', async () => {
const updateData = {
name: 'Updated Group Name',
category: 'updated-category',
oneliner: 'Updated description',
};
const response = await request(app)
.patch(`/api/prompts/groups/${testGroup._id}`)
.send(updateData)
.expect(200);
expect(response.body.name).toBe(updateData.name);
expect(response.body.category).toBe(updateData.category);
expect(response.body.oneliner).toBe(updateData.oneliner);
});
it('should reject request with author field (400 Bad Request)', async () => {
const maliciousUpdate = {
name: 'Legit Update',
author: testUsers.noAccess._id.toString(), // Try to change ownership
};
const response = await request(app)
.patch(`/api/prompts/groups/${testGroup._id}`)
.send(maliciousUpdate)
.expect(400);
// Verify the request was rejected
expect(response.body.error).toBe('Invalid request body');
expect(response.body.details).toBeDefined();
});
it('should reject request with authorName field (400 Bad Request)', async () => {
const maliciousUpdate = {
name: 'Legit Update',
authorName: 'Malicious Author Name',
};
const response = await request(app)
.patch(`/api/prompts/groups/${testGroup._id}`)
.send(maliciousUpdate)
.expect(400);
// Verify the request was rejected
expect(response.body.error).toBe('Invalid request body');
});
it('should reject request with _id field (400 Bad Request)', async () => {
const newId = new ObjectId();
const maliciousUpdate = {
name: 'Legit Update',
_id: newId.toString(),
};
const response = await request(app)
.patch(`/api/prompts/groups/${testGroup._id}`)
.send(maliciousUpdate)
.expect(400);
// Verify the request was rejected
expect(response.body.error).toBe('Invalid request body');
});
it('should reject request with productionId field (400 Bad Request)', async () => {
const newProductionId = new ObjectId();
const maliciousUpdate = {
name: 'Legit Update',
productionId: newProductionId.toString(),
};
const response = await request(app)
.patch(`/api/prompts/groups/${testGroup._id}`)
.send(maliciousUpdate)
.expect(400);
// Verify the request was rejected
expect(response.body.error).toBe('Invalid request body');
});
it('should reject request with createdAt field (400 Bad Request)', async () => {
const maliciousDate = new Date('2020-01-01');
const maliciousUpdate = {
name: 'Legit Update',
createdAt: maliciousDate.toISOString(),
};
const response = await request(app)
.patch(`/api/prompts/groups/${testGroup._id}`)
.send(maliciousUpdate)
.expect(400);
// Verify the request was rejected
expect(response.body.error).toBe('Invalid request body');
});
it('should reject request with __v field (400 Bad Request)', async () => {
const maliciousUpdate = {
name: 'Legit Update',
__v: 999,
};
const response = await request(app)
.patch(`/api/prompts/groups/${testGroup._id}`)
.send(maliciousUpdate)
.expect(400);
// Verify the request was rejected
expect(response.body.error).toBe('Invalid request body');
});
it('should reject request with multiple sensitive fields (400 Bad Request)', async () => {
const maliciousUpdate = {
name: 'Legit Update',
author: testUsers.noAccess._id.toString(),
authorName: 'Hacker',
_id: new ObjectId().toString(),
productionId: new ObjectId().toString(),
createdAt: new Date('2020-01-01').toISOString(),
__v: 999,
};
const response = await request(app)
.patch(`/api/prompts/groups/${testGroup._id}`)
.send(maliciousUpdate)
.expect(400);
// Verify the request was rejected with validation errors
expect(response.body.error).toBe('Invalid request body');
expect(response.body.details).toBeDefined();
expect(Array.isArray(response.body.details)).toBe(true);
});
});
describe('Pagination', () => {
beforeEach(async () => {
// Create multiple prompt groups for pagination testing
const groups = [];
for (let i = 0; i < 15; i++) {
const group = await PromptGroup.create({
name: `Test Group ${i + 1}`,
category: 'pagination-test',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
updatedAt: new Date(Date.now() - i * 1000), // Stagger updatedAt for consistent ordering
});
groups.push(group);
// Grant owner permissions on each group
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
}
});
afterEach(async () => {
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('should correctly indicate hasMore when there are more pages', async () => {
const response = await request(app)
.get('/api/prompts/groups')
.query({ limit: '10' })
.expect(200);
expect(response.body.promptGroups).toHaveLength(10);
expect(response.body.has_more).toBe(true);
expect(response.body.after).toBeTruthy();
// Since has_more is true, pages should be a high number (9999 in our fix)
expect(parseInt(response.body.pages)).toBeGreaterThan(1);
});
it('should correctly indicate no more pages on the last page', async () => {
// First get the cursor for page 2
const firstPage = await request(app)
.get('/api/prompts/groups')
.query({ limit: '10' })
.expect(200);
expect(firstPage.body.has_more).toBe(true);
expect(firstPage.body.after).toBeTruthy();
// Now fetch the second page using the cursor
const response = await request(app)
.get('/api/prompts/groups')
.query({ limit: '10', cursor: firstPage.body.after })
.expect(200);
expect(response.body.promptGroups).toHaveLength(5); // 15 total, 10 on page 1, 5 on page 2
expect(response.body.has_more).toBe(false);
});
it('should support cursor-based pagination', async () => {
// First page
const firstPage = await request(app)
.get('/api/prompts/groups')
.query({ limit: '5' })
.expect(200);
expect(firstPage.body.promptGroups).toHaveLength(5);
expect(firstPage.body.has_more).toBe(true);
expect(firstPage.body.after).toBeTruthy();
// Second page using cursor
const secondPage = await request(app)
.get('/api/prompts/groups')
.query({ limit: '5', cursor: firstPage.body.after })
.expect(200);
expect(secondPage.body.promptGroups).toHaveLength(5);
expect(secondPage.body.has_more).toBe(true);
expect(secondPage.body.after).toBeTruthy();
// Verify different groups
const firstPageIds = firstPage.body.promptGroups.map((g) => g._id);
const secondPageIds = secondPage.body.promptGroups.map((g) => g._id);
expect(firstPageIds).not.toEqual(secondPageIds);
});
it('should paginate correctly with category filtering', async () => {
// Create groups with different categories
await PromptGroup.deleteMany({}); // Clear existing groups
await AclEntry.deleteMany({});
// Create 8 groups with category 'test-cat-1'
for (let i = 0; i < 8; i++) {
const group = await PromptGroup.create({
name: `Category 1 Group ${i + 1}`,
category: 'test-cat-1',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
updatedAt: new Date(Date.now() - i * 1000),
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
}
// Create 7 groups with category 'test-cat-2'
for (let i = 0; i < 7; i++) {
const group = await PromptGroup.create({
name: `Category 2 Group ${i + 1}`,
category: 'test-cat-2',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
updatedAt: new Date(Date.now() - (i + 8) * 1000),
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
}
// Test pagination with category filter
const firstPage = await request(app)
.get('/api/prompts/groups')
.query({ limit: '5', category: 'test-cat-1' })
.expect(200);
expect(firstPage.body.promptGroups).toHaveLength(5);
expect(firstPage.body.promptGroups.every((g) => g.category === 'test-cat-1')).toBe(true);
expect(firstPage.body.has_more).toBe(true);
expect(firstPage.body.after).toBeTruthy();
const secondPage = await request(app)
.get('/api/prompts/groups')
.query({ limit: '5', cursor: firstPage.body.after, category: 'test-cat-1' })
.expect(200);
expect(secondPage.body.promptGroups).toHaveLength(3); // 8 total, 5 on page 1, 3 on page 2
expect(secondPage.body.promptGroups.every((g) => g.category === 'test-cat-1')).toBe(true);
expect(secondPage.body.has_more).toBe(false);
});
it('should paginate correctly with name/keyword filtering', async () => {
// Create groups with specific names
await PromptGroup.deleteMany({}); // Clear existing groups
await AclEntry.deleteMany({});
// Create 12 groups with 'Search' in the name
for (let i = 0; i < 12; i++) {
const group = await PromptGroup.create({
name: `Search Test Group ${i + 1}`,
category: 'search-test',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
updatedAt: new Date(Date.now() - i * 1000),
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
}
// Create 5 groups without 'Search' in the name
for (let i = 0; i < 5; i++) {
const group = await PromptGroup.create({
name: `Other Group ${i + 1}`,
category: 'other-test',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
updatedAt: new Date(Date.now() - (i + 12) * 1000),
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
}
// Test pagination with name filter
const firstPage = await request(app)
.get('/api/prompts/groups')
.query({ limit: '10', name: 'Search' })
.expect(200);
expect(firstPage.body.promptGroups).toHaveLength(10);
expect(firstPage.body.promptGroups.every((g) => g.name.includes('Search'))).toBe(true);
expect(firstPage.body.has_more).toBe(true);
expect(firstPage.body.after).toBeTruthy();
const secondPage = await request(app)
.get('/api/prompts/groups')
.query({ limit: '10', cursor: firstPage.body.after, name: 'Search' })
.expect(200);
expect(secondPage.body.promptGroups).toHaveLength(2); // 12 total, 10 on page 1, 2 on page 2
expect(secondPage.body.promptGroups.every((g) => g.name.includes('Search'))).toBe(true);
expect(secondPage.body.has_more).toBe(false);
});
it('should paginate correctly with combined filters', async () => {
// Create groups with various combinations
await PromptGroup.deleteMany({}); // Clear existing groups
await AclEntry.deleteMany({});
// Create 6 groups matching both category and name filters
for (let i = 0; i < 6; i++) {
const group = await PromptGroup.create({
name: `API Test Group ${i + 1}`,
category: 'api-category',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
updatedAt: new Date(Date.now() - i * 1000),
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
}
// Create groups that only match one filter
for (let i = 0; i < 4; i++) {
const group = await PromptGroup.create({
name: `API Other Group ${i + 1}`,
category: 'other-category',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
updatedAt: new Date(Date.now() - (i + 6) * 1000),
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
}
// Test pagination with both filters
const response = await request(app)
.get('/api/prompts/groups')
.query({ limit: '5', name: 'API', category: 'api-category' })
.expect(200);
expect(response.body.promptGroups).toHaveLength(5);
expect(
response.body.promptGroups.every(
(g) => g.name.includes('API') && g.category === 'api-category',
),
).toBe(true);
expect(response.body.has_more).toBe(true);
expect(response.body.after).toBeTruthy();
// Page 2
const page2 = await request(app)
.get('/api/prompts/groups')
.query({ limit: '5', cursor: response.body.after, name: 'API', category: 'api-category' })
.expect(200);
expect(page2.body.promptGroups).toHaveLength(1); // 6 total, 5 on page 1, 1 on page 2
expect(page2.body.has_more).toBe(false);
});
});
});
async function responseOf(pending) {
const { status, body } = await pending;
return { status, body };
}
describe('GET /api/prompts/groups/:groupId/resolve', () => {
afterEach(async () => {
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('resolves the production revision for a native group', async () => {
const { group, prompt } = await createAccessiblePromptGroup({
name: 'Resolve native group',
prompt: 'Native production text',
});
const response = await request(app).get(`/api/prompts/groups/${group._id}/resolve`).expect(200);
expect(response.body).toEqual({
source: 'native',
groupId: group._id.toString(),
promptId: prompt._id.toString(),
prompt: 'Native production text',
type: 'text',
});
});
it('returns 403 without VIEW permission', async () => {
const { group } = await createAccessiblePromptGroup({
name: 'Resolve forbidden group',
prompt: 'Native text',
});
setTestUser(app, testUsers.noAccess);
const response = await request(app).get(`/api/prompts/groups/${group._id}/resolve`).expect(403);
expect(response.body.error).toBe('Forbidden');
});
it('returns 404 for a missing group', async () => {
const response = await request(app)
.get(`/api/prompts/groups/${new ObjectId()}/resolve`)
.expect(404);
expect(response.body).toEqual({
error: 'Not Found',
message: `${ResourceType.PROMPTGROUP} not found`,
});
});
it('is not captured by GET /:promptId', async () => {
const { group, prompt } = await createAccessiblePromptGroup({
name: 'Resolve route segments',
prompt: 'Native text',
});
const response = await request(app).get(`/api/prompts/groups/${group._id}/resolve`);
expect(response.status).toBe(200);
expect(response.body).toEqual({
source: 'native',
groupId: group._id.toString(),
promptId: prompt._id.toString(),
prompt: 'Native text',
type: 'text',
});
});
describe('a Langfuse-origin group', () => {
const langfuseEnv = {
LANGFUSE_PROMPT_SYNC_AVAILABLE: 'true',
LANGFUSE_PUBLIC_KEY: 'pk-resolve',
LANGFUSE_SECRET_KEY: 'sk-resolve',
LANGFUSE_PROJECT_ID: 'resolve-project',
LANGFUSE_BASE_URL: 'https://langfuse.resolve.test',
};
let fetchSpy;
let group;
let previousLangfuseEnv;
beforeEach(async () => {
previousLangfuseEnv = {};
for (const key of Object.keys(langfuseEnv)) {
previousLangfuseEnv[key] = process.env[key];
}
Object.assign(process.env, langfuseEnv);
await db.upsertConfig(
PrincipalType.ROLE,
BASE_CONFIG_PRINCIPAL_ID,
PrincipalModel.ROLE,
{ langfuse: { promptSync: { enabled: true } } },
10,
);
group = await PromptGroup.create({
name: 'Langfuse group',
category: 'resolve-test',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
source: 'langfuse',
sourcePromptName: 'greeting',
sourceProjectId: 'resolve-project',
sourceDestination: 'env',
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
});
afterEach(async () => {
for (const key of Object.keys(langfuseEnv)) {
if (previousLangfuseEnv[key] === undefined) {
delete process.env[key];
} else {
process.env[key] = previousLangfuseEnv[key];
}
}
if (fetchSpy) {
fetchSpy.mockRestore();
fetchSpy = undefined;
}
await Config.deleteMany({});
});
function mockLangfuseFetch(responder) {
fetchSpy = jest.spyOn(global, 'fetch').mockImplementation(responder);
}
function textPromptResponse(payload, status = 200) {
return new Response(JSON.stringify(payload), {
status,
headers: { 'Content-Type': 'application/json' },
});
}
it('resolves the production label, with no sourceUrl for a non-admin', async () => {
mockLangfuseFetch(async () =>
textPromptResponse({
name: 'greeting',
version: 1,
type: 'text',
labels: ['production'],
prompt: 'Hello {{name}}',
}),
);
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/resolve`)
.expect(200);
expect(response.body).toEqual({
source: 'langfuse',
groupId: group._id.toString(),
prompt: 'Hello {{name}}',
type: 'text',
version: 1,
labels: ['production'],
});
expect(response.body.sourceUrl).toBeUndefined();
const [url] = fetchSpy.mock.calls[0];
expect(url).toContain('label=production');
expect(url).not.toContain('version=');
});
it('resolves the production label with sourceUrl for an admin', async () => {
setTestUser(app, testUsers.admin);
mockLangfuseFetch(async () =>
textPromptResponse({
name: 'greeting',
version: 1,
type: 'text',
labels: ['production'],
prompt: 'Hello {{name}}',
}),
);
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/resolve`)
.expect(200);
expect(response.body).toEqual({
source: 'langfuse',
groupId: group._id.toString(),
prompt: 'Hello {{name}}',
type: 'text',
version: 1,
labels: ['production'],
sourceUrl: 'https://langfuse.resolve.test/project/resolve-project/prompts/greeting',
});
});
it('allows a public viewer with no explicit grant to resolve the group, with no sourceUrl', async () => {
await grantPermission({
principalType: PrincipalType.PUBLIC,
principalId: null,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
grantedBy: testUsers.owner._id,
});
setTestUser(app, testUsers.noAccess);
mockLangfuseFetch(async () =>
textPromptResponse({
name: 'greeting',
version: 1,
type: 'text',
labels: ['production'],
prompt: 'Hello {{name}}',
}),
);
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/resolve`)
.expect(200);
expect(response.body).toEqual({
source: 'langfuse',
groupId: group._id.toString(),
prompt: 'Hello {{name}}',
type: 'text',
version: 1,
labels: ['production'],
});
expect(response.body.sourceUrl).toBeUndefined();
});
it('returns 403 for a user with no grant at all on the group', async () => {
setTestUser(app, testUsers.noAccess);
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/resolve`)
.expect(403);
expect(response.body.error).toBe('Forbidden');
});
it('resolves an exact version and sends it with no label', async () => {
mockLangfuseFetch(async () =>
textPromptResponse({
name: 'greeting',
version: 3,
type: 'text',
labels: [],
prompt: 'Hello v3',
}),
);
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/resolve`)
.query({ version: 3 })
.expect(200);
expect(response.body).toEqual({
source: 'langfuse',
groupId: group._id.toString(),
prompt: 'Hello v3',
type: 'text',
version: 3,
labels: [],
});
expect(response.body.sourceUrl).toBeUndefined();
const [url] = fetchSpy.mock.calls[0];
expect(url).toContain('version=3');
expect(url).not.toContain('label=');
});
it('rejects a chat prompt with 422', async () => {
mockLangfuseFetch(async () =>
textPromptResponse({
name: 'greeting',
version: 1,
type: 'chat',
labels: ['production'],
prompt: [{ role: 'system', content: 'secret' }],
}),
);
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/resolve`)
.expect(422);
expect(response.body).toEqual({ code: 'unsupported_type' });
});
it('returns 404 with the Langfuse message for a missing prompt', async () => {
mockLangfuseFetch(async () => new Response(null, { status: 404 }));
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/resolve`)
.expect(404);
expect(response.body).toEqual({
code: 'not_found',
message: 'Prompt not found in Langfuse',
});
});
it('returns 404 not_available when prompt sync is gated off', async () => {
delete process.env.LANGFUSE_PROMPT_SYNC_AVAILABLE;
mockLangfuseFetch(async () => textPromptResponse({}));
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/resolve`)
.expect(404);
expect(response.body).toEqual({ code: 'not_available' });
expect(fetchSpy).not.toHaveBeenCalled();
});
});
});
describe('GET /api/prompts/groups/:groupId/revisions', () => {
afterEach(async () => {
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('lists native revisions newest first with the Production entry marked', async () => {
const { group, prompt: production } = await createAccessiblePromptGroup({
name: 'Revisions native group',
prompt: 'Production text',
});
const draft = await Prompt.create({
prompt: 'Draft text',
author: testUsers.owner._id,
type: 'text',
groupId: group._id,
});
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/revisions`)
.expect(200);
expect(response.body).toEqual({
source: 'native',
groupId: group._id.toString(),
revisions: [
{ source: 'native', promptId: draft._id.toString(), version: 2, isProduction: false },
{
source: 'native',
promptId: production._id.toString(),
version: 1,
isProduction: true,
},
],
});
});
it('returns 403 without VIEW permission on the group', async () => {
const { group } = await createAccessiblePromptGroup({
name: 'Revisions forbidden group',
prompt: 'Native text',
});
setTestUser(app, testUsers.noAccess);
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/revisions`)
.expect(403);
expect(response.body.error).toBe('Forbidden');
});
it('returns 404 for a missing group', async () => {
const response = await request(app)
.get(`/api/prompts/groups/${new ObjectId()}/revisions`)
.expect(404);
expect(response.body).toEqual({
error: 'Not Found',
message: `${ResourceType.PROMPTGROUP} not found`,
});
});
it('allows a user with only VIEW access, not just the owner', async () => {
const { group } = await createAccessiblePromptGroup({
name: 'Revisions viewer group',
prompt: 'Native text',
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.viewer._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
grantedBy: testUsers.owner._id,
});
setTestUser(app, testUsers.viewer);
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/revisions`)
.expect(200);
expect(response.body.source).toBe('native');
});
it('returns 403 for a role without PROMPTS USE, before the group VIEW check', async () => {
const { group } = await createAccessiblePromptGroup({
name: 'Revisions no-PROMPTS-USE group',
prompt: 'Native text',
});
// getRoleByName's mock returns null for any role besides USER/ADMIN, so this
// role carries no PROMPTS.USE grant even though the user has group VIEW access.
const noUseUser = await User.create({
name: 'No Prompts Use',
email: 'no-prompts-use@example.com',
role: 'NoPromptsUseRole',
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: noUseUser._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
grantedBy: testUsers.owner._id,
});
setTestUser(app, noUseUser);
const response = await request(app)
.get(`/api/prompts/groups/${group._id}/revisions`)
.expect(403);
expect(response.body).toEqual({ message: 'Forbidden: Insufficient permissions' });
});
});
describe('Externally managed (Langfuse) prompt groups are read-only', () => {
const readOnlyBody = { code: 'read_only', error: 'Externally managed prompts are read-only' };
let group;
async function seedLangfuseGroup(owner = testUsers.owner) {
const langfuseGroup = await PromptGroup.create({
name: 'Read-only Langfuse group',
category: 'langfuse-read-only',
author: owner._id,
authorName: owner.name,
source: 'langfuse',
sourcePromptName: 'greeting',
sourceProjectId: 'ro-project',
sourceDestination: 'env',
});
await grantPermission({
principalType: PrincipalType.USER,
principalId: owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: langfuseGroup._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: owner._id,
});
return langfuseGroup;
}
beforeEach(async () => {
group = await seedLangfuseGroup();
});
afterEach(async () => {
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('rejects PATCH /groups/:groupId with 403 and leaves the group unchanged', async () => {
const before = await PromptGroup.findById(group._id).lean();
const response = await request(app)
.patch(`/api/prompts/groups/${group._id}`)
.send({ name: 'Hacked name' })
.expect(403);
expect(response.body).toEqual(readOnlyBody);
const after = await PromptGroup.findById(group._id).lean();
expect(after).toEqual(before);
});
it('rejects DELETE /groups/:groupId with 403 and leaves the group in place', async () => {
const response = await request(app).delete(`/api/prompts/groups/${group._id}`).expect(403);
expect(response.body).toEqual(readOnlyBody);
await expect(PromptGroup.findById(group._id)).resolves.not.toBeNull();
const ownerEntry = await AclEntry.findOne({
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
});
expect(ownerEntry).toBeTruthy();
});
it('rejects POST /groups/:groupId/prompts (new revision) with 403 and adds no revision', async () => {
const response = await request(app)
.post(`/api/prompts/groups/${group._id}/prompts`)
.send({ prompt: { prompt: 'New text', type: 'text' } })
.expect(403);
expect(response.body).toEqual(readOnlyBody);
await expect(Prompt.countDocuments({ groupId: group._id })).resolves.toBe(0);
});
it('rejects PATCH /groups/:groupId for an admin too (MANAGE_PROMPTS ACL bypass still hits the service guard)', async () => {
setTestUser(app, testUsers.admin);
const before = await PromptGroup.findById(group._id).lean();
const response = await request(app)
.patch(`/api/prompts/groups/${group._id}`)
.send({ name: 'Admin hack' })
.expect(403);
expect(response.body).toEqual(readOnlyBody);
const after = await PromptGroup.findById(group._id).lean();
expect(after).toEqual(before);
});
it('rejects DELETE /groups/:groupId for an admin too (MANAGE_PROMPTS ACL bypass still hits the service guard)', async () => {
setTestUser(app, testUsers.admin);
const response = await request(app).delete(`/api/prompts/groups/${group._id}`).expect(403);
expect(response.body).toEqual(readOnlyBody);
await expect(PromptGroup.findById(group._id)).resolves.not.toBeNull();
});
describe('with a Prompt row inserted directly for the group', () => {
let revision;
beforeEach(async () => {
revision = await Prompt.create({
prompt: 'Synced from Langfuse',
author: testUsers.owner._id,
type: 'text',
groupId: group._id,
});
});
it('rejects PATCH /:promptId/tags/production with 403 and does not promote', async () => {
const response = await request(app)
.patch(`/api/prompts/${revision._id}/tags/production`)
.expect(403);
expect(response.body).toEqual(readOnlyBody);
const after = await PromptGroup.findById(group._id).lean();
expect(after.productionId ?? null).toBeNull();
await expect(Prompt.findById(revision._id)).resolves.not.toBeNull();
});
it('rejects DELETE /:promptId with 403 and keeps the revision', async () => {
const response = await request(app)
.delete(`/api/prompts/${revision._id}`)
.query({ groupId: group._id.toString() })
.expect(403);
expect(response.body).toEqual(readOnlyBody);
await expect(Prompt.findById(revision._id)).resolves.not.toBeNull();
await expect(PromptGroup.findById(group._id)).resolves.not.toBeNull();
});
it('rejects DELETE /:promptId for an admin too (MANAGE_PROMPTS ACL bypass still hits the service guard)', async () => {
setTestUser(app, testUsers.admin);
const response = await request(app)
.delete(`/api/prompts/${revision._id}`)
.query({ groupId: group._id.toString() })
.expect(403);
expect(response.body).toEqual(readOnlyBody);
await expect(Prompt.findById(revision._id)).resolves.not.toBeNull();
});
});
it('keeps POST /groups/:groupId/use working: it increments numberOfGenerations', async () => {
const response = await request(app).post(`/api/prompts/groups/${group._id}/use`).expect(200);
expect(response.body).toEqual({ numberOfGenerations: 1 });
const after = await PromptGroup.findById(group._id).lean();
expect(after.numberOfGenerations).toBe(1);
});
it('keeps sharing working through the access-permissions routes', async () => {
setTestUser(app, testUsers.owner);
const response = await request(app)
.put(`/api/permissions/${ResourceType.PROMPTGROUP}/${group._id}`)
.send({
updated: [
{
type: PrincipalType.USER,
id: testUsers.viewer._id.toString(),
accessRoleId: AccessRoleIds.PROMPTGROUP_VIEWER,
},
],
})
.expect(200);
expect(response.body.message).toBe('Permissions updated successfully');
const sharedEntry = await AclEntry.findOne({
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
principalType: PrincipalType.USER,
principalId: testUsers.viewer._id,
});
expect(sharedEntry).toBeTruthy();
// Sharing an externally managed group only grants an ACL entry; it never touches
// the read-only group document itself.
const after = await PromptGroup.findById(group._id).lean();
expect(after.name).toBe(group.name);
});
});
describe('A stored prompt group with no source (predates the field) stays editable', () => {
let group;
beforeEach(async () => {
// Bypasses the schema's `source: 'native'` default to reproduce a group
// written before the field existed.
const inserted = await PromptGroup.collection.insertOne({
name: 'Pre-source Group',
category: 'legacy-no-source',
author: testUsers.owner._id,
authorName: testUsers.owner.name,
productionId: new ObjectId(),
});
group = { _id: inserted.insertedId };
await grantPermission({
principalType: PrincipalType.USER,
principalId: testUsers.owner._id,
resourceType: ResourceType.PROMPTGROUP,
resourceId: group._id,
accessRoleId: AccessRoleIds.PROMPTGROUP_OWNER,
grantedBy: testUsers.owner._id,
});
});
afterEach(async () => {
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('allows PATCH /groups/:groupId to rename it, same as a native group', async () => {
const response = await request(app)
.patch(`/api/prompts/groups/${group._id}`)
.send({ name: 'Renamed legacy group' })
.expect(200);
expect(response.body.name).toBe('Renamed legacy group');
const stored = await PromptGroup.findById(group._id).lean();
expect(stored.name).toBe('Renamed legacy group');
});
it('allows POST /groups/:groupId/prompts to add a text prompt, same as a native group', async () => {
const response = await request(app)
.post(`/api/prompts/groups/${group._id}/prompts`)
.send({ prompt: { prompt: 'New legacy prompt text', type: 'text' } })
.expect(200);
expect(response.body.prompt.prompt).toBe('New legacy prompt text');
await expect(Prompt.countDocuments({ groupId: group._id })).resolves.toBe(1);
});
});
describe('Prompt Routes - response and failure compatibility', () => {
let consoleErrorSpy;
let group;
let revision;
beforeEach(async () => {
consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
({ group, prompt: revision } = await createAccessiblePromptGroup({
name: 'Compatibility Group',
prompt: 'Compatibility prompt',
}));
});
afterEach(async () => {
consoleErrorSpy.mockRestore();
jest.restoreAllMocks();
await Prompt.deleteMany({});
await PromptGroup.deleteMany({});
await AclEntry.deleteMany({});
});
it('rejects a group whose initial prompt has no type', async () => {
await request(app)
.post('/api/prompts')
.send({ prompt: { prompt: 'Untyped prompt' }, group: { name: 'Untyped Group' } })
.expect(400, { error: 'Prompt type must be "text" or "chat"' });
await expect(PromptGroup.countDocuments({ name: 'Untyped Group' })).resolves.toBe(0);
});
it('sends 404 from the access check for a malformed ID', async () => {
const notFound = (resourceType) => ({
status: 404,
body: { error: 'Not Found', message: `${resourceType} not found` },
});
expect(await responseOf(request(app).get('/api/prompts/groups/not-an-id'))).toEqual(
notFound(ResourceType.PROMPTGROUP),
);
expect(await responseOf(request(app).get('/api/prompts/not-an-id'))).toEqual(
notFound(ResourceType.PROMPTGROUP),
);
});
it('sends 500 from the access check when the database read fails', async () => {
const accessFailure = {
status: 500,
body: {
error: 'Internal Server Error',
message: 'Failed to check resource access permissions',
},
};
jest.spyOn(PromptGroup, 'aggregate').mockImplementationOnce(() => {
throw new Error('database unavailable');
});
expect(await responseOf(request(app).get(`/api/prompts/groups/${group._id}`))).toEqual(
accessFailure,
);
jest.spyOn(Prompt, 'findOne').mockImplementationOnce(() => {
throw new Error('database unavailable');
});
expect(await responseOf(request(app).get(`/api/prompts/${revision._id}`))).toEqual(
accessFailure,
);
});
it('adds a revision from the editor payload, which includes groupId', async () => {
const response = await request(app)
.post(`/api/prompts/groups/${group._id}/prompts`)
.send({ prompt: { prompt: 'Second revision', type: 'chat', groupId: group._id.toString() } })
.expect(200);
expect(response.body.prompt).toEqual(
expect.objectContaining({
prompt: 'Second revision',
type: 'chat',
groupId: group._id.toString(),
author: testUsers.owner._id.toString(),
}),
);
await expect(Prompt.countDocuments({ groupId: group._id })).resolves.toBe(2);
});
it('sends the legacy 200 message when saving a revision fails', async () => {
jest.spyOn(Prompt, 'create').mockRejectedValueOnce(new Error('database unavailable'));
const response = await request(app)
.post(`/api/prompts/groups/${group._id}/prompts`)
.send({ prompt: { prompt: 'Lost revision', type: 'text' } })
.expect(200);
expect(response.body).toEqual({ message: 'Error saving prompt' });
});
it('returns the group detail with its full Production revision', async () => {
const response = await request(app).get(`/api/prompts/groups/${group._id}`).expect(200);
expect(response.body._id).toBe(group._id.toString());
expect(response.body.productionPrompt).toEqual(
expect.objectContaining({
_id: revision._id.toString(),
prompt: 'Compatibility prompt',
type: 'text',
groupId: group._id.toString(),
}),
);
});
it('returns 404 from the handler when a capability bypass reads a missing group', async () => {
setTestUser(app, testUsers.admin);
const response = await request(app).get(`/api/prompts/groups/${new ObjectId()}`).expect(404);
expect(response.body).toEqual({ message: 'Prompt group not found' });
});
it('returns an empty 200 when a capability bypass reads a missing revision', async () => {
setTestUser(app, testUsers.admin);
const response = await request(app).get(`/api/prompts/${new ObjectId()}`).expect(200);
expect(response.text).toBe('');
});
it('returns revision history newest first with management fields', async () => {
const newer = await Prompt.create({
prompt: 'Newer revision',
author: testUsers.owner._id,
type: 'text',
groupId: group._id,
createdAt: new Date(Date.now() + 1000),
});
const response = await request(app)
.get('/api/prompts')
.query({ groupId: group._id.toString() })
.expect(200);
expect(response.body.map((item) => item._id)).toEqual([
newer._id.toString(),
revision._id.toString(),
]);
expect(response.body[0]).toEqual(
expect.objectContaining({ author: testUsers.owner._id.toString(), type: 'text' }),
);
});
it('keeps the malformed and denied revision-history responses', async () => {
expect(
await responseOf(request(app).get('/api/prompts').query({ groupId: 'not-an-id' })),
).toEqual({ status: 400, body: { error: 'Invalid groupId' } });
setTestUser(app, testUsers.noAccess);
expect(
await responseOf(request(app).get('/api/prompts').query({ groupId: group._id.toString() })),
).toEqual({
status: 403,
body: { error: 'Insufficient permissions to view prompts in this group' },
});
});
it('sends the legacy 200 message when revision history fails', async () => {
jest.spyOn(Prompt, 'find').mockImplementationOnce(() => {
throw new Error('database unavailable');
});
const response = await request(app)
.get('/api/prompts')
.query({ groupId: group._id.toString() })
.expect(200);
expect(response.body).toEqual({ message: 'Error getting prompts' });
});
it('returns the updated group document fields from a metadata update', async () => {
const response = await request(app)
.patch(`/api/prompts/groups/${group._id}`)
.send({ name: 'Renamed Group', command: 'renamed' })
.expect(200);
expect(Object.keys(response.body).sort()).toEqual(
[
'__v',
'_id',
'author',
'authorName',
'category',
'command',
'createdAt',
'name',
'numberOfGenerations',
'oneliner',
'productionId',
'source',
'updatedAt',
].sort(),
);
expect(response.body).toEqual(
expect.objectContaining({ name: 'Renamed Group', command: 'renamed', source: 'native' }),
);
});
it('sends the legacy 200 message when a metadata update fails', async () => {
jest.spyOn(PromptGroup, 'findOneAndUpdate').mockImplementationOnce(() => {
throw new Error('database unavailable');
});
const response = await request(app)
.patch(`/api/prompts/groups/${group._id}`)
.send({ name: 'Renamed Group' })
.expect(200);
expect(response.body).toEqual({ message: 'Error updating prompt group' });
});
it('sends the legacy 200 message when a capability bypass promotes a missing revision', async () => {
setTestUser(app, testUsers.admin);
const response = await request(app)
.patch(`/api/prompts/${new ObjectId()}/tags/production`)
.expect(200);
expect(response.body).toEqual({ message: 'Error making prompt production' });
});
it('does not promote when the preliminary read of a capability bypass fails', async () => {
const candidate = await Prompt.create({
prompt: 'Candidate revision',
author: testUsers.owner._id,
type: 'text',
groupId: group._id,
});
setTestUser(app, testUsers.admin);
jest.spyOn(Prompt, 'findOne').mockImplementationOnce(() => {
throw new Error('database unavailable');
});
const promote = jest.spyOn(PromptGroup, 'findByIdAndUpdate');
await request(app)
.patch(`/api/prompts/${candidate._id}/tags/production`)
.expect(500, { error: 'Error updating prompt production' });
expect(promote).not.toHaveBeenCalled();
const stored = await PromptGroup.findById(group._id).lean();
expect(stored.productionId.toString()).toBe(revision._id.toString());
});
it('requires groupId for revision history, including READ_PROMPTS callers', async () => {
const missingGroupId = { status: 400, body: { error: 'Invalid or missing groupId' } };
expect(await responseOf(request(app).get('/api/prompts'))).toEqual(missingGroupId);
setTestUser(app, testUsers.admin);
expect(await responseOf(request(app).get('/api/prompts'))).toEqual(missingGroupId);
});
it('reuses the records that the access check loaded', async () => {
const readGroup = jest.spyOn(PromptGroup, 'aggregate');
await request(app).get(`/api/prompts/groups/${group._id}`).expect(200);
expect(readGroup).toHaveBeenCalledTimes(1);
const readRevision = jest.spyOn(Prompt, 'findOne');
await request(app).get(`/api/prompts/${revision._id}`).expect(200);
expect(readRevision).toHaveBeenCalledTimes(1);
readRevision.mockClear();
await request(app).patch(`/api/prompts/${revision._id}/tags/production`).expect(200);
// The access check reads once; the mutation's own `findById` is the second call.
expect(readRevision).toHaveBeenCalledTimes(2);
});
it('returns 500 for GET /groups without limit or pageSize', async () => {
expect(await responseOf(request(app).get('/api/prompts/groups'))).toEqual({
status: 500,
body: { error: 'Error getting prompt groups' },
});
});
it('returns the full catalog array from GET /all with the public flag', async () => {
const response = await request(app).get('/api/prompts/all').expect(200);
expect(response.body).toEqual([
expect.objectContaining({
_id: group._id.toString(),
productionPrompt: { _id: revision._id.toString(), prompt: 'Compatibility prompt' },
}),
]);
expect(response.body[0].isPublic).toBeUndefined();
});
it('keeps the Usage responses', async () => {
const recordUsage = () => request(app).post(`/api/prompts/groups/${group._id}/use`);
expect(await responseOf(recordUsage())).toEqual({
status: 200,
body: { numberOfGenerations: 1 },
});
jest.spyOn(PromptGroup, 'findByIdAndUpdate').mockImplementationOnce(() => {
throw new Error('database unavailable');
});
expect(await responseOf(recordUsage())).toEqual({
status: 500,
body: { error: 'Error recording prompt usage' },
});
});
it('keeps the revision and group deletion responses', async () => {
await request(app)
.delete(`/api/prompts/${revision._id}`)
.expect(400, { error: 'Invalid or missing groupId' });
const response = await request(app)
.delete(`/api/prompts/${revision._id}`)
.query({ groupId: group._id.toString() })
.expect(200);
expect(response.body).toEqual({
prompt: 'Prompt deleted successfully',
promptGroup: { message: 'Prompt group deleted successfully', id: group._id.toString() },
});
await expect(PromptGroup.countDocuments({ _id: group._id })).resolves.toBe(0);
});
it('keeps the group deletion response', async () => {
expect(await responseOf(request(app).delete(`/api/prompts/groups/${group._id}`))).toEqual({
status: 200,
body: { message: 'Prompt group deleted successfully' },
});
});
});