@adventurelabs/scout-core 1.4.57 → 1.4.59

package/dist/constants/db.d.ts

@@ -1,2 +1,4 @@
 export declare const BUCKET_NAME_SCOUT = "scout";
+/** Event media when `file_path` uses the `events/...` prefix */
+export declare const BUCKET_NAME_EVENTS = "events";
 export declare const SIGNED_URL_EXPIRATION_SECONDS: number;

package/dist/constants/db.js

@@ -1,3 +1,4 @@
 export const BUCKET_NAME_SCOUT = "scout";
-// Signed URL expiration time in seconds (12 hours = 43200 seconds)
+/** Event media when `file_path` uses the `events/...` prefix */
+export const BUCKET_NAME_EVENTS = "events";
 export const SIGNED_URL_EXPIRATION_SECONDS = 12 * 60 * 60;

package/dist/helpers/deviceTransfer.d.ts

@@ -0,0 +1,2 @@
+import { IWebResponseCompatible } from "../types/requests";
+export declare function transferDeviceToHerd(deviceId: number, targetHerdId: number): Promise<IWebResponseCompatible<boolean>>;

package/dist/helpers/deviceTransfer.js

@@ -0,0 +1,14 @@
+"use server";
+import { newServerClient } from "../supabase/server";
+import { IWebResponse } from "../types/requests";
+export async function transferDeviceToHerd(deviceId, targetHerdId) {
+    const client = await newServerClient();
+    const { error } = await client.rpc("transfer_device_to_herd", {
+        p_device_id: deviceId,
+        p_target_herd_id: targetHerdId,
+    });
+    if (error) {
+        return IWebResponse.error(error.message).to_compatible();
+    }
+    return IWebResponse.success(true).to_compatible();
+}

package/dist/helpers/storage.d.ts

@@ -1,11 +1,5 @@
 import { SupabaseClient } from "@supabase/supabase-js";
 import { Database } from "../types/supabase";
-/**
- * Generates a signed URL for a file in Supabase storage
- * @param filePath - The path to the file in storage (e.g., "events/123/image.jpg")
- * @param expiresIn - Number of seconds until the URL expires (default: 12 hours)
- * @param supabaseClient - Optional Supabase client (will create new one if not provided)
- * @returns Promise<string | null> - The signed URL or null if error
- */
+export { parseStorageFilePath } from "./storagePath";
 export declare function generateSignedUrl(filePath: string, expiresIn?: number, supabaseClient?: SupabaseClient<Database>): Promise<string | null>;
 export declare function generateSignedUrlsBatch(filePaths: string[], expiresIn?: number, supabaseClient?: SupabaseClient<Database>): Promise<(string | null)[]>;

package/dist/helpers/storage.js

@@ -1,64 +1,18 @@
-"use server";
 import { newServerClient } from "../supabase/server";
