Browse Source
* Refactor and consolitdate store imports - Created a new index file in the core stores directory to export all stores from a single module. - Updated imports to use consolidated store exports. * Remove unnecessary import * Update imports * First steps to persist nodeDB * Use named exports * Change store import after merge * Persistent nodeDB initial work * Key mishmatch warning, new serialization handler * Minor copilot changes * Add NODEDB_RETENTION_NUM * Updated tests * Refactor PKI mismatch logic * Clear persisted db on reset * Only persist on featureFlag * Mock featureFlag in tests --------- Co-authored-by: philon- <[email protected]>pull/802/head
Jeremy Gallant
10 months ago
committed by
GitHub
GitHub
43 changed files with 1333 additions and 474 deletions
@ -1,13 +1,15 @@ |
|||||
import { type Device, DeviceContext } from "@core/stores"; |
import { CurrentDeviceContext } from "@core/stores"; |
||||
import type { ReactNode } from "react"; |
import type { ReactNode } from "react"; |
||||
|
|
||||
export interface DeviceWrapperProps { |
export interface DeviceWrapperProps { |
||||
children: ReactNode; |
children: ReactNode; |
||||
device?: Device; |
deviceId: number; |
||||
} |
} |
||||
|
|
||||
export const DeviceWrapper = ({ children, device }: DeviceWrapperProps) => { |
export const DeviceWrapper = ({ children, deviceId }: DeviceWrapperProps) => { |
||||
return ( |
return ( |
||||
<DeviceContext.Provider value={device}>{children}</DeviceContext.Provider> |
<CurrentDeviceContext.Provider value={{ deviceId }}> |
||||
|
{children} |
||||
|
</CurrentDeviceContext.Provider> |
||||
); |
); |
||||
}; |
}; |
||||
|
|||||
@ -1,22 +1,45 @@ |
|||||
export { useAppStore } from "@core/stores/appStore"; |
import { useDeviceContext } from "@app/core/stores/utils/useDeviceContext"; |
||||
|
import { type Device, useDeviceStore } from "@core/stores/deviceStore"; |
||||
|
import { type NodeDB, useNodeDBStore } from "@core/stores/nodeDBStore"; |
||||
|
|
||||
|
export { |
||||
|
CurrentDeviceContext, |
||||
|
type DeviceContext, |
||||
|
useDeviceContext, |
||||
|
} from "@app/core/stores/utils/useDeviceContext"; |
||||
|
export { useAppStore } from "@core/stores/appStore"; |
||||
export { |
export { |
||||
type Device, |
type Device, |
||||
DeviceContext, |
type Page, |
||||
useDevice, |
|
||||
useDeviceStore, |
useDeviceStore, |
||||
type ValidConfigType, |
type ValidConfigType, |
||||
type ValidModuleConfigType, |
type ValidModuleConfigType, |
||||
} from "@core/stores/deviceStore"; |
} from "@core/stores/deviceStore"; |
||||
|
|
||||
export { |
export { |
||||
MessageState, |
MessageState, |
||||
type MessageStore, |
type MessageStore, |
||||
MessageType, |
MessageType, |
||||
useMessageStore, |
useMessageStore, // TODO: Bring hook into this file
|
||||
} from "@core/stores/messageStore"; |
} from "@core/stores/messageStore"; |
||||
|
export { type NodeDB, useNodeDBStore } from "@core/stores/nodeDBStore"; |
||||
export { |
export { |
||||
SidebarProvider, |
SidebarProvider, |
||||
useSidebar, |
useSidebar, // TODO: Bring hook into this file
|
||||
} from "@core/stores/sidebarStore"; |
} from "@core/stores/sidebarStore"; |
||||
|
|
||||
|
// Define hooks to access the stores
|
||||
|
export const useNodeDB = (): NodeDB => { |
||||
|
const { deviceId } = useDeviceContext(); |
||||
|
const nodeDB = useNodeDBStore( |
||||
|
(s) => s.getNodeDB(deviceId) ?? s.addNodeDB(deviceId), |
||||
|
); |
||||
|
return nodeDB; |
||||
|
}; |
||||
|
export const useDevice = (): Device => { |
||||
|
const { deviceId } = useDeviceContext(); |
||||
|
|
||||
|
const device = useDeviceStore( |
||||
|
(s) => s.getDevice(deviceId) ?? s.addDevice(deviceId), |
||||
|
); |
||||
|
return device; |
||||
|
}; |
||||
|
|||||
@ -0,0 +1,440 @@ |
|||||
|
import { create } from "@bufbuild/protobuf"; |
||||
|
import { featureFlags } from "@core/services/featureFlags"; |
||||
|
import { createStorage } from "@core/stores/utils/indexDB.ts"; |
||||
|
import { Protobuf, type Types } from "@meshtastic/core"; |
||||
|
import { produce } from "immer"; |
||||
|
import { create as createStore, type StateCreator } from "zustand"; |
||||
|
import { type PersistOptions, persist } from "zustand/middleware"; |
||||
|
import type { NodeError, NodeErrorType, ProcessPacketParams } from "./types"; |
||||
|
|
||||
|
const CURRENT_STORE_VERSION = 0; |
||||
|
const NODEDB_RETENTION_NUM = 10; |
||||
|
|
||||
|
export interface NodeDB { |
||||
|
id: number; |
||||
|
myNodeNum: number | undefined; |
||||
|
nodeMap: Map<number, Protobuf.Mesh.NodeInfo>; |
||||
|
nodeErrors: Map<number, NodeError>; |
||||
|
|
||||
|
addNode: (nodeInfo: Protobuf.Mesh.NodeInfo) => void; |
||||
|
removeNode: (nodeNum: number) => void; |
||||
|
removeAllNodes: (keepMyNode?: boolean) => void; |
||||
|
processPacket: (data: ProcessPacketParams) => void; |
||||
|
addUser: (user: Types.PacketMetadata<Protobuf.Mesh.User>) => void; |
||||
|
addPosition: (position: Types.PacketMetadata<Protobuf.Mesh.Position>) => void; |
||||
|
updateFavorite: (nodeNum: number, isFavorite: boolean) => void; |
||||
|
updateIgnore: (nodeNum: number, isIgnored: boolean) => void; |
||||
|
setNodeNum: (nodeNum: number) => void; |
||||
|
setNodeError: (nodeNum: number, error: NodeErrorType) => void; |
||||
|
clearNodeError: (nodeNum: number) => void; |
||||
|
removeAllNodeErrors: () => void; |
||||
|
|
||||
|
getNodesLength: () => number; |
||||
|
getNode: (nodeNum: number) => Protobuf.Mesh.NodeInfo | undefined; |
||||
|
getNodes: ( |
||||
|
filter?: (node: Protobuf.Mesh.NodeInfo) => boolean, |
||||
|
) => Protobuf.Mesh.NodeInfo[]; |
||||
|
getMyNode: () => Protobuf.Mesh.NodeInfo; |
||||
|
|
||||
|
getNodeError: (nodeNum: number) => NodeError | undefined; |
||||
|
hasNodeError: (nodeNum: number) => boolean; |
||||
|
} |
||||
|
|
||||
|
export interface nodeDBState { |
||||
|
addNodeDB: (id: number) => NodeDB; |
||||
|
removeNodeDB: (id: number) => void; |
||||
|
getNodeDBs: () => NodeDB[]; |
||||
|
getNodeDB: (id: number) => NodeDB | undefined; |
||||
|
} |
||||
|
|
||||
|
interface PrivateNodeDBState extends nodeDBState { |
||||
|
nodeDBs: Map<number, NodeDB>; |
||||
|
} |
||||
|
|
||||
|
type NodeDBData = { |
||||
|
id: number; |
||||
|
myNodeNum: number | undefined; |
||||
|
nodeMap: Map<number, Protobuf.Mesh.NodeInfo>; |
||||
|
nodeErrors: Map<number, NodeError>; |
||||
|
}; |
||||
|
|
||||
|
type NodeDBPersisted = { |
||||
|
nodeDBs: Map<number, NodeDBData>; |
||||
|
}; |
||||
|
|
||||
|
function nodeDBFactory( |
||||
|
id: number, |
||||
|
get: () => PrivateNodeDBState, |
||||
|
set: typeof useNodeDBStore.setState, |
||||
|
data?: Partial<NodeDBData>, |
||||
|
): NodeDB { |
||||
|
const nodeMap = data?.nodeMap ?? new Map<number, Protobuf.Mesh.NodeInfo>(); |
||||
|
const nodeErrors = data?.nodeErrors ?? new Map<number, NodeError>(); |
||||
|
const myNodeNum = data?.myNodeNum; |
||||
|
|
||||
|
return { |
||||
|
id, |
||||
|
myNodeNum, |
||||
|
nodeMap, |
||||
|
nodeErrors, |
||||
|
|
||||
|
addNode: (node) => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const nodeDB = draft.nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
nodeDB.nodeMap.set(node.num, node); |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
removeNode: (nodeNum) => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const nodeDB = draft.nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
nodeDB.nodeMap.delete(nodeNum); |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
removeAllNodes: (keepMyNode) => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const nodeDB = draft.nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
const newNodeMap = new Map<number, Protobuf.Mesh.NodeInfo>(); |
||||
|
if ( |
||||
|
keepMyNode && |
||||
|
nodeDB.myNodeNum !== undefined && |
||||
|
nodeDB.nodeMap.has(nodeDB.myNodeNum) |
||||
|
) { |
||||
|
newNodeMap.set( |
||||
|
nodeDB.myNodeNum, |
||||
|
nodeDB.nodeMap.get(nodeDB.myNodeNum) ?? |
||||
|
create(Protobuf.Mesh.NodeInfoSchema), |
||||
|
); |
||||
|
} |
||||
|
nodeDB.nodeMap = newNodeMap; |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
setNodeError: (nodeNum, error) => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const nodeDB = draft.nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
nodeDB.nodeErrors.set(nodeNum, { node: nodeNum, error }); |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
clearNodeError: (nodeNum) => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const nodeDB = draft.nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
nodeDB.nodeErrors.delete(nodeNum); |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
removeAllNodeErrors: () => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const nodeDB = draft.nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
nodeDB.nodeErrors = new Map<number, NodeError>(); |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
processPacket: (data) => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const nodeDB = draft.nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
const node = nodeDB.nodeMap.get(data.from); |
||||
|
if (node) { |
||||
|
node.lastHeard = data.time; |
||||
|
node.snr = data.snr; |
||||
|
nodeDB.nodeMap.set(data.from, node); |
||||
|
} else { |
||||
|
nodeDB.nodeMap.set( |
||||
|
data.from, |
||||
|
create(Protobuf.Mesh.NodeInfoSchema, { |
||||
|
num: data.from, |
||||
|
lastHeard: data.time, |
||||
|
snr: data.snr, |
||||
|
}), |
||||
|
); |
||||
|
} |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
addUser: (user) => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const nodeDB = draft.nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
const current = |
||||
|
nodeDB.nodeMap.get(user.from) ?? |
||||
|
create(Protobuf.Mesh.NodeInfoSchema); |
||||
|
current.user = user.data; |
||||
|
current.num = user.from; |
||||
|
nodeDB.nodeMap.set(user.from, current); |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
addPosition: (position) => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const nodeDB = draft.nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
const current = |
||||
|
nodeDB.nodeMap.get(position.from) ?? |
||||
|
create(Protobuf.Mesh.NodeInfoSchema); |
||||
|
current.position = position.data; |
||||
|
current.num = position.from; |
||||
|
nodeDB.nodeMap.set(position.from, current); |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
setNodeNum: (nodeNum) => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const newDB = draft.nodeDBs.get(id); |
||||
|
if (!newDB) { |
||||
|
throw new Error(`No nodeDB found for id: ${id}`); |
||||
|
} |
||||
|
|
||||
|
newDB.myNodeNum = nodeNum; |
||||
|
|
||||
|
for (const [key, oldDB] of draft.nodeDBs) { |
||||
|
if (key === id) { |
||||
|
continue; |
||||
|
} |
||||
|
if (oldDB.myNodeNum === nodeNum) { |
||||
|
// The new DB is typically empty when nodenum is set, so we can safely copy over from the old DB
|
||||
|
// otherwise, discard the old DB completely
|
||||
|
if (newDB.nodeMap.size === 0) { |
||||
|
newDB.nodeMap = oldDB.nodeMap; |
||||
|
newDB.nodeErrors = oldDB.nodeErrors; |
||||
|
} else { |
||||
|
console.error( |
||||
|
`NodeDB with id: ${id} already has nodes, not merging with old DB`, |
||||
|
); |
||||
|
} |
||||
|
|
||||
|
draft.nodeDBs.delete(key); |
||||
|
} |
||||
|
} |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
updateFavorite: (nodeNum, isFavorite) => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const nodeDB = draft.nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
|
||||
|
const node = nodeDB.nodeMap.get(nodeNum); |
||||
|
if (node) { |
||||
|
node.isFavorite = isFavorite; |
||||
|
} |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
updateIgnore: (nodeNum, isIgnored) => |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const nodeDB = draft.nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
|
||||
|
const node = nodeDB.nodeMap.get(nodeNum); |
||||
|
if (node) { |
||||
|
node.isIgnored = isIgnored; |
||||
|
} |
||||
|
}), |
||||
|
), |
||||
|
|
||||
|
getNodesLength: () => { |
||||
|
const nodeDB = get().nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
return nodeDB.nodeMap.size; |
||||
|
}, |
||||
|
|
||||
|
getNode: (nodeNum) => { |
||||
|
const nodeDB = get().nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
return nodeDB.nodeMap.get(nodeNum); |
||||
|
}, |
||||
|
|
||||
|
getNodes: (filter) => { |
||||
|
const nodeDB = get().nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
const all = Array.from(nodeDB.nodeMap.values()).filter( |
||||
|
(n) => n.num !== nodeDB.myNodeNum, |
||||
|
); |
||||
|
return filter ? all.filter(filter) : all; |
||||
|
}, |
||||
|
|
||||
|
getMyNode: () => { |
||||
|
const nodeDB = get().nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
if (!nodeDB.myNodeNum) { |
||||
|
throw new Error(`No myNodeNum set for nodeDB with id: ${id}`); |
||||
|
} |
||||
|
return ( |
||||
|
nodeDB.nodeMap.get(nodeDB.myNodeNum) ?? |
||||
|
create(Protobuf.Mesh.NodeInfoSchema) |
||||
|
); |
||||
|
}, |
||||
|
|
||||
|
getNodeError: (nodeNum) => { |
||||
|
const nodeDB = get().nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
return nodeDB.nodeErrors.get(nodeNum); |
||||
|
}, |
||||
|
|
||||
|
hasNodeError: (nodeNum) => { |
||||
|
const nodeDB = get().nodeDBs.get(id); |
||||
|
if (!nodeDB) { |
||||
|
throw new Error(`No nodeDB found (id: ${id})`); |
||||
|
} |
||||
|
return nodeDB.nodeErrors.has(nodeNum); |
||||
|
}, |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
export const nodeDBInitializer: StateCreator<PrivateNodeDBState> = ( |
||||
|
set, |
||||
|
get, |
||||
|
) => ({ |
||||
|
nodeDBs: new Map(), |
||||
|
|
||||
|
addNodeDB: (id) => { |
||||
|
const existing = get().nodeDBs.get(id); |
||||
|
if (existing) { |
||||
|
return existing; |
||||
|
} |
||||
|
|
||||
|
const nodeDB = nodeDBFactory(id, get, set); |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
draft.nodeDBs.set(id, nodeDB); |
||||
|
|
||||
|
// If over limit, remove oldest inserted. FIFO
|
||||
|
if (draft.nodeDBs.size > NODEDB_RETENTION_NUM) { |
||||
|
const firstKey = draft.nodeDBs.keys().next().value; |
||||
|
if (firstKey !== undefined) { |
||||
|
draft.nodeDBs.delete(firstKey); |
||||
|
} |
||||
|
} |
||||
|
}), |
||||
|
); |
||||
|
|
||||
|
return nodeDB; |
||||
|
}, |
||||
|
removeNodeDB: (id) => { |
||||
|
set( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
draft.nodeDBs.delete(id); |
||||
|
}), |
||||
|
); |
||||
|
}, |
||||
|
getNodeDBs: () => Array.from(get().nodeDBs.values()), |
||||
|
getNodeDB: (id) => get().nodeDBs.get(id), |
||||
|
}); |
||||
|
|
||||
|
const persistOptions: PersistOptions<PrivateNodeDBState, NodeDBPersisted> = { |
||||
|
name: "meshtastic-nodedb-store", |
||||
|
storage: createStorage<NodeDBPersisted>(), |
||||
|
version: CURRENT_STORE_VERSION, |
||||
|
partialize: (s): NodeDBPersisted => ({ |
||||
|
nodeDBs: new Map( |
||||
|
Array.from(s.nodeDBs.entries()).map(([id, db]) => [ |
||||
|
id, |
||||
|
{ |
||||
|
id: db.id, |
||||
|
myNodeNum: db.myNodeNum, |
||||
|
nodeMap: db.nodeMap, |
||||
|
nodeErrors: db.nodeErrors, |
||||
|
}, |
||||
|
]), |
||||
|
), |
||||
|
}), |
||||
|
onRehydrateStorage: () => (state) => { |
||||
|
if (!state) { |
||||
|
return; |
||||
|
} |
||||
|
console.debug( |
||||
|
"NodeDBStore: Rehydrating state with ", |
||||
|
state.nodeDBs.size, |
||||
|
" nodeDBs -", |
||||
|
state.nodeDBs, |
||||
|
); |
||||
|
|
||||
|
useNodeDBStore.setState( |
||||
|
produce<PrivateNodeDBState>((draft) => { |
||||
|
const rebuilt = new Map<number, NodeDB>(); |
||||
|
for (const [id, data] of ( |
||||
|
draft.nodeDBs as unknown as Map<number, NodeDBData> |
||||
|
).entries()) { |
||||
|
if (data.myNodeNum !== undefined) { |
||||
|
// Only rebuild if there is a nodenum set otherwise orphan dbs will acumulate
|
||||
|
rebuilt.set( |
||||
|
id, |
||||
|
nodeDBFactory( |
||||
|
id, |
||||
|
useNodeDBStore.getState, |
||||
|
useNodeDBStore.setState, |
||||
|
data, |
||||
|
), |
||||
|
); |
||||
|
} |
||||
|
} |
||||
|
draft.nodeDBs = rebuilt; |
||||
|
}), |
||||
|
); |
||||
|
}, |
||||
|
}; |
||||
|
|
||||
|
// Add persist middleware on the store if the feature flag is enabled
|
||||
|
const persistNodes = featureFlags.get("persistNodeDB"); |
||||
|
console.debug( |
||||
|
`NodeDBStore: Persisting nodes is ${persistNodes ? "enabled" : "disabled"}`, |
||||
|
); |
||||
|
|
||||
|
export const useNodeDBStore = persistNodes |
||||
|
? createStore<PrivateNodeDBState, [["zustand/persist", NodeDBPersisted]]>( |
||||
|
persist(nodeDBInitializer, persistOptions), |
||||
|
) |
||||
|
: createStore<PrivateNodeDBState>()(nodeDBInitializer); |
||||
@ -0,0 +1,30 @@ |
|||||
|
import { vi } from "vitest"; |
||||
|
import type { NodeDB } from "./index.ts"; |
||||
|
|
||||
|
/** |
||||
|
* You can spread this base mock in your tests and override only the |
||||
|
* properties relevant to a specific test case. |
||||
|
*/ |
||||
|
export const mockNodeDBStore: NodeDB = { |
||||
|
id: 0, |
||||
|
myNodeNum: 0, |
||||
|
nodeErrors: new Map(), |
||||
|
nodeMap: new Map(), |
||||
|
|
||||
|
addNode: vi.fn(), |
||||
|
addUser: vi.fn(), |
||||
|
addPosition: vi.fn(), |
||||
|
removeNode: vi.fn(), |
||||
|
processPacket: vi.fn(), |
||||
|
setNodeError: vi.fn(), |
||||
|
clearNodeError: vi.fn(), |
||||
|
getNodeError: vi.fn().mockReturnValue(undefined), |
||||
|
hasNodeError: vi.fn().mockReturnValue(false), |
||||
|
getNodes: vi.fn().mockReturnValue([]), |
||||
|
getNodesLength: vi.fn().mockReturnValue(0), |
||||
|
getNode: vi.fn().mockReturnValue(undefined), |
||||
|
getMyNode: vi.fn(), |
||||
|
updateFavorite: vi.fn(), |
||||
|
updateIgnore: vi.fn(), |
||||
|
setNodeNum: vi.fn(), |
||||
|
}; |
||||
@ -0,0 +1,258 @@ |
|||||
|
import { beforeEach, describe, expect, it, vi } from "vitest"; |
||||
|
|
||||
|
const idbMem = new Map<string, string>(); |
||||
|
vi.mock("idb-keyval", () => ({ |
||||
|
get: vi.fn((key: string) => Promise.resolve(idbMem.get(key))), |
||||
|
set: vi.fn((key: string, val: string) => { |
||||
|
idbMem.set(key, val); |
||||
|
return Promise.resolve(); |
||||
|
}), |
||||
|
del: vi.fn((k: string) => { |
||||
|
idbMem.delete(k); |
||||
|
return Promise.resolve(); |
||||
|
}), |
||||
|
})); |
||||
|
|
||||
|
// import a fresh copy of the store module (because the store is created at import time)
|
||||
|
async function freshStore() { |
||||
|
vi.resetModules(); |
||||
|
const mod = await import("../nodeDBStore"); |
||||
|
return mod; |
||||
|
} |
||||
|
|
||||
|
vi.mock("@core/services/featureFlags", () => { |
||||
|
return { |
||||
|
featureFlags: { |
||||
|
get: vi.fn((key: string) => { |
||||
|
if (key === "persistNodeDB") return true; |
||||
|
return false; |
||||
|
}), |
||||
|
}, |
||||
|
}; |
||||
|
}); |
||||
|
|
||||
|
function makeNode(num: number, extras: Record<string, any> = {}) { |
||||
|
return { num, ...extras } as any; |
||||
|
} |
||||
|
|
||||
|
describe("NodeDB store", () => { |
||||
|
beforeEach(() => { |
||||
|
idbMem.clear(); |
||||
|
vi.clearAllMocks(); |
||||
|
}); |
||||
|
|
||||
|
it("addNodeDB returns same instance on repeated calls; getNodeDB works", async () => { |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
|
||||
|
const db1 = useNodeDBStore.getState().addNodeDB(123); |
||||
|
const db2 = useNodeDBStore.getState().addNodeDB(123); |
||||
|
expect(db1).toBe(db2); |
||||
|
|
||||
|
const got = useNodeDBStore.getState().getNodeDB(123); |
||||
|
expect(got).toBe(db1); |
||||
|
|
||||
|
expect(useNodeDBStore.getState().getNodeDBs().length).toBe(1); |
||||
|
}); |
||||
|
|
||||
|
it("addNode, getNode(s), getNodesLength, removeNode", async () => { |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const db = useNodeDBStore.getState().addNodeDB(1); |
||||
|
|
||||
|
db.addNode(makeNode(10)); |
||||
|
db.addNode(makeNode(11)); |
||||
|
expect(db.getNodesLength()).toBe(2); |
||||
|
expect(db.getNode(10)?.num).toBe(10); |
||||
|
|
||||
|
const all = db.getNodes(); |
||||
|
expect(all.map(n => n.num).sort()).toEqual([10, 11]); |
||||
|
|
||||
|
db.removeNode(10); |
||||
|
expect(db.getNodesLength()).toBe(1); |
||||
|
expect(db.getNode(10)).toBeUndefined(); |
||||
|
}); |
||||
|
|
||||
|
it("processPacket creates or updates a node", async () => { |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const db = useNodeDBStore.getState().addNodeDB(1); |
||||
|
|
||||
|
db.processPacket({ from: 50, time: 1111, snr: 7 } as any); |
||||
|
expect(db.getNode(50)).toBeTruthy(); |
||||
|
expect(db.getNode(50)?.lastHeard).toBe(1111); |
||||
|
expect(db.getNode(50)?.snr).toBe(7); |
||||
|
|
||||
|
db.processPacket({ from: 50, time: 2222, snr: 9 } as any); |
||||
|
expect(db.getNode(50)?.lastHeard).toBe(2222); |
||||
|
expect(db.getNode(50)?.snr).toBe(9); |
||||
|
}); |
||||
|
|
||||
|
it("addUser and addPosition updates existing or creates new nodes", async () => { |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const db = useNodeDBStore.getState().addNodeDB(1); |
||||
|
|
||||
|
// addUser creates node if missing
|
||||
|
db.addUser({ from: 77, data: { id: "u" } } as any); |
||||
|
expect(db.getNode(77)?.user).toEqual({ id: "u" }); |
||||
|
|
||||
|
// addPosition updates same node
|
||||
|
db.addPosition({ from: 77, data: { lat: 1, lon: 2 } } as any); |
||||
|
expect(db.getNode(77)?.position).toEqual({ lat: 1, lon: 2 }); |
||||
|
expect(db.getNode(77)?.num).toBe(77); |
||||
|
}); |
||||
|
|
||||
|
it("errors map: setNodeError, getNodeError, hasNodeError, clearNodeError", async () => { |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const db = useNodeDBStore.getState().addNodeDB(1); |
||||
|
|
||||
|
db.setNodeError(10, "BadFoo" as any); |
||||
|
expect(db.hasNodeError(10)).toBe(true); |
||||
|
expect(db.getNodeError(10)).toEqual({ node: 10, error: "BadFoo" }); |
||||
|
|
||||
|
db.clearNodeError(10); |
||||
|
expect(db.hasNodeError(10)).toBe(false); |
||||
|
expect(db.getNodeError(10)).toBeUndefined(); |
||||
|
}); |
||||
|
|
||||
|
it("getMyNode throws before setNodeNum; works after", async () => { |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const db = useNodeDBStore.getState().addNodeDB(1); |
||||
|
db.addNode(makeNode(123)); |
||||
|
|
||||
|
expect(() => db.getMyNode()).toThrow(); |
||||
|
db.setNodeNum(123); |
||||
|
|
||||
|
const me = db.getMyNode(); |
||||
|
expect(me.num).toBe(123); |
||||
|
}); |
||||
|
|
||||
|
it("setNodeNum merges with existing DB with same myNodeNum", async () => { |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const st = useNodeDBStore.getState(); |
||||
|
|
||||
|
|
||||
|
const oldDB = st.addNodeDB(10); |
||||
|
oldDB.setNodeNum(999); |
||||
|
oldDB.addNode(makeNode(200)); |
||||
|
oldDB.setNodeError(200, "ERROR" as any); |
||||
|
|
||||
|
const newDB = st.addNodeDB(11); |
||||
|
// newDB currently empty; setting same myNodeNum should copy maps from oldDB and delete old
|
||||
|
newDB.setNodeNum(999); |
||||
|
|
||||
|
expect(st.getNodeDB(10)).toBeUndefined(); |
||||
|
expect(st.getNodeDB(11)).toBeDefined(); |
||||
|
expect(newDB.getNode(200)).toBeTruthy(); |
||||
|
expect(newDB.getNodeError(200)).toEqual({ node: 200, error: "ERROR" }); |
||||
|
}); |
||||
|
|
||||
|
it("setNodeNum does not merge when new DB already has nodes; old is removed", async () => { |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const st = useNodeDBStore.getState(); |
||||
|
|
||||
|
const oldDB = st.addNodeDB(10); |
||||
|
oldDB.setNodeNum(999); |
||||
|
oldDB.addNode(makeNode(200)); // old has data
|
||||
|
|
||||
|
const newDB = st.addNodeDB(11); |
||||
|
newDB.addNode(makeNode(300)); // new has data -> no merge
|
||||
|
newDB.setNodeNum(999); |
||||
|
|
||||
|
expect(st.getNodeDB(10)).toBeUndefined(); // old removed
|
||||
|
// new kept its own nodes; did not copy old's
|
||||
|
expect(newDB.getNode(300)).toBeTruthy(); |
||||
|
expect(newDB.getNode(200)).toBeUndefined(); |
||||
|
}); |
||||
|
|
||||
|
it("partialize persists only data, and onRehydrateStorage rebuilds methods", async () => { |
||||
|
{ |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const st = useNodeDBStore.getState(); |
||||
|
const db = st.addNodeDB(123); |
||||
|
db.setNodeNum(321); |
||||
|
db.addNode(makeNode(50)); |
||||
|
db.setNodeError(50, "ERROR" as any); |
||||
|
} |
||||
|
{ |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const st = useNodeDBStore.getState(); |
||||
|
const db = st.getNodeDB(123)!; |
||||
|
|
||||
|
// methods should work after rehydrate
|
||||
|
expect(db.getNode(50)?.num).toBe(50); |
||||
|
expect(db.getNodeError(50)).toEqual({ node: 50, error: "ERROR" }); |
||||
|
db.addNode(makeNode(51)); |
||||
|
expect(db.getNode(51)).toBeTruthy(); |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
it("getNodes applies filter and excludes myNodeNum", async () => { |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const db = useNodeDBStore.getState().addNodeDB(1); |
||||
|
db.setNodeNum(11); |
||||
|
db.addNode(makeNode(10)); |
||||
|
db.addNode(makeNode(11)); |
||||
|
db.addNode(makeNode(12)); |
||||
|
|
||||
|
const all = db.getNodes(); |
||||
|
expect(all.map((n) => n.num).sort()).toEqual([10, 12]); // excludes my (11)
|
||||
|
|
||||
|
const filtered = db.getNodes((n) => n.num > 10); |
||||
|
expect(filtered.map((n) => n.num).sort()).toEqual([12]); // still excludes 11
|
||||
|
}); |
||||
|
|
||||
|
it("when exceeding cap, evicts earliest inserted, not the newly added", async () => { |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const st = useNodeDBStore.getState(); |
||||
|
for (let i = 1; i <= 10; i++) st.addNodeDB(i); |
||||
|
st.addNodeDB(11); |
||||
|
expect(st.getNodeDB(1)).toBeUndefined(); |
||||
|
expect(st.getNodeDB(11)).toBeDefined(); |
||||
|
}); |
||||
|
|
||||
|
it("removeNodeDB persists removal across reload", async () => { |
||||
|
{ |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const st = useNodeDBStore.getState(); |
||||
|
st.addNodeDB(99); |
||||
|
expect(st.getNodeDB(99)).toBeDefined(); |
||||
|
st.removeNodeDB(99); |
||||
|
expect(st.getNodeDB(99)).toBeUndefined(); |
||||
|
} |
||||
|
{ |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const st = useNodeDBStore.getState(); |
||||
|
expect(st.getNodeDB(99)).toBeUndefined(); // still gone
|
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
it("on rehydrate only rebuilds DBs with myNodeNum set (orphans dropped)", async () => { |
||||
|
{ |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const st = useNodeDBStore.getState(); |
||||
|
|
||||
|
const orphan = st.addNodeDB(500); // no setNodeNum
|
||||
|
orphan.addNode(makeNode(1)); |
||||
|
|
||||
|
const good = st.addNodeDB(501); |
||||
|
good.setNodeNum(42); |
||||
|
good.addNode(makeNode(2)); |
||||
|
} |
||||
|
{ |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const st = useNodeDBStore.getState(); |
||||
|
expect(st.getNodeDB(500)).toBeUndefined(); // orphan dropped
|
||||
|
expect(st.getNodeDB(501)).toBeDefined(); // kept
|
||||
|
expect(st.getNodeDB(501)!.getNode(2)).toBeTruthy(); |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
it("methods throw after their DB is removed from the map", async () => { |
||||
|
const { useNodeDBStore } = await freshStore(); |
||||
|
const st = useNodeDBStore.getState(); |
||||
|
const db = st.addNodeDB(800); |
||||
|
|
||||
|
st.removeNodeDB(800); |
||||
|
|
||||
|
expect(() => db.getNodesLength()).toThrow(/No nodeDB found/); |
||||
|
expect(() => db.addNode(makeNode(1))).toThrow(/No nodeDB found/); |
||||
|
}); |
||||
|
}); |
||||
@ -0,0 +1,16 @@ |
|||||
|
import type { Protobuf } from "@meshtastic/core"; |
||||
|
|
||||
|
type NodeErrorType = Protobuf.Mesh.Routing_Error | "MISMATCH_PKI"; |
||||
|
|
||||
|
type NodeError = { |
||||
|
node: number; |
||||
|
error: NodeErrorType; |
||||
|
}; |
||||
|
|
||||
|
type ProcessPacketParams = { |
||||
|
from: number; |
||||
|
snr: number; |
||||
|
time: number; |
||||
|
}; |
||||
|
|
||||
|
export type { NodeError, ProcessPacketParams, NodeErrorType }; |
||||
@ -0,0 +1,158 @@ |
|||||
|
import { beforeEach, describe, expect, it, vi } from "vitest"; |
||||
|
import * as idb from "idb-keyval"; |
||||
|
import { createStorage } from "./indexDB"; |
||||
|
|
||||
|
type PersistStorage<T> = ReturnType<typeof createStorage<T>>; |
||||
|
|
||||
|
describe("indexDB.ts persistence (steps 1–5)", () => { |
||||
|
let store: PersistStorage<any>; |
||||
|
|
||||
|
beforeEach(() => { |
||||
|
vi.restoreAllMocks(); |
||||
|
store = createStorage<any>(); |
||||
|
}); |
||||
|
|
||||
|
async function roundTrip(obj: any) { |
||||
|
const setSpy = vi.spyOn(idb, "set").mockResolvedValue(); |
||||
|
const getSpy = vi.spyOn(idb, "get"); |
||||
|
await store.setItem("rt", obj); |
||||
|
const storedStr = (setSpy.mock.calls[0] as any[])[1] as string; |
||||
|
getSpy.mockResolvedValue(storedStr); |
||||
|
return await store.getItem("rt"); |
||||
|
} |
||||
|
|
||||
|
// Basic methods
|
||||
|
it("getItem returns null when idb-keyval.get yields undefined", async () => { |
||||
|
const getSpy = vi.spyOn(idb, "get").mockResolvedValue(undefined); |
||||
|
const res = await store.getItem("missing-key"); |
||||
|
expect(getSpy).toHaveBeenCalledWith("missing-key"); |
||||
|
expect(res).toBeNull(); |
||||
|
}); |
||||
|
|
||||
|
it("setItem writes a string via idb-keyval.set", async () => { |
||||
|
const setSpy = vi.spyOn(idb, "set").mockResolvedValue(); |
||||
|
const payload = { state: { a: 1 }, version: 0 }; |
||||
|
await store.setItem("k1", payload); |
||||
|
expect(setSpy).toHaveBeenCalledTimes(1); |
||||
|
const [, value] = setSpy.mock.calls[0]!; |
||||
|
expect(typeof value).toBe("string"); |
||||
|
// sanity: it should be JSON
|
||||
|
expect(() => JSON.parse(value as string)).not.toThrow(); |
||||
|
}); |
||||
|
|
||||
|
it("removeItem calls idb-keyval.del and getItem returns null afterwards", async () => { |
||||
|
const delSpy = vi.spyOn(idb, "del").mockResolvedValue(); |
||||
|
await store.removeItem("k2"); |
||||
|
expect(delSpy).toHaveBeenCalledWith("k2"); |
||||
|
|
||||
|
const getSpy = vi.spyOn(idb, "get").mockResolvedValue(undefined); |
||||
|
const res = await store.getItem("k2"); |
||||
|
expect(getSpy).toHaveBeenCalledWith("k2"); |
||||
|
expect(res).toBeNull(); |
||||
|
}); |
||||
|
|
||||
|
// Map
|
||||
|
it("round-trips an empty Map", async () => { |
||||
|
const out = await roundTrip({ state: { m: new Map() }, version: 0 }); |
||||
|
expect(out?.state.m instanceof Map).toBe(true); |
||||
|
expect(out?.state.m.size).toBe(0); |
||||
|
}); |
||||
|
|
||||
|
it("round-trips a Map<number,string> and preserves numeric key semantics", async () => { |
||||
|
const m = new Map<number, string>([[1, "a"]]); |
||||
|
const out = await roundTrip({ state: { m }, version: 0 }); |
||||
|
const m2 = out!.state.m as Map<number, string>; |
||||
|
expect(m2 instanceof Map).toBe(true); |
||||
|
expect(m2.get(1)).toBe("a"); |
||||
|
}); |
||||
|
|
||||
|
it("round-trips nested Map inside arrays/objects", async () => { |
||||
|
const payload = { |
||||
|
state: { |
||||
|
list: [new Map<number, number>([[2, 3]])], |
||||
|
obj: { inner: new Map<string, number>([["k", 7]]) }, |
||||
|
}, |
||||
|
version: 0, |
||||
|
}; |
||||
|
const out = await roundTrip(payload); |
||||
|
|
||||
|
expect(out!.state.list[0] instanceof Map).toBe(true); |
||||
|
expect((out!.state.list[0] as Map<number, number>).get(2)).toBe(3); |
||||
|
expect(out!.state.obj.inner instanceof Map).toBe(true); |
||||
|
expect((out!.state.obj.inner as Map<string, number>).get("k")).toBe(7); |
||||
|
}); |
||||
|
|
||||
|
// Uint8Array
|
||||
|
it("round-trips a Uint8Array (simple)", async () => { |
||||
|
const u8 = new Uint8Array([1, 2, 255]); |
||||
|
const out = await roundTrip({ state: { u8 }, version: 0 }); |
||||
|
const u2 = out!.state.u8 as Uint8Array; |
||||
|
expect(u2 instanceof Uint8Array).toBe(true); |
||||
|
expect(Array.from(u2)).toEqual([1, 2, 255]); |
||||
|
}); |
||||
|
|
||||
|
it("round-trips a Uint8Array view with non-zero byteOffset", async () => { |
||||
|
const buf = new Uint8Array([0, 9, 8, 7, 6, 5, 4, 3]).buffer; |
||||
|
const view = new Uint8Array(buf, 2, 4); // [8,7,6,5]
|
||||
|
const out = await roundTrip({ state: { view }, version: 0 }); |
||||
|
const v2 = out!.state.view as Uint8Array; |
||||
|
expect(v2 instanceof Uint8Array).toBe(true); |
||||
|
expect(Array.from(v2)).toEqual([8, 7, 6, 5]); |
||||
|
// ensure it's a standalone buffer now, without offset
|
||||
|
expect(v2.byteOffset).toBe(0); |
||||
|
}); |
||||
|
|
||||
|
// Mixed & nested structures
|
||||
|
it("round-trips Map values containing objects with nested Uint8Array", async () => { |
||||
|
const inner = { key: new Uint8Array([7, 8]) }; |
||||
|
const m = new Map<number, { key: Uint8Array }>([[42, inner]]); |
||||
|
const out = await roundTrip({ state: { m }, version: 0 }); |
||||
|
const m2 = out!.state.m as Map<number, { key: Uint8Array }>; |
||||
|
expect(m2 instanceof Map).toBe(true); |
||||
|
|
||||
|
const got = m2.get(42)!; |
||||
|
expect(got.key instanceof Uint8Array).toBe(true); |
||||
|
expect(Array.from(got.key)).toEqual([7, 8]); |
||||
|
}); |
||||
|
|
||||
|
it("round-trips deep nesting (array → object → map → u8)", async () => { |
||||
|
const payload = { |
||||
|
state: { |
||||
|
arr: [ |
||||
|
{ |
||||
|
obj: { |
||||
|
m: new Map<string, Uint8Array>([["k", new Uint8Array([9])]]), |
||||
|
}, |
||||
|
}, |
||||
|
], |
||||
|
}, |
||||
|
version: 0, |
||||
|
}; |
||||
|
const out = await roundTrip(payload); |
||||
|
const m2 = out!.state.arr[0].obj.m as Map<string, Uint8Array>; |
||||
|
expect(m2 instanceof Map).toBe(true); |
||||
|
const u = m2.get("k")!; |
||||
|
expect(u instanceof Uint8Array).toBe(true); |
||||
|
expect(Array.from(u)).toEqual([9]); |
||||
|
}); |
||||
|
|
||||
|
it("does not alter plain objects/arrays", async () => { |
||||
|
const payload = { state: { a: 1, b: [2, 3], c: { d: 4 } }, version: 0 }; |
||||
|
const out = await roundTrip(payload); |
||||
|
expect(out).toEqual(payload); |
||||
|
}); |
||||
|
|
||||
|
it("revives envelope-looking objects", async () => { |
||||
|
// Current implementation will treat any {__datatype:"Map",value:[...]} as an envelope.
|
||||
|
const forged = JSON.stringify({ |
||||
|
state: { m: { __datatype: "Map", value: [[1, "x"]] } }, |
||||
|
version: 0, |
||||
|
}); |
||||
|
const getSpy = vi.spyOn(idb, "get").mockResolvedValue(forged); |
||||
|
const out = await store.getItem("forged"); |
||||
|
expect(getSpy).toHaveBeenCalled(); |
||||
|
const m2 = out!.state.m as Map<number, string>; |
||||
|
expect(m2 instanceof Map).toBe(true); |
||||
|
expect(m2.get(1)).toBe("x"); |
||||
|
}); |
||||
|
}); |
||||
@ -0,0 +1,19 @@ |
|||||
|
import { createContext, useContext } from "react"; |
||||
|
|
||||
|
export type DeviceContext = { |
||||
|
deviceId: number; // Unique identifier for the device, not nodeNum
|
||||
|
}; |
||||
|
|
||||
|
export const CurrentDeviceContext = createContext<DeviceContext | undefined>( |
||||
|
undefined, |
||||
|
); |
||||
|
|
||||
|
export function useDeviceContext(): DeviceContext { |
||||
|
const ctx = useContext(CurrentDeviceContext); |
||||
|
if (!ctx) { |
||||
|
throw new Error( |
||||
|
"useDeviceContext must be used within CurrentDeviceContext provider", |
||||
|
); |
||||
|
} |
||||
|
return ctx; |
||||
|
} |
||||
Loading…
Reference in new issue