snice 3.6.0 → 3.8.0

package/bin/templates/pwa/src/services/jwt.ts

@@ -0,0 +1,35 @@
+interface JWTPayload {
+  exp?: number;
+  iat?: number;
+  sub?: string;
+  [key: string]: any;
+}
+
+export function decodeJWT(token: string): JWTPayload | null {
+  try {
+    const parts = token.split('.');
+    if (parts.length !== 3) return null;
+
+    const payload = parts[1];
+    const decoded = atob(payload.replace(/-/g, '+').replace(/_/g, '/'));
+    return JSON.parse(decoded);
+  } catch (err) {
+    console.error('Failed to decode JWT:', err);
+    return null;
+  }
+}
+
+export function isTokenExpired(token: string): boolean {
+  const payload = decodeJWT(token);
+  if (!payload || !payload.exp) return true;
+
+  const now = Math.floor(Date.now() / 1000);
+  return payload.exp < now;
+}
+
+export function getTokenExpiration(token: string): Date | null {
+  const payload = decodeJWT(token);
+  if (!payload || !payload.exp) return null;
+
+  return new Date(payload.exp * 1000);
+}

package/bin/templates/pwa/src/services/storage.ts

@@ -0,0 +1,24 @@
+const TOKEN_KEY = 'auth_token';
+const USER_KEY = 'auth_user';
+
+export function getToken(): string | null {
+  return localStorage.getItem(TOKEN_KEY);
+}
+
+export function setToken(token: string): void {
+  localStorage.setItem(TOKEN_KEY, token);
+}
+
+export function clearToken(): void {
+  localStorage.removeItem(TOKEN_KEY);
+  localStorage.removeItem(USER_KEY);
+}
+
+export function getUser<T>(): T | null {
+  const user = localStorage.getItem(USER_KEY);
+  return user ? JSON.parse(user) : null;
+}
+
+export function setUser<T>(user: T): void {
+  localStorage.setItem(USER_KEY, JSON.stringify(user));
+}

package/bin/templates/pwa/src/styles/global.css

@@ -0,0 +1,55 @@
+:root {
+  --primary-color: #6366f1;
+  --secondary-color: #8b5cf6;
+  --success-color: #10b981;
+  --warning-color: #f59e0b;
+  --danger-color: #ef4444;
+  --info-color: #3b82f6;
+
+  --bg-primary: #ffffff;
+  --bg-secondary: #f9fafb;
+  --text-color: #1f2937;
+  --text-light: #6b7280;
+  --border-color: #e5e7eb;
+
+  --radius-sm: 0.375rem;
+  --radius-md: 0.5rem;
+  --radius-lg: 0.75rem;
+
+  --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+  --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1);
+  --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1);
+
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+    sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+  color-scheme: light;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  padding: 0;
+  background-color: var(--bg-secondary);
+  color: var(--text-color);
+}
+
+#app {
+  min-height: 100vh;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg-primary: #1f2937;
+    --bg-secondary: #111827;
+    --text-color: #f9fafb;
+    --text-light: #9ca3af;
+    --border-color: #374151;
+    color-scheme: dark;
+  }
+}

package/bin/templates/pwa/src/types/auth.ts

@@ -0,0 +1,21 @@
+export interface User {
+  id: string;
+  email: string;
+  name: string;
+  avatar?: string;
+}
+
+export interface LoginCredentials {
+  email: string;
+  password: string;
+}
+
+export interface LoginResponse {
+  token: string;
+  user: User;
+}
+
+export interface Principal {
+  user: User | null;
+  isAuthenticated: boolean;
+}

package/bin/templates/pwa/src/types/notifications.ts

@@ -0,0 +1,9 @@
+export type NotificationType = 'info' | 'success' | 'warning' | 'error';
+
+export interface Notification {
+  id: string;
+  title: string;
+  message: string;
+  type: NotificationType;
+  timestamp: string;
+}

package/bin/templates/pwa/tests/helpers/test-utils.ts