-import { SIGNED_URL_EXPIRATION_SECONDS, } from "../constants/db";
-/**
- * Splits file path into bucket name and path. Must be at leaast one slash in your file path
- * @param filePath
- * @returns IFilePathParts | null - null if invalid file path
- */
-function getBucketFromFilePath(filePath) {
-    // delete any start or end slashes/whitespace
-    filePath = filePath.replace(/^\/+|\/+$/g, "");
-    const parts = filePath.split("/");
-    if (parts.length < 2) {
-        return null;
-    }
-    const bucket_name = parts[0];
-    return bucket_name;
-}
-/**
- * Extracts the short path from a file path
- * @param filePath
- * @returns string | null - null if invalid file path
- */
-// for example if the input is /artifacts/10/52/test.mp4 - the output shld be 10/52/test.mp4
-function getFormattedPath(filePath) {
-    const cleaned = cleanPath(filePath);
-    const parts = cleaned.split("/");
-    if (parts.length < 2) {
-        return null;
-    }
-    // Remove the first part (bucket name) and return the rest
-    return parts.slice(1).join("/");
-}
-/** Removes leading and trailing slashes and leading/trailing whitespace */
-function cleanPath(filePath) {
-    // delete leading/trailing slash and whitespace
-    return filePath.trim().replace(/^\/+|\/+$/g, "");
-}
-/**
- * Generates a signed URL for a file in Supabase storage
- * @param filePath - The path to the file in storage (e.g., "events/123/image.jpg")
- * @param expiresIn - Number of seconds until the URL expires (default: 12 hours)
- * @param supabaseClient - Optional Supabase client (will create new one if not provided)
- * @returns Promise<string | null> - The signed URL or null if error
- */
+import { SIGNED_URL_EXPIRATION_SECONDS } from "../constants/db";
+import { parseStorageFilePath } from "./storagePath";
+export { parseStorageFilePath } from "./storagePath";
 export async function generateSignedUrl(filePath, expiresIn = SIGNED_URL_EXPIRATION_SECONDS, supabaseClient) {
     try {
         const supabase = supabaseClient || (await newServerClient());
-        const bucket_name = getBucketFromFilePath(filePath);
-        if (!bucket_name) {
+        const parsed = parseStorageFilePath(filePath);
+        if (!parsed) {
             console.error("Invalid file path:", filePath);
             return null;
         }
-        const formattedPath = getFormattedPath(filePath);
-        if (!formattedPath) {
-            console.error("Invalid formatted path:", formattedPath);
-            return null;
-        }
         const { data, error } = await supabase.storage
-            .from(bucket_name)
-            .createSignedUrl(formattedPath, expiresIn);
+            .from(parsed.bucket)
+            .createSignedUrl(parsed.objectPath, expiresIn);
         if (error) {
             console.error("Error generating signed URL:", error.message);
             return null;
@@ -75,19 +29,14 @@ export async function generateSignedUrlsBatch(filePaths, expiresIn = SIGNED_URL_
         const supabase = supabaseClient || (await newServerClient());
         const signedUrlPromises = filePaths.map(async (filePath) => {
             try {
-                const bucket_name = getBucketFromFilePath(filePath);
-                if (!bucket_name) {
+                const parsed = parseStorageFilePath(filePath);
+                if (!parsed) {
                     console.error("Invalid file path:", filePath);
                     return null;
                 }
-                const formattedPath = getFormattedPath(filePath);
-                if (!formattedPath) {
-                    console.error("Invalid formatted path:", formattedPath);
-                    return null;
-                }
                 const { data, error } = await supabase.storage
-                    .from(bucket_name)
-                    .createSignedUrl(formattedPath, expiresIn);
+                    .from(parsed.bucket)
+                    .createSignedUrl(parsed.objectPath, expiresIn);
                 if (error) {
                     console.warn(`Error generating signed URL for ${filePath}:`, error.message);
                     return null;

package/dist/helpers/storagePath.d.ts

@@ -0,0 +1,5 @@
+/** Assumes DB `file_path` is always `bucket/object/...` */
+export declare function parseStorageFilePath(filePath: string): {
+    bucket: string;
+    objectPath: string;
+} | null;

package/dist/helpers/storagePath.js

@@ -0,0 +1,16 @@
+/** Assumes DB `file_path` is always `bucket/object/...` */
+export function parseStorageFilePath(filePath) {
+    const cleaned = filePath.trim().replace(/^\/+|\/+$/g, "");
+    if (!cleaned) {
+        return null;
+    }
+    const parts = cleaned.split("/");
+    if (parts.length < 2) {
+        return null;
+    }
+    const bucket = parts[0];
+    if (/^[0-9]+$/.test(bucket)) {
+        return null;
+    }
+    return { bucket, objectPath: parts.slice(1).join("/") };
+}

package/dist/providers/ScoutRefreshProvider.d.ts

@@ -2772,6 +2772,13 @@ export declare function useSupabase(): SupabaseClient<Database, "public", "publi
                 status: string;
             }[];
         };
+        transfer_device_to_herd: {
+            Args: {
+                p_device_id: number;
+                p_target_herd_id: number;
+            };
+            Returns: undefined;
+        };
     };
     Enums: {
         analysis_work_status: "waiting" | "cancelled" | "processing" | "failed" | "success";

package/dist/store/api.js

@@ -1,5 +1,31 @@
 import { createApi, fakeBaseQuery } from "@reduxjs/toolkit/query/react";
 import { generateSignedUrlsBatch } from "../helpers/storage";
+async function signedUrlMapForFeedRows(rows) {
+    const seen = new Set();
+    const paths = [];
+    for (const row of rows) {
+        const ep = row.event_data?.file_path;
+        if (ep && !seen.has(ep)) {
+            seen.add(ep);
+            paths.push(ep);
+        }
+        const ap = row.artifact_data?.file_path;
+        if (ap && !seen.has(ap)) {
+            seen.add(ap);
+            paths.push(ap);
+        }
+    }
+    const map = new Map();
+    if (paths.length === 0) {
+        return map;
+    }
+    const r = await generateSignedUrlsBatch(paths);
+    paths.forEach((p, i) => {
+        if (r[i])
+            map.set(p, r[i]);
+    });
+    return map;
+}
 // Custom serialize function to exclude supabase client
 const serializeQueryArgs = ({ queryArgs, endpointDefinition, endpointName, }) => {
     const { supabase, ...serializableArgs } = queryArgs;
@@ -478,26 +504,12 @@ export const scoutApi = createApi({
                     // Full page (rows.length >= limit) means there might be more; only signal hasMore when we have a nextCursor
                     const hasMore = rows.length >= limit;
                     const resultRows = hasMore ? rows.slice(0, limit) : rows;
-                    const uniqueFilePaths = Array.from(new Set(resultRows.flatMap((row) => {
-                        const paths = [];
-                        if (row.event_data?.file_path)
-                            paths.push(row.event_data.file_path);
-                        if (row.artifact_data?.file_path)
-                            paths.push(row.artifact_data.file_path);
-                        return paths;
-                    })));
                     let urlMap = new Map();
-                    if (uniqueFilePaths.length > 0) {
-                        try {
-                            const urlResults = await generateSignedUrlsBatch(uniqueFilePaths);
-                            urlResults.forEach((url, index) => {
-                                if (url)
-                                    urlMap.set(uniqueFilePaths[index], url);
-                            });
-                        }
-                        catch (urlError) {
-                            console.warn("Failed to generate signed URLs for feed:", urlError);
-                        }
+                    try {
+                        urlMap = await signedUrlMapForFeedRows(resultRows);
+                    }
+                    catch (urlError) {
+                        console.warn("Failed to generate signed URLs for feed:", urlError);
                     }
                     const items = resultRows.map((row) => ({
                         ...row,
@@ -567,26 +579,12 @@ export const scoutApi = createApi({
                     // Full page (rows.length >= limit) means there might be more; only signal hasMore when we have a nextCursor
                     const hasMore = rows.length >= limit;
                     const resultRows = hasMore ? rows.slice(0, limit) : rows;
-                    const uniqueFilePaths = Array.from(new Set(resultRows.flatMap((row) => {
-                        const paths = [];
-                        if (row.event_data?.file_path)
-                            paths.push(row.event_data.file_path);
-                        if (row.artifact_data?.file_path)
-                            paths.push(row.artifact_data.file_path);
-                        return paths;
-                    })));
                     let urlMap = new Map();
-                    if (uniqueFilePaths.length > 0) {
-                        try {
-                            const urlResults = await generateSignedUrlsBatch(uniqueFilePaths);
-                            urlResults.forEach((url, index) => {
-                                if (url)
-                                    urlMap.set(uniqueFilePaths[index], url);
-                            });
-                        }
-                        catch (urlError) {
-                            console.warn("Failed to generate signed URLs for feed:", urlError);
-                        }
+                    try {
+                        urlMap = await signedUrlMapForFeedRows(resultRows);
+                    }
+                    catch (urlError) {
+                        console.warn("Failed to generate signed URLs for feed:", urlError);
                     }
                     const items = resultRows.map((row) => ({
                         ...row,

package/dist/types/supabase.d.ts

@@ -2857,6 +2857,13 @@ export type Database = {
                     status: string;
                 }[];
             };
+            transfer_device_to_herd: {
+                Args: {
+                    p_device_id: number;
+                    p_target_herd_id: number;
+                };
+                Returns: undefined;
+            };
         };
         Enums: {
             analysis_work_status: "waiting" | "cancelled" | "processing" | "failed" | "success";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adventurelabs/scout-core",
-  "version": "1.4.57",
+  "version": "1.4.59",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,8 @@
     "build": "tsc",
     "prepare": "yarn build",
     "dev": "tsc --watch",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "migrate-storage-paths-device-prefix": "node scripts/migrate-storage-paths-device-prefix.mjs"
   },
   "keywords": [
     "scout",