feat(api): improve storage API, move store & http from app to global

packages/api/types/app.d.ts

@@ -1,13 +1,9 @@
-import type { AppHttp } from './http';
 import type { AppLogger } from './logger';
 import type { AppPrompt } from './prompt';
-import type { AppStorage } from './storage';
 import type { AppUtils } from './utils';
 
 export type App = {
   log: AppLogger;
-  http: AppHttp;
   prompt: AppPrompt;
-  store: AppStorage;
   utils: AppUtils;
 };

packages/api/types/global.d.ts

@@ -1,7 +1,9 @@
 import { App } from './app';
 import { AppStorage } from './storage';
+import { AppHttp } from './http';
 
 declare global {
   const app: App;
   const storage: AppStorage;
+  const http: AppHttp;
 }

packages/api/types/prompt.d.ts

@@ -1,3 +1,10 @@
+export type PromptForm = {
+  title?: string;
+  subtitle?: string;
+} & {
+  [field: string]: { label: string; defaultValue?: string };
+};
+
 export type PromptFormResponse = { [field: string]: string };
 
 export type AppPrompt = {

packages/api/types/storage.d.ts

@@ -1,5 +1,8 @@
-export type AppStorage = {
-  state: Record<string, any>;
-  getState: <T = any>(cookiesKey?: string | null) => Promise<T>;
-  setState: <T = Record<string, any>>(data?: T) => Promise<void>;
-};
+export type AppStorage<T = Record<string, any>> = {
+  load(): Promise<void>;
+  get(key: string): Promise<any>;
+  set(key: string, value: any): Promise<void>;
+  delete(key: string): Promise<void>;
+  clear(): Promise<void>;
+  save(items: T): Promise<void>;
+} & T;

packages/core/lib/store.ts

@@ -26,6 +26,58 @@ const getCookiesFromTxt = async (dir: string) => {
   return cookies;
 };
 
+export const createStorage = async (name: string) => {
+  const storageDir = initDir(join(getSettings().servicesDir, name));
+  const storagePath = join(storageDir, `${name}.storage.json`);
+
+  const configPath = join(storageDir, 'config.json');
+  if (fs.exists(configPath)) await fs.rename(configPath, storagePath);
+
+  const serializable = (obj: any) => {
+    const result: any = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value !== 'function') result[key] = value;
+    }
+    return result;
+  };
+
+  const storage: Record<string, any> = {
+    async load() {
+      const data = (await fs.readJson<any>(storagePath).catch(() => {})) || {};
+      for (const [key, value] of Object.entries(data)) storage[key] = value;
+      // Automatically load cookies from cookies.txt
+      const cookies = await getCookiesFromTxt(storagePath);
+      if (!!cookies.length) await storage.set('cookies', cookies);
+    },
+    async get(key: string) {
+      const data = (await fs.readJson<any>(storagePath).catch(() => {})) || {};
+      return data[key];
+    },
+    async set(key: string, value: any) {
+      storage[key] = value;
+      await fs.writeJson(storagePath, serializable(storage));
+    },
+    async delete(key: string) {
+      delete storage[key];
+      await fs.writeJson(storagePath, serializable(storage));
+    },
+    async clear() {
+      for (const [key, value] of Object.entries(storage)) {
+        const isFn = typeof value === 'function';
+        if (!isFn) delete storage[key];
+      }
+      await fs.writeJson(storagePath, serializable(storage));
+    },
+    async save(items?: Record<string, any>) {
+      const data = items || serializable(storage);
+      for (const [key, value] of Object.entries(data)) storage[key] = value;
+      await fs.writeJson(storagePath, data);
+    },
+  };
+
+  return storage;
+};
+
 export const createStore = (name: string) => {
   const storePath = createStorePath(name);
   const state = {} as Record<string, any>;