@@ -0,0 +1,84 @@
+/**
+ * Wait for a specified number of milliseconds
+ */
+export async function waitFor(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Wait for a condition to become true
+ */
+export async function waitUntil(
+  condition: () => boolean,
+  timeout = 1000,
+  interval = 10
+): Promise<void> {
+  const start = Date.now();
+  while (!condition()) {
+    if (Date.now() - start > timeout) {
+      throw new Error('Timeout waiting for condition');
+    }
+    await waitFor(interval);
+  }
+}
+
+/**
+ * Create a container div and append it to document.body
+ */
+export function createContainer(id = 'app'): HTMLDivElement {
+  const container = document.createElement('div');
+  container.id = id;
+  document.body.appendChild(container);
+  return container;
+}
+
+/**
+ * Clean up the document body
+ */
+export function cleanup(): void {
+  document.body.innerHTML = '';
+}
+
+/**
+ * Mock localStorage for tests
+ */
+export function mockLocalStorage(): {
+  getItem: ReturnType<typeof vi.fn>;
+  setItem: ReturnType<typeof vi.fn>;
+  removeItem: ReturnType<typeof vi.fn>;
+  clear: ReturnType<typeof vi.fn>;
+} {
+  const store: Record<string, string> = {};
+
+  return {
+    getItem: vi.fn((key: string) => store[key] || null),
+    setItem: vi.fn((key: string, value: string) => {
+      store[key] = value;
+    }),
+    removeItem: vi.fn((key: string) => {
+      delete store[key];
+    }),
+    clear: vi.fn(() => {
+      Object.keys(store).forEach(key => delete store[key]);
+    }),
+  };
+}
+
+/**
+ * Mock fetch for tests
+ */
+export function mockFetch(
+  response: unknown = {},
+  status = 200,
+  ok = true
+): ReturnType<typeof vi.fn> {
+  return vi.fn(() =>
+    Promise.resolve({
+      ok,
+      status,
+      json: () => Promise.resolve(response),
+      text: () => Promise.resolve(JSON.stringify(response)),
+      headers: new Headers(),
+    } as Response)
+  );
+}

package/bin/templates/pwa/tests/middleware/auth.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Context } from 'snice';
+import { authMiddleware } from '../../src/middleware/auth';
+import * as storage from '../../src/services/storage';
+
+describe('Auth Middleware', () => {
+  let mockContext: Context;
+  let mockRequest: Request;
+  let mockNext: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    localStorage.clear();
+    vi.clearAllMocks();
+
+    // Create mock context
+    mockContext = {
+      application: {
+        principal: {
+          user: null,
+          isAuthenticated: false,
+        },
+      },
+      navigation: {
+        route: '/',
+        params: {},
+      },
+      update: vi.fn(),
+    } as unknown as Context;
+
+    // Create mock request
+    mockRequest = new Request('https://api.example.com/data', {
+      headers: new Headers(),
+    });
+
+    // Create mock next function
+    const mockResponse = new Response('{}', { status: 200 });
+    mockNext = vi.fn(() => Promise.resolve(mockResponse));
+  });
+
+  it('should add Authorization header when token exists', async () => {
+    const token = 'test-token-123';
+    storage.setToken(token);
+
+    await authMiddleware.call(mockContext, mockRequest, mockNext);
+
+    expect(mockRequest.headers.get('Authorization')).toBe(`Bearer ${token}`);
+    expect(mockNext).toHaveBeenCalled();
+  });
+
+  it('should not add Authorization header when no token exists', async () => {
+    await authMiddleware.call(mockContext, mockRequest, mockNext);
+
+    expect(mockRequest.headers.get('Authorization')).toBeNull();
+    expect(mockNext).toHaveBeenCalled();
+  });
+
+  it('should call next() and return response', async () => {
+    const token = 'test-token-123';
+    storage.setToken(token);
+
+    const response = await authMiddleware.call(mockContext, mockRequest, mockNext);
+
+    expect(mockNext).toHaveBeenCalledTimes(1);
+    expect(response).toBeInstanceOf(Response);
+    expect(response.status).toBe(200);
+  });
+});

