@nextsparkjs/theme-default 0.1.0-beta.22 → 0.1.0-beta.24

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 NextSpark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextsparkjs/theme-default",
-  "version": "0.1.0-beta.22",
+  "version": "0.1.0-beta.24",
   "private": false,
   "type": "module",
   "main": "./config/theme.config.ts",
@@ -9,7 +9,7 @@
   ],
   "dependencies": {},
   "peerDependencies": {
-    "@nextsparkjs/core": "workspace:*",
+    "@nextsparkjs/core": "0.1.0-beta.24",
     "@tanstack/react-query": "^5.0.0",
     "lucide-react": "^0.539.0",
     "next": "^15.0.0",
@@ -23,4 +23,4 @@
     "type": "theme",
     "name": "default"
   }
-}
+}

package/tests/jest/__mocks__/jose.js

@@ -0,0 +1,22 @@
+/**
+ * Mock for jose package
+ * Resolves ES module import issues in Jest tests
+ */
+
+module.exports = {
+  jwtVerify: jest.fn(),
+  SignJWT: jest.fn().mockImplementation(() => ({
+    setProtectedHeader: jest.fn().mockReturnThis(),
+    setIssuedAt: jest.fn().mockReturnThis(),
+    setExpirationTime: jest.fn().mockReturnThis(),
+    sign: jest.fn().mockResolvedValue('mock-jwt-token')
+  })),
+  importJWK: jest.fn(),
+  generateSecret: jest.fn(),
+  createRemoteJWKSet: jest.fn(),
+  errors: {
+    JWTExpired: class JWTExpired extends Error {},
+    JWTInvalid: class JWTInvalid extends Error {},
+    JWTClaimValidationFailed: class JWTClaimValidationFailed extends Error {}
+  }
+}

package/tests/jest/__mocks__/next-server.js

@@ -0,0 +1,56 @@
+/**
+ * Mock for next/server
+ * Provides NextRequest and NextResponse mocks for API testing
+ */
+
+class MockNextRequest {
+  constructor(url, options = {}) {
+    this.url = url
+    this.method = options.method || 'GET'
+    this.headers = new Map(Object.entries(options.headers || {}))
+    this._body = options.body
+  }
+
+  async json() {
+    if (!this._body) return {}
+    try {
+      return typeof this._body === 'string' ? JSON.parse(this._body) : this._body
+    } catch {
+      throw new SyntaxError('Invalid JSON')
+    }
+  }
+
+  async text() {
+    return this._body || ''
+  }
+}
+
+class MockNextResponse {
+  constructor(body, options = {}) {
+    this.body = body
+    this.status = options.status || 200
+    this.statusText = options.statusText || 'OK'
+    this.headers = new Map(Object.entries(options.headers || {}))
+  }
+
+  async json() {
+    if (!this.body) return {}
+    try {
+      return typeof this.body === 'string' ? JSON.parse(this.body) : this.body
+    } catch {
+      throw new SyntaxError('Invalid JSON')
+    }
+  }
+
+  static json(data, options = {}) {
+    return new MockNextResponse(data, {
+      ...options,
+      headers: { 'Content-Type': 'application/json', ...options.headers }
+    })
+  }
+}
+
+module.exports = {
+  NextRequest: MockNextRequest,
+  NextResponse: MockNextResponse
+}

package/tests/jest/jest.config.cjs

