Fix: Change local secure storage implementation

DorShakedMonday · DorShakedMonday · commit f681340eb6c8 · 2023-04-02T11:11:56.000+03:00
- Change usage of lowdb to using native nodejs capabilities - Adjust tests - Adjust usage in secure-storage.local.ts ##monday.com item id https://monday.monday.com/boards/3670992828/views/83352826/pulses/3875667859
diff --git a/jest.config.js b/jest.config.js
@@ -9,7 +9,7 @@ function makeModuleNameMapper(srcPath, tsconfigPath) {
   // Iterate over paths and convert them into moduleNameMapper format
   Object.keys(paths).forEach(item => {
     const key = `^${item.replace('/*', '/(.*)')}$`;
-    const path = paths[item][0].replace('./lib/', '').replace('/*', '/$1');
+    const path = paths[item][0].replace('./lib/', '').replace('*', '$1');
     aliases[key] = srcPath + '/' + path;
   });
   return aliases;
@@ -22,4 +22,10 @@ module.exports = {
   moduleNameMapper: makeModuleNameMapper(SRC_PATH, TS_CONFIG_PATH),
   preset: 'ts-jest',
   testEnvironment: 'node',
+  clearMocks: true,
+  globals: {
+    'ts-jest': {
+      tsconfig: '<rootDir>/tsconfig.general.json',
+    },
+  },
 };
diff --git a/lib/lowdb.d.ts b/lib/lowdb.d.ts
diff --git a/lib/secure-storage/secure-storage.local.ts b/lib/secure-storage/secure-storage.local.ts
@@ -1,8 +1,7 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call */
-
 import { BadRequestError, NotFoundError } from 'errors/apps-sdk-error';
 import { isDefined } from 'types/guards';
 import { ISecureStorageInstance } from 'types/secure-storage';
+import { ILocalStorageInstance } from 'types/secure-storage.local';
 import { decrypt, encrypt } from 'utils/cipher';
 import { initDb } from 'utils/local-db';
 
@@ -13,31 +12,25 @@ const validateKey = (key: string) => {
 };
 
 export class LocalSecureStorage implements ISecureStorageInstance {
-  private db;
+  private db: ILocalStorageInstance;
   
-  private async init() {
-    if (!isDefined(this.db)) {
-      this.db = await initDb('local-secure-storage.db');
-    }
+  constructor() {
+    this.db = initDb('local-secure-storage.db');
   }
   
   async delete(key: string) {
     validateKey(key);
-    await this.init();
-    delete this.db.data[key];
-    await this.db.write();
+    await this.db.delete(key);
     return true;
   }
   
   async get<T>(key: string) {
     validateKey(key);
-    await this.init();
-    const encryptedValue = this.db.data[key] as string;
+    const encryptedValue = await this.db.get<string>(key);
     if (!isDefined(encryptedValue)) {
       throw new NotFoundError(`No data found for ${key}`);
     }
     
-    console.log(encryptedValue);
     const stringifiedValue = decrypt(encryptedValue);
     return JSON.parse(stringifiedValue) as T;
   }
@@ -48,11 +41,9 @@ export class LocalSecureStorage implements ISecureStorageInstance {
     }
     
     validateKey(key);
-    await this.init();
     const stringifiedValue = JSON.stringify(value);
     const encryptedValue = encrypt(stringifiedValue);
-    this.db.data[key] = encryptedValue;
-    this.db.write();
+    await this.db.set(key, encryptedValue);
     return true;
   }
 }
diff --git a/lib/types/secure-storage.local.ts b/lib/types/secure-storage.local.ts
@@ -0,0 +1,5 @@
+export type ILocalStorageInstance = {
+  set: <T>(key: string, value: T) => Promise<boolean>;
+  get: <T>(key: string) => Promise<T>;
+  delete: (key: string) => Promise<boolean>;
+}
diff --git a/lib/utils/local-db.ts b/lib/utils/local-db.ts
@@ -1,10 +1,19 @@
-import { existsSync, unlinkSync } from 'node:fs';
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import {
+  accessSync,
+  existsSync,
+  constants as fsConstants,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from 'node:fs';
 import { join } from 'node:path';
 
 import appRoot from 'app-root-path';
-import { Low } from 'lowdb';
-import { JSONFile } from 'lowdb/node';
 
+import { InternalServerError, NotFoundError } from 'errors/apps-sdk-error';
+import { isDefined } from 'types/guards';
+import { ILocalStorageInstance } from 'types/secure-storage.local';
 import { Logger } from 'utils/logger';
 
 const DEFAULT_DB_NAME = 'storage';
@@ -13,24 +22,108 @@ const logger = new Logger('LocalDb', { passThrough: true });
 
 const getDbPath = (dbName: string) => join(appRoot.toString(), `${dbName}.json`);
 
+const hasDiskWriteAccess = () => {
+  const rootDir = appRoot.toString();
+  try {
+    accessSync(rootDir, fsConstants.W_OK);
+    return true;
+  } catch (_err) {
+    return false;
+  }
+};
+
 export const deleteDb = (dbName = DEFAULT_DB_NAME): void => {
-  const file = getDbPath(dbName);
-  if (existsSync(file)) {
-    unlinkSync(file);
+  if (hasDiskWriteAccess()) {
+    const file = getDbPath(dbName);
+    if (existsSync(file)) {
+      unlinkSync(file);
+    }
   }
 };
 
-export const initDb = async (dbName = DEFAULT_DB_NAME) => {
-  const file = getDbPath(dbName);
-  logger.info(`Initializing local db in ${file}`);
+const inMemoryData: Record<string, any> = {};
+
+export class LocalMemoryDb implements ILocalStorageInstance {
+  async set<T>(key: string, value: T): Promise<boolean> {
+    inMemoryData[key] = value;
+    return Promise.resolve(true);
+  }
+  
+  async delete(key: string): Promise<boolean> {
+    delete inMemoryData[key];
+    return Promise.resolve(true);
+  }
+  
+  async get<T>(key: string): Promise<T> {
+    if (key in inMemoryData) {
+      return Promise.resolve(inMemoryData[key] as T);
+    }
+    
+    throw new NotFoundError(`Data not found for '${key}'`);
+  }
+}
+
+export class LocalDb implements ILocalStorageInstance {
+  private readonly dbFilePath: string;
+  private memoryData: Record<string, any>;
   
-  const adapter = new JSONFile(file);
-  const db = new Low(adapter);
+  constructor(dbFileName: string = DEFAULT_DB_NAME) {
+    if (!hasDiskWriteAccess()) {
+      throw new InternalServerError('Missing write permissions');
+    }
+    
+    this.dbFilePath = getDbPath(dbFileName);
+    if (!existsSync(this.dbFilePath)) {
+      this.memoryData = {};
+      writeFileSync(this.dbFilePath, JSON.stringify(this.memoryData), { encoding: 'utf8', flag: 'wx' });
+      return;
+    }
+    
+    const stringifiedDbData = readFileSync(this.dbFilePath, 'utf-8');
+    if (isDefined(stringifiedDbData)) {
+      this.memoryData = JSON.parse(stringifiedDbData);
+      return;
+    }
+    
+    this.memoryData = {};
+  }
   
-  await db.read();
-  db.data ||= {};
-  await db.write();
-  logger.info('initialized local db');
+  async set<T>(key: string, value: T): Promise<boolean> {
+    this.memoryData[key] = value;
+    
+    writeFileSync(this.dbFilePath, JSON.stringify(this.memoryData));
+    return Promise.resolve(true);
+  }
+  
+  async delete(key: string): Promise<boolean> {
+    delete this.memoryData[key];
+    
+    writeFileSync(this.dbFilePath, JSON.stringify(this.memoryData));
+    return Promise.resolve(true);
+  }
+  
+  async get<T>(key: string): Promise<T> {
+    if (key in this.memoryData) {
+      return Promise.resolve(this.memoryData[key] as T);
+    }
+    
+    const data = readFileSync(this.dbFilePath, 'utf-8');
+    const parsedData: Record<string, any> = JSON.parse(data);
+    this.memoryData = parsedData;
+    if (key in this.memoryData) {
+      return Promise.resolve(this.memoryData[key] as T);
+    }
+    
+    throw new NotFoundError(`Data not found for '${key}'`);
+  }
+}
+
+export const initDb = (dbName = DEFAULT_DB_NAME) => {
+  if (hasDiskWriteAccess()) {
+    logger.info('Initializing local db');
+    return new LocalDb(dbName);
+  }
   
-  return db;
+  logger.info('No disk access, initializing in memory db');
+  return new LocalMemoryDb();
 };
diff --git a/package.json b/package.json
@@ -1,19 +1,32 @@
 {
   "name": "@mondaycom/apps-sdk",
-  "version": "1.0.0",
+  "version": "0.0.1",
   "description": "monday apps SDK for NodeJS",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    "import": "./dist/esm/index.js",
+    "require": "./dist/cjs/index.js",
+    "default": "./dist/cjs/index.js"
+  },
   "scripts": {
     "test": "jest --forceExit",
     "test:coverage": "npm run test -- --coverage",
     "lint": "eslint --ext .js,.ts lib",
     "lint-fix": "npm run lint -- --fix",
     "prettier:fix": "prettier --write .",
     "prettier:check": "prettier --check .",
-    "build": "tsc --project ./tsconfig.json && tsc-alias -f -p tsconfig.json",
+    "build:esm": "tsc -p ./tsconfig.esm.json && tsc-alias -f -p tsconfig.esm.json",
+    "build:cjs": "tsc -p ./tsconfig.cjs.json && tsc-alias -f -p ./tsconfig.cjs.json",
+    "build": "rm -rf dist/ && yarn prettier:fix && yarn lint-fix && yarn build:esm && yarn build:cjs",
     "prepublish-and-build": "yarn install --frozen-lockfile && yarn build"
   },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mondaycom/apps-sdk.git"
@@ -37,17 +50,16 @@
     "@types/app-root-path": "^1.2.4",
     "@types/jest": "^29.5.0",
     "@types/jsonwebtoken": "^9.0.1",
-    "@types/lowdb": "^1.0.11",
     "@typescript-eslint/eslint-plugin": "^5.48.2",
     "@typescript-eslint/parser": "^5.48.2",
     "eslint": "^8.32.0",
     "eslint-config-prettier": "^8.7.0",
     "eslint-import-resolver-typescript": "^3.5.3",
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-n": "^15.6.1",
-    "jest": "^29.3.1",
+    "jest": "^27.3.1",
     "prettier": "^2.8.4",
-    "ts-jest": "^29.0.5",
+    "ts-jest": "^27.0.5",
     "tsc-alias": "^1.8.4",
     "tsconfig-paths": "^4.1.2",
     "typescript": "^4.9.4"
@@ -57,7 +69,6 @@
     "google-auth-library": "^8.7.0",
     "http-status-codes": "^2.2.0",
     "jsonwebtoken": "^9.0.0",
-    "lowdb": "^5.1.0",
     "node-fetch": "^3.3.1"
   }
 }
diff --git a/tests/secure-storage/secure-storage.local.test.ts b/tests/secure-storage/secure-storage.local.test.ts
@@ -1,19 +1,22 @@
-import { LocalSecureStorage } from '../../lib/secure-storage/secure-storage.local';
-import { encrypt } from '../../lib/utils/cipher';
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { LocalSecureStorage } from 'lib/secure-storage/secure-storage.local';
+import { encrypt } from 'utils/cipher';
 
 const MOCK_KEY = 'mock';
 const MOCK_VALUE = { mock: 'mock' };
 const MOCK_ENCRYPTED_VALUE = encrypt(JSON.stringify(MOCK_VALUE));
 const MOCK_STORED_DATA = { [`${MOCK_KEY}`]: MOCK_ENCRYPTED_VALUE };
 
-let mockRead = jest.fn();
-let mockWrite = jest.fn();
+const mockGet = jest.fn();
+const mockSet = jest.fn();
+const mockDelete = jest.fn();
+
 jest.mock('../../lib/utils/local-db', () => ({
   initDb() {
     return {
-      read: mockRead,
-      data: MOCK_STORED_DATA,
-      write: mockWrite,
+      get: mockGet,
+      set: mockSet,
+      delete: mockDelete,
     };
   },
 }));
@@ -43,7 +46,7 @@ describe('LocalSecureStorage', () => {
 
     it('should set data when all is valid', async () => {
       await localSecureStorage.set(MOCK_KEY, MOCK_VALUE);
-      expect(mockWrite).toBeCalled();
+      expect(mockSet).toBeCalled();
     });
   });
 
@@ -55,12 +58,11 @@ describe('LocalSecureStorage', () => {
 
     it('should fail for key without value', async () => {
       const badKey = 'badKey';
-      // @ts-ignore
       await expect(localSecureStorage.get(badKey)).rejects.toThrow();
     });
 
     it('should succeed for key with value', async () => {
-      // @ts-ignore
+      mockGet.mockImplementation(() => MOCK_STORED_DATA[MOCK_KEY]);
       const result = await localSecureStorage.get(MOCK_KEY);
       expect(result).toEqual(MOCK_VALUE);
     });
@@ -74,14 +76,12 @@ describe('LocalSecureStorage', () => {
 
     it('should delete for valid key', async () => {
       const mockKeyToDelete = 'deleteMe';
-      MOCK_STORED_DATA[mockKeyToDelete] = MOCK_ENCRYPTED_VALUE;
       await localSecureStorage.delete(mockKeyToDelete);
-      expect(MOCK_STORED_DATA[mockKeyToDelete]).toBeUndefined();
+      expect(mockDelete).toBeCalledWith(mockKeyToDelete);
     });
 
     it('should not fail for multiple deletions of the same key', async () => {
       const mockKeyToDelete = 'deleteMe';
-      MOCK_STORED_DATA[mockKeyToDelete] = MOCK_ENCRYPTED_VALUE;
       await localSecureStorage.delete(mockKeyToDelete);
       await expect(localSecureStorage.delete(mockKeyToDelete)).resolves.toBeTruthy();
     });
diff --git a/tests/utils/local-db.test.ts b/tests/utils/local-db.test.ts
diff --git a/yarn.lock b/yarn.lock
