5.0.11

.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,13 +1,13 @@
 {
   "name": "@push.rocks/npmextra",
-  "version": "3.0.10",
+  "version": "5.0.11",
   "private": false,
   "description": "do more with npm",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "scripts": {
     "test": "(tstest test/ --web)",
-    "build": "(tsbuild --web)",
+    "build": "(tsbuild --web --allowimplicitany)",
     "buildDocs": "tsdoc"
   },
   "repository": {
@@ -21,18 +21,21 @@
   },
   "homepage": "https://gitlab.com/pushrocks/npmextra#README",
   "dependencies": {
-    "@push.rocks/smartfile": "^10.0.26",
+    "@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.0.10"
+    "@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",
-    "@push.rocks/tapbundle": "^5.0.8",
-    "@types/node": "^20.4.6"
+    "@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.11.17"
   },
   "files": [
     "ts/**/*",

test/somekv.json

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

test/test.kvstore.ts

@@ -5,10 +5,14 @@ import * as npmextra from '../ts/index.js';
 let myKeyValueStore: npmextra.KeyValueStore;
 
 tap.test('should create a keyValueStore', async () => {
-  myKeyValueStore = new npmextra.KeyValueStore('custom', 'test');
+  myKeyValueStore = new npmextra.KeyValueStore('custom', 'test', 'test/somekv.json');
   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.10',
+  version: '5.0.11',
   description: 'do more with npm'
 }

ts/index.ts

@@ -1,4 +1,3 @@
-import * as plugins from './npmextra.plugins.js';
-
-export * from './npmextra.classes.npmextra.js';
+export * from './npmextra.classes.appdata.js';
 export * from './npmextra.classes.keyvaluestore.js';
+export * from './npmextra.classes.npmextra.js';

ts/npmextra.classes.appdata.ts

@@ -0,0 +1,149 @@
+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 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 (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.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({
+      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();
+  }
+
+  /**
+   * returns a kvtore that resides in appdata
+   */
+  public async getKvStore() {
+    await this.readyDeferred.promise;
+    return this.kvStore;
+  }
+
+  public async logMissingKeys() {
+    const kvStore = await this.getKvStore();
+    const missingMandatoryKeys = 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

@@ -3,20 +3,32 @@ import * as paths from './npmextra.paths.js';
 
 import { Task } from '@push.rocks/taskbuffer';
 
-export type TKeyValueStore = 'path' | 'gitProject' | 'custom';
+export type TKeyValueStore = 'custom' | 'userHomeDir';
+
+export interface IKvStoreConstructorOptions {
+  typeArg: TKeyValueStore;
+  identityArg: string;
+  customPath?: string;
+  mandatoryKeys?: string[];
+}
 
 /**
- * kvStore is a simple key vlaue store to store data about projects between runs
+ * 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,43 +37,72 @@ export class KeyValueStore {
         delete this.dataObject[key];
       }
       this.deletedObject = {};
-      await plugins.smartfile.memory.toFs(JSON.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
+   * computes the identity and filePath
    */
   private initFilePath = () => {
-    // determine the right base directory
+    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');
+      }
+      plugins.smartfile.fs.ensureFileSync(this.filePath, '{}');
+      return;
+    }
+
     let baseDir: string;
-    if (this.type === 'custom') {
-      baseDir = paths.kvCustomDir;
-    } else if (this.type === 'gitProject') {
-      baseDir = paths.kvGitDir;
-    } else if (this.type === 'path') {
-      baseDir = paths.kvPathDir;
+    if (this.type === 'userHomeDir') {
+      baseDir = paths.kvUserHomeDirBase;
+    } else {
+      throw new Error('kv type not supported');
     }
     this.filePath = plugins.path.join(baseDir, this.identity + '.json');
-    plugins.smartfile.fs.ensureDirSync(paths.kvCustomDir);
-    plugins.smartfile.fs.ensureDirSync(paths.kvGitDir);
-    plugins.smartfile.fs.ensureDirSync(paths.kvPathDir);
+    plugins.smartfile.fs.ensureDirSync(baseDir);
     plugins.smartfile.fs.ensureFileSync(this.filePath, '{}');
   };
 
-  public type: TKeyValueStore; // the type of the kvStore
-  public identity: string; // the identity of the kvStore
-  public filePath: string; // the filePath of the kvStore
+  // if no custom path is provided, try to store at home directory
+  public type: TKeyValueStore;
+  public identity: string;
+  public filePath: string;
+  private customPath?: string; // Optionally allow custom path
 
   /**
    * the constructor of keyvalue store
    * @param typeArg
-   * @param customStringArg
+   * @param identityArg
+   * @param customPath Optional custom path for the keyValue store
    */
-  constructor(typeArg: TKeyValueStore, customStringArg: string) {
-    // set kvStoreType
-    this.type = typeArg;
-    this.identity = customStringArg;
+  constructor(optionsArg: IKvStoreConstructorOptions) {
+    if (optionsArg.customPath && optionsArg.typeArg !== 'custom') {
+      throw new Error('customPath can only be provided if typeArg is custom');
+    }
+    if (optionsArg.typeArg === 'custom' && !optionsArg.customPath) {
+      throw new Error('customPath must be provided if typeArg is custom');
+    }
+    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);
+    }
   }
 
   /**
@@ -97,7 +138,7 @@ export class KeyValueStore {
   /**
    * writes all keyValue pairs in the object argument
    */
-  public async writeAll(keyValueObject) {
+  public async writeAll(keyValueObject: { [key: string]: any }) {
     this.dataObject = { ...this.dataObject, ...keyValueObject };
     await this.syncTask.trigger();
   }
@@ -109,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.paths.ts

@@ -16,22 +16,7 @@ export let home = plugins.smartpath.get.home();
 /**
  * keyValue base path
  */
-export let kvBase = plugins.path.join(home, '.npmextra/kv');
-
-/**
- * the base directory for custom string based key value store
- */
-export let kvCustomDir = plugins.path.join(kvBase, 'custom');
-
-/**
- * the subdir for git based keyValue
- */
-export let kvGitDir = plugins.path.join(kvBase, 'git');
-
-/**
- * keyValue for path based keyValue store
- */
-export let kvPathDir = plugins.path.join(kvBase, 'path');
+export let kvUserHomeDirBase = plugins.path.join(home, '.npmextra/kv');
 
 // files
 export let configFile = plugins.path.join(cwd, 'npmextra.json');

ts/npmextra.plugins.ts

@@ -1,8 +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, 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"
+  ]
 }