@jmruthers/pace-core 0.6.5 → 0.6.7

package/dist/{chunk-RGAWHO7N.js → chunk-L4XMVJKY.js}

@@ -1,33 +1,14 @@
-import {
-  archiveFile,
-  deleteFile,
-  downloadFile,
-  extractFileMetadata,
-  generateFilePath,
-  generateUniqueFileName,
-  getPublicUrl,
-  getSignedUrl,
-  listFiles,
-  uploadFile
-} from "./chunk-UPPMRMYG.js";
-import {
-  useOrganisationSecurity,
-  usePublicPageContext
-} from "./chunk-NTM7ZSB6.js";
-import {
-  useOrganisations
-} from "./chunk-IHB5DR3H.js";
-import {
-  assertOrganisationId
-} from "./chunk-QXHPKYJV.js";
-import {
-  createLogger,
-  logger
-} from "./chunk-PWLANIRT.js";
+import { generateFilePath, generateUniqueFileName, extractFileMetadata, uploadFile, getPublicUrl, getSignedUrl, deleteFile, downloadFile, listFiles, archiveFile } from './chunk-5X4QLXRG.js';
+import { useOrganisationSecurity, usePublicPageContext } from './chunk-VBCS3DUA.js';
+import { useOrganisations } from './chunk-FTCRZOG2.js';
+import { assertOrganisationId } from './chunk-4SXLQIZO.js';
+import { createLogger, logger } from './chunk-TTRFSOKR.js';
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { useState, useMemo, useCallback, useEffect } from 'react';
+import { createClient } from '@supabase/supabase-js';
+import { useParams, useLocation } from 'react-router-dom';
 
