1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
import { toast } from "sonner";
import { create } from "zustand";
import {
createInstance,
deleteInstance,
duplicateInstance,
getActiveInstance,
getInstance,
listInstances,
setActiveInstance,
updateInstance,
} from "@/client";
import type { Instance } from "@/types";
interface InstancesState {
// State
instances: Instance[];
activeInstance: Instance | null;
// Actions
refresh: () => Promise<void>;
create: (name: string) => Promise<Instance | null>;
delete: (id: string) => Promise<void>;
update: (instance: Instance) => Promise<void>;
setActiveInstance: (instance: Instance) => Promise<void>;
duplicate: (id: string, newName: string) => Promise<Instance | null>;
getInstance: (id: string) => Promise<Instance | null>;
}
export const useInstancesStore = create<InstancesState>((set, get) => ({
// Initial state
instances: [],
activeInstance: null,
// Actions
refresh: async () => {
const { setActiveInstance } = get();
try {
const instances = await listInstances();
const active = await getActiveInstance();
if (!active && instances.length > 0) {
// If no active instance but instances exist, set the first one as active
await setActiveInstance(instances[0]);
}
set({ instances });
} catch (e) {
console.error("Failed to load instances:", e);
toast.error("Error loading instances");
}
},
create: async (name) => {
const { refresh } = get();
try {
const instance = await createInstance(name);
await refresh();
toast.success(`Instance "${name}" created successfully`);
return instance;
} catch (e) {
console.error("Failed to create instance:", e);
toast.error("Error creating instance");
return null;
}
},
delete: async (id) => {
const { refresh, instances, activeInstance, setActiveInstance } = get();
try {
await deleteInstance(id);
await refresh();
// If deleted instance was active, set another as active
if (activeInstance?.id === id) {
if (instances.length > 0) {
await setActiveInstance(instances[0]);
} else {
set({ activeInstance: null });
}
}
toast.success("Instance deleted successfully");
} catch (e) {
console.error("Failed to delete instance:", e);
toast.error("Error deleting instance");
}
},
update: async (instance) => {
const { refresh } = get();
try {
await updateInstance(instance);
await refresh();
toast.success("Instance updated successfully");
} catch (e) {
console.error("Failed to update instance:", e);
toast.error("Error updating instance");
}
},
setActiveInstance: async (instance) => {
try {
await setActiveInstance(instance.id);
set({ activeInstance: instance });
toast.success("Active instance changed");
} catch (e) {
console.error("Failed to set active instance:", e);
toast.error("Error setting active instance");
}
},
duplicate: async (id, newName) => {
const { refresh } = get();
try {
const instance = await duplicateInstance(id, newName);
await refresh();
toast.success(`Instance duplicated as "${newName}"`);
return instance;
} catch (e) {
console.error("Failed to duplicate instance:", e);
toast.error("Error duplicating instance");
return null;
}
},
getInstance: async (id) => {
try {
return await getInstance(id);
} catch (e) {
console.error("Failed to get instance:", e);
return null;
}
},
}));
|