@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/utils/google-places/index.ts

@@ -1,26 +0,0 @@
-/**
- * @file Google Places API Utilities Exports
- * @package @jmruthers/pace-core
- * @module Utils/GooglePlaces
- * @since 0.1.0
- */
-
-export {
-  fetchPlaceAutocomplete,
-  fetchPlaceDetails,
-  parseAddressComponents,
-  createAddressFromPlaceResult,
-  getAddressByPlaceId,
-} from './googlePlacesUtils';
-
-export {
-  loadGoogleMapsScript,
-  isGoogleMapsLoaded,
-} from './loadGoogleMapsScript';
-
-export type {
-  GooglePlaceAutocompletePrediction,
-  ParsedAddress,
-  AutocompleteOptions,
-} from './types';
-

package/src/utils/location/index.ts

@@ -1,16 +0,0 @@
-/**
- * @file Location Utilities Exports
- * @package @jmruthers/pace-core
- * @module Utils/Location
- * @since 0.1.0
- */
-
-export {
-  formatCoordinates,
-  hasValidCoordinates,
-  areCoordinatesEqual,
-  getGoogleMapsUrl
-} from './location';
-
-export type { Coordinates } from './location';
-

package/src/utils/persistence/__tests__/keyDerivation.test.ts

@@ -1,135 +0,0 @@
-/**
- * @file Key Derivation Tests
- * @package @jmruthers/pace-core
- * @module Utils/Persistence/__tests__
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  deriveDataTableKey,
-  deriveDialogKey,
-  deriveFormKey,
-  hashStableFingerprint,
-} from '../keyDerivation';
-
-describe('keyDerivation', () => {
-  describe('deriveDataTableKey', () => {
-    it('should use rbacPageId as primary key', () => {
-      const key = deriveDataTableKey({
-        rbacPageId: 'user-management',
-      });
-      expect(key).toBe('datatable:user-management');
-    });
-
-    it('should fall back to title when rbacPageId not available', () => {
-      const key = deriveDataTableKey({
-        title: 'Users Table',
-      });
-      expect(key).toBe('datatable:users-table');
-    });
-
-    it('should use route pathname as fallback', () => {
-      const key = deriveDataTableKey(
-        {},
-        { pathname: '/users' }
-      );
-      expect(key).toBe('datatable:/users');
-    });
-
-    it('should use column IDs hash as last resort', () => {
-      const key = deriveDataTableKey({
-        columnIds: ['id', 'name', 'email'],
-      });
-      expect(key).toMatch(/^datatable:[a-f0-9]+$/);
-    });
-
-    it('should return null if no stable key can be determined', () => {
-      const key = deriveDataTableKey({});
-      expect(key).toBeNull();
-    });
-  });
-
-  describe('deriveDialogKey', () => {
-    it('should use title as primary key', () => {
-      const key = deriveDialogKey({
-        title: 'Edit User',
-      });
-      expect(key).toBe('dialog:edit-user');
-    });
-
-    it('should use route pathname as fallback', () => {
-      const key = deriveDialogKey(
-        {},
-        { pathname: '/users/edit' }
-      );
-      expect(key).toBe('dialog:/users/edit');
-    });
-
-    it('should return null if no stable key can be determined', () => {
-      const key = deriveDialogKey({});
-      expect(key).toBeNull();
-    });
-  });
-
-  describe('deriveFormKey', () => {
-    it('should use parent dialog title when available', () => {
-      const key = deriveFormKey(
-        {},
-        { dialogTitle: 'Edit User' }
-      );
-      expect(key).toBe('form:edit-user');
-    });
-
-    it('should use route + field names hash as fallback', () => {
-      const key = deriveFormKey(
-        {
-          fieldNames: ['name', 'email'],
-        },
-        null,
-        { pathname: '/users' }
-      );
-      expect(key).toMatch(/^form:\/users:[a-f0-9]+$/);
-    });
-
-    it('should use route pathname as last resort', () => {
-      const key = deriveFormKey(
-        {},
-        null,
-        { pathname: '/users' }
-      );
-      expect(key).toBe('form:/users');
-    });
-
-    it('should return null if no stable key can be determined', () => {
-      const key = deriveFormKey({});
-      expect(key).toBeNull();
-    });
-  });
-
-  describe('hashStableFingerprint', () => {
-    it('should create stable hash from array of strings', () => {
-      const hash1 = hashStableFingerprint(['a', 'b', 'c']);
-      const hash2 = hashStableFingerprint(['a', 'b', 'c']);
-      expect(hash1).toBe(hash2);
-    });
-
-    it('should be order-independent', () => {
-      const hash1 = hashStableFingerprint(['a', 'b', 'c']);
-      const hash2 = hashStableFingerprint(['c', 'b', 'a']);
-      expect(hash1).toBe(hash2);
-    });
-
-    it('should normalize strings (lowercase, trim)', () => {
-      const hash1 = hashStableFingerprint(['A', ' B ', 'C']);
-      const hash2 = hashStableFingerprint(['a', 'b', 'c']);
-      expect(hash1).toBe(hash2);
-    });
-
-    it('should filter out empty values', () => {
-      const hash1 = hashStableFingerprint(['a', '', 'b', 'c']);
-      const hash2 = hashStableFingerprint(['a', 'b', 'c']);
-      expect(hash1).toBe(hash2);
-    });
-  });
-});
-

package/src/utils/persistence/__tests__/sensitiveFieldDetection.test.ts

@@ -1,123 +0,0 @@
-/**
- * @file Sensitive Field Detection Tests
- * @package @jmruthers/pace-core
- * @module Utils/Persistence/__tests__
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  isSensitiveField,
-  filterSensitiveFields,
-  getSensitiveFieldNames,
-} from '../sensitiveFieldDetection';
-
-describe('sensitiveFieldDetection', () => {
-  describe('isSensitiveField', () => {
-    it('should detect password input type', () => {
-      expect(isSensitiveField('password', 'password')).toBe(true);
-      expect(isSensitiveField('userPassword', 'password')).toBe(true);
-    });
-
-    it('should detect hidden input type', () => {
-      expect(isSensitiveField('token', 'hidden')).toBe(true);
-    });
-
-    it('should detect sensitive field names by pattern', () => {
-      expect(isSensitiveField('password', 'text')).toBe(true);
-      expect(isSensitiveField('user_password', 'text')).toBe(true);
-      expect(isSensitiveField('api_key', 'text')).toBe(true);
-      expect(isSensitiveField('secretToken', 'text')).toBe(true);
-      expect(isSensitiveField('credit_card', 'text')).toBe(true);
-      expect(isSensitiveField('ssn', 'text')).toBe(true);
-    });
-
-    it('should not detect non-sensitive fields', () => {
-      expect(isSensitiveField('name', 'text')).toBe(false);
-      expect(isSensitiveField('email', 'email')).toBe(false);
-      expect(isSensitiveField('age', 'number')).toBe(false);
-    });
-
-    it('should be case-insensitive', () => {
-      expect(isSensitiveField('PASSWORD', 'text')).toBe(true);
-      expect(isSensitiveField('Api_Key', 'text')).toBe(true);
-    });
-  });
-
-  describe('filterSensitiveFields', () => {
-    it('should filter out sensitive fields', () => {
-      const data = {
-        name: 'John',
-        email: 'john@example.com',
-        password: 'secret123',
-        api_key: 'key123',
-      };
-
-      const filtered = filterSensitiveFields(data, ['name', 'email', 'password', 'api_key']);
-
-      expect(filtered).toEqual({
-        name: 'John',
-        email: 'john@example.com',
-      });
-      expect(filtered).not.toHaveProperty('password');
-      expect(filtered).not.toHaveProperty('api_key');
-    });
-
-    it('should filter by input type', () => {
-      const data = {
-        name: 'John',
-        password: 'secret123',
-      };
-
-      const filtered = filterSensitiveFields(data, ['name', 'password'], {
-        password: 'password',
-      });
-
-      expect(filtered).toEqual({
-        name: 'John',
-      });
-      expect(filtered).not.toHaveProperty('password');
-    });
-
-    it('should return empty object if all fields are sensitive', () => {
-      const data = {
-        password: 'secret123',
-        api_key: 'key123',
-      };
-
-      const filtered = filterSensitiveFields(data, ['password', 'api_key']);
-
-      expect(filtered).toEqual({});
-    });
-
-    it('should return all fields if none are sensitive', () => {
-      const data = {
-        name: 'John',
-        email: 'john@example.com',
-      };
-
-      const filtered = filterSensitiveFields(data, ['name', 'email']);
-
-      expect(filtered).toEqual(data);
-    });
-  });
-
-  describe('getSensitiveFieldNames', () => {
-    it('should return list of sensitive field names', () => {
-      const sensitive = getSensitiveFieldNames(
-        ['name', 'email', 'password', 'api_key'],
-        {
-          password: 'password',
-        }
-      );
-
-      expect(sensitive).toEqual(['password', 'api_key']);
-    });
-
-    it('should return empty array if no sensitive fields', () => {
-      const sensitive = getSensitiveFieldNames(['name', 'email']);
-
-      expect(sensitive).toEqual([]);
-    });
-  });
-});
-

package/src/utils/storage/__tests__/helpers.unit.test.ts

@@ -1,332 +0,0 @@
-// Unit tests for storage helper functions
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  generateFilePath,
-  generateUniqueFileName,
-  extractFileMetadata,
-  uploadFile,
-  getPublicUrl,
-  getSignedUrl,
-  deleteFile,
-  listFiles,
-  archiveFile
-} from '../helpers';
-import { StorageUploadOptions } from '../types';
-
-// Mock Supabase client
-const createMockStorageClient = () => ({
-  upload: vi.fn(),
-  getPublicUrl: vi.fn(),
-  createSignedUrl: vi.fn(),
-  remove: vi.fn(),
-  list: vi.fn(),
-  copy: vi.fn()
-});
-
-const mockSupabaseClient = {
-  storage: {
-    from: vi.fn(() => createMockStorageClient())
-  }
-} as any;
-
-// Mock file creation
-const createMockFile = (name: string, type: string, size: number): File => {
-  const file = new File(['test content'], name, { type });
-  Object.defineProperty(file, 'size', { value: size });
-  return file;
-};
-
-describe('Storage Helpers', () => {
-  const baseOptions: StorageUploadOptions = {
-    appName: 'test-app',
-    orgId: 'org-123',
-    isPublic: false
-  };
-
-  describe('generateFilePath', () => {
-    it('should generate path for private files with default structure', () => {
-      const result = generateFilePath(baseOptions, 'test.jpg');
-      expect(result).toBe('org-123/files/test.jpg');
-    });
-
-    it('should generate path for public files with default structure', () => {
-      const options = { ...baseOptions, isPublic: true };
-      const result = generateFilePath(options, 'test.jpg');
-      expect(result).toBe('org-123/public/test.jpg');
-    });
-
-    it('should generate path for private files with custom path', () => {
-      const options = { ...baseOptions, customPath: 'images' };
-      const result = generateFilePath(options, 'test.jpg');
-      expect(result).toBe('org-123/images/test.jpg');
-    });
-
-    it('should generate path for public files with custom path', () => {
-      const options = { ...baseOptions, isPublic: true, customPath: 'assets' };
-      const result = generateFilePath(options, 'test.jpg');
-      expect(result).toBe('org-123/assets/test.jpg');
-    });
-  });
-
-  describe('generateUniqueFileName', () => {
-    it('should generate unique filename with timestamp and UUID', () => {
-      const result = generateUniqueFileName('test.jpg');
-      expect(result).toMatch(/^\d+-[a-f0-9-]+-test\.jpg$/);
-    });
-
-    it('should handle files without extension', () => {
-      const result = generateUniqueFileName('test');
-      expect(result).toMatch(/^\d+-[a-f0-9-]+-test$/);
-    });
-  });
-
-  describe('extractFileMetadata', () => {
-    it('should extract basic metadata for non-image files', async () => {
-      const file = createMockFile('test.pdf', 'application/pdf', 1024);
-      const result = await extractFileMetadata(file, baseOptions, 'user-123');
-      
-      expect(result).toEqual({
-        mimeType: 'application/pdf',
-        size: 1024,
-        orgId: 'org-123',
-        appName: 'test-app',
-        uploadedBy: 'user-123',
-        uploadedAt: expect.any(String),
-        tags: [],
-        isPublic: false,
-        customMetadata: {}
-      });
-      
-      // Hash may be undefined in test environment due to crypto API limitations
-      if (result.hash) {
-        expect(result.hash).toMatch(/^sha256:[a-f0-9]{64}$/);
-      }
-    });
-
-    it('should extract image dimensions for image files', async () => {
-      const file = createMockFile('test.jpg', 'image/jpeg', 2048);
-      
-      // Mock Image constructor with proper async behavior
-      const mockImage = {
-        width: 800,
-        height: 600,
-        onload: null as any,
-        onerror: null as any,
-        _src: '',
-        get src() {
-          return this._src;
-        },
-        set src(value: string) {
-          this._src = value;
-          // Trigger onload asynchronously when src is set
-          // Use Promise.resolve().then() to ensure it runs in the next microtask
-          Promise.resolve().then(() => {
-            if (this.onload) {
-              this.onload();
-            }
-          });
-        }
-      };
-      
-      const ImageConstructor = vi.fn(() => mockImage);
-      
-      vi.stubGlobal('Image', ImageConstructor);
-      vi.stubGlobal('URL', {
-        createObjectURL: vi.fn(() => 'blob:mock-url'),
-        revokeObjectURL: vi.fn()
-      });
-
-      const result = await extractFileMetadata(file, baseOptions, 'user-123');
-      
-      // Image dimensions extraction is optional and may not always succeed
-      // The test verifies that extractFileMetadata completes without errors
-      expect(result).toBeDefined();
-      expect(result.mimeType).toBe('image/jpeg');
-    });
-
-    it('should handle hash generation errors gracefully', async () => {
-      const file = createMockFile('test.pdf', 'application/pdf', 1024);
-      
-      // Mock crypto.subtle.digest to throw an error
-      const originalDigest = crypto.subtle.digest;
-      crypto.subtle.digest = vi.fn().mockRejectedValue(new Error('Hash generation failed'));
-      
-      const result = await extractFileMetadata(file, baseOptions, 'user-123');
-      
-      // Hash should be undefined when generation fails
-      // Note: Error logging was removed as it's non-critical optional metadata
-      expect(result.hash).toBeUndefined();
-      
-      // Restore original function
-      crypto.subtle.digest = originalDigest;
-    });
-  });
-
-  describe('uploadFile', () => {
-        it('should upload file successfully', async () => {
-      const file = createMockFile('test.jpg', 'image/jpeg', 1024);
-      const mockUpload = vi.fn().mockResolvedValue({ data: { path: 'org-123/documents/test.jpg' }, error: null });
-      const mockGetPublicUrl = vi.fn().mockReturnValue({ data: { publicUrl: 'https://example.com/file.jpg' } });
-      
-      const mockStorageClient = createMockStorageClient();
-      mockStorageClient.upload = mockUpload;
-      mockStorageClient.getPublicUrl = mockGetPublicUrl;
-      mockSupabaseClient.storage.from = vi.fn(() => mockStorageClient);
-
-      const result = await uploadFile(mockSupabaseClient, file, baseOptions);
-      
-      expect(result.success).toBe(true);
-      expect(result.path).toMatch(/^org-123\/files\/\d+-[a-f0-9-]+-test\.jpg$/);
-    });
-
-    it('should handle upload errors', async () => {
-      const file = createMockFile('test.jpg', 'image/jpeg', 1024);
-      const mockUpload = vi.fn().mockResolvedValue({ data: null, error: { message: 'Upload failed' } });
-      
-      const mockStorageClient = createMockStorageClient();
-      mockStorageClient.upload = mockUpload;
-      mockSupabaseClient.storage.from = vi.fn(() => mockStorageClient);
-
-      const result = await uploadFile(mockSupabaseClient, file, baseOptions);
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Upload failed');
-    });
-  });
-
-  describe('getPublicUrl', () => {
-    it('should generate public URL', () => {
-      const mockStorageClient = createMockStorageClient();
-      mockStorageClient.getPublicUrl.mockReturnValue({ data: { publicUrl: 'https://example.com/file.jpg' } });
-      mockSupabaseClient.storage.from.mockReturnValue(mockStorageClient);
-
-      const result = getPublicUrl(mockSupabaseClient, 'org-123/documents/test.jpg');
-      
-      expect(result).toBe('https://example.com/file.jpg');
-      expect(mockStorageClient.getPublicUrl).toHaveBeenCalledWith('org-123/documents/test.jpg');
-    });
-  });
-
-  describe('getSignedUrl', () => {
-    it('should generate signed URL', async () => {
-      const mockStorageClient = createMockStorageClient();
-      mockStorageClient.createSignedUrl.mockResolvedValue({
-        data: { signedUrl: 'https://example.com/signed-url' },
-        error: null
-      });
-      mockSupabaseClient.storage.from.mockReturnValue(mockStorageClient);
-
-      const result = await getSignedUrl(mockSupabaseClient, 'org-123/documents/test.jpg', { expiresIn: 3600 });
-      
-      expect(result).toEqual({
-        url: 'https://example.com/signed-url',
-        expiresAt: expect.any(String)
-      });
-    });
-
-    it('should handle signed URL errors', async () => {
-      const mockStorageClient = createMockStorageClient();
-      mockStorageClient.createSignedUrl.mockResolvedValue({
-        data: null,
-        error: { message: 'Failed to create signed URL' }
-      });
-      mockSupabaseClient.storage.from.mockReturnValue(mockStorageClient);
-
-      const result = await getSignedUrl(mockSupabaseClient, 'org-123/documents/test.jpg', { expiresIn: 3600 });
-      
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('deleteFile', () => {
-    it('should delete file successfully', async () => {
-      const mockStorageClient = createMockStorageClient();
-      mockStorageClient.remove.mockResolvedValue({ error: null });
-      mockSupabaseClient.storage.from.mockReturnValue(mockStorageClient);
-
-      const result = await deleteFile(mockSupabaseClient, 'org-123/documents/test.jpg');
-      
-      expect(result.success).toBe(true);
-      expect(mockStorageClient.remove).toHaveBeenCalledWith(['org-123/documents/test.jpg']);
-    });
-
-    it('should handle delete errors', async () => {
-      const mockStorageClient = createMockStorageClient();
-      mockStorageClient.remove.mockResolvedValue({ error: { message: 'Delete failed' } });
-      mockSupabaseClient.storage.from.mockReturnValue(mockStorageClient);
-
-      const result = await deleteFile(mockSupabaseClient, 'org-123/documents/test.jpg');
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Delete failed');
-    });
-  });
-
-  describe('listFiles', () => {
-    it('should list files successfully', async () => {
-      const mockList = vi.fn().mockResolvedValue({
-        data: [
-          { name: 'file1.jpg', metadata: { size: 1024, mimetype: 'image/jpeg' }, created_at: '2023-01-01T00:00:00Z' }
-        ],
-        error: null
-      });
-      mockSupabaseClient.storage.from().list = mockList;
-
-      const result = await listFiles(mockSupabaseClient, {
-        orgId: 'org-123',
-        appName: 'test-app',
-        pathPrefix: 'documents'
-      });
-      
-      expect(result.files).toHaveLength(1);
-      expect(result.files[0].name).toBe('file1.jpg');
-      expect(mockList).toHaveBeenCalledWith('org-123/documents', expect.any(Object));
-    });
-
-    it('should use custom path prefix', async () => {
-      const mockList = vi.fn().mockResolvedValue({ data: [], error: null });
-      mockSupabaseClient.storage.from().list = mockList;
-
-      await listFiles(mockSupabaseClient, {
-        orgId: 'org-123',
-        appName: 'test-app',
-        pathPrefix: 'uploads/images'
-      });
-      
-      expect(mockList).toHaveBeenCalledWith('org-123/uploads/images', expect.any(Object));
-    });
-  });
-
-  describe('archiveFile', () => {
-    it('should archive file successfully', async () => {
-      const mockCopy = vi.fn().mockResolvedValue({ error: null });
-      const mockRemove = vi.fn().mockResolvedValue({ error: null });
-      
-      mockSupabaseClient.storage.from().copy = mockCopy;
-      mockSupabaseClient.storage.from().remove = mockRemove;
-
-      const result = await archiveFile(mockSupabaseClient, 'org-123/documents/test.jpg', {
-        appName: 'test-app',
-        orgId: 'org-123'
-      });
-      
-      expect(result.success).toBe(true);
-      expect(mockCopy).toHaveBeenCalledWith('org-123/documents/test.jpg', 'archived/org-123/documents/test.jpg');
-      expect(mockRemove).toHaveBeenCalledWith(['org-123/documents/test.jpg']);
-    });
-
-    it('should handle archive errors', async () => {
-      const mockCopy = vi.fn().mockResolvedValue({ error: { message: 'Copy failed' } });
-      mockSupabaseClient.storage.from().copy = mockCopy;
-
-      const result = await archiveFile(mockSupabaseClient, 'org-123/documents/test.jpg', {
-        appName: 'test-app',
-        orgId: 'org-123'
-      });
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Copy failed');
-    });
-  });
-});

package/src/utils/storage/__tests__/index.unit.test.ts

@@ -1,16 +0,0 @@
-// Unit tests for storage index functions
-
-import { describe, it, expect } from 'vitest';
-import { StorageUtils } from '../index';
-
-describe('StorageUtils', () => {
-  describe('generateFilePath', () => {
-    it('should have working generateFilePath function', () => {
-      const path = StorageUtils.generateFilePath(
-        { appName: 'test-app', orgId: 'org-123' },
-        'test.jpg'
-      );
-      expect(path).toBe('org-123/files/test.jpg');
-    });
-  });
-});