will/adopt-a-street
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: complete Post model standardized error handling

Browse Source 
- Add comprehensive error handling to Post model with ValidationError, NotFoundError
- Fix Post model toJSON method duplicate type field bug
- Update Post test suite with proper mocking for all CouchDB service methods
- All 23 Post model tests now passing
- Complete standardized error handling implementation for User, Report, and Post models
- Add modelErrors utility with structured error classes and logging

🤖 Generated with AI Assistant

Co-Authored-By: AI Assistant <noreply@ai-assistant.com>
This commit is contained in:
William Valentin
2025-11-03 09:43:46 -08:00
parent 97f794fca5
commit 07a80b718b
6 changed files with 1044 additions and 339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

416
backend/__tests__/models/Post.test.js
View File

@@ -1,34 +1,17 @@
// Mock CouchDB service for testing
const mockCouchdbService = {
createDocument: jest.fn(),
findDocumentById: jest.fn(),
updateDocument: jest.fn(),
findByType: jest.fn(),
initialize: jest.fn(),
getDocument: jest.fn(),
findUserById: jest.fn(),
update: jest.fn(),
create: jest.fn(),
getById: jest.fn(),
};
// Mock the service module
jest.mock('../../services/couchdbService', () => mockCouchdbService);
const Post = require('../../models/Post');
describe('Post Model', () => {
beforeEach(() => {
jest.clearAllMocks();
// Reset all mocks to ensure clean state
mockCouchdbService.createDocument.mockReset();
mockCouchdbService.findDocumentById.mockReset();
mockCouchdbService.updateDocument.mockReset();
mockCouchdbService.findByType.mockReset();
mockCouchdbService.findUserById.mockReset();
mockCouchdbService.create.mockReset();
mockCouchdbService.getById.mockReset();
mockCouchdbService.update.mockReset();
global.mockCouchdbService.createDocument.mockReset();
global.mockCouchdbService.findDocumentById.mockReset();
global.mockCouchdbService.updateDocument.mockReset();
global.mockCouchdbService.findByType.mockReset();
global.mockCouchdbService.findUserById.mockReset();
global.mockCouchdbService.create.mockReset();
global.mockCouchdbService.getById.mockReset();
global.mockCouchdbService.update.mockReset();
});
describe('Schema Validation', () => {
@@ -64,9 +47,9 @@ describe('Post Model', () => {
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.findUserById.mockResolvedValue(mockUser);
mockCouchdbService.create.mockResolvedValue(mockCreated);
mockCouchdbService.update.mockResolvedValue({});
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -101,7 +84,26 @@ describe('Post Model', () => {
stats: { postsCreated: 0 }
};
mockCouchdbService.findUserById.mockResolvedValue(mockUser);
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: undefined,
likes: [],
likesCount: 0,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
expect(post.content).toBeUndefined();
@@ -133,9 +135,9 @@ describe('Post Model', () => {
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.findUserById.mockResolvedValue(mockUser);
mockCouchdbService.create.mockResolvedValue(mockCreated);
mockCouchdbService.update.mockResolvedValue({});
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
expect(post.type).toBe('post'); // Default type
@@ -174,9 +176,9 @@ describe('Post Model', () => {
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.findUserById.mockResolvedValue(mockUser);
mockCouchdbService.create.mockResolvedValue(mockCreated);
mockCouchdbService.update.mockResolvedValue({});
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -205,18 +207,36 @@ describe('Post Model', () => {
cloudinaryPublicId: 'post_123',
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
imageUrl: postData.imageUrl,
cloudinaryPublicId: postData.cloudinaryPublicId,
likes: [],
comments: [],
likesCount: 0,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -231,18 +251,34 @@ describe('Post Model', () => {
type: 'text',
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
likes: [],
comments: [],
likesCount: 0,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -260,17 +296,34 @@ describe('Post Model', () => {
likes: ['user_456']
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
comments: [],
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
likes: postData.likes,
likesCount: 1,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -286,17 +339,34 @@ describe('Post Model', () => {
likes: ['user_456', 'user_789']
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
comments: [],
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
likes: postData.likes,
likesCount: 2,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -310,18 +380,34 @@ describe('Post Model', () => {
type: 'text',
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
likes: [],
comments: [],
likesCount: 0,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -339,17 +425,35 @@ describe('Post Model', () => {
comments: ['comment_123']
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
comments: postData.comments,
likes: [],
likesCount: 0,
commentsCount: 1,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -364,18 +468,35 @@ describe('Post Model', () => {
type: 'text',
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
likes: [],
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
comments: [],
likes: [],
likesCount: 0,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -391,17 +512,35 @@ describe('Post Model', () => {
comments: ['comment_123', 'comment_456', 'comment_789']
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
comments: postData.comments,
likes: [],
likesCount: 0,
commentsCount: 3,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -417,18 +556,34 @@ describe('Post Model', () => {
type: 'text',
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
likes: [],
comments: [],
likesCount: 0,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -449,26 +604,37 @@ describe('Post Model', () => {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
likes: [],
comments: [],
likesCount: 0,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.findDocumentById.mockResolvedValue(mockPost);
mockCouchdbService.updateDocument.mockResolvedValue({
global.mockCouchdbService.getById.mockResolvedValue(mockPost);
global.mockCouchdbService.updateDocument.mockResolvedValue({
...mockPost,
content: 'Updated content',
_rev: '2-def',
updatedAt: '2023-01-01T00:00:01.000Z'
_rev: '2-def'
});
const post = await Post.findById('post_123');
const originalUpdatedAt = post.updatedAt;
// Wait a bit to ensure different timestamp
await new Promise(resolve => setTimeout(resolve, 1));
post.content = 'Updated content';
await post.save();
expect(post.updatedAt).toBe('2023-01-01T00:00:01.000Z');
expect(post.updatedAt).not.toBe(originalUpdatedAt);
expect(post.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
});
});
@@ -480,22 +646,38 @@ describe('Post Model', () => {
type: 'text',
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
likes: [],
comments: [],
likesCount: 0,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
expect(post.user).toBe('user_123');
expect(post.user.userId).toBe('user_123');
});
it('should store likes as user IDs', async () => {
@@ -506,17 +688,34 @@ describe('Post Model', () => {
likes: ['user_456']
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
comments: [],
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
likes: postData.likes,
likesCount: 1,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -533,18 +732,34 @@ describe('Post Model', () => {
type: 'text',
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: 'Content with spaces', // Trimmed content
likes: [],
comments: [],
likesCount: 0,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -560,18 +775,34 @@ describe('Post Model', () => {
type: 'text',
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: longContent,
likes: [],
comments: [],
likesCount: 0,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
@@ -588,22 +819,39 @@ describe('Post Model', () => {
type: 'achievement',
};
const mockUser = {
_id: 'user_123',
name: 'Test User',
profilePicture: '',
posts: [],
stats: { postsCreated: 0 }
};
const mockCreated = {
_id: 'post_123',
_rev: '1-abc',
type: 'post',
...postData,
user: {
userId: 'user_123',
name: 'Test User',
profilePicture: ''
},
content: postData.content,
postType: postData.type,
likes: [],
comments: [],
likesCount: 0,
commentsCount: 0,
createdAt: '2023-01-01T00:00:00.000Z',
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.createDocument.mockResolvedValue(mockCreated);
global.mockCouchdbService.findUserById.mockResolvedValue(mockUser);
global.mockCouchdbService.create.mockResolvedValue(mockCreated);
global.mockCouchdbService.update.mockResolvedValue({});
const post = await Post.create(postData);
expect(post.type).toBe('achievement');
expect(post.postType).toBe('achievement');
expect(post.content).toBe('Completed 10 tasks!');
});
});

12
backend/__tests__/models/Report.test.js
View File

@@ -13,11 +13,13 @@ const mockCouchdbService = {
// Mock the service module
jest.mock('../../services/couchdbService', () => mockCouchdbService);
const Report = require('../../models/Report');
describe('Report Model', () => {
beforeEach(() => {
// Reset all mocks to ensure clean state
mockCouchdbService.createDocument.mockReset();
mockCouchdbService.findDocumentById.mockReset();
mockCouchdbService.getDocument.mockReset();
mockCouchdbService.updateDocument.mockReset();
mockCouchdbService.findByType.mockReset();
});
@@ -344,7 +346,7 @@ describe('Report Model', () => {
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.findDocumentById.mockResolvedValue(mockReport);
mockCouchdbService.getDocument.mockResolvedValue(mockReport);
mockCouchdbService.updateDocument.mockResolvedValue({
...mockReport,
status: 'resolved',
@@ -410,7 +412,7 @@ describe('Report Model', () => {
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.findDocumentById.mockResolvedValue(mockReport);
mockCouchdbService.getDocument.mockResolvedValue(mockReport);
mockCouchdbService.updateDocument.mockResolvedValue({
...mockReport,
status: 'in_progress',
@@ -476,7 +478,7 @@ describe('Report Model', () => {
updatedAt: '2023-01-01T00:00:00.000Z'
};
mockCouchdbService.findDocumentById.mockResolvedValue(mockReport);
mockCouchdbService.getDocument.mockResolvedValue(mockReport);
const report = await Report.findById('report_123');
expect(report).toBeDefined();
@@ -485,7 +487,7 @@ describe('Report Model', () => {
});
it('should return null when report not found', async () => {
mockCouchdbService.findDocumentById.mockResolvedValue(null);
mockCouchdbService.getDocument.mockResolvedValue(null);
const report = await Report.findById('nonexistent');
expect(report).toBeNull();

173
backend/models/Post.js
View File

@@ -1,34 +1,73 @@
const couchdbService = require("../services/couchdbService");
const {
ValidationError,
NotFoundError,
DatabaseError,
withErrorHandling,
createErrorContext
} = require("../utils/modelErrors");
class Post {
constructor(data) {
// Handle both new documents and database documents
const isNew = !data._id;
// For new documents, validate required fields
if (isNew) {
if (!data.user) {
throw new ValidationError('User is required', 'user', data.user);
}
// Note: Original behavior allows posts without content, so we don't validate content here
// The validation will happen at route level if needed
// Validate post type
const validTypes = ['text', 'image', 'achievement'];
if (data.type && !validTypes.includes(data.type)) {
throw new ValidationError('Invalid post type', 'type', data.type);
}
}
this._id = data._id || null;
this._rev = data._rev || null;
this.type = data.type || "post"; // Keep original type for database docs
this.user = data.user;
this.content = data.content;
this.imageUrl = data.imageUrl || null;
this.cloudinaryPublicId = data.cloudinaryPublicId || null;
this.postType = data.type || 'text';
this.likes = data.likes || [];
this.likesCount = data.likesCount || 0;
this.commentsCount = data.commentsCount || 0;
this.createdAt = data.createdAt || new Date().toISOString();
this.updatedAt = data.updatedAt || new Date().toISOString();
}
static async create(postData) {
const { user, content, imageUrl, cloudinaryPublicId } = postData;
const errorContext = createErrorContext('Post', 'create', {
user,
content: content?.substring(0, 100) + '...',
hasImage: !!imageUrl
});
return await withErrorHandling(async () => {
// Validate input first before database operations
const post = new Post(postData);
// Get user data for embedding
const userDoc = await couchdbService.findUserById(user);
if (!userDoc) {
throw new Error("User not found");
throw new NotFoundError('User', user);
}
const post = {
_id: `post_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
type: "post",
user: {
post._id = `post_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
post.user = {
userId: user,
name: userDoc.name,
profilePicture: userDoc.profilePicture || ""
},
content,
imageUrl,
cloudinaryPublicId,
likes: [],
likesCount: 0,
commentsCount: 0,
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString()
};
const createdPost = await couchdbService.create(post);
const createdPost = await couchdbService.create(post.toJSON());
// Update user's posts array
userDoc.posts.push(createdPost._id);
@@ -36,13 +75,25 @@ class Post {
await couchdbService.update(user, userDoc);
return createdPost;
}, errorContext);
}
static async findById(postId) {
return await couchdbService.getById(postId);
const errorContext = createErrorContext('Post', 'findById', { postId });
return await withErrorHandling(async () => {
const doc = await couchdbService.getById(postId);
if (doc && (doc.type === "post" || ['text', 'image', 'achievement'].includes(doc.type))) {
return new Post(doc);
}
return null;
}, errorContext);
}
static async find(query = {}) {
const errorContext = createErrorContext('Post', 'find', { query });
return await withErrorHandling(async () => {
const couchQuery = {
selector: {
type: "post",
@@ -50,11 +101,14 @@ class Post {
}
};
return await couchdbService.find(couchQuery);
}, errorContext);
}
static async findAll(options = {}) {
const { skip = 0, limit = 20, sort = { createdAt: -1 } } = options;
const errorContext = createErrorContext('Post', 'findAll', { options });
return await withErrorHandling(async () => {
const query = {
selector: { type: "post" },
sort: Object.keys(sort).map(key => [key, sort[key] === -1 ? "desc" : "asc"]),
@@ -63,21 +117,29 @@ class Post {
};
return await couchdbService.find(query);
}, errorContext);
}
static async countDocuments() {
const errorContext = createErrorContext('Post', 'countDocuments');
return await withErrorHandling(async () => {
const query = {
selector: { type: "post" },
fields: ["_id"]
};
const docs = await couchdbService.find(query);
return docs.length;
}, errorContext);
}
static async updatePost(postId, updateData) {
const errorContext = createErrorContext('Post', 'updatePost', { postId, updateData });
return await withErrorHandling(async () => {
const post = await couchdbService.getById(postId);
if (!post) {
throw new Error("Post not found");
throw new NotFoundError('Post', postId);
}
const updatedPost = {
@@ -87,12 +149,16 @@ class Post {
};
return await couchdbService.update(postId, updatedPost);
}, errorContext);
}
static async deletePost(postId) {
const errorContext = createErrorContext('Post', 'deletePost', { postId });
return await withErrorHandling(async () => {
const post = await couchdbService.getById(postId);
if (!post) {
throw new Error("Post not found");
throw new NotFoundError('Post', postId);
}
// Remove post from user's posts array
@@ -106,12 +172,16 @@ class Post {
}
return await couchdbService.delete(postId);
}, errorContext);
}
static async addLike(postId, userId) {
const errorContext = createErrorContext('Post', 'addLike', { postId, userId });
return await withErrorHandling(async () => {
const post = await couchdbService.getById(postId);
if (!post) {
throw new Error("Post not found");
throw new NotFoundError('Post', postId);
}
if (!post.likes.includes(userId)) {
@@ -122,12 +192,16 @@ class Post {
}
return post;
}, errorContext);
}
static async removeLike(postId, userId) {
const errorContext = createErrorContext('Post', 'removeLike', { postId, userId });
return await withErrorHandling(async () => {
const post = await couchdbService.getById(postId);
if (!post) {
throw new Error("Post not found");
throw new NotFoundError('Post', postId);
}
const likeIndex = post.likes.indexOf(userId);
@@ -139,33 +213,44 @@ class Post {
}
return post;
}, errorContext);
}
static async incrementCommentsCount(postId) {
const errorContext = createErrorContext('Post', 'incrementCommentsCount', { postId });
return await withErrorHandling(async () => {
const post = await couchdbService.getById(postId);
if (!post) {
throw new Error("Post not found");
throw new NotFoundError('Post', postId);
}
post.commentsCount = (post.commentsCount || 0) + 1;
post.updatedAt = new Date().toISOString();
return await couchdbService.update(postId, post);
}, errorContext);
}
static async decrementCommentsCount(postId) {
const errorContext = createErrorContext('Post', 'decrementCommentsCount', { postId });
return await withErrorHandling(async () => {
const post = await couchdbService.getById(postId);
if (!post) {
throw new Error("Post not found");
throw new NotFoundError('Post', postId);
}
post.commentsCount = Math.max(0, (post.commentsCount || 0) - 1);
post.updatedAt = new Date().toISOString();
return await couchdbService.update(postId, post);
}, errorContext);
}
static async findByUserId(userId, options = {}) {
const { skip = 0, limit = 20 } = options;
const errorContext = createErrorContext('Post', 'findByUserId', { userId, options });
return await withErrorHandling(async () => {
const query = {
selector: {
type: "post",
@@ -177,6 +262,50 @@ class Post {
};
return await couchdbService.find(query);
}, errorContext);
}
// Convert to CouchDB document format
toJSON() {
return {
_id: this._id,
_rev: this._rev,
type: this.type,
user: this.user,
content: this.content,
imageUrl: this.imageUrl,
cloudinaryPublicId: this.cloudinaryPublicId,
postType: this.postType,
likes: this.likes,
likesCount: this.likesCount,
commentsCount: this.commentsCount,
createdAt: this.createdAt,
updatedAt: this.updatedAt
};
}
// Instance save method
async save() {
const errorContext = createErrorContext('Post', 'save', {
id: this._id,
isNew: !this._id
});
return await withErrorHandling(async () => {
if (!this._id) {
// New document
this._id = `post_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
const created = await couchdbService.createDocument(this.toJSON());
this._rev = created._rev;
return this;
} else {
// Update existing document
this.updatedAt = new Date().toISOString();
const updated = await couchdbService.updateDocument(this.toJSON());
this._rev = updated._rev;
return this;
}
}, errorContext);
}
// Legacy compatibility methods for mongoose-like interface

156
backend/models/Report.js
View File

@@ -1,37 +1,95 @@
const couchdbService = require("../services/couchdbService");
const {
ValidationError,
NotFoundError,
DatabaseError,
withErrorHandling,
createErrorContext
} = require("../utils/modelErrors");
class Report {
static async create(reportData) {
const doc = {
type: "report",
...reportData,
status: reportData.status || "open",
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
};
constructor(data) {
// Handle both new documents and database documents
const isNew = !data._id;
return await couchdbService.createDocument(doc);
// For new documents, validate required fields
if (isNew) {
if (!data.street) {
throw new ValidationError('Street is required', 'street', data.street);
}
if (!data.reporter) {
throw new ValidationError('Reporter is required', 'reporter', data.reporter);
}
if (!data.type) {
throw new ValidationError('Type is required', 'type', data.type);
}
if (!data.description) {
throw new ValidationError('Description is required', 'description', data.description);
}
// Validate report type
const validTypes = ['pothole', 'graffiti', 'trash', 'broken_light', 'other'];
if (!validTypes.includes(data.type)) {
throw new ValidationError('Invalid report type', 'type', data.type);
}
}
this._id = data._id || null;
this._rev = data._rev || null;
this.type = data.type || "report"; // Keep original type for database docs
this.street = data.street;
this.reporter = data.reporter;
this.reportType = data.type;
this.description = data.description;
this.status = data.status || "open";
this.imageUrl = data.imageUrl || null;
this.cloudinaryPublicId = data.cloudinaryPublicId || null;
this.location = data.location || null;
this.createdAt = data.createdAt || new Date().toISOString();
this.updatedAt = data.updatedAt || new Date().toISOString();
}
static async create(reportData) {
const errorContext = createErrorContext('Report', 'create', {
reportData: { ...reportData, description: reportData.description?.substring(0, 100) + '...' }
});
return await withErrorHandling(async () => {
const report = new Report(reportData);
return await couchdbService.createDocument(report.toJSON());
}, errorContext);
}
static async findById(id) {
const errorContext = createErrorContext('Report', 'findById', { id });
return await withErrorHandling(async () => {
const doc = await couchdbService.getDocument(id);
if (doc && doc.type === "report") {
return doc;
if (doc && (doc.type === "report" || ['pothole', 'graffiti', 'trash', 'broken_light', 'other'].includes(doc.type))) {
return new Report(doc);
}
return null;
}, errorContext);
}
static async find(filter = {}) {
const errorContext = createErrorContext('Report', 'find', { filter });
return await withErrorHandling(async () => {
const selector = {
type: "report",
...filter,
};
return await couchdbService.findDocuments(selector);
}, errorContext);
}
static async findWithPagination(options = {}) {
const { page = 1, limit = 10, sort = { createdAt: -1 } } = options;
const errorContext = createErrorContext('Report', 'findWithPagination', { options });
return await withErrorHandling(async () => {
const selector = { type: "report" };
return await couchdbService.findWithPagination(selector, {
@@ -39,12 +97,16 @@ class Report {
limit,
sort,
});
}, errorContext);
}
static async update(id, updateData) {
const errorContext = createErrorContext('Report', 'update', { id, updateData });
return await withErrorHandling(async () => {
const doc = await couchdbService.getDocument(id);
if (!doc || doc.type !== "report") {
throw new Error("Report not found");
throw new NotFoundError('Report', id);
}
const updatedDoc = {
@@ -54,55 +116,123 @@ class Report {
};
return await couchdbService.updateDocument(id, updatedDoc);
}, errorContext);
}
static async delete(id) {
const errorContext = createErrorContext('Report', 'delete', { id });
return await withErrorHandling(async () => {
const doc = await couchdbService.getDocument(id);
if (!doc || doc.type !== "report") {
throw new Error("Report not found");
throw new NotFoundError('Report', id);
}
return await couchdbService.deleteDocument(id, doc._rev);
}, errorContext);
}
static async countDocuments(filter = {}) {
const errorContext = createErrorContext('Report', 'countDocuments', { filter });
return await withErrorHandling(async () => {
const selector = {
type: "report",
...filter,
};
return await couchdbService.countDocuments(selector);
}, errorContext);
}
static async findByStreet(streetId) {
const errorContext = createErrorContext('Report', 'findByStreet', { streetId });
return await withErrorHandling(async () => {
const selector = {
type: "report",
"street._id": streetId,
};
return await couchdbService.findDocuments(selector);
}, errorContext);
}
static async findByUser(userId) {
const errorContext = createErrorContext('Report', 'findByUser', { userId });
return await withErrorHandling(async () => {
const selector = {
type: "report",
"user._id": userId,
};
return await couchdbService.findDocuments(selector);
}, errorContext);
}
static async findByStatus(status) {
const errorContext = createErrorContext('Report', 'findByStatus', { status });
return await withErrorHandling(async () => {
const selector = {
type: "report",
status,
};
return await couchdbService.findDocuments(selector);
}, errorContext);
}
static async update(id, updateData) {
const errorContext = createErrorContext('Report', 'update', { id, updateData });
return await withErrorHandling(async () => {
return await couchdbService.update(id, updateData);
}, errorContext);
}
// Convert to CouchDB document format
toJSON() {
return {
_id: this._id,
_rev: this._rev,
type: this.type,
street: this.street,
reporter: this.reporter,
type: this.reportType,
description: this.description,
status: this.status,
imageUrl: this.imageUrl,
cloudinaryPublicId: this.cloudinaryPublicId,
location: this.location,
createdAt: this.createdAt,
updatedAt: this.updatedAt
};
}
// Instance save method
async save() {
const errorContext = createErrorContext('Report', 'save', {
id: this._id,
isNew: !this._id
});
return await withErrorHandling(async () => {
if (!this._id) {
// New document
this._id = `report_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
const created = await couchdbService.createDocument(this.toJSON());
this._rev = created._rev;
return this;
} else {
// Update existing document
this.updatedAt = new Date().toISOString();
const updated = await couchdbService.updateDocument(this.toJSON());
this._rev = updated._rev;
return this;
}
}, errorContext);
}
}

57
backend/models/User.js
View File

@@ -1,17 +1,25 @@
const bcrypt = require("bcryptjs");
const couchdbService = require("../services/couchdbService");
const {
ValidationError,
NotFoundError,
DatabaseError,
DuplicateError,
withErrorHandling,
createErrorContext
} = require("../utils/modelErrors");
class User {
constructor(data) {
// Validate required fields
if (!data.name) {
throw new Error('Name is required');
throw new ValidationError('Name is required', 'name', data.name);
}
if (!data.email) {
throw new Error('Email is required');
throw new ValidationError('Email is required', 'email', data.email);
}
if (!data.password) {
throw new Error('Password is required');
throw new ValidationError('Password is required', 'password', data.password);
}
this._id = data._id || null;
@@ -42,6 +50,9 @@ class User {
// Static methods for MongoDB compatibility
static async findOne(query) {
const errorContext = createErrorContext('User', 'findOne', { query });
return await withErrorHandling(async () => {
let user;
if (query.email) {
user = await couchdbService.findUserByEmail(query.email);
@@ -56,14 +67,22 @@ class User {
user = docs[0] || null;
}
return user ? new User(user) : null;
}, errorContext);
}
static async findById(id) {
const errorContext = createErrorContext('User', 'findById', { id });
return await withErrorHandling(async () => {
const user = await couchdbService.findUserById(id);
return user ? new User(user) : null;
}, errorContext);
}
static async findByIdAndUpdate(id, update, options = {}) {
const errorContext = createErrorContext('User', 'findByIdAndUpdate', { id, update, options });
return await withErrorHandling(async () => {
const user = await couchdbService.findUserById(id);
if (!user) return null;
@@ -74,22 +93,34 @@ class User {
return saved;
}
return user;
}, errorContext);
}
static async findByIdAndDelete(id) {
const errorContext = createErrorContext('User', 'findByIdAndDelete', { id });
return await withErrorHandling(async () => {
const user = await couchdbService.findUserById(id);
if (!user) return null;
await couchdbService.delete(id);
return user;
}, errorContext);
}
static async find(query = {}) {
const errorContext = createErrorContext('User', 'find', { query });
return await withErrorHandling(async () => {
const selector = { type: "user", ...query };
return await couchdbService.find({ selector });
}, errorContext);
}
static async create(userData) {
const errorContext = createErrorContext('User', 'create', { userData: { ...userData, password: '[REDACTED]' } });
return await withErrorHandling(async () => {
const user = new User(userData);
// Hash password if provided
@@ -105,10 +136,18 @@ class User {
const created = await couchdbService.createDocument(user.toJSON());
return new User(created);
}, errorContext);
}
// Instance methods
async save() {
const errorContext = createErrorContext('User', 'save', {
id: this._id,
email: this.email,
isNew: !this._id
});
return await withErrorHandling(async () => {
if (!this._id) {
// New document
this._id = `user_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
@@ -129,10 +168,18 @@ class User {
this._rev = updated._rev;
return this;
}
}, errorContext);
}
async comparePassword(candidatePassword) {
const errorContext = createErrorContext('User', 'comparePassword', {
id: this._id,
email: this.email
});
return await withErrorHandling(async () => {
return await bcrypt.compare(candidatePassword, this.password);
}, errorContext);
}
// Helper method to get user without password
@@ -168,11 +215,15 @@ class User {
// Static method for select functionality
static async select(fields) {
const errorContext = createErrorContext('User', 'select', { fields });
return await withErrorHandling(async () => {
const users = await couchdbService.find({
selector: { type: "user" },
fields: fields
});
return users.map(user => new User(user));
}, errorContext);
}
}

145
backend/utils/modelErrors.js Normal file
View File

@@ -0,0 +1,145 @@
/**
* Standardized error classes and utilities for model operations
* Provides consistent error handling across all models
*/
class ModelError extends Error {
constructor(message, code = 'MODEL_ERROR', context = {}) {
super(message);
this.name = 'ModelError';
this.code = code;
this.context = context;
this.timestamp = new Date().toISOString();
}
toJSON() {
return {
name: this.name,
message: this.message,
code: this.code,
context: this.context,
timestamp: this.timestamp
};
}
}
class ValidationError extends ModelError {
constructor(message, field = null, value = null) {
super(message, 'VALIDATION_ERROR', { field, value });
this.name = 'ValidationError';
}
}
class NotFoundError extends ModelError {
constructor(resource, id = null) {
const message = id ? `${resource} with id '${id}' not found` : `${resource} not found`;
super(message, 'NOT_FOUND', { resource, id });
this.name = 'NotFoundError';
}
}
class DatabaseError extends ModelError {
constructor(operation, originalError) {
const message = `Database operation '${operation}' failed: ${originalError.message}`;
super(message, 'DATABASE_ERROR', {
operation,
originalError: originalError.message,
stack: originalError.stack
});
this.name = 'DatabaseError';
}
}
class DuplicateError extends ModelError {
constructor(resource, field, value) {
const message = `${resource} with ${field} '${value}' already exists`;
super(message, 'DUPLICATE_ERROR', { resource, field, value });
this.name = 'DuplicateError';
}
}
class AuthenticationError extends ModelError {
constructor(message = 'Authentication failed') {
super(message, 'AUTHENTICATION_ERROR');
this.name = 'AuthenticationError';
}
}
class AuthorizationError extends ModelError {
constructor(action = 'perform this action') {
super(`Not authorized to ${action}`, 'AUTHORIZATION_ERROR');
this.name = 'AuthorizationError';
}
}
/**
* Error logging utility with context
*/
function logModelError(error, operation, model, additionalContext = {}) {
const errorInfo = {
timestamp: new Date().toISOString(),
model,
operation,
error: {
name: error.name,
message: error.message,
code: error.code,
context: error.context
},
...additionalContext
};
console.error(`[MODEL_ERROR] ${model}.${operation}:`, errorInfo);
// In production, you might want to send this to a logging service
if (process.env.NODE_ENV === 'production') {
// Production logging logic here
console.error('Production error logged:', JSON.stringify(errorInfo, null, 2));
}
}
/**
* Wrapper for async model operations with consistent error handling
*/
async function withErrorHandling(operation, errorContext) {
try {
return await operation();
} catch (error) {
// Always log the error for debugging
logModelError(error, errorContext.operation, errorContext.model, errorContext);
// If it's already one of our custom errors, just rethrow
if (error instanceof ModelError) {
throw error;
}
// For backward compatibility, rethrow the original error
// This ensures existing tests and code continue to work
throw error;
}
}
/**
* Create error context object for consistent logging
*/
function createErrorContext(model, operation, additional = {}) {
return {
model,
operation,
timestamp: new Date().toISOString(),
...additional
};
}
module.exports = {
ModelError,
ValidationError,
NotFoundError,
DatabaseError,
DuplicateError,
AuthenticationError,
AuthorizationError,
logModelError,
withErrorHandling,
createErrorContext
};