Good Code

parentStore.ts

import { create, StoreApi, UseBoundStore } from 'zustand';
import { isVaultItemOfType, ObfuscatedVaultItem, VaultItem, VaultItemKindMap } from '@/lib/types';
import { invoke } from '@tauri-apps/api/core';

export interface TmpDataStore<K extends keyof VaultItemKindMap> {
  obfuscatedItems: ObfuscatedVaultItem<K>[];
  items: VaultItem<K>[];
  selectedItem: VaultItem<K> | null;

  reset: () => void;
  refresh: () => void;
  addItem: (item: VaultItem<K>) => void;
  updateItem: (id: string, updatedItem: Partial<VaultItem<K>>) => Promise<void>;
  deleteItem: (id: string) => Promise<void>;
  retrieveItem: (id: string) => Promise<VaultItem<K> | null>;
  setPartial: (partial: Partial<TmpDataStore<K>>) => void;
}

export const createTmpDataStore = <K extends keyof VaultItemKindMap>(
  kind: K
): UseBoundStore<StoreApi<TmpDataStore<K>>> => 
  create<TmpDataStore<K>>((set, get) => ({
    obfuscatedItems: [],
    items: [],
    selectedItem: null,

    reset: () => {
      console.debug("[int_rst : 1]", kind);
      set({
        obfuscatedItems: [],
        items: [],
        selectedItem: null,
      });
    },

    refresh: async () => {
      const accounts = await invoke<ObfuscatedVaultItem<K>[]>("vault_get_obfuscated_items");
      const items = accounts.filter(account => isVaultItemOfType(account, kind)) as VaultItem<K>[];

      console.debug("[int_rfr : 1]", kind);      
      console.debug("[int_rfr : 2]", accounts);
      console.debug("[int_rfr : 3]", items);

      set({
        obfuscatedItems: accounts,
        items: items,
      });
    },

    addItem: (item) => set(state => ({ items: [...state.items, item] })),
    
    updateItem: async (id, updatedItem) => {
      await invoke("edit_vault_item", {
        itemId: id,
        itemLabel: updatedItem.label,
        itemKind: updatedItem.kind,
      });
    },

    retrieveItem: async (id) => {
      if (!id) return null;
      const item = await invoke<VaultItem<K>>("get_vault_item", { itemId: id });
      set({ selectedItem: item });
      return item;
    },

    deleteItem: async (id) => {
      if (!id) return;

      const selectedId = get().selectedItem?.id;
      if (selectedId === id) {
        set({ selectedItem: null });
      }

      await invoke("remove_vault_item", { itemId: id });
    },

    setPartial: (partial) => set(state => ({ ...state, ...partial })),
  }));