5.0.12

.gitea/workflows/default_tags.yaml

@@ -119,6 +119,6 @@ jobs:
         run: |
           npmci node install stable
           npmci npm install
-          pnpm install -g @gitzone/tsdoc
+          pnpm install -g @git.zone/tsdoc
           npmci command tsdoc
         continue-on-error: true

npmextra.json

@@ -11,12 +11,15 @@
   "gitzone": {
     "projectType": "npm",
     "module": {
-      "githost": "gitlab.com",
+      "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "npmextra",
       "description": "do more with npm",
       "npmPackagename": "@push.rocks/npmextra",
       "license": "MIT"
     }
+  },
+  "tsdocs": {
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
   }
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/npmextra",
-  "version": "3.0.12",
+  "version": "5.0.12",
   "private": false,
   "description": "do more with npm",
   "main": "dist_ts/index.js",
@@ -21,19 +21,21 @@
   },
   "homepage": "https://gitlab.com/pushrocks/npmextra#README",
   "dependencies": {
-    "@push.rocks/smartfile": "^10.0.30",
-    "@push.rocks/smartjson": "^5.0.8",
+    "@push.rocks/qenv": "^6.0.5",
+    "@push.rocks/smartfile": "^11.0.4",
+    "@push.rocks/smartjson": "^5.0.10",
     "@push.rocks/smartlog": "^3.0.2",
     "@push.rocks/smartpath": "^5.0.11",
     "@push.rocks/smartpromise": "^4.0.2",
-    "@push.rocks/taskbuffer": "^3.1.6"
+    "@push.rocks/smartrx": "^3.0.7",
+    "@push.rocks/taskbuffer": "^3.1.7"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.66",
-    "@gitzone/tsrun": "^1.2.44",
-    "@gitzone/tstest": "^1.0.77",
+    "@git.zone/tsbuild": "^2.1.66",
+    "@git.zone/tsrun": "^1.2.44",
+    "@git.zone/tstest": "^1.0.77",
     "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^20.5.3"
+    "@types/node": "^20.11.17"
   },
   "files": [
     "ts/**/*",

test/somekv.json

@@ -1 +1,3 @@
-{"myKey":"myValue"}
+{
+  "myKey": "myValue"
+}

test/test.kvstore.ts

@@ -9,6 +9,10 @@ tap.test('should create a keyValueStore', async () => {
   expect(myKeyValueStore).toBeInstanceOf(npmextra.KeyValueStore);
 });
 
+tap.test('should reset the keyValueStore', async () => {
+  await myKeyValueStore.reset();
+});
+
 tap.test('expect result to be empty', async () => {
   let result = await myKeyValueStore.readAll();
   expect(JSON.stringify(result)).toEqual('{}');

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/npmextra',
-  version: '3.0.12',
+  version: '5.0.12',
   description: 'do more with npm'
 }

ts/npmextra.classes.appdata.ts

@@ -1,29 +1,120 @@
 import * as plugins from './npmextra.plugins.js';
 import * as paths from './npmextra.paths.js';
 import { KeyValueStore } from './npmextra.classes.keyvaluestore.js';
+import { env } from 'process';
 
-export class AppData {
-  public readyDeferred = plugins.smartpromise.defer();
-  public dirPathArg: string;
-  private kvStore: KeyValueStore;
-  constructor(pathArg?: string) {
-    this.init(pathArg);
+export interface IAppDataOptions {
+  dirPath?: string;
+  requiredKeys?: string[];
+
+  /**
+   * kvStoreKey: 'MY_ENV_VAR'
+   */
+  envMapping?: {
+    [key: string]: string | object;
+  };
+}
+
+export class AppData<T = any> {
+  /**
+   * creates appdata. If no pathArg is given, data will be stored here:
+   * ${PWD}/.nogit/appdata
+   * @param pathArg
+   * @returns
+   */
+  public static async createAndInit<T = any>(optionsArg: IAppDataOptions = {}): Promise<AppData<T>> {
+    const appData = new AppData<T>(optionsArg);
+    await appData.readyDeferred.promise;
+    return appData;
   }
 
+  // instance
+  public readyDeferred = plugins.smartpromise.defer();
+  public options: IAppDataOptions;
+  private kvStore: KeyValueStore<T>;
+  constructor(optionsArg: IAppDataOptions = {}) {
+    this.options = optionsArg;
+    this.init();
+  }
+
+  /**
+   * inits app data
+   * @param pathArg
+   */
   private async init(pathArg?: string) {
-    if (pathArg) {
-      this.dirPathArg = pathArg;
+    if (this.options.dirPath) {
+      // ok, nothing to do here;
     } else {
       const appDataDir = '/app/data';
       const dataDir = '/data';
+      const nogitAppData = '.nogit/appdata';
       const appDataExists = plugins.smartfile.fs.isDirectory(appDataDir);
       const dataExists = plugins.smartfile.fs.isDirectory(dataDir);
       if (appDataExists) {
-        this.dirPathArg = appDataDir;
-        this.dirPathArg = dataDir;
+        this.options.dirPath = appDataDir;
+      } else if (dataExists) {
+        this.options.dirPath = dataDir;
+      } else {
+        await plugins.smartfile.fs.ensureDir(nogitAppData);
+        this.options.dirPath = nogitAppData;
       }
     }
-    this.kvStore = new KeyValueStore('custom', 'appkv', this.dirPathArg);
+    this.kvStore = new KeyValueStore({
+      typeArg: 'custom',
+      identityArg: 'appkv',
+      customPath: this.options.dirPath,
+      mandatoryKeys: this.options.requiredKeys
+    });
+
+    if (this.options.envMapping) {
+      const qenvInstance = new plugins.qenv.Qenv(process.cwd(), plugins.path.join(process.cwd(), '.nogit'));
+    
+      // Recursive function to handle nested objects, now includes key parameter
+      const processEnvMapping = async (key: string, mappingValue: any, parentKey: string = ''): Promise<any> => {
+        if (typeof mappingValue === 'string') {
+          let envValue: string;
+          if (mappingValue.startsWith('hard:')) {
+            envValue = mappingValue.replace('hard:', '');
+          } else {
+            envValue = await qenvInstance.getEnvVarOnDemand(mappingValue);
+          }
+          if (envValue) {
+            if (mappingValue.endsWith('_JSON')) {
+              envValue = JSON.parse(envValue);
+            }
+            if (!parentKey) {
+              await this.kvStore.writeKey(key, envValue);
+            } else {
+              return envValue;
+            }
+          } else {
+            return undefined;
+          }
+        } else if (typeof mappingValue === 'object' && mappingValue !== null) {
+          const resultObject = {};
+          for (const innerKey in mappingValue) {
+            const nestedValue = mappingValue[innerKey];
+            // For nested objects, call recursively but do not immediately write to kvStore
+            const nestedResult = await processEnvMapping(innerKey, nestedValue, key);
+            resultObject[innerKey] = nestedResult;
+          }
+          if (parentKey === '') {
+            // Only write to kvStore if at the top level
+            await this.kvStore.writeKey(key, resultObject);
+          } else {
+            // For nested objects, return the constructed object instead of writing to kvStore
+            return resultObject;
+          }
+        }
+      };
+    
+      for (const key in this.options.envMapping) {
+        await processEnvMapping(key, this.options.envMapping[key]);
+      }
+    }
+    
+    
+
     this.readyDeferred.resolve();
   }
 
@@ -34,4 +125,25 @@ export class AppData {
     await this.readyDeferred.promise;
     return this.kvStore;
   }
-}
+
+  public async logMissingKeys() {
+    const kvStore = await this.getKvStore();
+    const missingMandatoryKeys = await kvStore.getMissingMandatoryKeys();
+    if (missingMandatoryKeys.length > 0) {
+      console.log(
+        `The following mandatory keys are missing in the appdata:\n   -> ${missingMandatoryKeys.join(
+          ',\n   -> '
+        )}`
+      );
+    } else {
+      console.log('All mandatory keys are present in the appdata');
+    }
+    return missingMandatoryKeys;
+  }
+
+  public async waitForAndGetKey(keyArg: string) {
+    await this.readyDeferred.promise;
+    await this.kvStore.waitForKeysPresent([keyArg]);
+    return this.kvStore.readKey[keyArg];
+  }
+}

ts/npmextra.classes.keyvaluestore.ts

@@ -5,18 +5,30 @@ import { Task } from '@push.rocks/taskbuffer';
 
 export type TKeyValueStore = 'custom' | 'userHomeDir';
 
+export interface IKvStoreConstructorOptions {
+  typeArg: TKeyValueStore;
+  identityArg: string;
+  customPath?: string;
+  mandatoryKeys?: string[];
+}
+
 /**
  * kvStore is a simple key value store to store data about projects between runs
  */
-export class KeyValueStore {
-  private dataObject: any = {};
+export class KeyValueStore<T = any> {
+  private dataObject: Partial<T> = {};
   private deletedObject: any = {};
+  private mandatoryKeys: Set<string> = new Set();
+  public changeSubject = new plugins.smartrx.rxjs.Subject();
+  
+  private storedStateString: string = '';
   public syncTask = new Task({
     name: 'syncTask',
     buffered: true,
     bufferMax: 1,
     execDelay: 0,
     taskFunction: async () => {
+      
       this.dataObject = {
         ...plugins.smartfile.fs.toObjectSync(this.filePath),
         ...this.dataObject,
@@ -25,16 +37,27 @@ export class KeyValueStore {
         delete this.dataObject[key];
       }
       this.deletedObject = {};
-      await plugins.smartfile.memory.toFs(plugins.smartjson.stringify(this.dataObject), this.filePath);
+      await plugins.smartfile.memory.toFs(
+        plugins.smartjson.stringifyPretty(this.dataObject),
+        this.filePath
+      );
+      const newStateString = plugins.smartjson.stringify(this.dataObject);
+
+      // change detection
+      if (newStateString !== this.storedStateString) {
+        this.storedStateString = newStateString;
+        this.changeSubject.next(this.dataObject);
+      }
     },
   });
-  
+
   /**
    * computes the identity and filePath
    */
   private initFilePath = () => {
-    if (this.customPath) { // Use custom path if provided
-      const absolutePath = plugins.smartpath.transform.makeAbsolute(this.customPath, paths.cwd)
+    if (this.customPath) {
+      // Use custom path if provided
+      const absolutePath = plugins.smartpath.transform.makeAbsolute(this.customPath, paths.cwd);
       this.filePath = absolutePath;
       if (plugins.smartfile.fs.isDirectorySync(this.filePath)) {
         this.filePath = plugins.path.join(this.filePath, this.identity + '.json');
@@ -42,7 +65,7 @@ export class KeyValueStore {
       plugins.smartfile.fs.ensureFileSync(this.filePath, '{}');
       return;
     }
-    
+
     let baseDir: string;
     if (this.type === 'userHomeDir') {
       baseDir = paths.kvUserHomeDirBase;
@@ -66,17 +89,20 @@ export class KeyValueStore {
    * @param identityArg
    * @param customPath Optional custom path for the keyValue store
    */
-  constructor(typeArg: TKeyValueStore, identityArg: string, customPath?: string) {
-    if (customPath && typeArg !== 'custom') {
+  constructor(optionsArg: IKvStoreConstructorOptions) {
+    if (optionsArg.customPath && optionsArg.typeArg !== 'custom') {
       throw new Error('customPath can only be provided if typeArg is custom');
     }
-    if (typeArg === 'custom' && !customPath) {
+    if (optionsArg.typeArg === 'custom' && !optionsArg.customPath) {
       throw new Error('customPath must be provided if typeArg is custom');
     }
-    this.type = typeArg;
-    this.identity = identityArg;
-    this.customPath = customPath; // Store custom path if provided
+    this.type = optionsArg.typeArg;
+    this.identity = optionsArg.identityArg;
+    this.customPath = optionsArg.customPath; // Store custom path if provided
     this.initFilePath();
+    if (optionsArg.mandatoryKeys) {
+      this.setMandatoryKeys(optionsArg.mandatoryKeys);
+    }
   }
 
   /**
@@ -124,4 +150,44 @@ export class KeyValueStore {
     this.dataObject = {};
     await plugins.smartfile.fs.remove(this.filePath);
   }
+
+  /**
+   * resets the KeyValueStore to the initial state by syncing first, deleting all keys, and then triggering a sync again
+   */
+  public async reset() {
+    await this.syncTask.trigger(); // Sync to get the latest state
+
+    // Delete all keys from the dataObject and add them to deletedObject
+    for (const key of Object.keys(this.dataObject)) {
+      this.deletedObject[key] = this.dataObject[key];
+      delete this.dataObject[key];
+    }
+
+    await this.syncTask.trigger(); // Sync again to reflect the deletion
+  }
+
+  private setMandatoryKeys(keys: string[]) {
+    keys.forEach(key => this.mandatoryKeys.add(key));
+  }
+
+  public async getMissingMandatoryKeys(): Promise<string[]> {
+    await this.readAll();
+    return Array.from(this.mandatoryKeys).filter(key => !(key in this.dataObject));
+  }
+
+  public async waitForKeysPresent(keysArg: string[]): Promise<void> {
+    const missingKeys = keysArg.filter(keyArg => !this.dataObject[keyArg]);
+    if (missingKeys.length === 0) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const subscription = this.changeSubject.subscribe(() => {
+        const missingKeys = keysArg.filter(keyArg => !this.dataObject[keyArg]);
+        if (missingKeys.length === 0) {
+          subscription.unsubscribe();
+          resolve();
+        }
+      });
+    });
+  }
 }

ts/npmextra.plugins.ts

@@ -1,9 +1,11 @@
+import * as qenv from '@push.rocks/qenv';
 import * as smartlog from '@push.rocks/smartlog';
 import * as path from 'path';
 import * as smartfile from '@push.rocks/smartfile';
 import * as smartjson from '@push.rocks/smartjson';
 import * as smartpath from '@push.rocks/smartpath';
 import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
 import * as taskbuffer from '@push.rocks/taskbuffer';
 
-export { smartlog, path, smartfile, smartjson, smartpath, smartpromise, taskbuffer };
+export { qenv, smartlog, path, smartfile, smartjson, smartpath, smartpromise, smartrx, taskbuffer };

tsconfig.json

@@ -3,9 +3,12 @@
     "experimentalDecorators": true,
     "useDefineForClassFields": false,
     "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "nodenext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
     "esModuleInterop": true,
-    "verbatimModuleSyntax": true,
-  }
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
 }