@jmruthers/pace-core 0.6.9 → 0.6.11

package/dist/eslint-rules/rules/06-security-rbac.cjs

@@ -9,6 +9,16 @@
  * - No wrapper components/functions around RBAC hooks
  * - Proper permission loading state handling
  * 
+ * Note: This file contains TypeScript/JavaScript ESLint rules. For SQL migration
+ * validation (including SECURITY DEFINER function checks), see the audit tool:
+ * packages/core/audit-tool/audits/06-security-rbac.cjs
+ * 
+ * SECURITY DEFINER Requirements (for SQL functions):
+ * - SECURITY DEFINER is REQUIRED when helper functions query RLS-protected tables
+ * - All SECURITY DEFINER functions MUST have SET search_path TO public
+ * - All table/function references MUST be schema-qualified
+ * - Functions MUST document why SECURITY DEFINER is needed
+ * 
  * Reference: packages/core/docs/standards/6-security-rbac-standards.md
  */
 
@@ -805,6 +815,80 @@ module.exports = {
           }
         };
       }
+    },
+
+    /**
+     * Require derived organisationId when both selectedOrganisation and selectedEvent are in scope.
+     * Prevents incorrect org resolution when event is selected without an explicit org (e.g. RPCs
+     * getting undefined instead of selectedEvent.organisation_id).
+     */
+    'require-derived-organisation-id': {
+      meta: {
+        type: 'problem',
+        docs: {
+          description: 'When both selectedOrganisation and selectedEvent are in scope, use a derived organisationId (selectedOrganisation?.id ?? selectedEvent?.organisation_id) for p_organisation_id, organisation_id, and selectedOrganisationId so org is resolved correctly when an event is selected without an explicit org.',
+          category: 'Security',
+          recommended: true,
+          url: 'https://github.com/jmruthers/pace-core/blob/main/packages/core/docs/standards/6-security-rbac-standards.md'
+        },
+        messages: {
+          useDerivedOrgId: "Organisation context ({{key}}) is set from selectedOrganisation?.id while selectedEvent is in scope. Use a derived organisationId (e.g. selectedOrganisation?.id ?? selectedEvent?.organisation_id) so org is resolved correctly when an event is selected without an explicit org."
+        },
+        schema: []
+      },
+      create(context) {
+        const filename = context.getFilename();
+        if (isPaceCoreSourceFile(filename)) {
+          return {};
+        }
+        const sourceCode = context.getSourceCode();
+        const fileText = sourceCode.getText();
+        const hasOrg = /\bselectedOrganisation\b|useOrganisations\s*\(/.test(fileText);
+        const hasEvent = /\bselectedEvent\b|useEvents\s*\(/.test(fileText);
+        if (!hasOrg || !hasEvent) {
+          return {};
+        }
+
+        const orgParamKeys = new Set(['p_organisation_id', 'organisation_id', 'selectedOrganisationId']);
+
+        return {
+          Property(node) {
+            const keyName = node.key && (node.key.name || (node.key.type === 'Literal' && node.key.value));
+            if (!keyName || !orgParamKeys.has(keyName)) return;
+            const value = node.value;
+            if (!value) return;
+            let usesSelectedOrgId = false;
+            if (value.type === 'MemberExpression' || value.type === 'OptionalMemberExpression') {
+              const obj = value.object;
+              const prop = value.property;
+              if (obj.type === 'Identifier' && obj.name === 'selectedOrganisation' &&
+                  prop && (prop.name === 'id' || (prop.type === 'Literal' && prop.value === 'id'))) {
+                usesSelectedOrgId = true;
+              }
+            }
+            if (value.type === 'LogicalExpression' && value.operator === '||') {
+              const left = value.left;
+              const right = value.right;
+              const check = (n) => n.type === 'MemberExpression' && n.object.type === 'Identifier' &&
+                n.object.name === 'selectedOrganisation' && n.property && n.property.name === 'id';
+              if (check(left) || check(right)) usesSelectedOrgId = true;
+            }
+            if (usesSelectedOrgId) {
+              context.report({
+                node: value,
+                messageId: 'useDerivedOrgId',
+                data: { key: keyName },
+                suggest: [{
+                  desc: 'Use derived organisationId (selectedOrganisation?.id ?? selectedEvent?.organisation_id)',
+                  fix(fixer) {
+                    return null;
+                  }
+                }]
+              });
+            }
+          }
+        };
+      }
     }
   }
 };

