2.0.8

.gitlab-ci.yml

@@ -12,6 +12,9 @@ stages:
   - release
   - metadata
 
+before_script:
+  - npm install -g @shipzone/npmci
+
 # ====================
 # security stage
 # ====================
@@ -19,23 +22,36 @@ mirror:
   stage: security
   script:
     - npmci git mirror
+  only:
+    - tags
   tags:
     - lossless
     - docker
     - notpriv
 
-audit:
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install --production --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=prod --production
+  tags:
+    - docker
+  allow_failure: true
+
+auditDevDependencies:
   image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
     - npmci npm prepare
     - npmci command npm install --ignore-scripts
     - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high
+    - npmci command npm audit --audit-level=high --only=dev
   tags:
-    - lossless
     - docker
-    - notpriv
+  allow_failure: true
 
 # ====================
 # test stage
@@ -50,9 +66,7 @@ testStable:
     - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - priv
 
 testBuild:
   stage: test
@@ -63,9 +77,7 @@ testBuild:
     - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - notpriv
 
 release:
   stage: release
@@ -85,11 +97,12 @@ release:
 codequality:
   stage: metadata
   allow_failure: true
+  only:
+    - tags
   script:
-    - npmci command npm install -g tslint typescript
+    - npmci command npm install -g typescript
     - npmci npm prepare
     - npmci npm install
-    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
   tags:
     - lossless
     - docker

.vscode/launch.json

@@ -2,28 +2,10 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "current file",
-      "type": "node",
+      "command": "npm test",
+      "name": "Run npm test",
       "request": "launch",
-      "args": [
-        "${relativeFile}"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
-    },
-    {
-      "name": "test.ts",
-      "type": "node",
-      "request": "launch",
-      "args": [
-        "test/test.ts"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
+      "type": "node-terminal"
     }
   ]
 }

.vscode/settings.json

@@ -15,7 +15,7 @@
             "properties": {
               "projectType": {
                 "type": "string",
-                "enum": ["website", "element", "service", "npm"]
+                "enum": ["website", "element", "service", "npm", "wcc"]
               }
             }
           }

npmextra.json

@@ -5,7 +5,7 @@
       "githost": "gitlab.com",
       "gitscope": "pushrocks",
       "gitrepo": "webstore",
-      "shortDescription": "high performance storage in the browser using indexed db",
+      "description": "high performance storage in the browser using indexed db",
       "npmPackagename": "@pushrocks/webstore",
       "license": "MIT",
       "projectDomain": "push.rocks"

package.json

