@vnejs/desktop 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/desktop",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Tools to run desktop app of @vnejs",
   "main": "src/index.js",
   "bin": {

package/src/server.js

@@ -3,21 +3,37 @@ const os = require("os");
 const fastify = require("fastify");
 const fastifyCors = require("@fastify/cors");
 const fastifyStatic = require("@fastify/static");
-const { readFile, readdir, writeFile, appendFile, mkdir, unlink, access } = require("fs/promises");
+const { readFile, readdir, writeFile, appendFile, mkdir, unlink, rmdir, access } = require("fs/promises");
 const { default: getPort } = require("get-port");
 
-const getPrefix = (key) => {
-  const dot = key.indexOf(".");
+const STORAGE_DEFAULT_GROUP = "_";
 
-  return dot === -1 ? key : key.slice(0, dot);
+const toPosixPath = (value) => value.split(path.sep).join("/");
+
+const getStateRelPath = (key) => {
+  const first = key.indexOf("/");
+
+  if (first === -1) return `${key}.json`;
+
+  const module = key.slice(0, first);
+  const afterModule = key.slice(first + 1);
+  const second = afterModule.indexOf("/");
+
+  if (second === -1) return `${module}.json`;
+
+  const group = afterModule.slice(0, second);
+
+  if (!group || group === STORAGE_DEFAULT_GROUP) return `${module}.json`;
+
+  return toPosixPath(path.join(module, `${group}.json`));
 };
 
-const splitStateByPrefix = (state) =>
+const splitStateByPath = (state) =>
   Object.entries(state).reduce((groups, [key, value]) => {
-    const prefix = getPrefix(key);
+    const relPath = getStateRelPath(key);
 
-    groups[prefix] ??= {};
-    groups[prefix][key] = value;
+    groups[relPath] ??= {};
+    groups[relPath][key] = value;
 
     return groups;
   }, {});
@@ -62,43 +78,135 @@ const pathExists = async (target) => {
   }
 };
 
-const readPortPreferred = async (rootDir) => {
+const readPackageVnejs = async (rootDir) => {
   const pkg = JSON.parse(await readFile(path.join(rootDir, "package.json"), "utf8"));
-  const port = Number(pkg.vnejs?.portPreferred);
+
+  return pkg.vnejs || {};
+};
+
+const readPortPreferred = async (rootDir) => {
+  const port = Number((await readPackageVnejs(rootDir)).portPreferred);
 
   return Number.isInteger(port) && port > 0 ? port : undefined;
 };
 
-const runServer = async ({ rootDir, stateDir, oldApp, onAchievementLock, onAchievementUnlock } = {}) => {
+const readDefaultLanguage = async (rootDir) => {
+  const language = (await readPackageVnejs(rootDir)).defaultLanguage;
+
+  return typeof language === "string" && language ? language : "ru";
+};
+
+const runServer = async ({
+  rootDir,
+  stateDir,
+  oldApp,
+  onAchievementLock,
+  onAchievementUnlock,
+  onStateSave,
+  onStateGet,
+  onStateClear,
+  getConfig,
+} = {}) => {
   const port = await getPort({ port: await readPortPreferred(rootDir) });
 
   const resolvedStateDir = stateDir || path.join(rootDir, "state");
   const gamePath = path.join(rootDir, "game");
+  const defaultLanguage = await readDefaultLanguage(rootDir);
 
   const ensureStateDir = () => mkdir(resolvedStateDir, { recursive: true });
 
-  const getStateFiles = async () => {
+  const listStateJsonFiles = async (dir = resolvedStateDir) => {
     try {
-      const files = await readdir(resolvedStateDir);
+      const entries = await readdir(dir, { withFileTypes: true });
+      const files = await Promise.all(
+        entries.map(async (entry) => {
+          const fullPath = path.join(dir, entry.name);
+
+          if (entry.isDirectory()) return listStateJsonFiles(fullPath);
+
+          if (entry.isFile() && entry.name.endsWith(".json")) return [toPosixPath(path.relative(resolvedStateDir, fullPath))];
+
+          return [];
+        }),
+      );
 
-      return files.filter((file) => file.endsWith(".json"));
+      return files.flat();
     } catch {
       return [];
     }
   };
 
-  const onSaveState = async (req, reply) => {
+  const removeEmptyStateDirs = async (dir = resolvedStateDir) => {
+    let entries;
+
     try {
-      await ensureStateDir();
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    await Promise.all(
+      entries
+        .filter((entry) => entry.isDirectory())
+        .map(async (entry) => {
+          const fullPath = path.join(dir, entry.name);
+
+          await removeEmptyStateDirs(fullPath);
+
+          try {
+            await rmdir(fullPath);
+          } catch {
+            // directory is not empty
+          }
+        }),
+    );
+  };
+
+  const writeStateToDisk = async (state) => {
+    await ensureStateDir();
 
-      const groups = splitStateByPrefix(req.body);
-      const activePrefixes = new Set(Object.keys(groups));
-      const stalePrefixes = (await getStateFiles()).map((file) => file.slice(0, -".json".length)).filter((prefix) => !activePrefixes.has(prefix));
+    const groups = splitStateByPath(state);
+    const activePaths = new Set(Object.keys(groups));
+    const existingPaths = await listStateJsonFiles();
 
-      await Promise.all([
-        ...Object.entries(groups).map(([prefix, state]) => writeFile(path.join(resolvedStateDir, `${prefix}.json`), JSON.stringify(state))),
-        ...stalePrefixes.map((prefix) => unlink(path.join(resolvedStateDir, `${prefix}.json`))),
-      ]);
+    await Promise.all([
+      ...Object.entries(groups).map(async ([relPath, groupState]) => {
+        const fullPath = path.join(resolvedStateDir, relPath);
+
+        await mkdir(path.dirname(fullPath), { recursive: true });
+        await writeFile(fullPath, JSON.stringify(groupState));
+      }),
+      ...existingPaths.filter((relPath) => !activePaths.has(relPath)).map((relPath) => unlink(path.join(resolvedStateDir, relPath))),
+    ]);
+
+    await removeEmptyStateDirs();
+  };
+
+  const readStateFromDisk = async () => {
+    const stateFiles = await listStateJsonFiles();
+
+    if (!stateFiles.length) return {};
+
+    const chunks = await Promise.all(stateFiles.map((file) => readFile(path.join(resolvedStateDir, file), "utf8").then(JSON.parse)));
+
+    return Object.assign({}, ...chunks);
+  };
+
+  const resolveConfigLanguage = () => {
+    if (typeof getConfig === "function") {
+      const config = getConfig() || {};
+
+      if (typeof config.language === "string" && config.language) return config.language;
+    }
+
+    return defaultLanguage;
+  };
+
+  const onSaveState = async (req, reply) => {
+    try {
+      await writeStateToDisk(req.body);
+
+      if (typeof onStateSave === "function") onStateSave(req.body);
 
       return reply.send({ status: "ok" });
     } catch {
@@ -107,14 +215,40 @@ const runServer = async ({ rootDir, stateDir, oldApp, onAchievementLock, onAchie
   };
 
   const onGetState = async (req, reply) => {
-    const stateFiles = await getStateFiles();
+    try {
+      let state = null;
+      let fromCloud = false;
+
+      if (typeof onStateGet === "function") {
+        const cloudState = onStateGet();
+
+        if (cloudState && typeof cloudState === "object") {
+          state = cloudState;
+          fromCloud = true;
+        }
+      }
+
+      if (!state) state = await readStateFromDisk();
 
-    if (!stateFiles.length) return reply.send({ status: "ok", state: {} });
+      if (fromCloud) await writeStateToDisk(state);
 
+      return reply.send({ status: "ok", state });
+    } catch {
+      return reply.send({ status: "error" });
+    }
+  };
+
+  const onGetConfig = (req, reply) => reply.send({ language: resolveConfigLanguage() });
+
+  const onClearState = async (req, reply) => {
     try {
-      const chunks = await Promise.all(stateFiles.map((file) => readFile(path.join(resolvedStateDir, file), "utf8").then(JSON.parse)));
+      const stateFiles = await getStateFiles();
 
-      return reply.send({ status: "ok", state: Object.assign({}, ...chunks) });
+      await Promise.all(stateFiles.map((file) => unlink(path.join(resolvedStateDir, file))));
+
+      if (typeof onStateClear === "function") onStateClear();
+
+      return reply.send({ status: "ok" });
     } catch {
       return reply.send({ status: "error" });
     }
@@ -149,6 +283,8 @@ const runServer = async ({ rootDir, stateDir, oldApp, onAchievementLock, onAchie
 
     app.post("/state/save", onSaveState);
     app.get("/state/get", onGetState);
+    app.post("/state/clear", onClearState);
+    app.get("/config", onGetConfig);
     app.post("/achievement/lock", onAchievementLockMiddleware);
     app.post("/achievement/unlock", onAchievementUnlockMiddleware);
     app.post("/log", onLog);
@@ -189,7 +325,17 @@ const runServer = async ({ rootDir, stateDir, oldApp, onAchievementLock, onAchie
     if (error.code === "EADDRINUSE") {
       console.log("server not started on port: ", port);
 
-      return runServer({ rootDir, stateDir, oldApp: app, onAchievementLock, onAchievementUnlock });
+      return runServer({
+        rootDir,
+        stateDir,
+        oldApp: app,
+        onAchievementLock,
+        onAchievementUnlock,
+        onStateSave,
+        onStateGet,
+        onStateClear,
+        getConfig,
+      });
     }
 
     throw error;