@@ -0,0 +1,127 @@
+/**
+ * Jest Configuration for Default Theme
+ *
+ * This config works in both monorepo and npm mode.
+ * Run with: pnpm test:theme
+ */
+
+const path = require('path')
+const fs = require('fs')
+
+// Paths relative to this config file
+const themeTestsRoot = __dirname
+const themeRoot = path.resolve(__dirname, '../..')
+
+// In monorepo: themes/default/tests/jest -> apps/dev (via symlink in contents/)
+// In npm mode: contents/themes/default/tests/jest -> project root (5 levels up)
+const monorepoRepoRoot = path.resolve(__dirname, '../../../..')
+const npmModeRoot = path.resolve(__dirname, '../../../../..')
+
+// Detect if running in npm mode (no packages/core folder) vs monorepo
+const isNpmMode = !fs.existsSync(path.join(monorepoRepoRoot, 'packages/core'))
+
+// In monorepo, use apps/dev as rootDir since contents/ symlinks to themes/
+const monorepoAppRoot = path.join(monorepoRepoRoot, 'apps/dev')
+const projectRoot = isNpmMode ? npmModeRoot : monorepoAppRoot
+
+// Module name mapper based on mode
+const moduleNameMapper = isNpmMode
+  ? {
+      // NPM mode: resolve from node_modules
+      '^@nextsparkjs/core/(.*)$': '@nextsparkjs/core/$1',
+      '^@nextsparkjs/core$': '@nextsparkjs/core',
+      '^@/contents/(.*)$': '<rootDir>/contents/$1',
+      '^@/entities/(.*)$': '<rootDir>/contents/entities/$1',
+      '^@/plugins/(.*)$': '<rootDir>/contents/plugins/$1',
+      '^@/themes/(.*)$': '<rootDir>/contents/themes/$1',
+      '^@/(.*)$': '<rootDir>/$1',
+      // Mocks from theme-local folder
+      'next/server': path.join(themeTestsRoot, '__mocks__/next-server.js'),
+      '^jose$': path.join(themeTestsRoot, '__mocks__/jose.js'),
+      '^jose/(.*)$': path.join(themeTestsRoot, '__mocks__/jose.js'),
+    }
+  : {
+      // Monorepo mode: resolve from packages/core/src (rootDir is apps/dev)
+      '^@nextsparkjs/core/(.*)$': '<rootDir>/../../packages/core/src/$1',
+      '^@nextsparkjs/core$': '<rootDir>/../../packages/core/src',
+      '^@/contents/(.*)$': '<rootDir>/contents/$1',
+      '^@/entities/(.*)$': '<rootDir>/contents/entities/$1',
+      '^@/plugins/(.*)$': '<rootDir>/contents/plugins/$1',
+      '^@/themes/(.*)$': '<rootDir>/contents/themes/$1',
+      '^@/(.*)$': '<rootDir>/$1',
+      // Mocks from core
+      'next/server': '<rootDir>/../../packages/core/tests/jest/__mocks__/next-server.js',
+      '^jose$': '<rootDir>/../../packages/core/tests/jest/__mocks__/jose.js',
+      '^jose/(.*)$': '<rootDir>/../../packages/core/tests/jest/__mocks__/jose.js',
+    }
+
+// Setup files based on mode
+const setupFilesAfterEnv = isNpmMode
+  ? [
+      // NPM mode: use theme's local setup only (it includes everything needed)
+      path.join(themeTestsRoot, 'setup.ts'),
+    ]
+  : [
+      // Monorepo mode: use local core setup (rootDir is apps/dev)
+      '<rootDir>/../../packages/core/tests/jest/setup.ts',
+    ]
+
+/** @type {import('jest').Config} */
+module.exports = {
+  displayName: 'theme-default',
+  rootDir: projectRoot,
+
+  // Use roots to explicitly set test location (handles symlinks better)
+  roots: [themeTestsRoot],
+
+  // Test file patterns
+  testMatch: [
+    '**/*.{test,spec}.{js,ts,tsx}',
+  ],
+  testPathIgnorePatterns: [
+    '<rootDir>/node_modules/',
+    '<rootDir>/.next/',
+  ],
+
+  // Preset and environment
+  preset: 'ts-jest',
+  testEnvironment: 'jsdom',
+
+  // Module resolution
+  moduleNameMapper,
+
+  // Setup files
+  setupFilesAfterEnv,
+
+  // Transform configuration
+  transform: {
+    '^.+\\.(ts|tsx)$': ['ts-jest', {
+      tsconfig: path.join(projectRoot, 'tsconfig.json'),
+    }],
+  },
+
+  // Transform ignore patterns - allow TypeScript from core's jest-setup
+  transformIgnorePatterns: [
+    'node_modules/(?!(uncrypto|better-auth|@noble|.*jose.*|remark.*|unified.*|@nextsparkjs/core/tests|.*\\.mjs$))',
+    'node_modules/\\.pnpm/(?!(.*uncrypto.*|.*better-auth.*|.*@noble.*|.*jose.*|.*remark.*|.*unified.*|@nextsparkjs.*core.*tests|.*\\.mjs$))',
+  ],
+
+  // File extensions
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json'],
+
+  // Test timeout
+  testTimeout: 10000,
+
+  // Verbose output
+  verbose: true,
+
+  // Force exit after tests complete
+  forceExit: true,
+
+  // Disable watchman for symlink support
+  watchman: false,
+
+  // Coverage output directory
+  coverageDirectory: path.join(themeTestsRoot, 'coverage'),
+  coverageReporters: ['text', 'lcov', 'html'],
+}

package/tests/jest/services/tasks.service.test.ts