@@ -1,27 +1,34 @@
 {
   "name": "@pushrocks/webstore",
-  "version": "1.0.7",
+  "version": "2.0.8",
   "private": false,
   "description": "high performance storage in the browser using indexed db",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
     "test": "(tstest test/ --web)",
-    "build": "(tsbuild --web)",
-    "format": "(gitzone format)"
+    "build": "(tsbuild --web --allowimplicitany)"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.0.22",
-    "@gitzone/tstest": "^1.0.39",
-    "@pushrocks/tapbundle": "^3.0.7",
-    "@types/node": "^14.0.20",
-    "tslint": "^6.1.2",
-    "tslint-config-prettier": "^1.15.0"
+    "@gitzone/tsbuild": "^2.1.65",
+    "@gitzone/tsrun": "^1.2.39",
+    "@gitzone/tstest": "^1.0.74",
+    "@pushrocks/smartntml": "^2.0.3",
+    "@pushrocks/tapbundle": "^5.0.4",
+    "@types/node": "^18.16.3"
   },
   "dependencies": {
-    "idb": "^5.0.4"
+    "@apiglobal/typedrequest-interfaces": "^2.0.1",
+    "@pushrocks/lik": "^6.0.2",
+    "@pushrocks/smartenv": "^5.0.5",
+    "@pushrocks/smartjson": "^5.0.5",
+    "@pushrocks/smartpromise": "^4.0.2",
+    "@pushrocks/smartrx": "^3.0.0",
+    "fake-indexeddb": "^4.0.1",
+    "idb": "^7.1.1"
   },
   "browserslist": [
     "last 1 chrome versions"

test/skip.coexistence.smartntml.ts

@@ -0,0 +1,44 @@
+import { expect, tap } from '@pushrocks/tapbundle';
+
+import * as smartntml from '@pushrocks/smartntml';
+const smartntmlInstance = new smartntml.Smartntml();
+
+import * as webstore from '../ts/index.js';
+
+let testWebstore: webstore.WebStore;
+
+tap.test('first test', async () => {
+  testWebstore = new webstore.WebStore({
+    dbName: 'mytest-db',
+    storeName: 'mytest-store',
+  });
+  expect(testWebstore).toBeInstanceOf(webstore.WebStore);
+});
+
+tap.test('should allow storing a string', async () => {
+  await testWebstore.set('mystring', 'heythere');
+  expect(await testWebstore.get('mystring')).toEqual('heythere');
+});
+
+tap.test('should allow storing an object', async () => {
+  await testWebstore.set('testProp1', {
+    wow: 'wowVal',
+  });
+  console.log(JSON.stringify(await testWebstore.get('testProp1')));
+});
+
+tap.test('should overwrite a value', async () => {
+  await testWebstore.set('testProp1', {
+    wow: 'wowVal2',
+  });
+  console.log(JSON.stringify(await testWebstore.get('testProp1')));
+});
+
+tap.test('should correctly check the existence of keys', async () => {
+  const resultNotThere = await testWebstore.check('notThere');
+  const resultThere = await testWebstore.check('testProp1');
+  expect(resultNotThere).toBeFalse();
+  expect(resultThere).toBeTrue();
+});
+
+tap.start();

test/test.typedrequestcache.both.ts

@@ -0,0 +1,11 @@
+import { expect, tap } from '@pushrocks/tapbundle';
+import * as webstore from '../ts/index.js';
+
+let testTypedrequestcache: webstore.TypedrequestCache;
+
+tap.test('first test', async () => {
+  testTypedrequestcache = new webstore.TypedrequestCache('https://test.lossless.com/typedrequest');
+  expect(testTypedrequestcache).toBeInstanceOf(webstore.TypedrequestCache);
+});
+
+tap.start();

test/test.webstore.both.ts

@@ -1,39 +1,40 @@
 import { expect, tap } from '@pushrocks/tapbundle';
-import * as webstore from '../ts/index';
+import * as webstore from '../ts/index.js';
 
 let testWebstore: webstore.WebStore;
 
 tap.test('first test', async () => {
   testWebstore = new webstore.WebStore({
     dbName: 'mytest-db',
-    storeName: 'mytest-store'
+    storeName: 'mytest-store',
   });
-  expect(testWebstore).to.be.instanceOf(webstore.WebStore);
+  expect(testWebstore).toBeInstanceOf(webstore.WebStore);
 });
 
-tap.test('should init the database', async () => {
-  await testWebstore.init();
+tap.test('should allow storing a string', async () => {
+  await testWebstore.set('mystring', 'heythere');
+  expect(await testWebstore.get('mystring')).toEqual('heythere');
 });
 
-tap.test('should store a value', async () => {
+tap.test('should allow storing an object', async () => {
   await testWebstore.set('testProp1', {
-    wow: 'wowVal'
+    wow: 'wowVal',
   });
   console.log(JSON.stringify(await testWebstore.get('testProp1')));
 });
 
 tap.test('should overwrite a value', async () => {
   await testWebstore.set('testProp1', {
-    wow: 'wowVal2'
+    wow: 'wowVal2',
   });
   console.log(JSON.stringify(await testWebstore.get('testProp1')));
 });
 
 tap.test('should correctly check the existence of keys', async () => {
-  const resultNotThere = await  testWebstore.check('notThere');
+  const resultNotThere = await testWebstore.check('notThere');
   const resultThere = await testWebstore.check('testProp1');
-  expect(resultNotThere).to.be.false;
-  expect(resultThere).to.be.true;
+  expect(resultNotThere).toBeFalse();
+  expect(resultThere).toBeTrue();
 });
 
 tap.start();

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@pushrocks/webstore',
+  version: '2.0.8',
+  description: 'high performance storage in the browser using indexed db'
+}

ts/index.ts

@@ -1 +1,2 @@
-export * from './webstiore.classes.webstore';
+export * from './webstore.classes.typedrequestcache.js';
+export * from './webstore.classes.webstore.js';

ts/webstore.classes.typedrequestcache.ts

@@ -0,0 +1,47 @@
+import { WebStore } from './webstore.classes.webstore.js';
+import * as plugins from './webstore.plugins.js';
+
+/**
+ * a cache that can be used to store and retrieve typedrequests
+ */
+export class TypedrequestCache {
+  private webstore: WebStore;
+
+  constructor(domainArg = 'default') {
+    this.webstore = new WebStore<plugins.typedrequestInterfaces.ITypedRequest>({
+      dbName: 'trStore',
+      storeName: `trStore-${domainArg}`,
+    });
+  }
+
+  private buildKey(requestArg: plugins.typedrequestInterfaces.ITypedRequest) {
+    return plugins.smartjson.stringify({
+      method: requestArg.method,
+      request: requestArg.request,
+    });
+  }
+
+  /**
+   * stores by request
+   * @param typedrequestarg
+   */
+  public async setByRequest(
+    typedrequestArg: plugins.typedrequestInterfaces.ITypedRequest
+  ): Promise<void> {
+    if (!typedrequestArg.response) {
+      throw new Error('You cannot store requests without a response present');
+    }
+    await this.webstore.set(this.buildKey(typedrequestArg), typedrequestArg);
+  }
+
+  /**
+   * get by full tyoedrequest by partial typedrequest
+   * @param typedrequestarg
+   */
+  public async getByRequest(
+    typedrequestArg: plugins.typedrequestInterfaces.ITypedRequest
+  ): Promise<plugins.typedrequestInterfaces.ITypedRequest> {
+    const result = await this.webstore.get(this.buildKey(typedrequestArg));
+    return result;
+  }
+}

ts/webstore.classes.webstore.ts

@@ -1,4 +1,4 @@
-import * as plugins from './webstore.plugins';
+import * as plugins from './webstore.plugins.js';
 
 export interface IWebStoreOptions {
   dbName: string;
@@ -9,42 +9,68 @@ export class WebStore<T = any> {
   public db: plugins.idb.IDBPDatabase;
   public objectStore: plugins.idb.IDBPObjectStore;
   public options: IWebStoreOptions;
-  
+  private initCalled: boolean = false;
+  private readyDeferred = plugins.smartpromise.defer();
 
   constructor(optionsArg: IWebStoreOptions) {
     this.options = optionsArg;
   }
 
-  public async init () {
+  public async init() {
+    if (this.initCalled) {
+      await this.readyDeferred.promise;
+      return;
+    }
+    this.initCalled = true;
+
+    const smartenv = new plugins.smartenv.Smartenv();
+    if (!smartenv.isBrowser && !globalThis.indexedDB) {
+      console.log('hey');
+      console.log(globalThis.indexedDB);
+      await smartenv.getSafeNodeModule('fake-indexeddb/auto');
+      if (!globalThis.indexedDB) {
+        const mod = await smartenv.getSafeNodeModule('fake-indexeddb');
+        globalThis.indexedDB = new mod.IDBFactory();
+      }
+    }
+
     this.db = await plugins.idb.openDB(this.options.dbName, 1, {
       upgrade: (db) => {
         db.createObjectStore(this.options.storeName);
       },
     });
+    this.readyDeferred.resolve();
+    return;
   }
 
-  async get(key: string) {
+  async get(key: string): Promise<T> {
+    await this.init();
     return this.db.get(this.options.storeName, key);
   }
 
   async check(keyArg: string): Promise<boolean> {
+    await this.init();
     const result = await this.get(keyArg);
     return !!result;
   }
 
   async set(key: string, val: T) {
+    await this.init();
     return this.db.put(this.options.storeName, val, key);
   }
 
   async delete(key: string) {
+    await this.init();
     return this.db.delete(this.options.storeName, key);
   }
 
   async clear() {
+    await this.init();
     return this.db.clear(this.options.storeName);
   }
 
   async keys() {
+    await this.init();
     return this.db.getAllKeys(this.options.storeName);
   }
-}
+}

ts/webstore.plugins.ts

@@ -1,5 +1,18 @@
+// pushrocks scope
+import * as lik from '@pushrocks/lik';
+import * as smartenv from '@pushrocks/smartenv';
+import * as smartjson from '@pushrocks/smartjson';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrx from '@pushrocks/smartrx';
+
+export { lik, smartenv, smartjson, smartpromise, smartrx };
+
+// apiglobal scope
+import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
+
+export { typedrequestInterfaces };
+
+// thirdparty scope
 import * as idb from 'idb';
 
-export {
-  idb
-}
+export { idb };

tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true
+  }
+}

tslint.json

@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}