-// src/hooks/useZodForm.ts
-import { useForm } from "react-hook-form";
-import { zodResolver } from "@hookform/resolvers/zod";
 function useZodForm({
   schema,
   defaultValues,
@@ -39,9 +20,6 @@ function useZodForm({
     mode
   });
 }
-
-// src/hooks/useFormDialog.ts
-import { useState } from "react";
 function useFormDialog({
   onOpenChange,
   resetOnClose = true
@@ -75,9 +53,6 @@ function useFormDialog({
     handleOpenChange
   };
 }
-
-// src/hooks/useOrganisationPermissions.ts
-import { useMemo } from "react";
 function useOrganisationPermissions(orgId) {
   const {
     selectedOrganisation,
@@ -85,11 +60,8 @@ function useOrganisationPermissions(orgId) {
     validateOrganisationAccess,
     ensureOrganisationContext
   } = useOrganisations();
-  let superAdminContext = { isSuperAdmin: false };
-  try {
-    superAdminContext = useOrganisationSecurity().superAdminContext;
-  } catch {
-  }
+  const organisationSecurity = useOrganisationSecurity();
+  const superAdminContext = organisationSecurity.superAdminContext;
   const organisationId = useMemo(() => {
     if (orgId) {
       return orgId;
@@ -127,8 +99,6 @@ function useOrganisationPermissions(orgId) {
     }
     const isOrgAdmin = userRole === "org_admin";
     const isLeader = userRole === "leader";
-    const isMember = userRole === "member";
-    const isSupporter = userRole === "supporter";
     const isSuperAdmin = superAdminContext.isSuperAdmin;
     return {
       isOrgAdmin,
@@ -197,10 +167,6 @@ StorageUtils.deleteFile = deleteFile;
 StorageUtils.downloadFile = downloadFile;
 StorageUtils.listFiles = listFiles;
 StorageUtils.archiveFile = archiveFile;
-
-// src/hooks/public/usePublicEvent.ts
-import { useState as useState2, useEffect, useCallback, useMemo as useMemo2 } from "react";
-import { createClient } from "@supabase/supabase-js";
 var publicDataCache = /* @__PURE__ */ new Map();
 function usePublicEvent(eventCode, options = {}) {
   const {
@@ -208,19 +174,12 @@ function usePublicEvent(eventCode, options = {}) {
     // 5 minutes
     enableCache = true
   } = options;
-  const [event, setEvent] = useState2(null);
-  const [isLoading, setIsLoading] = useState2(true);
-  const [error, setError] = useState2(null);
-  let environment;
-  try {
-    environment = usePublicPageContext().environment;
-  } catch {
-    environment = {
-      supabaseUrl: import.meta.env?.VITE_SUPABASE_URL || import.meta.env?.NEXT_PUBLIC_SUPABASE_URL || null,
-      supabaseKey: import.meta.env?.VITE_SUPABASE_PUBLISHABLE_KEY || import.meta.env?.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY || null
-    };
-  }
-  const supabase = useMemo2(() => {
+  const [event, setEvent] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const publicPageContext = usePublicPageContext();
+  const environment = publicPageContext.environment;
+  const supabase = useMemo(() => {
     if (typeof window === "undefined") return null;
     if (!environment.supabaseUrl || !environment.supabaseKey) {
       logger.warn("usePublicEvent", "Missing Supabase environment variables. Please ensure VITE_SUPABASE_URL and VITE_SUPABASE_PUBLISHABLE_KEY are set in your environment.");
@@ -228,13 +187,6 @@ function usePublicEvent(eventCode, options = {}) {
     }
     return createClient(environment.supabaseUrl, environment.supabaseKey);
   }, [environment.supabaseUrl, environment.supabaseKey]);
-  const refreshSchemaCache = useCallback(async () => {
-    try {
-      await supabase.from("information_schema.routines").select("routine_name").limit(1);
-    } catch (error2) {
-      logger.debug("usePublicEvent", "Schema cache refresh attempt failed:", error2);
-    }
-  }, [supabase]);
   const fetchEvent = useCallback(async () => {
     if (!eventCode || !supabase) {
       setError(new Error("Invalid event code or Supabase client not available"));
@@ -254,115 +206,40 @@ function usePublicEvent(eventCode, options = {}) {
     try {
       setIsLoading(true);
       setError(null);
-      let eventData = null;
-      try {
-        const response = await supabase.rpc("get_public_event_by_code", {
-          event_code_param: eventCode
-        });
-        const data = response?.data;
-        const rpcError = response?.error;
-        if (rpcError) {
-          if (rpcError.message?.includes("Could not find the function") || rpcError.message?.includes("does not exist") || rpcError.message?.includes("schema cache")) {
-            logger.warn("usePublicEvent", "RPC function not found or schema cache issue, attempting refresh:", rpcError.message);
-            await refreshSchemaCache();
-            try {
-              const retryResponse = await supabase.rpc("get_public_event_by_code", {
-                event_code_param: eventCode
-              });
-              const retryData = retryResponse?.data;
-              const retryError = retryResponse?.error;
-              if (!retryError && retryData && retryData.length > 0) {
-                eventData = retryData[0];
-              } else {
-                throw new Error("RPC still failing after cache refresh");
-              }
-            } catch (retryError) {
-              logger.warn("usePublicEvent", "RPC still failing after cache refresh, falling back to direct table access");
-              const tableResponse2 = await supabase.from("core_events").select(`
-                event_id,
-                event_name,
-                event_date,
-                event_venue,
-                event_participants,
-                event_colours,
-                organisation_id,
-                event_days,
-                event_typicalunit,
-                event_rounddown,
-                event_youthmultiplier,
-                event_catering_email,
-                event_news,
-                event_billing,
-                event_email
-              `).eq("event_code", eventCode).eq("is_visible", true).not("organisation_id", "is", null).limit(1).single();
-              const tableData = tableResponse2?.data;
-              const tableError = tableResponse2?.error;
-              if (tableError) {
-                throw new Error(tableError?.message || "Failed to fetch event from table");
-              }
-              if (!tableData) {
-                setEvent(null);
-                setError(new Error("Event not found"));
-                return;
-              }
-              const logoResponse = await supabase.from("core_file_references").select("file_path").eq("table_name", "core_events").eq("record_id", tableData.event_id).eq("is_public", true).eq("file_metadata->>category", "event_logos").limit(1).single();
-              const logoData = logoResponse?.data;
-              eventData = {
-                ...tableData,
-                event_logo: logoData?.file_path || null
-              };
-            }
-          } else {
-            const errorMessage = rpcError?.message || rpcError?.toString() || "Failed to fetch event";
-            setEvent(null);
-            setError(new Error(errorMessage));
-            setIsLoading(false);
-            return;
-          }
-        } else {
-          if (!data || data.length === 0 || !data[0]) {
-            setEvent(null);
-            setError(new Error("Event not found"));
-            return;
-          }
-          eventData = data[0];
-        }
-      } catch (rpcError) {
-        logger.warn("usePublicEvent", "RPC call failed, falling back to direct table access:", rpcError);
-        const tableResponse = await supabase.from("core_events").select(`
-            event_id,
-            event_name,
-            event_date,
-            event_venue,
-            event_participants,
-            event_colours,
-            organisation_id,
-            event_days,
-            event_typicalunit,
-            event_rounddown,
-            event_youthmultiplier,
-            event_catering_email,
-            event_news,
-            event_billing,
-            event_email
-          `).eq("event_code", eventCode).eq("is_visible", true).not("organisation_id", "is", null).limit(1).single();
-        const tableData = tableResponse?.data;
-        const tableError = tableResponse?.error;
-        if (tableError) {
-          throw new Error(tableError?.message || "Failed to fetch event from table");
-        }
-        if (!tableData) {
-          setEvent(null);
-          setError(new Error("Event not found"));
-          return;
-        }
-        const logoResponse = await supabase.from("core_file_references").select("file_path").eq("table_name", "core_events").eq("record_id", tableData.event_id).eq("is_public", true).eq("file_metadata->>category", "event_logos").limit(1).single();
-        const logoData = logoResponse?.data;
-        eventData = {
-          ...tableData,
-          event_logo: logoData?.file_path || null
-        };
+      const tableResponse = await supabase.from("core_events").select(`
+          event_id,
+          event_name,
+          event_date,
+          event_venue,
+          event_participants,
+          event_colours,
+          organisation_id,
+          event_days,
+          event_typicalunit,
+          event_rounddown,
+          event_youthmultiplier,
+          event_catering_email,
+          event_news,
+          event_billing,
+          event_email
+        `).eq("event_code", eventCode).eq("is_visible", true).not("organisation_id", "is", null).limit(1).single();
+      const tableData = tableResponse?.data;
+      const tableError = tableResponse?.error;
+      if (tableError) {
+        const errorMessage = tableError.message === "No rows found" || tableError.code === "PGRST116" ? "Event not found" : tableError?.message || "Failed to fetch event from table";
+        throw new Error(errorMessage);
+      }
+      if (!tableData) {
+        setEvent(null);
+        setError(new Error("Event not found"));
+        return;
       }
+      const logoResponse = await supabase.from("core_file_references").select("file_path").eq("table_name", "core_events").eq("record_id", tableData.event_id).eq("is_public", true).eq("file_metadata->>category", "event_logos").limit(1).single();
+      const logoData = logoResponse?.data;
+      const eventData = {
+        ...tableData,
+        event_logo: logoData?.file_path || null
+      };
       const transformedEvent = {
         id: eventData.event_id,
         event_id: eventData.event_id,
@@ -426,9 +303,6 @@ function getPublicEventCacheStats() {
     keys
   };
 }
-
-// src/hooks/public/usePublicEventLogo.ts
-import { useState as useState3, useEffect as useEffect2, useCallback as useCallback2, useMemo as useMemo3 } from "react";
 var log = createLogger("usePublicEventLogo");
 var publicDataCache2 = /* @__PURE__ */ new Map();
 function defaultGenerateFallbackText(eventName) {
@@ -444,13 +318,13 @@ function usePublicEventLogo(eventId, eventName, organisationId, options) {
     generateFallbackText = defaultGenerateFallbackText,
     supabase
   } = options;
-  const [logoUrl, setLogoUrl] = useState3(null);
-  const [isLoading, setIsLoading] = useState3(false);
-  const [error, setError] = useState3(null);
-  const fallbackText = useMemo3(() => {
+  const [logoUrl, setLogoUrl] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fallbackText = useMemo(() => {
     return eventName ? generateFallbackText(eventName) : "EV";
   }, [eventName, generateFallbackText]);
-  const fetchLogo = useCallback2(async () => {
+  const fetchLogo = useCallback(async () => {
     if (!eventId || !organisationId || !supabase) {
       setLogoUrl(null);
       setIsLoading(false);
@@ -473,18 +347,19 @@ function usePublicEventLogo(eventId, eventName, organisationId, options) {
     try {
       setIsLoading(true);
       setError(null);
-      const { data, error: rpcError } = await supabase.rpc("get_public_event_logo", {
-        event_id_param: eventId,
-        organisation_id_param: organisationId
-      });
-      if (rpcError) {
-        throw new Error(rpcError.message || "Failed to fetch logo");
+      const { data: logoData, error: queryError } = await supabase.from("core_file_references").select("file_path").eq("table_name", "core_events").eq("record_id", eventId).eq("is_public", true).eq("file_metadata->>category", "event_logos").limit(1).single();
+      if (queryError) {
+        if (queryError.code === "PGRST116") {
+          setLogoUrl(null);
+          return;
+        }
+        throw new Error(queryError.message || "Failed to fetch logo");
       }
-      if (!data || data.length === 0 || !data[0] || !data[0].logo_url) {
+      if (!logoData || !logoData.file_path) {
         setLogoUrl(null);
         return;
       }
-      const logoUrl2 = data[0].logo_url;
+      const logoUrl2 = logoData.file_path;
       if (validateImage) {
         try {
           const response = await fetch(logoUrl2, { method: "HEAD" });
@@ -516,7 +391,7 @@ function usePublicEventLogo(eventId, eventName, organisationId, options) {
       setIsLoading(false);
     }
   }, [eventId, organisationId, supabase, cacheTtl, enableCache, validateImage]);
-  useEffect2(() => {
+  useEffect(() => {
     if (eventId && organisationId) {
       fetchLogo();
     } else {
@@ -525,7 +400,7 @@ function usePublicEventLogo(eventId, eventName, organisationId, options) {
       setError(null);
     }
   }, [fetchLogo, eventId, organisationId]);
-  const refetch = useCallback2(async () => {
+  const refetch = useCallback(async () => {
     if (!eventId || !organisationId) return;
     if (enableCache) {
       const cacheKey = `public_logo_${eventId}_${organisationId}`;
@@ -555,10 +430,6 @@ function getPublicLogoCacheStats() {
     keys
   };
 }
-
-// src/hooks/public/usePublicRouteParams.ts
-import { useState as useState4, useCallback as useCallback3, useMemo as useMemo4 } from "react";
-import { useParams, useLocation } from "react-router-dom";
 function validateEventCodeFormat(eventCode) {
   if (!eventCode || typeof eventCode !== "string") return false;
   if (eventCode.length < 2 || eventCode.length > 50) return false;
@@ -580,9 +451,9 @@ function usePublicRouteParams(options = {}) {
     validateEventCode = true
   } = options;
   const params = useParams();
-  const location = useLocation();
-  const [error, setError] = useState4(null);
-  const eventCode = useMemo4(() => {
+  useLocation();
+  const [error, setError] = useState(null);
+  const eventCode = useMemo(() => {
     const code = params[eventCodeParam];
     if (!code) {
       return null;
@@ -604,20 +475,20 @@ function usePublicRouteParams(options = {}) {
     cacheTtl: 5 * 60 * 1e3
     // 5 minutes
   });
-  const isLoading = useMemo4(() => {
+  const isLoading = useMemo(() => {
     if (!fetchEventData) return false;
     return eventLoading;
   }, [fetchEventData, eventLoading]);
-  const finalError = useMemo4(() => {
+  const finalError = useMemo(() => {
     if (error) return error;
     if (eventError) return eventError;
     return null;
   }, [error, eventError]);
-  const eventId = useMemo4(() => {
+  const eventId = useMemo(() => {
     if (!event) return null;
     return event.event_id || event.id;
   }, [event]);
-  const refetch = useCallback3(async () => {
+  const refetch = useCallback(async () => {
     if (!fetchEventData) return;
     await refetchEvent();
   }, [fetchEventData, refetchEvent]);
@@ -632,7 +503,7 @@ function usePublicRouteParams(options = {}) {
 }
 function usePublicEventCode(eventCodeParam = "eventCode") {
   const params = useParams();
-  const eventCode = useMemo4(() => {
+  const eventCode = useMemo(() => {
     const code = params[eventCodeParam];
     if (!code) {
       return null;
@@ -642,7 +513,7 @@ function usePublicEventCode(eventCodeParam = "eventCode") {
     }
     return code;
   }, [params, eventCodeParam]);
-  const error = useMemo4(() => {
+  const error = useMemo(() => {
     if (!eventCode) {
       return new Error(`Event code parameter '${eventCodeParam}' not found or invalid`);
     }
@@ -669,20 +540,4 @@ function extractEventCodeFromPath(path) {
   return eventCode;
 }
 
-export {
-  useZodForm,
-  useFormDialog,
-  useOrganisationPermissions,
-  StorageUtils,
-  usePublicEvent,
-  clearPublicEventCache,
-  getPublicEventCacheStats,
-  usePublicEventLogo,
-  clearPublicLogoCache,
-  getPublicLogoCacheStats,
-  usePublicRouteParams,
-  usePublicEventCode,
-  generatePublicRoutePath,
-  extractEventCodeFromPath
-};
-//# sourceMappingURL=chunk-RGAWHO7N.js.map
+export { StorageUtils, clearPublicEventCache, clearPublicLogoCache, extractEventCodeFromPath, generatePublicRoutePath, getPublicEventCacheStats, getPublicLogoCacheStats, useFormDialog, useOrganisationPermissions, usePublicEvent, usePublicEventCode, usePublicEventLogo, usePublicRouteParams, useZodForm };

package/dist/chunk-MBADTM7L.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+
+// src/utils/validation/schema.ts
+function pickSchema(schema, keys) {
+  const shape = Object.entries(schema.shape).filter(([key]) => keys.includes(key)).reduce((acc, [key, value]) => {
+    acc[key] = value;
+    return acc;
+  }, {});
+  return z.object(shape);
+}
+function combineSchemas(schemas) {
+  return schemas.reduce(
+    (merged, schema) => merged.merge(schema),
+    z.object({})
+  );
+}
+var emailSchema = z.string().email("Please enter a valid email address");
+var nameSchema = z.string().min(1, "Name is required").max(100, "Name must be less than 100 characters");
+var phoneSchema = z.string().regex(/^\+?[\d\s\-\(\)]+$/, "Please enter a valid phone number");
+var urlSchema = z.string().url("Please enter a valid URL");
+var dateSchema = z.string().refine((date) => !isNaN(Date.parse(date)), "Please enter a valid date");
+var passwordSchema = z.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number");
+var securePasswordSchema = passwordSchema.regex(/[!@#$%^&*(),.?":{}|<>]/, "Password must contain at least one special character");
+var loginSchema = z.object({
+  email: emailSchema,
+  password: z.string().min(1, "Password is required")
+});
+var registrationSchema = z.object({
+  email: emailSchema,
+  password: passwordSchema,
+  confirmPassword: z.string()
+}).refine((data) => data.password === data.confirmPassword, {
+  message: "Passwords don't match",
+  path: ["confirmPassword"]
+});
+var secureLoginSchema = z.object({
+  email: emailSchema,
+  password: securePasswordSchema
+});
+var passwordResetSchema = z.object({
+  email: emailSchema
+});
+var changePasswordSchema = z.object({
+  currentPassword: z.string().min(1, "Current password is required"),
+  newPassword: securePasswordSchema,
+  confirmPassword: z.string()
+}).refine((data) => data.newPassword === data.confirmPassword, {
+  message: "Passwords don't match",
+  path: ["confirmPassword"]
+});
+var userProfileSchema = z.object({
+  name: nameSchema,
+  email: emailSchema,
+  phone: phoneSchema.optional(),
+  website: urlSchema.optional(),
+  bio: z.string().max(500).optional()
+});
+var contactFormSchema = z.object({
+  name: nameSchema,
+  email: emailSchema,
+  message: z.string().min(1, "Message is required").max(1e3, "Message must be less than 1000 characters")
+});
+
+export { changePasswordSchema, combineSchemas, contactFormSchema, dateSchema, emailSchema, loginSchema, nameSchema, passwordResetSchema, passwordSchema, phoneSchema, pickSchema, registrationSchema, secureLoginSchema, securePasswordSchema, urlSchema, userProfileSchema };

package/dist/{chunk-M7MPQISP.js → chunk-OJ4SKRSV.js}

@@ -1,9 +1,5 @@
-import {
-  createLogger
-} from "./chunk-PWLANIRT.js";
-import {
-  __require
-} from "./chunk-DGUM43GV.js";
+import { createLogger } from './chunk-TTRFSOKR.js';
+import { __require } from './chunk-3RG5ZIWI.js';
 
 // src/utils/app/appNameResolver.ts
 var log = createLogger("AppNameResolver");
@@ -106,13 +102,4 @@ function getCurrentAppNameWithFallback(fallback = "default-app") {
   return getCurrentAppName() || fallback;
 }
 
-export {
-  getAppNameFromPackageJson,
-  getAppNameFromBuildTime,
-  getAppNameFromGlobal,
-  getAppNameFromEnvironment,
-  getCurrentAppName,
-  setRBACAppName,
-  getCurrentAppNameWithFallback
-};
-//# sourceMappingURL=chunk-M7MPQISP.js.map
+export { getAppNameFromBuildTime, getAppNameFromEnvironment, getAppNameFromGlobal, getAppNameFromPackageJson, getCurrentAppName, getCurrentAppNameWithFallback, setRBACAppName };