@@ -0,0 +1,707 @@
+/**
+ * Unit Tests - TasksService
+ *
+ * Tests for the TasksService class methods:
+ * - Input validation (required fields, empty strings)
+ * - Data transformation (database null → undefined)
+ * - Default values for optional fields
+ * - Error handling
+ *
+ * Focus on business logic WITHOUT actual database calls.
+ * Database functions are mocked to isolate the service logic.
+ */
+
+// Mock the database module before importing the service
+jest.mock('@nextsparkjs/core/lib/db', () => ({
+  queryOneWithRLS: jest.fn(),
+  queryWithRLS: jest.fn(),
+}))
+
+import { TasksService } from '@/themes/default/entities/tasks/tasks.service'
+import type { Task, TaskStatus, TaskPriority } from '@/themes/default/entities/tasks/tasks.types'
+
+// Get the mocked functions
+const mockQueryOneWithRLS = jest.requireMock('@nextsparkjs/core/lib/db').queryOneWithRLS
+const mockQueryWithRLS = jest.requireMock('@nextsparkjs/core/lib/db').queryWithRLS
+
+// Helper to create a mock database task row
+const createMockDbTask = (overrides = {}) => ({
+  id: 'task-123',
+  title: 'Test Task',
+  description: 'Test description',
+  status: 'todo' as TaskStatus,
+  priority: 'medium' as TaskPriority,
+  tags: ['tag1', 'tag2'],
+  dueDate: '2025-12-31',
+  estimatedHours: 5,
+  completed: false,
+  createdAt: '2025-01-01T00:00:00Z',
+  updatedAt: '2025-01-01T00:00:00Z',
+  ...overrides,
+})
+
+describe('TasksService', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  // ============================================================
+  // getById
+  // ============================================================
+  describe('getById', () => {
+    describe('Input Validation', () => {
+      it('should throw error when id is empty', async () => {
+        await expect(TasksService.getById('', 'user-123'))
+          .rejects.toThrow('Task ID is required')
+      })
+
+      it('should throw error when id is whitespace only', async () => {
+        await expect(TasksService.getById('   ', 'user-123'))
+          .rejects.toThrow('Task ID is required')
+      })
+
+      it('should throw error when userId is empty', async () => {
+        await expect(TasksService.getById('task-123', ''))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+
+      it('should throw error when userId is whitespace only', async () => {
+        await expect(TasksService.getById('task-123', '   '))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+    })
+
+    describe('Successful Retrieval', () => {
+      it('should return task when found', async () => {
+        const mockTask = createMockDbTask()
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result).not.toBeNull()
+        expect(result?.id).toBe('task-123')
+        expect(result?.title).toBe('Test Task')
+        expect(mockQueryOneWithRLS).toHaveBeenCalledWith(
+          expect.stringContaining('SELECT'),
+          ['task-123'],
+          'user-123'
+        )
+      })
+
+      it('should return null when task not found', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(null)
+
+        const result = await TasksService.getById('non-existent', 'user-123')
+
+        expect(result).toBeNull()
+      })
+    })
+
+    describe('Data Transformation', () => {
+      it('should transform null description to undefined', async () => {
+        const mockTask = createMockDbTask({ description: null })
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.description).toBeUndefined()
+      })
+
+      it('should transform null tags to undefined', async () => {
+        const mockTask = createMockDbTask({ tags: null })
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.tags).toBeUndefined()
+      })
+
+      it('should transform null dueDate to undefined', async () => {
+        const mockTask = createMockDbTask({ dueDate: null })
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.dueDate).toBeUndefined()
+      })
+
+      it('should transform null estimatedHours to undefined', async () => {
+        const mockTask = createMockDbTask({ estimatedHours: null })
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.estimatedHours).toBeUndefined()
+      })
+
+      it('should transform null completed to undefined', async () => {
+        const mockTask = createMockDbTask({ completed: null })
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.completed).toBeUndefined()
+      })
+
+      it('should preserve non-null values', async () => {
+        const mockTask = createMockDbTask()
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.getById('task-123', 'user-123')
+
+        expect(result?.description).toBe('Test description')
+        expect(result?.tags).toEqual(['tag1', 'tag2'])
+        expect(result?.dueDate).toBe('2025-12-31')
+        expect(result?.estimatedHours).toBe(5)
+        expect(result?.completed).toBe(false)
+      })
+    })
+
+    describe('Error Handling', () => {
+      it('should wrap database errors with descriptive message', async () => {
+        mockQueryOneWithRLS.mockRejectedValue(new Error('Database connection failed'))
+
+        await expect(TasksService.getById('task-123', 'user-123'))
+          .rejects.toThrow('Database connection failed')
+      })
+    })
+  })
+
+  // ============================================================
+  // list
+  // ============================================================
+  describe('list', () => {
+    describe('Input Validation', () => {
+      it('should throw error when userId is empty', async () => {
+        await expect(TasksService.list(''))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+
+      it('should throw error when userId is whitespace only', async () => {
+        await expect(TasksService.list('   '))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+    })
+
+    describe('Default Options', () => {
+      it('should use default limit of 10', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }]) // count query
+          .mockResolvedValueOnce([]) // data query
+
+        await TasksService.list('user-123')
+
+        // Second call is the data query with LIMIT
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[0]).toContain('LIMIT')
+        expect(dataQueryCall[1]).toContain(10) // default limit
+      })
+
+      it('should use default offset of 0', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123')
+
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[1]).toContain(0) // default offset
+      })
+
+      it('should use default orderBy createdAt DESC', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123')
+
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[0]).toContain('"createdAt"')
+        expect(dataQueryCall[0]).toContain('DESC')
+      })
+    })
+
+    describe('Filtering', () => {
+      it('should filter by status when provided', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '2' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { status: 'todo' })
+
+        const countQueryCall = mockQueryWithRLS.mock.calls[0]
+        expect(countQueryCall[0]).toContain('status = $1')
+        expect(countQueryCall[1]).toContain('todo')
+      })
+
+      it('should filter by priority when provided', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '2' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { priority: 'high' })
+
+        const countQueryCall = mockQueryWithRLS.mock.calls[0]
+        expect(countQueryCall[0]).toContain('priority = $1')
+        expect(countQueryCall[1]).toContain('high')
+      })
+
+      it('should filter by teamId when provided', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '2' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { teamId: 'team-456' })
+
+        const countQueryCall = mockQueryWithRLS.mock.calls[0]
+        expect(countQueryCall[0]).toContain('"teamId" = $1')
+        expect(countQueryCall[1]).toContain('team-456')
+      })
+
+      it('should combine multiple filters with AND', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '1' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { status: 'todo', priority: 'high' })
+
+        const countQueryCall = mockQueryWithRLS.mock.calls[0]
+        expect(countQueryCall[0]).toContain('status = $1')
+        expect(countQueryCall[0]).toContain('priority = $2')
+        expect(countQueryCall[0]).toContain('AND')
+      })
+    })
+
+    describe('Ordering', () => {
+      const validOrderByFields = ['title', 'status', 'priority', 'dueDate', 'createdAt']
+
+      validOrderByFields.forEach(field => {
+        it(`should order by ${field} when specified`, async () => {
+          mockQueryWithRLS
+            .mockResolvedValueOnce([{ count: '5' }])
+            .mockResolvedValueOnce([])
+
+          await TasksService.list('user-123', { orderBy: field as any })
+
+          const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+          // dueDate and createdAt need quotes in SQL
+          const expectedColumn = ['dueDate', 'createdAt'].includes(field)
+            ? `"${field}"`
+            : field
+          expect(dataQueryCall[0]).toContain(expectedColumn)
+        })
+      })
+
+      it('should fallback to createdAt for invalid orderBy', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { orderBy: 'invalidField' as any })
+
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[0]).toContain('"createdAt"')
+      })
+
+      it('should order ASC when orderDir is asc', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { orderDir: 'asc' })
+
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[0]).toContain('ASC')
+      })
+
+      it('should order DESC when orderDir is desc', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '5' }])
+          .mockResolvedValueOnce([])
+
+        await TasksService.list('user-123', { orderDir: 'desc' })
+
+        const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+        expect(dataQueryCall[0]).toContain('DESC')
+      })
+    })
+
+    describe('Result Structure', () => {
+      it('should return tasks array and total count', async () => {
+        const mockTasks = [createMockDbTask(), createMockDbTask({ id: 'task-456' })]
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '10' }])
+          .mockResolvedValueOnce(mockTasks)
+
+        const result = await TasksService.list('user-123')
+
+        expect(result.tasks).toHaveLength(2)
+        expect(result.total).toBe(10)
+      })
+
+      it('should transform database rows to Task type', async () => {
+        const mockTask = createMockDbTask({ description: null, tags: null })
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '1' }])
+          .mockResolvedValueOnce([mockTask])
+
+        const result = await TasksService.list('user-123')
+
+        expect(result.tasks[0].description).toBeUndefined()
+        expect(result.tasks[0].tags).toBeUndefined()
+      })
+
+      it('should return empty array when no tasks found', async () => {
+        mockQueryWithRLS
+          .mockResolvedValueOnce([{ count: '0' }])
+          .mockResolvedValueOnce([])
+
+        const result = await TasksService.list('user-123')
+
+        expect(result.tasks).toEqual([])
+        expect(result.total).toBe(0)
+      })
+    })
+  })
+
+  // ============================================================
+  // getByStatus
+  // ============================================================
+  describe('getByStatus', () => {
+    it('should call list with status filter', async () => {
+      mockQueryWithRLS
+        .mockResolvedValueOnce([{ count: '2' }])
+        .mockResolvedValueOnce([createMockDbTask(), createMockDbTask({ id: 'task-456' })])
+
+      const result = await TasksService.getByStatus('user-123', 'in-progress')
+
+      expect(result).toHaveLength(2)
+      const countQueryCall = mockQueryWithRLS.mock.calls[0]
+      expect(countQueryCall[1]).toContain('in-progress')
+    })
+
+    it('should order by priority DESC', async () => {
+      mockQueryWithRLS
+        .mockResolvedValueOnce([{ count: '1' }])
+        .mockResolvedValueOnce([createMockDbTask()])
+
+      await TasksService.getByStatus('user-123', 'todo')
+
+      const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+      expect(dataQueryCall[0]).toContain('priority')
+      expect(dataQueryCall[0]).toContain('DESC')
+    })
+
+    it('should use large limit to get all matching tasks', async () => {
+      mockQueryWithRLS
+        .mockResolvedValueOnce([{ count: '500' }])
+        .mockResolvedValueOnce([])
+
+      await TasksService.getByStatus('user-123', 'todo')
+
+      const dataQueryCall = mockQueryWithRLS.mock.calls[1]
+      expect(dataQueryCall[1]).toContain(1000) // Large limit
+    })
+  })
+
+  // ============================================================
+  // getOverdue
+  // ============================================================
+  describe('getOverdue', () => {
+    describe('Input Validation', () => {
+      it('should throw error when userId is empty', async () => {
+        await expect(TasksService.getOverdue(''))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+
+      it('should throw error when userId is whitespace only', async () => {
+        await expect(TasksService.getOverdue('   '))
+          .rejects.toThrow('User ID is required for authentication')
+      })
+    })
+
+    describe('Query', () => {
+      it('should query tasks with dueDate before today', async () => {
+        mockQueryWithRLS.mockResolvedValue([])
+
+        await TasksService.getOverdue('user-123')
+
+        const queryCall = mockQueryWithRLS.mock.calls[0]
+        expect(queryCall[0]).toContain('"dueDate" < CURRENT_DATE')
+      })
+
+      it('should exclude done tasks', async () => {
+        mockQueryWithRLS.mockResolvedValue([])
+
+        await TasksService.getOverdue('user-123')
+
+        const queryCall = mockQueryWithRLS.mock.calls[0]
+        expect(queryCall[0]).toContain("status != 'done'")
+      })
+
+      it('should exclude completed tasks', async () => {
+        mockQueryWithRLS.mockResolvedValue([])
+
+        await TasksService.getOverdue('user-123')
+
+        const queryCall = mockQueryWithRLS.mock.calls[0]
+        expect(queryCall[0]).toContain('completed IS NULL OR completed = false')
+      })
+
+      it('should order by dueDate ascending', async () => {
+        mockQueryWithRLS.mockResolvedValue([])
+
+        await TasksService.getOverdue('user-123')
+
+        const queryCall = mockQueryWithRLS.mock.calls[0]
+        expect(queryCall[0]).toContain('"dueDate" ASC')
+      })
+    })
+
+    describe('Result', () => {
+      it('should return array of overdue tasks', async () => {
+        const mockTasks = [
+          createMockDbTask({ dueDate: '2024-01-01' }),
+          createMockDbTask({ id: 'task-456', dueDate: '2024-06-01' }),
+        ]
+        mockQueryWithRLS.mockResolvedValue(mockTasks)
+
+        const result = await TasksService.getOverdue('user-123')
+
+        expect(result).toHaveLength(2)
+      })
+
+      it('should transform database rows correctly', async () => {
+        const mockTask = createMockDbTask({ description: null })
+        mockQueryWithRLS.mockResolvedValue([mockTask])
+
+        const result = await TasksService.getOverdue('user-123')
+
+        expect(result[0].description).toBeUndefined()
+      })
+    })
+  })
+
+  // ============================================================
+  // create
+  // ============================================================
+  describe('create', () => {
+    describe('Input Validation', () => {
+      it('should throw error when userId is missing', async () => {
+        await expect(TasksService.create('', { title: 'Test', teamId: 'team-123' }))
+          .rejects.toThrow('User ID is required')
+      })
+
+      it('should throw error when title is missing', async () => {
+        await expect(TasksService.create('user-123', { teamId: 'team-123' } as any))
+          .rejects.toThrow('Title is required')
+      })
+
+      it('should throw error when teamId is missing', async () => {
+        await expect(TasksService.create('user-123', { title: 'Test' } as any))
+          .rejects.toThrow('Team ID is required')
+      })
+    })
+
+    describe('Default Values', () => {
+      it('should use default status of todo', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(createMockDbTask())
+
+        await TasksService.create('user-123', { title: 'Test', teamId: 'team-123' })
+
+        const insertCall = mockQueryOneWithRLS.mock.calls[0]
+        expect(insertCall[1]).toContain('todo')
+      })
+
+      it('should use default priority of medium', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(createMockDbTask())
+
+        await TasksService.create('user-123', { title: 'Test', teamId: 'team-123' })
+
+        const insertCall = mockQueryOneWithRLS.mock.calls[0]
+        expect(insertCall[1]).toContain('medium')
+      })
+
+      it('should use empty array for tags by default', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(createMockDbTask())
+
+        await TasksService.create('user-123', { title: 'Test', teamId: 'team-123' })
+
+        const insertCall = mockQueryOneWithRLS.mock.calls[0]
+        expect(insertCall[1]).toContainEqual([])
+      })
+
+      it('should use false for completed by default', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(createMockDbTask())
+
+        await TasksService.create('user-123', { title: 'Test', teamId: 'team-123' })
+
+        const insertCall = mockQueryOneWithRLS.mock.calls[0]
+        expect(insertCall[1]).toContain(false)
+      })
+    })
+
+    describe('Successful Creation', () => {
+      it('should return created task', async () => {
+        const mockTask = createMockDbTask({ title: 'New Task' })
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.create('user-123', {
+          title: 'New Task',
+          teamId: 'team-123',
+        })
+
+        expect(result.id).toBe('task-123')
+        expect(result.title).toBe('New Task')
+      })
+
+      it('should pass userId and teamId to database', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(createMockDbTask())
+
+        await TasksService.create('user-123', {
+          title: 'Test',
+          teamId: 'team-456',
+        })
+
+        const insertCall = mockQueryOneWithRLS.mock.calls[0]
+        expect(insertCall[1]).toContain('user-123')
+        expect(insertCall[1]).toContain('team-456')
+      })
+
+      it('should include all provided fields', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(createMockDbTask())
+
+        await TasksService.create('user-123', {
+          title: 'Full Task',
+          teamId: 'team-123',
+          description: 'A description',
+          status: 'in-progress',
+          priority: 'high',
+          tags: ['urgent', 'important'],
+          dueDate: '2025-12-31',
+          estimatedHours: 10,
+        })
+
+        const insertCall = mockQueryOneWithRLS.mock.calls[0]
+        expect(insertCall[1]).toContain('Full Task')
+        expect(insertCall[1]).toContain('A description')
+        expect(insertCall[1]).toContain('in-progress')
+        expect(insertCall[1]).toContain('high')
+        expect(insertCall[1]).toContainEqual(['urgent', 'important'])
+        expect(insertCall[1]).toContain('2025-12-31')
+        expect(insertCall[1]).toContain(10)
+      })
+    })
+
+    describe('Error Handling', () => {
+      it('should throw error when database insert fails', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(null)
+
+        await expect(TasksService.create('user-123', {
+          title: 'Test',
+          teamId: 'team-123',
+        })).rejects.toThrow('Failed to create task')
+      })
+    })
+  })
+
+  // ============================================================
+  // update
+  // ============================================================
+  describe('update', () => {
+    describe('Input Validation', () => {
+      it('should throw error when userId is missing', async () => {
+        await expect(TasksService.update('', 'task-123', { title: 'Updated' }))
+          .rejects.toThrow('User ID is required')
+      })
+
+      it('should throw error when id is missing', async () => {
+        await expect(TasksService.update('user-123', '', { title: 'Updated' }))
+          .rejects.toThrow('Task ID is required')
+      })
+    })
+
+    describe('Partial Updates', () => {
+      it('should only update provided fields', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(createMockDbTask({ title: 'Updated Title' }))
+
+        await TasksService.update('user-123', 'task-123', { title: 'Updated Title' })
+
+        const updateCall = mockQueryOneWithRLS.mock.calls[0]
+        expect(updateCall[0]).toContain('title = $2')
+        expect(updateCall[0]).not.toContain('description =')
+        expect(updateCall[0]).not.toContain('status =')
+      })
+
+      it('should always update updatedAt timestamp', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(createMockDbTask())
+
+        await TasksService.update('user-123', 'task-123', { title: 'Updated' })
+
+        const updateCall = mockQueryOneWithRLS.mock.calls[0]
+        expect(updateCall[0]).toContain('"updatedAt" = NOW()')
+      })
+
+      it('should handle updating all fields', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(createMockDbTask())
+
+        await TasksService.update('user-123', 'task-123', {
+          title: 'Updated Title',
+          description: 'Updated description',
+          status: 'done',
+          priority: 'urgent',
+          tags: ['new-tag'],
+          dueDate: '2026-01-01',
+          estimatedHours: 20,
+          completed: true,
+        })
+
+        const updateCall = mockQueryOneWithRLS.mock.calls[0]
+        expect(updateCall[0]).toContain('title = $2')
+        expect(updateCall[0]).toContain('description = $3')
+        expect(updateCall[0]).toContain('status = $4')
+        expect(updateCall[0]).toContain('priority = $5')
+        expect(updateCall[0]).toContain('tags = $6')
+        expect(updateCall[0]).toContain('"dueDate" = $7')
+        expect(updateCall[0]).toContain('"estimatedHours" = $8')
+        expect(updateCall[0]).toContain('completed = $9')
+      })
+    })
+
+    describe('Empty Update', () => {
+      it('should return current task when no fields to update', async () => {
+        const mockTask = createMockDbTask()
+        mockQueryOneWithRLS.mockResolvedValue(mockTask)
+
+        const result = await TasksService.update('user-123', 'task-123', {})
+
+        // When no fields, it should call getById instead
+        expect(result.id).toBe('task-123')
+      })
+    })
+
+    describe('Successful Update', () => {
+      it('should return updated task', async () => {
+        const updatedTask = createMockDbTask({ title: 'New Title', status: 'done' })
+        mockQueryOneWithRLS.mockResolvedValue(updatedTask)
+
+        const result = await TasksService.update('user-123', 'task-123', {
+          title: 'New Title',
+          status: 'done',
+        })
+
+        expect(result.title).toBe('New Title')
+        expect(result.status).toBe('done')
+      })
+    })
+
+    describe('Error Handling', () => {
+      it('should throw error when task not found', async () => {
+        mockQueryOneWithRLS.mockResolvedValue(null)
+
+        await expect(TasksService.update('user-123', 'non-existent', { title: 'Test' }))
+          .rejects.toThrow('Task not found or update failed')
+      })
+    })
+  })
+})