package/bin/templates/pwa/tests/middleware/error.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { Context } from 'snice';
+import { errorMiddleware } from '../../src/middleware/error';
+import * as storage from '../../src/services/storage';
+import type { Principal } from '../../src/types/auth';
+
+describe('Error Middleware', () => {
+  let mockContext: Context;
+  let mockNext: ReturnType<typeof vi.fn>;
+  let originalLocation: Location;
+
+  beforeEach(() => {
+    localStorage.clear();
+    vi.clearAllMocks();
+
+    // Save original location
+    originalLocation = window.location;
+
+    // Mock window.location
+    delete (window as any).location;
+    window.location = { href: '' } as Location;
+
+    // Create mock context
+    mockContext = {
+      application: {
+        principal: {
+          user: { id: '1', name: 'Test', email: 'test@example.com' },
+          isAuthenticated: true,
+        } as Principal,
+      },
+      navigation: {
+        route: '/',
+        params: {},
+      },
+      update: vi.fn(),
+    } as unknown as Context;
+
+    // Create mock next function
+    const mockResponse = new Response('{}', { status: 200 });
+    mockNext = vi.fn(() => Promise.resolve(mockResponse));
+  });
+
+  afterEach(() => {
+    window.location = originalLocation;
+  });
+
+  it('should pass through successful responses', async () => {
+    const mockResponse = new Response('{"data":"ok"}', { status: 200 });
+    const response = await errorMiddleware.call(mockContext, mockResponse, mockNext);
+
+    expect(mockNext).toHaveBeenCalled();
+    expect(response).toBeInstanceOf(Response);
+  });
+
+  it('should handle 401 unauthorized by clearing token and redirecting', async () => {
+    storage.setToken('test-token');
+    const mockResponse = new Response('Unauthorized', { status: 401 });
+
+    await expect(
+      errorMiddleware.call(mockContext, mockResponse, mockNext)
+    ).rejects.toThrow('Unauthorized - redirecting to login');
+
+    expect(storage.getToken()).toBeNull();
+    const principal = mockContext.application.principal as Principal;
+    expect(principal.user).toBeNull();
+    expect(principal.isAuthenticated).toBe(false);
+    expect(window.location.href).toBe('#/login');
+  });
+
+  it('should throw error for failed requests with JSON error message', async () => {
+    const mockResponse = new Response(
+      JSON.stringify({ message: 'Custom error message' }),
+      {
+        status: 400,
+        headers: { 'content-type': 'application/json' },
+      }
+    );
+
+    await expect(
+      errorMiddleware.call(mockContext, mockResponse, mockNext)
+    ).rejects.toThrow('Custom error message');
+  });
+
+  it('should throw error for failed requests without JSON body', async () => {
+    const mockResponse = new Response('Internal Server Error', {
+      status: 500,
+      headers: { 'content-type': 'text/plain' },
+    });
+
+    await expect(
+      errorMiddleware.call(mockContext, mockResponse, mockNext)
+    ).rejects.toThrow('Request failed with status 500');
+  });
+
+  it('should throw generic error for failed JSON requests without message', async () => {
+    const mockResponse = new Response(JSON.stringify({}), {
+      status: 400,
+      headers: { 'content-type': 'application/json' },
+    });
+
+    await expect(
+      errorMiddleware.call(mockContext, mockResponse, mockNext)
+    ).rejects.toThrow('Request failed with status 400');
+  });
+});

