@adventurelabs/scout-core 1.3.6 → 1.4.2

package/README.md

@@ -1,260 +1,3 @@
 # Scout Core
 
 Core utilities and helpers for Adventure Labs Scout applications.
-
-## Features
-
-- **Herd Management**: Comprehensive herd and device management
-- **Event Tracking**: Wildlife event monitoring and tagging
-- **Real-time Updates**: Supabase-powered real-time data synchronization
-- **State Management**: Redux-based state management with loading states
-
-## Herd Modules Loading State
-
-The core provides a global loading state for herd modules, which are essential for many consuming applications. This state tracks whether herd modules are currently loading, have loaded successfully, or failed to load.
-
-### Loading State Enum
-
-```typescript
-import { EnumHerdModulesLoadingState } from "@adventurelabs/scout-core";
-
-enum EnumHerdModulesLoadingState {
-  NOT_LOADING = "NOT_LOADING",
-  LOADING = "LOADING",
-  SUCCESSFULLY_LOADED = "SUCCESSFULLY_LOADED",
-  UNSUCCESSFULLY_LOADED = "UNSUCCESSFULLY_LOADED",
-}
-
-**Available Hooks:**
-- `useHerdModulesLoadingState()` - Get current loading state
-- `useIsHerdModulesLoading()` - Check if currently loading
-- `useIsHerdModulesLoaded()` - Check if successfully loaded
-- `useIsHerdModulesFailed()` - Check if loading failed
-- `useHerdModulesLoadedAt()` - Get how long the last loading took (in milliseconds)
-- `useHerdModulesLoadingDuration()` - Get loading duration in milliseconds
-- `useHerdModulesLoadingTimeAgo()` - Get formatted time ago since last loaded (e.g., "2.5s ago")
-```
-
-### Usage in Components
-
-```typescript
-import {
-  useHerdModulesLoadingState,
-  useIsHerdModulesLoading,
-  useIsHerdModulesLoaded,
-  useIsHerdModulesFailed,
-  useHerdModulesLoadedAt,
-  useHerdModulesLoadingTimeAgo,
-  useHerdModulesLoadingDuration,
-} from "@adventurelabs/scout-core";
-
-function MyComponent() {
-  const loadingState = useHerdModulesLoadingState();
-  const isLoading = useIsHerdModulesLoading();
-  const isLoaded = useIsHerdModulesLoaded();
-  const isFailed = useIsHerdModulesFailed();
-
-  if (isLoading) {
-    return <div>Loading herd modules...</div>;
-  }
-
-  if (isFailed) {
-    return <div>Failed to load herd modules</div>;
-  }
-
-  if (isLoaded) {
-    return <div>Herd modules loaded successfully!</div>;
-  }
-
-  return <div>Not loading</div>;
-}
-
-// Example with loading duration information
-function HerdModulesStatus() {
-  const loadingState = useHerdModulesLoadingState();
-  const loadingTimeMs = useHerdModulesLoadedAt();
-  const timeAgo = useHerdModulesLoadingTimeAgo();
-  const loadingDuration = useHerdModulesLoadingDuration();
-
-  return (
-    <div>
-      <div>Status: {loadingState}</div>
-      {loadingTimeMs && (
-        <>
-          <div>Last loading took: {loadingTimeMs}ms</div>
-          <div>Loaded: {timeAgo}</div>
-          <div>Loading duration: {loadingDuration}ms</div>
-        </>
-      )}
-    </div>
-  );
-}
-```
-
-### Manual Refresh
-
-```typescript
-import { useScoutRefresh } from "@adventurelabs/scout-core";
-
-function RefreshButton() {
-  const { handleRefresh } = useScoutRefresh({ autoRefresh: false });
-
-  return <button onClick={handleRefresh}>Refresh Data</button>;
-}
-```
-
-## Installation
-
-```bash
-npm install @adventurelabs/scout-core
-# or
-yarn add @adventurelabs/scout-core
-```
-
-## Setup
-
-Wrap your app with the ScoutRefreshProvider:
-
-```typescript
-import { ScoutRefreshProvider } from "@adventurelabs/scout-core";
-
-function App() {
-  return (
-    <ScoutRefreshProvider>{/* Your app components */}</ScoutRefreshProvider>
-  );
-}
-```
-
-## Recent Updates
-
-- **v1.0.58**: Added global herd modules loading state tracking with timestamps
-- Fixed repeat Supabase client creation logs
-- Enhanced loading state management for better UX
-- Added loading duration and time-ago tracking
-- Added comprehensive edge case handling and race condition prevention
-
-## Usage
-
-````typescript
-import "../../app/globals.css";
-import StoreProvider from "../../components/Store/StoreProvider";
-import { ScoutRefreshProvider } from "@adventurelabs/scout-core";
-
-export default function ScoutLayout({
-  children,
-}: Readonly<{
-  children: React.ReactNode;
-}>) {
-  return (
-    {/* Store provider for state management */}
-    <StoreProvider>
-      {/* Listen for updates and refresh data in background */}
-      <ScoutRefreshProvider>
-        <div className="">{children}</div>
-      </ScoutRefreshProvider>
-
-    </StoreProvider>
-  );
-}
-
-## Available Modules
-
-### Types
-
-- Database types from Supabase
-- Herd, Device, Event, User interfaces
-- Request/Response types
-- Herd module loading state enums (`EnumHerdModulesLoadingState`)
-
-### Helpers
-
-- Authentication utilities
-- Database operations
-- Email validation
-- GPS and location helpers
-- Device and event management
-- Tag and annotation utilities
-
-### Hooks
-
-- `useScoutDbListener` - Real-time database listening for plans, devices, and tags with robust disconnect handling
-- `useScoutRefresh` - Data refresh utilities
-- `useConnectionStatus` - Connection status monitoring and manual reconnection controls
-
-#### Robust Connection Features
-
-The `useScoutDbListener` hook includes several features to handle network disconnections and connection issues:
-
-- **Automatic Reconnection**: Automatically attempts to reconnect when the connection is lost
-- **Exponential Backoff**: Uses exponential backoff with jitter to avoid overwhelming the server
-- **Connection State Tracking**: Provides real-time connection status (connected, connecting, disconnected, error)
-- **Error Handling**: Comprehensive error handling with detailed error messages
-- **Manual Reconnection**: Allows manual reconnection attempts via the `reconnect()` function
-- **Retry Limits**: Configurable maximum retry attempts to prevent infinite reconnection loops
-- **Graceful Cleanup**: Proper cleanup of resources when the component unmounts
-
-Example usage:
-
-```tsx
-import { useConnectionStatus } from "@adventurelabs/scout-core";
-
-function ConnectionStatus() {
-  const { isConnected, isConnecting, lastError, retryCount, reconnect } =
-    useConnectionStatus();
-
-  if (isConnecting) {
-    return <div>Connecting to database...</div>;
-  }
-
-  if (lastError) {
-    return (
-      <div>
-        <p>Connection error: {lastError}</p>
-        <p>Retry attempts: {retryCount}</p>
-        <button onClick={reconnect}>Reconnect</button>
-      </div>
-    );
-  }
-
-  return <div>Status: {isConnected ? "Connected" : "Disconnected"}</div>;
-}
-````
-
-### Store
-
-- Zustand-based state management for Scout applications
-
-### Supabase
-
-- Client, server, and middleware utilities for Supabase integration
-
-### API Keys
-
-- API key management utilities
-
-## Development
-
-```bash
-# Install dependencies
-yarn install
-
-# Build the package
-yarn build
-
-# Watch for changes
-yarn dev
-
-# Clean build artifacts
-yarn clean
-```
-
-## License
-
-GPL-3.0
-
-**New Hooks** (in `core/store/hooks.ts`):
-
-- `useHerdModulesLoadingState()` - Get current loading state
-- `useIsHerdModulesLoading()` - Check if currently loading
-- `useIsHerdModulesLoaded()` - Check if successfully loaded
-- `

