Generalizace úložiště pro libovolná data

server/src/service.ts

@@ -43,7 +43,7 @@ function getEmptyData(date?: Date): ClientData {
  */
 export async function getData(date?: Date): Promise<ClientData> {
     const dateString = formatDate(date ?? getToday());
-    const data = await storage.getData(dateString) || getEmptyData(date);
+    const data: ClientData = await storage.getData(dateString) || getEmptyData(date);
     data.todayWeekIndex = getDayOfWeekIndex(getToday());
     // Dotažení jídel, pokud je ještě nemáme
     if (!data.menus) {

server/src/storage/StorageInterface.ts

@@ -8,21 +8,21 @@ import { ClientData } from "../../../types";
  */
 export interface StorageInterface {
     /**
-     * Vrátí příznak, zda existují data pro předané datum.
-     * @param date datum, pro které zjišťujeme data
+     * Vrátí příznak, zda existují data pro předaný klíč.
+     * @param key klíč, pro který zjišťujeme data (typicky datum)
      */
-    hasData(date: string): Promise<boolean>;
+    hasData(key: string): Promise<boolean>;
 
     /**
-     * Vrátí veškerá data pro předané datum.
-     * @param date datum, pro které vrátit data
+     * Vrátí veškerá data pro předaný klíč.
+     * @param key klíč, pro který vrátit data (typicky datum)
      */
-    getData(date: string): Promise<ClientData>;
+    getData<Type>(key: string): Promise<Type>;
 
     /**
-     * Uloží data pro předané datum.
-     * @param date datum, kterému patří ukládaná data
+     * Uloží data pod předaný klíč.
+     * @param key klíč, pod kterým uložit data (typicky datum)
      * @param data data pro uložení
      */
-    setData(date: string, data: ClientData): Promise<void>;
+    setData<Type>(key: string, data: Type): Promise<void>;
 }

server/src/storage/json.ts

@@ -1,5 +1,4 @@
 import JSONdb from 'simple-json-db';
-import { ClientData } from "../../../types";
 import { StorageInterface } from "./StorageInterface";
 
 const db = new JSONdb('./data.json');
@@ -9,16 +8,16 @@ const db = new JSONdb('./data.json');
  */
 export default class JsonStorage implements StorageInterface {
 
-    hasData(date: string): Promise<boolean> {
-        return Promise.resolve(db.has(date));
+    hasData(key: string): Promise<boolean> {
+        return Promise.resolve(db.has(key));
     }
 
-    getData(date: string): Promise<ClientData> {
-        return db.get(date);
+    getData<Type>(key: string): Promise<Type> {
+        return db.get(key);
     }
 
-    setData(date: string, data: ClientData): Promise<void> {
-        db.set(date, data);
+    setData<Type>(key: string, data: Type): Promise<void> {
+        db.set(key, data);
         return Promise.resolve();
     }
 }

server/src/storage/redis.ts

@@ -1,6 +1,5 @@
 import { RedisClientType, createClient } from 'redis';
 import { StorageInterface } from "./StorageInterface";
-import { ClientData } from '../../../types';
 
 let client: RedisClientType;
 
@@ -15,18 +14,18 @@ export default class RedisStorage implements StorageInterface {
         client.connect();
     }
 
-    async hasData(date: string) {
-        const data = await client.json.get(date);
+    async hasData(key: string) {
+        const data = await client.json.get(key);
         return (data ? true : false);
     }
 
-    async getData(date: string) {
-        const data = await client.json.get(date, { path: '.' });
-        return data as unknown as ClientData;
+    async getData<Type>(key: string) {
+        const data = await client.json.get(key, { path: '.' });
+        return data as Type;
     }
 
-    async setData(date: string, data: ClientData) {
-        await client.json.set(date, '.', data as any);
-        const check = await client.json.get(date);
+    async setData<Type>(key: string, data: Type) {
+        await client.json.set(key, '.', data as any);
+        await client.json.get(key);
     }
 }