@jmruthers/pace-core 0.5.185 → 0.5.187

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

@@ -0,0 +1,94 @@
+/**
+ * @file Google Places API Types
+ * @package @jmruthers/pace-core
+ * @module Utils/GooglePlaces
+ * @since 0.1.0
+ */
+
+/**
+ * Google Places Autocomplete API response prediction
+ */
+export interface GooglePlaceAutocompletePrediction {
+  description: string;
+  place_id: string;
+  structured_formatting?: {
+    main_text: string;
+    secondary_text: string;
+  };
+  types?: string[];
+}
+
+/**
+ * Google Places Autocomplete API response
+ */
+export interface GooglePlaceAutocompleteResponse {
+  predictions: GooglePlaceAutocompletePrediction[];
+  status: string;
+  error_message?: string;
+}
+
+/**
+ * Google Places Details API address component
+ */
+export interface GoogleAddressComponent {
+  long_name: string;
+  short_name: string;
+  types: string[];
+}
+
+/**
+ * Google Places Details API geometry
+ */
+export interface GoogleGeometry {
+  location: {
+    lat: number;
+    lng: number;
+  };
+}
+
+/**
+ * Google Places Details API response
+ */
+export interface GooglePlaceDetailsResponse {
+  result: {
+    place_id: string;
+    formatted_address: string;
+    address_components: GoogleAddressComponent[];
+    geometry: GoogleGeometry;
+  };
+  status: string;
+  error_message?: string;
+}
+
+/**
+ * Parsed address matching pace_address table structure
+ */
+export interface ParsedAddress {
+  place_id: string;
+  full_address: string | null;
+  street_number: string | null;
+  route: string | null;
+  suburb: string | null;
+  state: string | null;
+  postcode: string | null;
+  country: string | null;
+  lat: number | null;
+  lng: number | null;
+}
+
+/**
+ * Options for Google Places Autocomplete API
+ */
+export interface AutocompleteOptions {
+  /** Restrict results to specific countries (ISO 3166-1 Alpha-2 country codes) */
+  components?: string;
+  /** Location bias (lat,lng) */
+  location?: string;
+  /** Radius in meters for location bias */
+  radius?: number;
+  /** Restrict results to specific place types */
+  types?: string;
+  /** Language code for results */
+  language?: string;
+}
+

package/src/utils/index.ts

@@ -156,3 +156,26 @@ export {
   getGoogleMapsUrl
 } from './location';
 export type { Coordinates } from './location';
+
+// Google Places utilities
+export {
+  fetchPlaceAutocomplete,
+  fetchPlaceDetails,
+  parseAddressComponents,
+  createAddressFromPlaceResult,
+  getAddressByPlaceId,
+} from './google-places';
+export type {
+  GooglePlaceAutocompletePrediction,
+  ParsedAddress,
+  AutocompleteOptions,
+} from './google-places';
+
+// Request deduplication utilities
+export {
+  generateRequestKey,
+  getOrCreateRequest,
+  clearInFlightRequests,
+  getInFlightRequestStats,
+  deduplicatedQuery
+} from './request-deduplication';

package/src/utils/request-deduplication.ts

