homeio

1import type {
2  SystemBackupListResponse,
3  SystemBackupSettings,
4  SystemPreferences,
5  SystemRestoreAcceptedResponse,
6  SystemSecuritySettings,
7  SystemUpdateApplyAcceptedResponse,
8  SystemUpdateStatus,
9} from "@/lib/shared/contracts/system";
10import { DEFAULT_SCHEDULED_REBOOT_CONFIG } from "@/modules/settings/hooks/backend/constants";
11import type {
12  BackupRunAcceptedResponse,
13  ScheduledRebootConfig,
14} from "@/modules/settings/hooks/backend/types";
15
16type ApiErrorPayload = {
17  error?: string;
18};
19
20type ApiEnvelope<T> = {
21  data?: T;
22};
23
24type TimedSettingsRequestOptions<T> = {
25  endpoint: string;
26  errorMessage: string;
27  init?: RequestInit;
28  readData?: (payload: ApiEnvelope<T>) => T;
29};
30
31async function readErrorMessage(response: Response, fallbackMessage: string) {
32  const payload = (await response.json().catch(() => ({}))) as ApiErrorPayload;
33  return payload.error ?? `${fallbackMessage} (${response.status})`;
34}
35
36async function requestSettingsData<T>({
37  endpoint,
38  errorMessage,
39  init,
40  readData,
41}: TimedSettingsRequestOptions<T>): Promise<T> {
42  const response = await fetch(endpoint, init);
43
44  if (!response.ok) {
45    throw new Error(await readErrorMessage(response, errorMessage));
46  }
47
48  const payload = (await response.json()) as ApiEnvelope<T>;
49  return readData ? readData(payload) : (payload.data as T);
50}
51
52export function fetchSystemUpdatesRequest(): Promise<SystemUpdateStatus> {
53  return requestSettingsData<SystemUpdateStatus>({
54    endpoint: "/api/v1/system/updates",
55    errorMessage: "Failed to load Homeio updates",
56    init: {
57      cache: "no-store",
58    },
59  });
60}
61
62export function checkSystemUpdatesRequest(): Promise<SystemUpdateStatus> {
63  return requestSettingsData<SystemUpdateStatus>({
64    endpoint: "/api/v1/system/updates/check",
65    errorMessage: "Failed to check for Homeio updates",
66    init: {
67      method: "POST",
68      headers: {
69        "Content-Type": "application/json",
70      },
71    },
72  });
73}
74
75export function applySystemUpdateRequest(): Promise<SystemUpdateApplyAcceptedResponse> {
76  return requestSettingsData<SystemUpdateApplyAcceptedResponse>({
77    endpoint: "/api/v1/system/updates/apply",
78    errorMessage: "Failed to schedule Homeio update",
79    init: {
80      method: "POST",
81    },
82  });
83}
84
85export function fetchSystemPreferencesRequest(): Promise<SystemPreferences> {
86  return requestSettingsData<SystemPreferences>({
87    endpoint: "/api/v1/system/preferences",
88    errorMessage: "Failed to load system preferences",
89    init: {
90      cache: "no-store",
91    },
92  });
93}
94
95export function saveSystemPreferencesRequest(input: SystemPreferences): Promise<SystemPreferences> {
96  return requestSettingsData<SystemPreferences>({
97    endpoint: "/api/v1/system/preferences",
98    errorMessage: "Failed to save system preferences",
99    init: {
100      method: "PUT",
101      headers: {
102        "Content-Type": "application/json",
103      },
104      body: JSON.stringify(input),
105    },
106  });
107}
108
109export function fetchSystemSecurityRequest(): Promise<SystemSecuritySettings> {
110  return requestSettingsData<SystemSecuritySettings>({
111    endpoint: "/api/v1/system/security",
112    errorMessage: "Failed to load security settings",
113    init: {
114      cache: "no-store",
115    },
116  });
117}
118
119export function saveSystemSecurityRequest(
120  input: SystemSecuritySettings,
121): Promise<SystemSecuritySettings> {
122  return requestSettingsData<SystemSecuritySettings>({
123    endpoint: "/api/v1/system/security",
124    errorMessage: "Failed to save security settings",
125    init: {
126      method: "PUT",
127      headers: {
128        "Content-Type": "application/json",
129      },
130      body: JSON.stringify(input),
131    },
132  });
133}
134
135export function rebootNowRequest(): Promise<unknown> {
136  return requestSettingsData<unknown>({
137    endpoint: "/api/v1/system/power/reboot",
138    errorMessage: "Failed to schedule reboot",
139    init: {
140      method: "POST",
141    },
142  });
143}
144
145export function shutdownNowRequest(): Promise<unknown> {
146  return requestSettingsData<unknown>({
147    endpoint: "/api/v1/system/power/shutdown",
148    errorMessage: "Failed to schedule shutdown",
149    init: {
150      method: "POST",
151    },
152  });
153}
154
155export function factoryResetRequest(): Promise<unknown> {
156  return requestSettingsData<unknown>({
157    endpoint: "/api/v1/system/power/factory-reset",
158    errorMessage: "Failed to schedule factory reset",
159    init: {
160      method: "POST",
161    },
162  });
163}
164
165export type PowerCapabilities = {
166  reboot: boolean;
167  shutdown: boolean;
168  factoryReset: boolean;
169  scheduledReboot: boolean;
170};
171
172const DEFAULT_POWER_CAPABILITIES: PowerCapabilities = {
173  reboot: false,
174  shutdown: false,
175  factoryReset: false,
176  scheduledReboot: false,
177};
178
179export function fetchPowerCapabilitiesRequest(): Promise<PowerCapabilities> {
180  return requestSettingsData<PowerCapabilities>({
181    endpoint: "/api/v1/system/power/capabilities",
182    errorMessage: "Failed to load power capabilities",
183    init: {
184      cache: "no-store",
185    },
186    readData: (payload) => payload.data ?? DEFAULT_POWER_CAPABILITIES,
187  });
188}
189
190export function fetchScheduledRebootRequest(): Promise<ScheduledRebootConfig> {
191  return requestSettingsData<ScheduledRebootConfig>({
192    endpoint: "/api/v1/system/power/schedule",
193    errorMessage: "Failed to load scheduled reboot configuration",
194    init: {
195      cache: "no-store",
196    },
197    readData: (payload) => payload.data ?? DEFAULT_SCHEDULED_REBOOT_CONFIG,
198  });
199}
200
201export function saveScheduledRebootRequest(
202  input: ScheduledRebootConfig,
203): Promise<ScheduledRebootConfig> {
204  return requestSettingsData<ScheduledRebootConfig>({
205    endpoint: "/api/v1/system/power/schedule",
206    errorMessage: "Failed to save scheduled reboot configuration",
207    init: {
208      method: "PUT",
209      headers: {
210        "Content-Type": "application/json",
211      },
212      body: JSON.stringify(input),
213    },
214    readData: (payload) => payload.data ?? input,
215  });
216}
217
218export function pruneDockerImagesRequest(): Promise<unknown> {
219  return requestSettingsData<unknown>({
220    endpoint: "/api/v1/docker/prune/images",
221    errorMessage: "Failed to prune Docker images",
222    init: {
223      method: "POST",
224    },
225  });
226}
227
228export function pruneDockerVolumesRequest(): Promise<unknown> {
229  return requestSettingsData<unknown>({
230    endpoint: "/api/v1/docker/prune/volumes",
231    errorMessage: "Failed to prune Docker volumes",
232    init: {
233      method: "POST",
234    },
235  });
236}
237
238export function fetchSystemBackupsRequest(): Promise<SystemBackupListResponse> {
239  return requestSettingsData<SystemBackupListResponse>({
240    endpoint: "/api/v1/system/backups",
241    errorMessage: "Failed to load backups",
242    init: {
243      cache: "no-store",
244    },
245  });
246}
247
248export function saveBackupSettingsRequest(
249  input: SystemBackupSettings,
250): Promise<SystemBackupSettings> {
251  return requestSettingsData<SystemBackupSettings>({
252    endpoint: "/api/v1/system/backups/settings",
253    errorMessage: "Failed to save backup settings",
254    init: {
255      method: "PUT",
256      headers: {
257        "Content-Type": "application/json",
258      },
259      body: JSON.stringify(input),
260    },
261  });
262}
263
264export function runBackupNowRequest(): Promise<BackupRunAcceptedResponse> {
265  return requestSettingsData<BackupRunAcceptedResponse>({
266    endpoint: "/api/v1/system/backups/run",
267    errorMessage: "Failed to run backup",
268    init: {
269      method: "POST",
270    },
271  });
272}
273
274export function restoreBackupRequest(backupId: string): Promise<SystemRestoreAcceptedResponse> {
275  return requestSettingsData<SystemRestoreAcceptedResponse>({
276    endpoint: `/api/v1/system/backups/${backupId}/restore`,
277    errorMessage: "Failed to restore backup",
278    init: {
279      method: "POST",
280    },
281  });
282}
283