package/bin/templates/pwa/tests/middleware/retry.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Context } from 'snice';
+import { createRetryMiddleware } from '../../src/middleware/retry';
+
+describe('Retry Middleware', () => {
+  let mockContext: Context;
+  let mockRequest: Request;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockContext = {
+      application: {
+        principal: {
+          user: null,
+          isAuthenticated: false,
+        },
+      },
+      navigation: {
+        route: '/',
+        params: {},
+      },
+      update: vi.fn(),
+    } as unknown as Context;
+
+    mockRequest = new Request('https://api.example.com/data');
+  });
+
+  it('should return response on first successful attempt', async () => {
+    const retryMiddleware = createRetryMiddleware(3, 10);
+    const mockResponse = new Response('{}', { status: 200 });
+    const mockNext = vi.fn(() => Promise.resolve(mockResponse));
+
+    const response = await retryMiddleware.call(mockContext, mockRequest, mockNext);
+
+    expect(mockNext).toHaveBeenCalledTimes(1);
+    expect(response).toBe(mockResponse);
+  });
+
+  it('should retry on failure and eventually succeed', async () => {
+    const retryMiddleware = createRetryMiddleware(3, 10);
+    const mockResponse = new Response('{}', { status: 200 });
+    const mockNext = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('Network error'))
+      .mockRejectedValueOnce(new Error('Network error'))
+      .mockResolvedValueOnce(mockResponse);
+
+    const response = await retryMiddleware.call(mockContext, mockRequest, mockNext);
+
+    expect(mockNext).toHaveBeenCalledTimes(3);
+    expect(response).toBe(mockResponse);
+  });
+
+  it('should throw error after max retries', async () => {
+    const retryMiddleware = createRetryMiddleware(3, 10);
+    const error = new Error('Network error');
+    const mockNext = vi.fn(() => Promise.reject(error));
+
+    await expect(
+      retryMiddleware.call(mockContext, mockRequest, mockNext)
+    ).rejects.toThrow('Network error');
+
+    expect(mockNext).toHaveBeenCalledTimes(3);
+  });
+
+  it('should not retry on Unauthorized errors', async () => {
+    const retryMiddleware = createRetryMiddleware(3, 10);
+    const error = new Error('Unauthorized');
+    const mockNext = vi.fn(() => Promise.reject(error));
+
+    await expect(
+      retryMiddleware.call(mockContext, mockRequest, mockNext)
+    ).rejects.toThrow('Unauthorized');
+
+    // Should only try once, no retries
+    expect(mockNext).toHaveBeenCalledTimes(1);
+  });
+
+  it('should use exponential backoff', async () => {
+    vi.useFakeTimers();
+
+    try {
+      const retryMiddleware = createRetryMiddleware(3, 100);
+      const mockNext = vi.fn(() => Promise.reject(new Error('Network error')));
+
+      const promise = retryMiddleware.call(mockContext, mockRequest, mockNext).catch(err => err);
+
+      // Run all timers to completion
+      await vi.runAllTimersAsync();
+
+      // All 3 attempts should have been made
+      expect(mockNext).toHaveBeenCalledTimes(3);
+
+      // Promise should have rejected with network error
+      const result = await promise;
+      expect(result).toBeInstanceOf(Error);
+      expect(result.message).toBe('Network error');
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});

package/bin/templates/pwa/tests/services/auth.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { login, logout, isAuthenticated, refreshToken } from '../../src/services/auth';
+import * as storage from '../../src/services/storage';
+
+describe('Auth Service', () => {
+  beforeEach(() => {
+    localStorage.clear();
+    vi.clearAllMocks();
+  });
+
+  describe('login', () => {
+    it('should login with valid credentials', async () => {
+      const credentials = { email: 'demo@example.com', password: 'demo' };
+      const result = await login(credentials);
+
+      expect(result).toHaveProperty('token');
+      expect(result).toHaveProperty('user');
+      expect(result.user.email).toBe('demo@example.com');
+      expect(result.user.name).toBe('Demo User');
+    });
+
+    it('should store token and user on successful login', async () => {
+      const credentials = { email: 'demo@example.com', password: 'demo' };
+      await login(credentials);
+
+      expect(storage.getToken()).toBeTruthy();
+      expect(storage.getUser()).toBeTruthy();
+    });
+
+    it('should throw error for invalid credentials', async () => {
+      const credentials = { email: 'wrong@example.com', password: 'wrong' };
+
+      await expect(login(credentials)).rejects.toThrow('Invalid credentials');
+    });
+
+    it('should throw error for wrong password', async () => {
+      const credentials = { email: 'demo@example.com', password: 'wrong' };
+
+      await expect(login(credentials)).rejects.toThrow('Invalid credentials');
+    });
+  });
+
+  describe('logout', () => {
+    it('should clear token on logout', async () => {
+      storage.setToken('test-token');
+      storage.setUser({ id: '1', name: 'Test' });
+
+      await logout();
+
+      expect(storage.getToken()).toBeNull();
+      expect(storage.getUser()).toBeNull();
+    });
+  });
+
+  describe('isAuthenticated', () => {
+    it('should return true when valid token exists', () => {
+      // Non-expired token
+      const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwiZW1haWwiOiJkZW1vQGV4YW1wbGUuY29tIiwiaWF0IjoxNjE2MjM5MDIyLCJleHAiOjk5OTk5OTk5OTl9.mock';
+      storage.setToken(token);
+
+      expect(isAuthenticated()).toBe(true);
+    });
+
+    it('should return false when no token exists', () => {
+      expect(isAuthenticated()).toBe(false);
+    });
+
+    it('should return false when token is expired', () => {
+      // Expired token
+      const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwiZXhwIjoxNjAwMDAwMDAwfQ.mock';
+      storage.setToken(token);
+
+      expect(isAuthenticated()).toBe(false);
+    });
+  });
+
+  describe('refreshToken', () => {
+    it('should return new token', async () => {
+      const newToken = await refreshToken();
+      expect(newToken).toBeTruthy();
+      expect(typeof newToken).toBe('string');
+    });
+
+    it('should update stored token', async () => {
+      await refreshToken();
+      expect(storage.getToken()).toBeTruthy();
+    });
+  });
+});

package/bin/templates/pwa/tests/services/jwt.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { decodeJWT, isTokenExpired, getTokenExpiration } from '../../src/services/jwt';
+
+describe('JWT Service', () => {
+  describe('decodeJWT', () => {
+    it('should decode a valid JWT', () => {
+      // Valid JWT: {"sub":"123","name":"Test","exp":9999999999}
+      const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMiLCJuYW1lIjoiVGVzdCIsImV4cCI6OTk5OTk5OTk5OX0.mock';
+      const payload = decodeJWT(token);
+
+      expect(payload).toBeTruthy();
+      expect(payload?.sub).toBe('123');
+      expect(payload?.name).toBe('Test');
+      expect(payload?.exp).toBe(9999999999);
+    });
+
+    it('should return null for invalid JWT format', () => {
+      const payload = decodeJWT('invalid-token');
+      expect(payload).toBeNull();
+    });
+
+    it('should return null for malformed JWT', () => {
+      const payload = decodeJWT('part1.part2');
+      expect(payload).toBeNull();
+    });
+
+    it('should return null for JWT with invalid base64', () => {
+      const payload = decodeJWT('header.!!!invalid!!!.signature');
+      expect(payload).toBeNull();
+    });
+  });
+
+  describe('isTokenExpired', () => {
+    it('should return false for non-expired token', () => {
+      // Token expires in year 2286
+      const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMiLCJleHAiOjk5OTk5OTk5OTl9.mock';
+      expect(isTokenExpired(token)).toBe(false);
+    });
+
+    it('should return true for expired token', () => {
+      // Token expired in 2020
+      const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMiLCJleHAiOjE2MDAwMDAwMDB9.mock';
+      expect(isTokenExpired(token)).toBe(true);
+    });
+
+    it('should return true for token without exp claim', () => {
+      // Token without exp: {"sub":"123"}
+      const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMifQ.mock';
+      expect(isTokenExpired(token)).toBe(true);
+    });
+
+    it('should return true for invalid token', () => {
+      expect(isTokenExpired('invalid')).toBe(true);
+    });
+  });
+
+  describe('getTokenExpiration', () => {
+    it('should return expiration date for valid token', () => {
+      // Token with exp: 9999999999 (Sat Nov 20 2286)
+      const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMiLCJleHAiOjk5OTk5OTk5OTl9.mock';
+      const expiration = getTokenExpiration(token);
+
+      expect(expiration).toBeInstanceOf(Date);
+      expect(expiration?.getTime()).toBe(9999999999 * 1000);
+    });
+
+    it('should return null for token without exp', () => {
+      const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjMifQ.mock';
+      expect(getTokenExpiration(token)).toBeNull();
+    });
+
+    it('should return null for invalid token', () => {
+      expect(getTokenExpiration('invalid')).toBeNull();
+    });
+  });
+});