@@ -0,0 +1,165 @@
+/**
+ * Request Deduplication Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/RequestDeduplication
+ * @since 2.0.0
+ * 
+ * Provides request deduplication to prevent duplicate in-flight requests.
+ * When multiple components request the same data simultaneously, only one
+ * request is made and all callers share the same promise.
+ */
+
+import { createLogger } from './core/logger';
+
+const log = createLogger('request-deduplication');
+
+/**
+ * In-flight request cache
+ * Key: request identifier (e.g., "GET:table:filter:value")
+ * Value: Promise that resolves to the request result
+ */
+const inFlightRequests = new Map<string, Promise<any>>();
+
+/**
+ * Generate a request key from request parameters
+ * 
+ * @param method - HTTP method (GET, POST, etc.)
+ * @param table - Table name
+ * @param filters - Filter object
+ * @param select - Select columns
+ * @returns Request key string
+ */
+export function generateRequestKey(
+  method: string,
+  table: string,
+  filters?: Record<string, any>,
+  select?: string
+): string {
+  const filterStr = filters ? JSON.stringify(filters) : '';
+  const selectStr = select || '*';
+  return `${method}:${table}:${filterStr}:${selectStr}`;
+}
+
+/**
+ * Get or create a request
+ * 
+ * If a request with the same key is already in-flight, returns the existing promise.
+ * Otherwise, creates a new request and stores it for deduplication.
+ * 
+ * @param key - Request key
+ * @param requestFn - Function that performs the actual request
+ * @returns Promise that resolves to the request result
+ * 
+ * @example
+ * ```ts
+ * const data = await getOrCreateRequest(
+ *   'GET:pace_person:{"user_id":"123"}',
+ *   async () => {
+ *     const { data } = await supabase
+ *       .from('pace_person')
+ *       .select('id, first_name')
+ *       .eq('user_id', '123')
+ *       .single();
+ *     return data;
+ *   }
+ * );
+ * ```
+ */
+export async function getOrCreateRequest<T>(
+  key: string,
+  requestFn: () => Promise<T>
+): Promise<T> {
+  // Check if request is already in-flight
+  const existingRequest = inFlightRequests.get(key);
+  if (existingRequest) {
+    log.debug(`Request deduplication: reusing in-flight request for ${key}`);
+    return existingRequest as Promise<T>;
+  }
+  
+  // Create new request
+  log.debug(`Creating new request for ${key}`);
+  const requestPromise = requestFn()
+    .then((result) => {
+      // Remove from in-flight cache after completion
+      inFlightRequests.delete(key);
+      return result;
+    })
+    .catch((error) => {
+      // Remove from in-flight cache on error
+      inFlightRequests.delete(key);
+      throw error;
+    });
+  
+  // Store in-flight request
+  inFlightRequests.set(key, requestPromise);
+  
+  return requestPromise;
+}
+
+/**
+ * Clear all in-flight requests
+ * 
+ * Useful for cleanup or testing.
+ */
+export function clearInFlightRequests(): void {
+  const count = inFlightRequests.size;
+  inFlightRequests.clear();
+  log.debug(`Cleared ${count} in-flight requests`);
+}
+
+/**
+ * Get statistics about in-flight requests
+ * 
+ * @returns Statistics object
+ */
+export function getInFlightRequestStats(): {
+  count: number;
+  keys: string[];
+} {
+  return {
+    count: inFlightRequests.size,
+    keys: Array.from(inFlightRequests.keys()),
+  };
+}
+
+/**
+ * Supabase query wrapper with automatic deduplication
+ * 
+ * Wraps a Supabase query to automatically deduplicate identical requests.
+ * 
+ * @param supabase - Supabase client
+ * @param table - Table name
+ * @param filters - Filter object (e.g., { user_id: '123' })
+ * @param select - Select columns (default: '*')
+ * @param requestFn - Function that performs the query
+ * @returns Promise that resolves to query result
+ * 
+ * @example
+ * ```ts
+ * const person = await deduplicatedQuery(
+ *   supabase,
+ *   'pace_person',
+ *   { user_id: userId },
+ *   'id, first_name, last_name',
+ *   async () => {
+ *     const { data } = await supabase
+ *       .from('pace_person')
+ *       .select('id, first_name, last_name')
+ *       .eq('user_id', userId)
+ *       .single();
+ *     return data;
+ *   }
+ * );
+ * ```
+ */
+export async function deduplicatedQuery<T>(
+  supabase: any,
+  table: string,
+  filters: Record<string, any>,
+  select: string,
+  requestFn: () => Promise<T>
+): Promise<T> {
+  const key = generateRequestKey('GET', table, filters, select);
+  return getOrCreateRequest(key, requestFn);
+}
+

package/src/utils/security/secureDataAccess.ts