package/tests/jest/setup.ts

@@ -0,0 +1,170 @@
+/**
+ * Jest Setup for Default Theme
+ *
+ * This file provides complete Jest setup for npm mode.
+ * It includes all necessary polyfills and mocks.
+ */
+
+import '@testing-library/jest-dom'
+import { TextEncoder, TextDecoder } from 'util'
+
+// Polyfill TextEncoder/TextDecoder for jsdom
+global.TextEncoder = TextEncoder
+global.TextDecoder = TextDecoder as typeof global.TextDecoder
+
+// Polyfill Web APIs for Next.js server components testing
+class MockHeaders {
+  private _headers: Map<string, string> = new Map()
+
+  constructor(init?: HeadersInit) {
+    if (init) {
+      if (init instanceof MockHeaders) {
+        init._headers.forEach((value, key) => this._headers.set(key, value))
+      } else if (Array.isArray(init)) {
+        init.forEach(([key, value]) => this._headers.set(key.toLowerCase(), value))
+      } else {
+        Object.entries(init).forEach(([key, value]) => this._headers.set(key.toLowerCase(), value))
+      }
+    }
+  }
+
+  get(name: string) { return this._headers.get(name.toLowerCase()) || null }
+  set(name: string, value: string) { this._headers.set(name.toLowerCase(), value) }
+  has(name: string) { return this._headers.has(name.toLowerCase()) }
+  delete(name: string) { this._headers.delete(name.toLowerCase()) }
+  forEach(cb: (value: string, key: string) => void) { this._headers.forEach(cb) }
+  entries() { return this._headers.entries() }
+  keys() { return this._headers.keys() }
+  values() { return this._headers.values() }
+}
+
+class MockRequest {
+  url: string
+  method: string
+  headers: MockHeaders
+  private _body: any
+
+  constructor(input: string | URL, init?: RequestInit) {
+    this.url = typeof input === 'string' ? input : input.toString()
+    this.method = init?.method || 'GET'
+    this.headers = new MockHeaders(init?.headers as HeadersInit)
+    this._body = init?.body
+  }
+
+  async json() {
+    if (!this._body) return {}
+    return typeof this._body === 'string' ? JSON.parse(this._body) : this._body
+  }
+
+  async text() {
+    return this._body?.toString() || ''
+  }
+
+  clone() {
+    return new MockRequest(this.url, {
+      method: this.method,
+      headers: Object.fromEntries(this.headers.entries()),
+      body: this._body,
+    })
+  }
+}
+
+class MockResponse {
+  body: any
+  status: number
+  statusText: string
+  headers: MockHeaders
+  ok: boolean
+
+  constructor(body?: any, init?: ResponseInit) {
+    this.body = body
+    this.status = init?.status || 200
+    this.statusText = init?.statusText || 'OK'
+    this.headers = new MockHeaders(init?.headers as HeadersInit)
+    this.ok = this.status >= 200 && this.status < 300
+  }
+
+  async json() {
+    if (!this.body) return {}
+    return typeof this.body === 'string' ? JSON.parse(this.body) : this.body
+  }
+
+  async text() {
+    return this.body?.toString() || ''
+  }
+
+  clone() {
+    return new MockResponse(this.body, {
+      status: this.status,
+      statusText: this.statusText,
+      headers: Object.fromEntries(this.headers.entries()),
+    })
+  }
+
+  static json(data: any, init?: ResponseInit) {
+    return new MockResponse(JSON.stringify(data), {
+      ...init,
+      headers: { 'Content-Type': 'application/json', ...(init?.headers || {}) as object },
+    })
+  }
+}
+
+// Assign to global scope
+global.Headers = MockHeaders as any
+global.Request = MockRequest as any
+global.Response = MockResponse as any
+
+// Mock fetch
+global.fetch = jest.fn().mockResolvedValue(new MockResponse('{}', { status: 200 }))
+
+// Mock Web Crypto API
+const crypto = require('crypto')
+Object.defineProperty(global, 'crypto', {
+  value: {
+    getRandomValues: (arr: Uint8Array) => crypto.randomFillSync(arr),
+    randomUUID: () => crypto.randomUUID(),
+    subtle: {
+      digest: async (algorithm: string, data: BufferSource) => {
+        const hash = crypto.createHash(algorithm.toLowerCase().replace('-', ''))
+        hash.update(Buffer.from(data as ArrayBuffer))
+        return hash.digest().buffer
+      },
+      encrypt: jest.fn(),
+      decrypt: jest.fn(),
+      sign: jest.fn(),
+      verify: jest.fn(),
+      generateKey: jest.fn(),
+      importKey: jest.fn(),
+      exportKey: jest.fn(),
+    },
+  },
+})
+
+// Mock matchMedia for component tests with media queries
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: jest.fn().mockImplementation((query) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: jest.fn(),
+    removeListener: jest.fn(),
+    addEventListener: jest.fn(),
+    removeEventListener: jest.fn(),
+    dispatchEvent: jest.fn(),
+  })),
+})
+
+// Mock ResizeObserver
+global.ResizeObserver = jest.fn().mockImplementation(() => ({
+  observe: jest.fn(),
+  unobserve: jest.fn(),
+  disconnect: jest.fn(),
+}))
+
+// Mock IntersectionObserver
+global.IntersectionObserver = jest.fn().mockImplementation(() => ({
+  observe: jest.fn(),
+  unobserve: jest.fn(),
+  disconnect: jest.fn(),
+}))