package/dist/event-BfCox3N2.d.ts

@@ -0,0 +1,265 @@
+import { U as UserId, O as OrganisationId } from './core-CUElvH_C.js';
+
+/**
+ * @file Organisation Types
+ * @package @jmruthers/pace-core
+ * @module Types/Organisation
+ * @since 1.0.0
+ *
+ * Type definitions for organisations, memberships, roles, and organisation context.
+ */
+
+interface Organisation {
+    id: string;
+    name: string;
+    display_name: string;
+    description?: string;
+    parent_id?: string;
+    subscription_tier: string;
+    settings: Record<string, unknown>;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+    created_by?: string;
+    updated_by?: string;
+}
+interface OrganisationMembership {
+    id: string;
+    user_id: UserId;
+    organisation_id: OrganisationId;
+    role: 'org_admin' | 'leader' | 'member' | 'supporter';
+    status: 'active' | 'inactive' | 'suspended';
+    granted_at: string;
+    granted_by?: string;
+    revoked_at?: string;
+    revoked_by?: string;
+    notes?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface UserProfile {
+    id: UserId;
+    email: string;
+    full_name?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface OrganisationSettings {
+    organisation_id: OrganisationId;
+    logo_url?: string;
+    primary_color?: string;
+    secondary_color?: string;
+    website_url?: string;
+    contact_email?: string;
+    phone?: string;
+    address?: Record<string, unknown>;
+    timezone?: string;
+    date_format?: string;
+    currency?: string;
+    language?: string;
+    custom_css?: string;
+    email_templates?: Record<string, unknown>;
+    notification_settings?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+    created_by?: string;
+    updated_by?: string;
+}
+interface OrganisationInvitation {
+    id: string;
+    organisation_id: OrganisationId;
+    email: string;
+    role: 'supporter' | 'member' | 'leader' | 'org_admin';
+    invited_by?: string;
+    expires_at: string;
+    accepted_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+interface OrganisationRoleDefinition {
+    id: string;
+    name: string;
+    display_name: string;
+    description?: string;
+    permissions: Record<string, unknown>;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface SuperAdminContext {
+    isSuperAdmin: boolean;
+    hasGlobalAccess: boolean;
+    canManageAllOrganisations: boolean;
+}
+interface OrganisationSecurityError extends Error {
+    name: 'OrganisationSecurityError';
+    code: string;
+    organisationId?: string;
+    userId?: string;
+}
+/** Organisation context state (ISP). */
+interface OrganisationContextState {
+    selectedOrganisation: Organisation | null;
+    organisations: Organisation[];
+    userMemberships: OrganisationMembership[];
+    isLoading: boolean;
+    error: Error | null;
+    hasValidOrganisationContext: boolean;
+    isContextReady: boolean;
+}
+/** Organisation context methods (ISP). */
+interface OrganisationContextMethods {
+    setSelectedOrganisation: (org: Organisation | null) => void;
+    switchOrganisation: (orgId: string) => Promise<void>;
+    getUserRole: (orgId?: string) => string;
+    validateOrganisationAccess: (orgId: string) => boolean;
+    ensureOrganisationContext: () => Organisation;
+    refreshOrganisations: () => Promise<void>;
+    getPrimaryOrganisation: () => Organisation | null;
+    isOrganisationSecure: () => boolean;
+}
+/** Enhanced organisation context features (ISP). */
+interface OrganisationContextEnhanced {
+    getOrganisationHierarchy?: (orgId: string) => Promise<OrganisationHierarchy[]>;
+    canAccessChildOrganisations?: (orgId: string) => boolean;
+    validateUserAccess?: (userId: string, orgId: string) => Promise<boolean>;
+    getUserPermissions?: (orgId?: string) => Promise<string[]>;
+    logOrganisationAccess?: (action: string, details?: unknown) => Promise<void>;
+}
+/** Organisation context type (ISP: composed from focused interfaces). */
+type OrganisationContextType = OrganisationContextState & OrganisationContextMethods & OrganisationContextEnhanced;
+interface OrganisationHierarchy {
+    organisation: Organisation;
+    children: OrganisationHierarchy[];
+    parent?: Organisation;
+    depth: number;
+}
+declare const ORGANISATION_ROLE_PERMISSIONS: {
+    readonly supporter: readonly ["view_basic"];
+    readonly member: readonly ["view_basic", "view_details"];
+    readonly leader: readonly ["view_basic", "view_details", "moderate_content", "manage_events"];
+    readonly org_admin: readonly ["view_basic", "view_details", "moderate_content", "manage_events", "manage_members", "manage_settings"];
+};
+type OrganisationRole = keyof typeof ORGANISATION_ROLE_PERMISSIONS;
+type OrganisationPermission = 'view_basic' | 'view_details' | 'moderate_content' | 'manage_events' | 'manage_members' | 'manage_settings' | '*';
+interface OrganisationAccessLog {
+    id: string;
+    user_id: UserId;
+    organisation_id: OrganisationId;
+    action: string;
+    details: Record<string, unknown>;
+    created_at: string;
+}
+interface SecureQueryOptions {
+    table: string;
+    select: string;
+    filters?: Record<string, unknown>;
+    organisationId: OrganisationId;
+    userId?: UserId;
+}
+
+/**
+ * @file Event Types
+ * @package @jmruthers/pace-core
+ * @module Types/Event
+ * @since 1.0.0
+ *
+ * Type definitions for events, event themes, and event context.
+ */
+
+/**
+ * Theme color configuration
+ */
+interface ThemeColors {
+    primary: string;
+    secondary: string;
+    hover?: string;
+    active?: string;
+    bgSoft?: string;
+}
+/**
+ * Event theme configuration with multiple color variants
+ */
+interface EventTheme {
+    mid: ThemeColors;
+    light: ThemeColors;
+}
+/** Primary identification for Event (ISP). */
+interface EventIdentity {
+    id: string;
+    event_id: string;
+    event_name: string;
+    event_code?: string;
+}
+/** Organisation context for Event - MANDATORY for security (ISP). */
+interface EventOrganisation {
+    organisation_id: OrganisationId;
+}
+/** Event details (ISP). */
+interface EventDetails {
+    event_date?: string;
+    event_days?: number;
+    event_venue?: string;
+    event_participants?: number;
+    is_visible?: boolean;
+}
+/** Visual branding for Event (ISP). */
+interface EventBranding {
+    /** @deprecated Use file_references table instead */
+    event_logo?: string | null;
+    event_colours?: Record<string, unknown> | null;
+    event_col_d1?: string;
+    event_col_d2?: string;
+    event_col_m1?: string;
+    event_col_m2?: string;
+    event_col_l1?: string;
+    event_col_l2?: string;
+}
+/** Additional metadata for Event (ISP). */
+interface EventMetadata {
+    event_news?: string;
+    event_billing?: string;
+    event_catering_email?: string;
+    event_email?: string;
+    event_footer?: string;
+    event_rounddown?: number;
+    event_youthmultiplier?: number;
+    event_typicalunit?: number;
+}
+/** Timestamps for Event (ISP). */
+interface EventTimestamps {
+    created_at: string;
+    updated_at: string;
+    created_by?: string;
+    updated_by?: string;
+}
+/** Additional optional fields for Event (ISP). */
+interface EventOptional {
+    description?: string;
+    end_date?: string;
+    theme_colors?: EventTheme;
+}
+/**
+ * Event type matching the database schema (ISP: composed from focused interfaces).
+ * All events must have an organisation_id for security.
+ */
+type Event = EventIdentity & EventOrganisation & EventDetails & EventBranding & EventMetadata & EventTimestamps & EventOptional;
+/**
+ * Event context type for event management hooks and providers
+ */
+interface EventContextType {
+    selectedEvent: Event | null;
+    currentEvent: Event | null;
+    events: Event[];
+    isLoading: boolean;
+    error: string | null;
+    selectEvent: (event: Event) => void;
+    setCurrentEvent: (event: Event | null) => void;
+    clearSelection: () => void;
+    refreshEvents: () => Promise<void>;
+    createEvent: (event: Partial<Event>) => Promise<Event>;
+    updateEvent: (id: string, updates: Partial<Event>) => Promise<Event>;
+    deleteEvent: (id: string) => Promise<void>;
+}
+
+export { type EventTheme as E, type Organisation as O, type SuperAdminContext as S, type ThemeColors as T, type UserProfile as U, type EventIdentity as a, type EventOrganisation as b, type EventDetails as c, type EventBranding as d, type EventMetadata as e, type EventTimestamps as f, type EventOptional as g, type Event as h, type EventContextType as i, type OrganisationMembership as j, type OrganisationSettings as k, type OrganisationInvitation as l, type OrganisationRoleDefinition as m, type OrganisationSecurityError as n, type OrganisationContextState as o, type OrganisationContextMethods as p, type OrganisationContextEnhanced as q, type OrganisationContextType as r, type OrganisationHierarchy as s, ORGANISATION_ROLE_PERMISSIONS as t, type OrganisationRole as u, type OrganisationPermission as v, type OrganisationAccessLog as w, type SecureQueryOptions as x };

package/dist/file-reference-DU1hcawx.d.ts

@@ -0,0 +1,164 @@
+import { A as AppId } from './core-CUElvH_C.js';
+import { A as ApiResult } from './api-result-USV1Czr-.js';
+
+interface FileReference {
+    id: string;
+    table_name: string;
+    record_id: string;
+    file_path: string;
+    file_metadata: FileMetadata;
+    organisation_id: string | null;
+    app_id: AppId;
+    is_public: boolean;
+    created_at: string;
+    updated_at: string;
+}
+interface FileMetadata {
+    fileName: string;
+    fileType: string;
+    fileSize?: number;
+    width?: number;
+    height?: number;
+    category: FileCategory;
+    hash?: string;
+    uploadedBy?: string;
+    uploadedAt?: string;
+    tags?: string[];
+    customMetadata?: Record<string, unknown>;
+}
+declare enum FileCategory {
+    PROFILE_PHOTOS = "profile_photos",
+    ID_DOCUMENTS = "id_documents",
+    QUALIFICATIONS = "qualifications",
+    MEDICAL_DOCUMENTS = "medical_documents",
+    DISH_IMAGES = "dish_images",
+    EVENT_LOGOS = "event_logos",
+    GENERAL_DOCUMENTS = "general_documents",
+    IMAGES = "images",
+    AUDIO = "audio",
+    VIDEO = "video",
+    ARCHIVES = "archives",
+    CAKE_DISH = "cake_dish",
+    TRAC_ACCOMMODATION = "trac_accommodation",
+    TRAC_ACTIVITY = "trac_activity",
+    TRAC_JOURNAL = "trac_journal",
+    TRAC_TRANSPORT = "trac_transport"
+}
+/**
+ * Options for uploading a file with a file reference
+ * @property pageContext - The page context where the file upload occurs (e.g., 'configuration', 'forms', 'applications')
+ *                          Used for context-aware permission checks. Required to check appropriate page-level permissions.
+ * @property event_id - Optional event ID for event-scoped permission checks. Required for event-based apps.
+ * @property organisation_id - Optional organisation ID. If not provided, the file is user-owned (record_id must match user_id).
+ *                              For user-owned files, users can only access their own files.
+ */
+interface FileUploadOptions {
+    table_name: string;
+    record_id: string;
+    organisation_id: string | null;
+    app_id: AppId;
+    category: FileCategory;
+    folder: string;
+    pageContext: string;
+    event_id?: string;
+    is_public?: boolean;
+    custom_metadata?: Record<string, unknown>;
+    userId?: string;
+}
+/** Create/read operations for FileReferenceService (ISP). */
+interface FileReferenceServiceCreateRead {
+    createFileReference(options: FileUploadOptions, file: File): Promise<ApiResult<FileReference>>;
+    getFileReference(table_name: string, record_id: string, organisation_id?: string): Promise<ApiResult<FileReference | null>>;
+    getFileReferenceById(id: string, organisation_id?: string): Promise<ApiResult<FileReference | null>>;
+}
+/** URL operations for FileReferenceService (ISP). */
+interface FileReferenceServiceUrls {
+    getFileUrl(table_name: string, record_id: string, organisation_id?: string): Promise<ApiResult<string | null>>;
+    getSignedUrl(table_name: string, record_id: string, organisation_id?: string, expires_in?: number): Promise<ApiResult<string | null>>;
+}
+/** Write operations for FileReferenceService (ISP). */
+interface FileReferenceServiceWrite {
+    updateFileReference(id: string, updates: Partial<FileReference>): Promise<ApiResult<FileReference>>;
+    deleteFileReference(table_name: string, record_id: string, organisation_id?: string, delete_file?: boolean): Promise<ApiResult<boolean>>;
+}
+/** List/count operations for FileReferenceService (ISP). */
+interface FileReferenceServiceList {
+    listFileReferences(table_name: string, record_id: string, organisation_id?: string): Promise<ApiResult<FileReference[]>>;
+    getFilesByCategory(table_name: string, record_id: string, category: FileCategory, organisation_id?: string): Promise<ApiResult<FileReference[]>>;
+    getFileCount(table_name: string, record_id: string, organisation_id?: string): Promise<ApiResult<number>>;
+}
+/** Bulk upload for FileReferenceService (ISP). */
+interface FileReferenceServiceBulk {
+    uploadMultipleFiles(options: FileUploadOptions, files: File[]): Promise<ApiResult<BulkUploadResult>>;
+}
+/** FileReferenceService (ISP: composed from focused interfaces). */
+type FileReferenceService = FileReferenceServiceCreateRead & FileReferenceServiceUrls & FileReferenceServiceWrite & FileReferenceServiceList & FileReferenceServiceBulk;
+interface StorageUploadOptions {
+    orgId: string;
+    isPublic?: boolean;
+    customPath?: string;
+}
+interface FileUploadResult {
+    file_reference: FileReference;
+    file_url: string;
+    signed_url?: string;
+}
+/**
+ * File reference with pre-fetched URL
+ * Useful for display components that need both metadata and URL
+ */
+interface FileReferenceWithUrl extends FileReference {
+    url: string;
+    isSignedUrl: boolean;
+    expiresAt?: Date;
+}
+/**
+ * Upload progress information
+ */
+interface UploadProgress {
+    loaded: number;
+    total: number;
+    percentage: number;
+    fileName: string;
+    status: 'idle' | 'uploading' | 'processing' | 'completed' | 'error';
+    error?: string;
+}
+/**
+ * Bulk upload result
+ */
+interface BulkUploadResult {
+    /** Successfully created file references */
+    success: FileReference[];
+    /** Per-file failures with associated errors */
+    failed: {
+        file: File;
+        error: string;
+    }[];
+    total?: number;
+    successful?: number;
+    results?: Array<{
+        file: File;
+        result: FileUploadResult | null;
+        error?: string;
+    }>;
+}
+/**
+ * Bucket information for file storage
+ */
+interface BucketInfo {
+    name: 'files' | 'public-files';
+    isPublic: boolean;
+    description: string;
+}
+/**
+ * File URL information (public or signed)
+ */
+interface FileUrlInfo {
+    url: string;
+    isPublic: boolean;
+    isSignedUrl: boolean;
+    expiresAt?: Date;
+    bucket: BucketInfo;
+}
+
+export { type BulkUploadResult as B, FileCategory as F, type StorageUploadOptions as S, type UploadProgress as U, type FileReference as a, type FileMetadata as b, type FileUploadOptions as c, type FileReferenceServiceCreateRead as d, type FileReferenceServiceUrls as e, type FileReferenceServiceWrite as f, type FileReferenceServiceList as g, type FileReferenceServiceBulk as h, type FileReferenceService as i, type FileUploadResult as j, type FileReferenceWithUrl as k, type BucketInfo as l, type FileUrlInfo as m };