@@ -102,7 +102,7 @@ export const createSecureDataAccess = (
       'cake_meal', 'cake_mealtype', 'pace_person', 'pace_member',
       // SECURITY: Phase 3A additions - medical and personal data
       'medi_profile', 'medi_condition', 'medi_diet', 'medi_action_plan', 'medi_profile_versions',
-      'pace_consent', 'pace_contact', 'pace_id_documents', 'pace_qualifications',
+      'pace_consent', 'pace_contact', 'pace_identification', 'pace_identification_type', 'pace_qualification',
       'form_responses', 'form_response_values', 'forms',
       // SECURITY: Phase 3B additions - remaining critical tables
       'invoice', 'line_item', 'credit_balance', 'payment_method',

package/src/utils/storage/helpers.ts

@@ -30,21 +30,21 @@ export function generateFilePath(options: StorageUploadOptions, fileName: string
   }
   
   if (isPublic) {
-    // Public files go to {orgId}/{category}/filename
+    // Public files go to {orgId}/{folder}/filename
     if (customPath) {
       return `${orgId}/${customPath}/${fileName}`;
     }
     return `${orgId}/public/${fileName}`;
   }
   
-  // Organization-first structure: {orgId}/{category}/filename
+  // Organization-first structure: {orgId}/{folder}/filename
   if (customPath) {
     return `${orgId}/${customPath}/${fileName}`;
   }
   
   // Use customPath if available, otherwise default to files
-  const pathCategory = customPath || 'files';
-  return `${orgId}/${pathCategory}/${fileName}`;
+  const pathFolder = customPath || 'files';
+  return `${orgId}/${pathFolder}/${fileName}`;
 }
 
 /**
@@ -153,6 +153,66 @@ async function generateFileHash(file: File): Promise<string> {
   return `sha256:${hashHex}`;
 }
 
+/**
+ * Ensure a folder exists in the storage bucket
+ * In Supabase storage, folders are created automatically when files are uploaded,
+ * but this function explicitly creates the folder structure by uploading a placeholder
+ * file if the folder doesn't exist
+ * @param supabase - Supabase client instance
+ * @param folderPath - Folder path to ensure exists (e.g., 'orgId/folder')
+ * @param bucketName - Bucket name
+ * @returns True if folder exists or was created, false on error
+ */
+async function ensureFolderExists(
+  supabase: SupabaseClient,
+  folderPath: string,
+  bucketName: string
+): Promise<boolean> {
+  try {
+    // Check if folder exists by trying to list it
+    const { data, error } = await supabase.storage
+      .from(bucketName)
+      .list(folderPath, {
+        limit: 1
+      });
+
+    // If listing succeeds (even with empty data), the folder exists
+    if (!error) {
+      return true;
+    }
+
+    // If we get a "not found" error, the folder doesn't exist yet
+    // Create it by uploading a placeholder file
+    // Supabase storage doesn't support empty folders, so we create a .keep file
+    const placeholderPath = `${folderPath}/.keep`;
+    const placeholderBlob = new Blob([''], { type: 'text/plain' });
+    const placeholderFile = new File([placeholderBlob], '.keep', { type: 'text/plain' });
+
+    const { error: uploadError } = await supabase.storage
+      .from(bucketName)
+      .upload(placeholderPath, placeholderFile, {
+        cacheControl: '3600',
+        upsert: true, // Use upsert to avoid errors if file already exists
+        contentType: 'text/plain'
+      });
+
+    if (uploadError) {
+      // If we can't create the placeholder, log it but don't fail
+      // The folder will be created automatically when we upload the actual file
+      log.debug(`Could not create folder placeholder (will be created on upload): ${uploadError.message}`);
+      return true; // Still return true - folder will be created on actual file upload
+    }
+
+    // Folder structure now exists
+    return true;
+  } catch (error) {
+    // If there's an exception, log it but proceed anyway
+    // The folder structure will be created when we upload the actual file
+    log.debug(`Folder creation exception (will be created on upload): ${error instanceof Error ? error.message : 'Unknown error'}`);
+    return true; // Return true to proceed - folder will be created on actual file upload
+  }
+}
+
 /**
  * Upload a file to Supabase storage with app segregation
  */