package/tests/jest/jest.config.ts

@@ -1,81 +0,0 @@
-/**
- * Jest Configuration for Default Theme
- *
- * This config is automatically loaded by the theme test runner.
- *
- * Usage:
- *   pnpm test:theme          # Run theme tests
- *   pnpm test:theme:watch    # Watch mode
- *   pnpm test:theme:coverage # With coverage
- */
-
-import type { Config } from 'jest'
-
-const config: Config = {
-  displayName: 'theme-default',
-  rootDir: '../../../../..',
-
-  // Test file patterns
-  testMatch: [
-    '<rootDir>/contents/themes/default/tests/jest/**/*.{test,spec}.{js,ts,tsx}',
-  ],
-  testPathIgnorePatterns: [
-    '<rootDir>/node_modules/',
-    '<rootDir>/.next/',
-  ],
-
-  // Preset and environment
-  preset: 'ts-jest',
-  testEnvironment: 'jsdom',
-
-  // Module resolution (aliases @/)
-  // IMPORTANT: More specific patterns MUST come before generic ones
-  moduleNameMapper: {
-    '^@nextsparkjs/core/(.*)$': '<rootDir>/packages/core/$1',
-    '^@/contents/(.*)$': '<rootDir>/contents/$1',
-    '^@/entities/(.*)$': '<rootDir>/contents/entities/$1',
-    '^@/plugins/(.*)$': '<rootDir>/contents/plugins/$1',
-    '^@/themes/(.*)$': '<rootDir>/contents/themes/$1',
-    '^@/(.*)$': '<rootDir>/$1',
-    'next/server': '<rootDir>/packages/core/tests/jest/__mocks__/next-server.js',
-    '^jose$': '<rootDir>/packages/core/tests/jest/__mocks__/jose.js',
-    '^jose/(.*)$': '<rootDir>/packages/core/tests/jest/__mocks__/jose.js',
-  },
-
-  // Setup files
-  setupFilesAfterEnv: ['<rootDir>/packages/core/tests/setup.ts'],
-
-  // Transform configuration
-  transform: {
-    '^.+\\.(ts|tsx)$': [
-      'ts-jest',
-      {
-        tsconfig: 'tsconfig.test.json',
-      },
-    ],
-  },
-
-  // Transform ignore patterns
-  transformIgnorePatterns: [
-    'node_modules/(?!(uncrypto|better-auth|@noble|.*jose.*|remark.*|unified.*|.*\\.mjs$))',
-    'node_modules/\\.pnpm/(?!(.*uncrypto.*|.*better-auth.*|.*@noble.*|.*jose.*|.*remark.*|.*unified.*|.*\\.mjs$))',
-  ],
-
-  // File extensions
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json'],
-
-  // Test timeout
-  testTimeout: 10000,
-
-  // Verbose output
-  verbose: true,
-
-  // Force exit after tests complete
-  forceExit: true,
-
-  // Coverage output directory
-  coverageDirectory: '<rootDir>/contents/themes/default/tests/jest/coverage',
-  coverageReporters: ['text', 'lcov', 'html'],
-}
-
-export default config