package/dist/helpers/artifacts.js

@@ -1,6 +1,6 @@
 "use server";
 import { newServerClient } from "../supabase/server";
-import { IWebResponse, } from "../types/requests";
+import { IWebResponse } from "../types/requests";
 import { generateSignedUrlsBatch } from "./storage";
 export async function server_get_artifacts_by_herd(herd_id, limit = 50, offset = 0, client) {
     const supabase = client || (await newServerClient());

package/dist/helpers/index.d.ts

@@ -19,7 +19,7 @@ export * from "./web";
 export * from "./zones";
 export * from "./cache";
 export * from "./operators";
-export * from "./components";
+export * from "./parts";
 export * from "./versions_software";
 export * from "./artifacts";
 export * from "./pins";

package/dist/helpers/index.js

@@ -19,7 +19,7 @@ export * from "./web";
 export * from "./zones";
 export * from "./cache";
 export * from "./operators";
-export * from "./components";
+export * from "./parts";
 export * from "./versions_software";
 export * from "./artifacts";
 export * from "./pins";

package/dist/helpers/parts.d.ts

@@ -0,0 +1,97 @@
+import { Database } from "../types/supabase";
+import { IPart, PartInsert } from "../types/db";
+import { IWebResponseCompatible } from "../types/requests";
+import { SupabaseClient } from "@supabase/supabase-js";
+/**
+ * Retrieves all active parts for a specific device
+ * @param client - Supabase client instance
+ * @param device_id - ID of the device to get parts for
+ */
+export declare function get_parts_by_device_id(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IPart[]>>;
+/**
+ * Retrieves a single active part by its ID
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to retrieve
+ */
+export declare function get_part_by_id(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IPart | null>>;
+/**
+ * Retrieves all active parts with a specific serial number
+ * @param client - Supabase client instance
+ * @param serial_number - Serial number to search for
+ */
+export declare function get_parts_by_serial_number(client: SupabaseClient<Database>, serial_number: string): Promise<IWebResponseCompatible<IPart[]>>;
+/**
+ * Retrieves all active parts with a specific product number
+ * @param client - Supabase client instance
+ * @param product_number - Product number to search for
+ */
+export declare function get_parts_by_product_number(client: SupabaseClient<Database>, product_number: string): Promise<IWebResponseCompatible<IPart[]>>;
+/**
+ * Retrieves all active parts with a specific status
+ * @param client - Supabase client instance
+ * @param status - Component status to filter by
+ */
+export declare function get_parts_by_status(client: SupabaseClient<Database>, status: Database["public"]["Enums"]["component_status"]): Promise<IWebResponseCompatible<IPart[]>>;
+/**
+ * Creates a new part with validation
+ * @param client - Supabase client instance
+ * @param newPart - Part data to create
+ */
+export declare function create_part(client: SupabaseClient<Database>, newPart: PartInsert): Promise<IWebResponseCompatible<IPart | null>>;
+/**
+ * Updates an existing part
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to update
+ * @param updatedPart - Partial part data to update
+ */
+export declare function update_part(client: SupabaseClient<Database>, part_id: number, updatedPart: Partial<PartInsert>): Promise<IWebResponseCompatible<IPart | null>>;
+/**
+ * Soft deletes a part by setting deleted_at timestamp
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to delete
+ */
+export declare function delete_part(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IPart | null>>;
+/**
+ * Updates the status of a specific part
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to update
+ * @param status - New status to set
+ */
+export declare function update_part_status(client: SupabaseClient<Database>, part_id: number, status: Database["public"]["Enums"]["component_status"]): Promise<IWebResponseCompatible<IPart | null>>;
+/**
+ * Retrieves all active parts associated with a certificate
+ * @param client - Supabase client instance
+ * @param certificate_id - ID of the certificate to search for
+ */
+export declare function get_parts_by_certificate_id(client: SupabaseClient<Database>, certificate_id: number): Promise<IWebResponseCompatible<IPart[]>>;
+/**
+ * Retrieves all active parts for devices in a specific herd
+ * @param client - Supabase client instance
+ * @param herd_id - ID of the herd to get parts for
+ */
+export declare function get_parts_by_herd_id(client: SupabaseClient<Database>, herd_id: number): Promise<IWebResponseCompatible<IPart[]>>;
+/**
+ * Restores a soft-deleted part by clearing deleted_at timestamp
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to restore
+ */
+export declare function restore_part(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IPart | null>>;
+/**
+ * Permanently deletes a soft-deleted part from database
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to permanently delete
+ */
+export declare function hard_delete_part(client: SupabaseClient<Database>, part_id: number): Promise<IWebResponseCompatible<IPart | null>>;
+/**
+ * Retrieves all soft-deleted parts for a specific device
+ * @param client - Supabase client instance
+ * @param device_id - ID of the device to get deleted parts for
+ */
+export declare function get_deleted_parts_by_device_id(client: SupabaseClient<Database>, device_id: number): Promise<IWebResponseCompatible<IPart[]>>;
+/**
+ * Retrieves a part by its composite unique constraint (product + serial)
+ * @param client - Supabase client instance
+ * @param product_number - Product number to search for
+ * @param serial_number - Serial number to search for
+ */
+export declare function get_parts_by_product_and_serial(client: SupabaseClient<Database>, product_number: string, serial_number: string): Promise<IWebResponseCompatible<IPart | null>>;

package/dist/helpers/parts.js

@@ -0,0 +1,329 @@
+import { IWebResponse } from "../types/requests";
+/**
+ * Retrieves all active parts for a specific device
+ * @param client - Supabase client instance
+ * @param device_id - ID of the device to get parts for
+ */
+export async function get_parts_by_device_id(client, device_id) {
+    const { data, error } = await client
+        .from("parts")
+        .select("*")
+        .eq("device_id", device_id)
+        .is("deleted_at", null)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No parts found for device").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Retrieves a single active part by its ID
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to retrieve
+ */
+export async function get_part_by_id(client, part_id) {
+    const { data, error } = await client
+        .from("parts")
+        .select("*")
+        .eq("id", part_id)
+        .is("deleted_at", null)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Part not found").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Retrieves all active parts with a specific serial number
+ * @param client - Supabase client instance
+ * @param serial_number - Serial number to search for
+ */
+export async function get_parts_by_serial_number(client, serial_number) {
+    const { data, error } = await client
+        .from("parts")
+        .select("*")
+        .eq("serial_number", serial_number)
+        .is("deleted_at", null)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error(`No parts found with serial number: ${serial_number}`).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Retrieves all active parts with a specific product number
+ * @param client - Supabase client instance
+ * @param product_number - Product number to search for
+ */
+export async function get_parts_by_product_number(client, product_number) {
+    const { data, error } = await client
+        .from("parts")
+        .select("*")
+        .eq("product_number", product_number)
+        .is("deleted_at", null)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error(`No parts found with product number: ${product_number}`).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Retrieves all active parts with a specific status
+ * @param client - Supabase client instance
+ * @param status - Component status to filter by
+ */
+export async function get_parts_by_status(client, status) {
+    const { data, error } = await client
+        .from("parts")
+        .select("*")
+        .eq("status", status)
+        .is("deleted_at", null)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error(`No parts found with status: ${status}`).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Creates a new part with validation
+ * @param client - Supabase client instance
+ * @param newPart - Part data to create
+ */
+export async function create_part(client, newPart) {
+    // Validate required fields
+    if (!newPart.device_id) {
+        return IWebResponse.error("Device ID is required").to_compatible();
+    }
+    if (!newPart.serial_number) {
+        return IWebResponse.error("Serial number is required").to_compatible();
+    }
+    if (!newPart.product_number) {
+        return IWebResponse.error("Product number is required").to_compatible();
+    }
+    const { data, error } = await client
+        .from("parts")
+        .insert([newPart])
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Failed to create part").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Updates an existing part
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to update
+ * @param updatedPart - Partial part data to update
+ */
+export async function update_part(client, part_id, updatedPart) {
+    // Remove fields that shouldn't be updated
+    const updateData = { ...updatedPart };
+    delete updateData.id;
+    delete updateData.created_at;
+    const { data, error } = await client
+        .from("parts")
+        .update(updateData)
+        .eq("id", part_id)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Part not found or update failed").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Soft deletes a part by setting deleted_at timestamp
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to delete
+ */
+export async function delete_part(client, part_id) {
+    // Soft delete by setting deleted_at timestamp
+    const { data, error } = await client
+        .from("parts")
+        .update({ deleted_at: new Date().toISOString() })
+        .eq("id", part_id)
+        .is("deleted_at", null)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Part not found or deletion failed").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Updates the status of a specific part
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to update
+ * @param status - New status to set
+ */
+export async function update_part_status(client, part_id, status) {
+    const { data, error } = await client
+        .from("parts")
+        .update({ status })
+        .eq("id", part_id)
+        .is("deleted_at", null)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Part not found or status update failed").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Retrieves all active parts associated with a certificate
+ * @param client - Supabase client instance
+ * @param certificate_id - ID of the certificate to search for
+ */
+export async function get_parts_by_certificate_id(client, certificate_id) {
+    const { data, error } = await client
+        .from("parts")
+        .select("*")
+        .eq("certificate_id", certificate_id)
+        .is("deleted_at", null)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error(`No parts found with certificate ID: ${certificate_id}`).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Retrieves all active parts for devices in a specific herd
+ * @param client - Supabase client instance
+ * @param herd_id - ID of the herd to get parts for
+ */
+export async function get_parts_by_herd_id(client, herd_id) {
+    const { data, error } = await client
+        .from("parts")
+        .select(`
+      *,
+      devices!parts_device_id_fkey(herd_id)
+    `)
+        .eq("devices.herd_id", herd_id)
+        .is("deleted_at", null)
+        .order("created_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error(`No parts found for herd: ${herd_id}`).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Restores a soft-deleted part by clearing deleted_at timestamp
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to restore
+ */
+export async function restore_part(client, part_id) {
+    // Restore soft deleted part by setting deleted_at to null
+    const { data, error } = await client
+        .from("parts")
+        .update({ deleted_at: null })
+        .eq("id", part_id)
+        .not("deleted_at", "is", null)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Part not found or restore failed").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Permanently deletes a soft-deleted part from database
+ * @param client - Supabase client instance
+ * @param part_id - ID of the part to permanently delete
+ */
+export async function hard_delete_part(client, part_id) {
+    // Permanently delete the part (only use for already soft-deleted parts)
+    const { data, error } = await client
+        .from("parts")
+        .delete()
+        .eq("id", part_id)
+        .not("deleted_at", "is", null)
+        .select("*")
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("Part not found or permanent deletion failed").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Retrieves all soft-deleted parts for a specific device
+ * @param client - Supabase client instance
+ * @param device_id - ID of the device to get deleted parts for
+ */
+export async function get_deleted_parts_by_device_id(client, device_id) {
+    const { data, error } = await client
+        .from("parts")
+        .select("*")
+        .eq("device_id", device_id)
+        .not("deleted_at", "is", null)
+        .order("deleted_at", { ascending: false });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error("No deleted parts found for device").to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}
+/**
+ * Retrieves a part by its composite unique constraint (product + serial)
+ * @param client - Supabase client instance
+ * @param product_number - Product number to search for
+ * @param serial_number - Serial number to search for
+ */
+export async function get_parts_by_product_and_serial(client, product_number, serial_number) {
+    // Get part by the composite unique constraint
+    const { data, error } = await client
+        .from("parts")
+        .select("*")
+        .eq("product_number", product_number)
+        .eq("serial_number", serial_number)
+        .is("deleted_at", null)
+        .single();
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    if (!data) {
+        return IWebResponse.error(`No part found with product number: ${product_number} and serial number: ${serial_number}`).to_compatible();
+    }
+    return IWebResponse.success(data).to_compatible();
+}

package/dist/hooks/index.d.ts

@@ -7,5 +7,6 @@ export { useScoutRealtimeTags } from "./useScoutRealtimeTags";
 export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
 export { useScoutRealtimePlans } from "./useScoutRealtimePlans";
 export { useScoutRealtimePins } from "./useScoutRealtimePins";
+export { useScoutRealtimeParts } from "./useScoutRealtimeParts";
 export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useIntersectionObserver, } from "./useInfiniteQuery";
 export { useLoadingPerformance, useSessionSummariesByHerd, useHasSessionSummaries, } from "../store/hooks";

package/dist/hooks/index.js

@@ -7,6 +7,7 @@ export { useScoutRealtimeTags } from "./useScoutRealtimeTags";
 export { useScoutRealtimeSessions } from "./useScoutRealtimeSessions";
 export { useScoutRealtimePlans } from "./useScoutRealtimePlans";
 export { useScoutRealtimePins } from "./useScoutRealtimePins";
+export { useScoutRealtimeParts } from "./useScoutRealtimeParts";
 // RTK Query infinite scroll hooks
 export { useInfiniteSessionsByHerd, useInfiniteSessionsByDevice, useInfiniteEventsByHerd, useInfiniteEventsByDevice, useInfiniteArtifactsByHerd, useInfiniteArtifactsByDevice, useIntersectionObserver, } from "./useInfiniteQuery";
 // Session summaries and performance hooks

package/dist/hooks/useScoutRealtimeParts.d.ts

@@ -0,0 +1,5 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { Database } from "../types/supabase";
+import { IPart } from "../types/db";
+import { RealtimeData } from "../types/realtime";
+export declare function useScoutRealtimeParts(scoutSupabase: SupabaseClient<Database>): [RealtimeData<IPart> | null, () => void];

package/dist/hooks/useScoutRealtimeParts.js

@@ -0,0 +1,113 @@
+"use client";
+import { useAppDispatch } from "../store/hooks";
+import { useSelector } from "react-redux";
+import { useEffect, useRef, useCallback, useState } from "react";
+import { EnumRealtimeOperation } from "../types/realtime";
+export function useScoutRealtimeParts(scoutSupabase) {
+    const channels = useRef([]);
+    const dispatch = useAppDispatch();
+    const [latestPartUpdate, setLatestPartUpdate] = useState(null);
+    const activeHerdId = useSelector((state) => state.scout.active_herd_id);
+    const herdModules = useSelector((state) => state.scout.herd_modules);
+    // Part broadcast handler
+    const handlePartBroadcast = useCallback((payload) => {
+        console.log("[Parts] Broadcast received:", payload.payload.operation);
+        const data = payload.payload;
+        const partData = data.record || data.old_record;
+        if (!partData)
+            return;
+        let operation;
+        // Find the target herd module and device
+        const herdModule = herdModules.find((hm) => hm.herd.id.toString() === activeHerdId);
+        if (!herdModule) {
+            console.warn("[Parts] No herd module found for active herd");
+            return;
+        }
+        const targetDevice = herdModule.devices.find((device) => device.id === partData.device_id);
+        if (!targetDevice) {
+            console.warn(`[Parts] No device found with ID: ${partData.device_id}`);
+            return;
+        }
+        // Ensure device has parts array
+        if (!targetDevice.parts) {
+            targetDevice.parts = [];
+        }
+        switch (data.operation) {
+            case "INSERT":
+                operation = EnumRealtimeOperation.INSERT;
+                if (data.record) {
+                    console.log("[Parts] New part received:", data.record);
+                    // Add part to device's parts array if not already present
+                    const existingPartIndex = targetDevice.parts.findIndex((p) => p.id === data.record.id);
+                    if (existingPartIndex === -1) {
+                        targetDevice.parts.push(data.record);
+                    }
+                }
+                break;
+            case "UPDATE":
+                operation = EnumRealtimeOperation.UPDATE;
+                if (data.record) {
+                    console.log("[Parts] Part updated:", data.record);
+                    // Update existing part in device's parts array
+                    const partIndex = targetDevice.parts.findIndex((p) => p.id === data.record.id);
+                    if (partIndex !== -1) {
+                        targetDevice.parts[partIndex] = data.record;
+                    }
+                    else {
+                        // Part not found, add it
+                        targetDevice.parts.push(data.record);
+                    }
+                }
+                break;
+            case "DELETE":
+                operation = EnumRealtimeOperation.DELETE;
+                if (data.old_record) {
+                    console.log("[Parts] Part deleted:", data.old_record);
+                    // Remove part from device's parts array
+                    targetDevice.parts = targetDevice.parts.filter((p) => p.id !== data.old_record.id);
+                }
+                break;
+            default:
+                return;
+        }
+        const realtimeData = {
+            data: partData,
+            operation,
+        };
+        console.log(`[scout-core realtime] PART ${data.operation} received:`, JSON.stringify(realtimeData));
+        setLatestPartUpdate(realtimeData);
+    }, [dispatch, activeHerdId, herdModules]);
+    // Clear latest update
+    const clearLatestUpdate = useCallback(() => {
+        setLatestPartUpdate(null);
+    }, []);
+    const cleanupChannels = () => {
+        channels.current.forEach((channel) => scoutSupabase.removeChannel(channel));
+        channels.current = [];
+    };
+    const createPartsChannel = (herdId) => {
+        return scoutSupabase
+            .channel(`${herdId}-parts`, { config: { private: true } })
+            .on("broadcast", { event: "*" }, handlePartBroadcast)
+            .subscribe((status) => {
+            if (status === "SUBSCRIBED") {
+                console.log(`[Parts] ✅ Connected to herd ${herdId}`);
+            }
+            else if (status === "CHANNEL_ERROR") {
+                console.warn(`[Parts] 🟡 Failed to connect to herd ${herdId}`);
+            }
+        });
+    };
+    useEffect(() => {
+        cleanupChannels();
+        // Clear previous update when switching herds
+        clearLatestUpdate();
+        // Create parts channel for active herd
+        if (activeHerdId) {
+            const channel = createPartsChannel(activeHerdId);
+            channels.current.push(channel);
+        }
+        return cleanupChannels;
+    }, [activeHerdId, clearLatestUpdate]);
+    return [latestPartUpdate, clearLatestUpdate];
+}

package/dist/index.d.ts

@@ -38,13 +38,14 @@ export * from "./helpers/heartbeats";
 export * from "./helpers/providers";
 export * from "./helpers/operators";
 export * from "./helpers/versions_software";
-export * from "./helpers/components";
+export * from "./helpers/parts";
 export * from "./hooks/useScoutRealtimeConnectivity";
 export * from "./hooks/useScoutRealtimeDevices";
 export * from "./hooks/useScoutRealtimeVersionsSoftware";
 export * from "./hooks/useScoutRealtimeEvents";
 export * from "./hooks/useScoutRealtimeTags";
 export * from "./hooks/useScoutRealtimeSessions";
+export * from "./hooks/useScoutRealtimeParts";
 export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRealtimePins";
 export * from "./hooks/useScoutRefresh";

package/dist/index.js

@@ -41,7 +41,7 @@ export * from "./helpers/heartbeats";
 export * from "./helpers/providers";
 export * from "./helpers/operators";
 export * from "./helpers/versions_software";
-export * from "./helpers/components";
+export * from "./helpers/parts";
 // Hooks
 export * from "./hooks/useScoutRealtimeConnectivity";
 export * from "./hooks/useScoutRealtimeDevices";
@@ -49,6 +49,7 @@ export * from "./hooks/useScoutRealtimeVersionsSoftware";
 export * from "./hooks/useScoutRealtimeEvents";
 export * from "./hooks/useScoutRealtimeTags";
 export * from "./hooks/useScoutRealtimeSessions";
+export * from "./hooks/useScoutRealtimeParts";
 export * from "./hooks/useScoutRealtimePlans";
 export * from "./hooks/useScoutRealtimePins";
 export * from "./hooks/useScoutRefresh";

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -160,51 +160,6 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 referencedColumns: ["id"];
             }];
         };
-        components: {
-            Row: {
-                certificate_id: number | null;
-                created_at: string;
-                device_id: number;
-                id: number;
-                product_number: string | null;
-                serial_number: string;
-                status: Database["public"]["Enums"]["component_status"];
-                updated_at: string | null;
-            };
-            Insert: {
-                certificate_id?: number | null;
-                created_at?: string;
-                device_id: number;
-                id?: number;
-                product_number?: string | null;
-                serial_number: string;
-                status?: Database["public"]["Enums"]["component_status"];
-                updated_at?: string | null;
-            };
-            Update: {
-                certificate_id?: number | null;
-                created_at?: string;
-                device_id?: number;
-                id?: number;
-                product_number?: string | null;
-                serial_number?: string;
-                status?: Database["public"]["Enums"]["component_status"];
-                updated_at?: string | null;
-            };
-            Relationships: [{
-                foreignKeyName: "components_certificate_id_fkey";
-                columns: ["certificate_id"];
-                isOneToOne: false;
-                referencedRelation: "certificates";
-                referencedColumns: ["id"];
-            }, {
-                foreignKeyName: "components_device_id_fkey";
-                columns: ["device_id"];
-                isOneToOne: false;
-                referencedRelation: "devices";
-                referencedColumns: ["id"];
-            }];
-        };
         connectivity: {
             Row: {
                 altitude: number;
@@ -547,6 +502,54 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 referencedColumns: ["id"];
             }];
         };
+        parts: {
+            Row: {
+                certificate_id: number | null;
+                created_at: string;
+                deleted_at: string | null;
+                device_id: number;
+                id: number;
+                product_number: string;
+                serial_number: string;
+                status: Database["public"]["Enums"]["component_status"];
+                updated_at: string | null;
+            };
+            Insert: {
+                certificate_id?: number | null;
+                created_at?: string;
+                deleted_at?: string | null;
+                device_id: number;
+                id?: number;
+                product_number: string;
+                serial_number: string;
+                status?: Database["public"]["Enums"]["component_status"];
+                updated_at?: string | null;
+            };
+            Update: {
+                certificate_id?: number | null;
+                created_at?: string;
+                deleted_at?: string | null;
+                device_id?: number;
+                id?: number;
+                product_number?: string;
+                serial_number?: string;
+                status?: Database["public"]["Enums"]["component_status"];
+                updated_at?: string | null;
+            };
+            Relationships: [{
+                foreignKeyName: "parts_certificate_id_fkey";
+                columns: ["certificate_id"];
+                isOneToOne: false;
+                referencedRelation: "certificates";
+                referencedColumns: ["id"];
+            }, {
+                foreignKeyName: "parts_device_id_fkey";
+                columns: ["device_id"];
+                isOneToOne: false;
+                referencedRelation: "devices";
+                referencedColumns: ["id"];
+            }];
+        };
         pins: {
             Row: {
                 altitude_relative_to_ground: number;

package/dist/supabase/middleware.d.ts

@@ -1,2 +1,7 @@
 import { NextResponse, type NextRequest } from "next/server";
-export declare function updateSession(request: NextRequest): Promise<NextResponse<unknown>>;
+export interface IOptionsMiddlewareAuth {
+    allowed_email_domains?: string[];
+    allowed_page_paths_without_auth: string[];
+    login_page_path: string;
+}
+export declare function updateSession(request: NextRequest, options: IOptionsMiddlewareAuth): Promise<NextResponse<unknown>>;

package/dist/supabase/middleware.js

@@ -1,33 +1,43 @@
 import { createServerClient } from "@supabase/ssr";
 import { NextResponse } from "next/server";
-export async function updateSession(request) {
-    let supabaseResponse = NextResponse.next({
-        request,
-    });
-    const supabase = createServerClient(process.env.NEXT_PUBLIC_SUPABASE_URL, process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY, {
+export async function updateSession(request, options) {
+    // Validate environment variables
+    const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+    const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+    if (!supabaseUrl || !supabaseAnonKey) {
+        throw new Error("Missing required Supabase environment variables");
+    }
+    let supabaseResponse = NextResponse.next({ request });
+    const supabase = createServerClient(supabaseUrl, supabaseAnonKey, {
         cookies: {
             getAll() {
                 return request.cookies.getAll();
             },
             setAll(cookiesToSet) {
-                cookiesToSet.forEach(({ name, value, options }) => request.cookies.set(name, value));
-                supabaseResponse = NextResponse.next({
-                    request,
-                });
+                cookiesToSet.forEach(({ name, value }) => request.cookies.set(name, value));
+                supabaseResponse = NextResponse.next({ request });
                 cookiesToSet.forEach(({ name, value, options }) => supabaseResponse.cookies.set(name, value, options));
             },
         },
     });
     // IMPORTANT: Avoid writing any logic between createServerClient and
-    // supabase.auth.getUser(). A simple mistake could make it very hard to debug
+    // supabase.auth.getClaims(). A simple mistake could make it very hard to debug
     // issues with users being randomly logged out.
-    const { data: { user }, } = await supabase.auth.getUser();
-    if (!user &&
-        !request.nextUrl.pathname.startsWith("/auth/login") &&
-        !request.nextUrl.pathname.startsWith("/auth")) {
-        // no user, potentially respond by redirecting the user to the login page
+    const { data: claims, error } = await supabase.auth.getClaims();
+    // Check if current path is allowed without authentication
+    const isPublicPath = options.allowed_page_paths_without_auth.some((page) => request.nextUrl.pathname.startsWith(page));
+    if (isPublicPath) {
+        return supabaseResponse;
+    }
+    // Check authentication requirements
+    const hasValidClaims = !error && claims?.claims?.sub;
+    const hasValidEmail = claims?.claims?.email &&
+        (!options.allowed_email_domains ||
+            options.allowed_email_domains.some((domain) => claims.claims.email.endsWith(`@${domain}`)));
+    if (!hasValidClaims || (claims?.claims?.email && !hasValidEmail)) {
+        // no valid claims - respond by redirecting the user to the login page
         const url = request.nextUrl.clone();
-        url.pathname = "/auth/login";
+        url.pathname = options.login_page_path;
         return NextResponse.redirect(url);
     }
     // IMPORTANT: You *must* return the supabaseResponse object as it is. If you're

package/dist/types/db.d.ts

@@ -8,6 +8,7 @@ export type TagObservationType = Database["public"]["Enums"]["tag_observation_ty
 export type IUser = User;
 export type IDevice = Database["public"]["CompositeTypes"]["device_pretty_location"] & {
     api_keys_scout?: IApiKeyScout[];
+    parts?: IPart[];
 };
 export type IPin = Database["public"]["CompositeTypes"]["pins_pretty_location"];
 export type IEvent = Database["public"]["Tables"]["events"]["Row"];
@@ -24,7 +25,7 @@ export type IConnectivity = Database["public"]["Tables"]["connectivity"]["Row"];
 export type IHeartbeat = Database["public"]["Tables"]["heartbeats"]["Row"];
 export type IOperator = Database["public"]["Tables"]["operators"]["Row"];
 export type IProvider = Database["public"]["Tables"]["providers"]["Row"];
-export type IComponent = Database["public"]["Tables"]["components"]["Row"];
+export type IPart = Database["public"]["Tables"]["parts"]["Row"];
 export type IVersionsSoftware = Database["public"]["Tables"]["versions_software"]["Row"];
 export type IArtifact = Database["public"]["Tables"]["artifacts"]["Row"];
 export type IArtifactWithMediaUrl = IArtifact & {
@@ -49,7 +50,7 @@ export interface ISessionSummary {
     };
 }
 export type ISessionUsageOverTime = Database["public"]["Functions"]["get_session_usage_over_time"]["Returns"];
-export type ComponentInsert = Database["public"]["Tables"]["components"]["Insert"];
+export type PartInsert = Database["public"]["Tables"]["parts"]["Insert"];
 export type VersionsSoftwareInsert = Database["public"]["Tables"]["versions_software"]["Insert"];
 export type ArtifactInsert = Database["public"]["Tables"]["artifacts"]["Insert"];
 export type PinInsert = Database["public"]["Tables"]["pins"]["Insert"];

package/dist/types/herd_module.js

@@ -4,6 +4,7 @@ import { server_get_plans_by_herd } from "../helpers/plans";
 import { server_get_layers_by_herd } from "../helpers/layers";
 import { server_get_providers_by_herd } from "../helpers/providers";
 import { server_get_users_with_herd_access } from "../helpers/users";
+import { get_parts_by_herd_id } from "../helpers/parts";
 import { EnumWebResponse } from "./requests";
 import { server_get_more_zones_and_actions_for_herd } from "../helpers/zones";
 import { server_list_api_keys_batch } from "../api_keys/actions";
@@ -86,13 +87,11 @@ export class HerdModule {
                     return { status: EnumWebResponse.ERROR, data: null };
                 }),
             ]);
-            // Load devices
+            // Load devices and parts in parallel
             const devicesPromise = get_devices_by_herd(herd.id, client);
-            // Wait for both devices and herd-level data
-            const [deviceResponse, herdLevelResults] = await Promise.all([
-                devicesPromise,
-                herdLevelPromises,
-            ]);
+            const partsPromise = get_parts_by_herd_id(client, herd.id);
+            // Wait for devices, parts, and herd-level data
+            const [deviceResponse, partsResponse, herdLevelResults] = await Promise.all([devicesPromise, partsPromise, herdLevelPromises]);
             // Check devices response
             if (deviceResponse.status == EnumWebResponse.ERROR ||
                 !deviceResponse.data) {
@@ -100,6 +99,15 @@ export class HerdModule {
                 return new HerdModule(herd, [], Date.now());
             }
             const new_devices = deviceResponse.data;
+            // Get parts data (optional - don't fail if parts can't be loaded)
+            let parts_data = [];
+            if (partsResponse.status !== EnumWebResponse.ERROR &&
+                partsResponse.data) {
+                parts_data = partsResponse.data;
+            }
+            else {
+                console.warn(`[HerdModule] Failed to load parts for herd ${herd.id}:`, partsResponse.status);
+            }
             // Load API keys for devices if we have any
             if (new_devices.length > 0) {
                 try {
@@ -116,6 +124,12 @@ export class HerdModule {
                     // Continue without API keys
                 }
             }
+            // Associate parts with devices
+            if (parts_data.length > 0) {
+                for (const device of new_devices) {
+                    device.parts = parts_data.filter((part) => part.device_id === device.id);
+                }
+            }
             // Extract herd-level data with safe fallbacks
             const [res_zones, res_user_roles, res_plans, res_layers, res_providers, session_summaries_result, session_usage_result,] = herdLevelResults;
             const zones = res_zones.status === "fulfilled" && res_zones.value?.data

package/dist/types/supabase.d.ts

@@ -166,54 +166,6 @@ export type Database = {
                     }
                 ];
             };
-            components: {
-                Row: {
-                    certificate_id: number | null;
-                    created_at: string;
-                    device_id: number;
-                    id: number;
-                    product_number: string | null;
-                    serial_number: string;
-                    status: Database["public"]["Enums"]["component_status"];
-                    updated_at: string | null;
-                };
-                Insert: {
-                    certificate_id?: number | null;
-                    created_at?: string;
-                    device_id: number;
-                    id?: number;
-                    product_number?: string | null;
-                    serial_number: string;
-                    status?: Database["public"]["Enums"]["component_status"];
-                    updated_at?: string | null;
-                };
-                Update: {
-                    certificate_id?: number | null;
-                    created_at?: string;
-                    device_id?: number;
-                    id?: number;
-                    product_number?: string | null;
-                    serial_number?: string;
-                    status?: Database["public"]["Enums"]["component_status"];
-                    updated_at?: string | null;
-                };
-                Relationships: [
-                    {
-                        foreignKeyName: "components_certificate_id_fkey";
-                        columns: ["certificate_id"];
-                        isOneToOne: false;
-                        referencedRelation: "certificates";
-                        referencedColumns: ["id"];
-                    },
-                    {
-                        foreignKeyName: "components_device_id_fkey";
-                        columns: ["device_id"];
-                        isOneToOne: false;
-                        referencedRelation: "devices";
-                        referencedColumns: ["id"];
-                    }
-                ];
-            };
             connectivity: {
                 Row: {
                     altitude: number;
@@ -574,6 +526,57 @@ export type Database = {
                     }
                 ];
             };
+            parts: {
+                Row: {
+                    certificate_id: number | null;
+                    created_at: string;
+                    deleted_at: string | null;
+                    device_id: number;
+                    id: number;
+                    product_number: string;
+                    serial_number: string;
+                    status: Database["public"]["Enums"]["component_status"];
+                    updated_at: string | null;
+                };
+                Insert: {
+                    certificate_id?: number | null;
+                    created_at?: string;
+                    deleted_at?: string | null;
+                    device_id: number;
+                    id?: number;
+                    product_number: string;
+                    serial_number: string;
+                    status?: Database["public"]["Enums"]["component_status"];
+                    updated_at?: string | null;
+                };
+                Update: {
+                    certificate_id?: number | null;
+                    created_at?: string;
+                    deleted_at?: string | null;
+                    device_id?: number;
+                    id?: number;
+                    product_number?: string;
+                    serial_number?: string;
+                    status?: Database["public"]["Enums"]["component_status"];
+                    updated_at?: string | null;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "parts_certificate_id_fkey";
+                        columns: ["certificate_id"];
+                        isOneToOne: false;
+                        referencedRelation: "certificates";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "parts_device_id_fkey";
+                        columns: ["device_id"];
+                        isOneToOne: false;
+                        referencedRelation: "devices";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
             pins: {
                 Row: {
                     altitude_relative_to_ground: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adventurelabs/scout-core",
-  "version": "1.3.6",
+  "version": "1.4.2",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,7 +37,7 @@
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0",
     "react-redux": ">=9.0.0",
-    "@supabase/supabase-js": "^2.57.4",
+    "@supabase/supabase-js": "^2.89.0",
     "@supabase/ssr": "^0.7.0",
     "@reduxjs/toolkit": "^2.0.0"
   },