@@ -175,13 +235,21 @@ export async function uploadFile(
     const uniqueFileName = generateUniqueFileName(file.name);
     const filePath = generateFilePath(options, uniqueFileName);
 
+    // Extract folder path from file path (everything except the filename)
+    const folderPath = filePath.substring(0, filePath.lastIndexOf('/'));
+
     // Extract metadata
     const metadata = await extractFileMetadata(file, options, 'current-user'); // TODO: Get actual user ID
 
     // Select bucket based on isPublic flag
     const bucketName = getBucketName(options.isPublic || false);
 
+    // Ensure folder exists (Supabase creates folders automatically on upload,
+    // but we verify the path is accessible)
+    await ensureFolderExists(supabase, folderPath, bucketName);
+
     // Upload file to Supabase
+    // Note: Supabase will automatically create the folder structure if it doesn't exist
     const { data, error } = await supabase.storage
       .from(bucketName)
       .upload(filePath, file, {
@@ -352,6 +420,145 @@ export async function getSignedUrl(
   }
 }
 
+// Global URL cache for batch operations (shared with useFileUrlCache)
+const globalUrlCache = new Map<string, { url: string; expiresAt: number }>();
+const MAX_CACHE_SIZE = 500;
+const DEFAULT_TTL_MS = 3600 * 1000;
+
+function getCacheKey(fileId: string, filePath: string, isPublic: boolean): string {
+  return `file-url:${fileId}:${isPublic ? 'public' : 'private'}`;
+}
+
+function cleanupUrlCache(): void {
+  const now = Date.now();
+  
+  // Remove expired entries
+  for (const [key, value] of globalUrlCache.entries()) {
+    if (value.expiresAt < now) {
+      globalUrlCache.delete(key);
+    }
+  }
+  
+  // Enforce size limit by removing oldest entries
+  if (globalUrlCache.size > MAX_CACHE_SIZE) {
+    const entries = Array.from(globalUrlCache.entries());
+    entries.sort((a, b) => a[1].expiresAt - b[1].expiresAt);
+    
+    const toRemove = Math.floor(MAX_CACHE_SIZE * 0.2);
+    for (let i = 0; i < toRemove && i < entries.length; i++) {
+      globalUrlCache.delete(entries[i][0]);
+    }
+  }
+}
+
+/**
+ * Generate URLs for multiple file references in parallel
+ * This batches URL generation to reduce sequential requests and uses caching
+ * @param supabase - Supabase client instance
+ * @param fileReferences - Array of file references to generate URLs for
+ * @param options - URL options including expiry time and organisation ID
+ * @returns Map of file ID to URL string (only includes successful URL generations)
+ */
+export async function generateFileUrlsBatch(
+  supabase: SupabaseClient,
+  fileReferences: Array<{ id: string; file_path: string; is_public: boolean }>,
+  options: StorageUrlOptions & { orgId?: string }
+): Promise<Map<string, string>> {
+  const urlMap = new Map<string, string>();
+  
+  if (fileReferences.length === 0) {
+    return urlMap;
+  }
+
+  const now = Date.now();
+  const ttl = (options.expiresIn || 3600) * 1000; // Convert seconds to milliseconds
+  
+  // Separate files into cached, public, and private
+  const publicFiles: Array<{ id: string; file_path: string }> = [];
+  const privateFiles: Array<{ id: string; file_path: string }> = [];
+  const uncachedFiles: Array<{ id: string; file_path: string; is_public: boolean }> = [];
+
+  for (const fileRef of fileReferences) {
+    const cacheKey = getCacheKey(fileRef.id, fileRef.file_path, fileRef.is_public);
+    const cached = globalUrlCache.get(cacheKey);
+    
+    // Use cached URL if still valid
+    if (cached && cached.expiresAt > now) {
+      urlMap.set(fileRef.id, cached.url);
+      continue;
+    }
+    
+    // Add to processing queue
+    if (fileRef.is_public) {
+      publicFiles.push({ id: fileRef.id, file_path: fileRef.file_path });
+    } else {
+      privateFiles.push({ id: fileRef.id, file_path: fileRef.file_path });
+    }
+    uncachedFiles.push(fileRef);
+  }
+
+  // Generate public URLs synchronously (they're just string concatenation)
+  for (const file of publicFiles) {
+    try {
+      const url = getPublicUrl(supabase, file.file_path, true);
+      if (url) {
+        urlMap.set(file.id, url);
+        // Cache the URL
+        const cacheKey = getCacheKey(file.id, file.file_path, true);
+        globalUrlCache.set(cacheKey, {
+          url,
+          expiresAt: now + ttl
+        });
+      }
+    } catch (err) {
+      log.error(`Failed to generate public URL for file ${file.id}:`, err);
+    }
+  }
+
+  // Generate signed URLs in parallel using Promise.all
+  if (privateFiles.length > 0) {
+    const signedUrlPromises = privateFiles.map(async (file) => {
+      try {
+        const signedUrlResult = await getSignedUrl(supabase, file.file_path, {
+          appName: options.appName || 'pace-core',
+          orgId: options.orgId,
+          expiresIn: options.expiresIn || 3600
+        });
+        const url = signedUrlResult?.url || null;
+        
+        // Cache the URL if generated successfully
+        if (url) {
+          const cacheKey = getCacheKey(file.id, file.file_path, false);
+          globalUrlCache.set(cacheKey, {
+            url,
+            expiresAt: now + ttl
+          });
+        }
+        
+        return { id: file.id, url };
+      } catch (err) {
+        log.error(`Failed to generate signed URL for file ${file.id}:`, err);
+        return { id: file.id, url: null };
+      }
+    });
+
+    const signedUrlResults = await Promise.all(signedUrlPromises);
+    
+    for (const result of signedUrlResults) {
+      if (result.url) {
+        urlMap.set(result.id, result.url);
+      }
+    }
+  }
+
+  // Clean up cache after adding new entries
+  if (uncachedFiles.length > 0) {
+    cleanupUrlCache();
+  }
+
+  return urlMap;
+}
+
 /**
  * Delete a file from storage
  * @param supabase - Supabase client instance