@gorgonjs/gorgon 1.4.1 → 1.5.1

package/.eslintrc

@@ -1,71 +1,29 @@
 {
   "rules": {
     "accessor-pairs": 0,
-    "array-bracket-spacing": 0,
-    "arrow-body-style": 0,
-    "arrow-parens": ["error", "as-needed"],
-    "arrow-spacing": 0,
     "block-scoped-var": 0,
-    "block-spacing": 0,
-    "brace-style": [
-      2,
-      "1tbs",
-      {
-        "allowSingleLine": true
-      }
-    ],
     "callback-return": 0,
     "camelcase": 2,
-    "comma-dangle": [
-      1,
-      "always-multiline"
-    ],
-    "comma-spacing": 0,
-    "comma-style": 0,
     "complexity": 0,
-    "computed-property-spacing": 0,
     "consistent-return": 0,
     "consistent-this": 0,
     "constructor-super": 0,
-    "curly": [
-      2,
-      "all"
-    ],
+    "curly": [2, "all"],
     "default-case": 2,
-    "dot-location": [
-      2,
-      "property"
-    ],
+    "dot-location": [2, "property"],
     "dot-notation": 0,
     "eol-last": 0,
     "eqeqeq": 2,
     "func-names": 0,
     "func-style": 0,
-    "generator-star-spacing": 0,
     "global-require": 0,
     "guard-for-in": 2,
     "handle-callback-err": 0,
     "id-length": 0,
     "id-match": 0,
     "indent": 0,
-    "indent-legacy": [
-      2,
-      2,
-      {"SwitchCase": 1}
-    ],
+    "indent-legacy": [2, 2, { "SwitchCase": 1 }],
     "init-declarations": 0,
-    "key-spacing": [
-      2,
-      {
-        "beforeColon": false,
-        "afterColon": true
-      }
-    ],
-    "linebreak-style": [
-      2,
-      "unix"
-    ],
-    "lines-around-comment": 0,
     "max-depth": 0,
     "max-len": [
       2,
@@ -87,7 +45,6 @@
       }
     ],
     "new-parens": 0,
-    "newline-after-var": 2,
     "no-alert": 0,
     "no-array-constructor": 2,
     "no-arrow-condition": 0,
@@ -127,13 +84,9 @@
     "no-implicit-coercion": 0,
     "no-implied-eval": 0,
     "no-inline-comments": 0,
-    "no-inner-declarations": [
-      2,
-      "functions"
-    ],
+    "no-inner-declarations": [2, "functions"],
     "no-invalid-regexp": 0,
     "no-invalid-this": 0,
-    "no-irregular-whitespace": 0,
     "no-iterator": 0,
     "no-label-var": 0,
     "no-labels": 0,
@@ -142,7 +95,6 @@
     "no-loop-func": 2,
     "no-magic-numbers": 0,
     "no-mixed-requires": 0,
-    "no-mixed-spaces-and-tabs": 2,
     "no-multi-spaces": 0,
     "no-multi-str": 2,
     "no-multiple-empty-lines": 0,
@@ -174,13 +126,11 @@
     "no-sequences": 0,
     "no-shadow": 0,
     "no-shadow-restricted-names": 0,
-    "no-spaced-func": 2,
     "no-sparse-arrays": 0,
     "no-sync": 0,
     "no-ternary": 0,
     "no-this-before-super": 0,
     "no-throw-literal": 0,
-    "no-trailing-spaces": 2,
     "no-undef": 2,
     "no-undef-init": 0,
     "no-undefined": 0,
@@ -197,17 +147,9 @@
     "no-void": 0,
     "no-warning-comments": 0,
     "no-with": 2,
-    "object-curly-spacing": [
-      2,
-      "never"
-    ],
     "object-shorthand": 0,
     "one-var": 0,
     "operator-assignment": 0,
-    "operator-linebreak": [
-      2,
-      "after"
-    ],
     "padded-blocks": 0,
     "prefer-arrow-callback": 0,
     "prefer-const": 1,
@@ -225,30 +167,8 @@
     "radix": 0,
     "require-jsdoc": 0,
     "require-yield": 0,
-    "semi-spacing": 0,
     "sort-vars": 0,
-    "space-after-keywords": 0,
-    "space-before-blocks": [
-      2,
-      "always"
-    ],
-    "space-before-function-paren": [
-      2,
-      "never"
-    ],
-    "space-before-keywords": 0,
-    "space-in-parens": [
-      2,
-      "never"
-    ],
-    "space-infix-ops": 2,
-    "space-return-throw-case": 0,
-    "space-unary-ops": 0,
-    "spaced-comment": 0,
-    "strict": [
-      2,
-      "global"
-    ],
+    "strict": [2, "global"],
     "use-isnan": 0,
     "valid-jsdoc": 2,
     "valid-typeof": 0,

package/CHANGELOG.md

@@ -7,16 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.5.0] - 2023-09-11
+
+### Added
+
+- Added a hook system to the cache
+
 ## [1.4.0] - 2022-11-19
 
 ### Added
+
 - added a file provider at @gorgon/file-provider
+
 ### Fixed
+
 - fixed a bug where when you cached something permanently (false) with the non default cache it would use the default provider
 
 ## [1.3.1] - 2022-11-14
 
 ### Added
+
 - added more library type support for older require syntax
 
 ## [1.3.0] - 2022-11-13
@@ -34,5 +44,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [1.2.0] - 2022-11-12
 
 ### Added
+
 - initial release to the public; migrated from @mikevalstar/gorgon
 - code is based off of medusa.js

package/README.md

@@ -1,7 +1,7 @@
 # Gorgon
 ![coverage](https://img.shields.io/badge/coverage-97%25-brightgreen)
-![size](https://img.shields.io/badge/size-4.03KB-brightgreen)
-![version](https://img.shields.io/badge/version-1.4.0-blue)
+![size](https://img.shields.io/badge/size-5.67KB-brightgreen)
+![version](https://img.shields.io/badge/version-1.5.0-blue)
 ![license](https://img.shields.io/badge/license-MIT-blue)
 
 A typescript async based caching library for node or the browser.

package/__tests__/basic.test.ts

@@ -2,143 +2,162 @@ import { describe, it, expect, afterAll } from 'vitest';
 import Gorgon from '../index';
 
 describe('settings', () => {
-
   afterAll(() => {
-    Gorgon.settings({debug: false});
+    Gorgon.settings({ debug: false });
   });
 
   it('returns default settings', () => {
-
     const retSettigns = Gorgon.settings();
 
     expect(retSettigns.debug).toEqual(false);
-
   });
 
   it('can set debug mode', () => {
-
     const retSettigns = Gorgon.settings({
       debug: true,
     });
 
     expect(retSettigns.debug).toEqual(true);
-
   });
-
 });
 
 describe('basic storage', () => {
-
-  it('gets the results of a promise', async() => {
-
-    const res = await  Gorgon.get('sample1', async() => {
-      return 'success';
-    }, 1000);
+  it('gets the results of a promise', async () => {
+    const res = await Gorgon.get(
+      'sample1',
+      async () => {
+        return 'success';
+      },
+      1000,
+    );
 
     return expect(res).toEqual('success');
-
   });
 
-
-  it('returns old value, not new value for promise', async() => {
-
-    const res = await Gorgon.get('sample2', async() => {
-      return 'success';
-    }, 1000);
+  it('returns old value, not new value for promise', async () => {
+    const res = await Gorgon.get(
+      'sample2',
+      async () => {
+        return 'success';
+      },
+      1000,
+    );
 
     expect(res).toEqual('success');
 
-    const res2 = await Gorgon.get('sample2', async() => {
-      return 'failure';
-    }, 1000);
+    const res2 = await Gorgon.get(
+      'sample2',
+      async () => {
+        return 'failure';
+      },
+      1000,
+    );
 
     return expect(res2).toEqual('success');
-
   });
 
-  it('overwtires the current cache item', async() => {
-
-    const res = await Gorgon.get('sample6', async() => {
-      return 'success';
-    }, 1000);
+  it('overwtires the current cache item', async () => {
+    const res = await Gorgon.get(
+      'sample6',
+      async () => {
+        return 'success';
+      },
+      1000,
+    );
 
     expect(res).toEqual('success');
 
-    const res2 = await Gorgon.overwrite('sample6', async() => {
-      return 'success2';
-    }, 1000);
-
+    const res2 = await Gorgon.overwrite(
+      'sample6',
+      async () => {
+        return 'success2';
+      },
+      1000,
+    );
 
     expect(res).toEqual('success');
     expect(res2).toEqual('success2');
-
   });
 
-  it('cache expires', async() => {
-
-    const res = await Gorgon.get('sample3', async() => {
-      return 'failure';
-    }, 1000);
+  it('cache expires', async () => {
+    const res = await Gorgon.get(
+      'sample3',
+      async () => {
+        return 'failure';
+      },
+      1000,
+    );
 
     expect(res).toEqual('failure');
 
     // await a time of 1.5 seconds
-    await new Promise(resolve => setTimeout(resolve, 1500));
+    await new Promise((resolve) => setTimeout(resolve, 1500));
 
-    const res2 = await Gorgon.get('sample3', async() => {
-      return 'success';
-    }, 1000);
+    const res2 = await Gorgon.get(
+      'sample3',
+      async () => {
+        return 'success';
+      },
+      1000,
+    );
 
     expect(res2).toEqual('success');
-
   });
 
-
-  it('throws and does not cache', async() => {
-
+  it('throws and does not cache', async () => {
     try {
-      const res = await Gorgon.get('sample4', async() => {
-        throw 'failure';
-      }, 1000);
-    }catch(e) {
+      const res = await Gorgon.get(
+        'sample4',
+        async () => {
+          throw 'failure';
+        },
+        1000,
+      );
+    } catch (e) {
       expect(e).toEqual('failure');
     }
 
-    const res2 = await Gorgon.get('sample4', async() => {
-      return 'success';
-    }, 1000);
+    const res2 = await Gorgon.get(
+      'sample4',
+      async () => {
+        return 'success';
+      },
+      1000,
+    );
 
     expect(res2).toEqual('success');
-
   });
 
-
-  it('clears all cache items', async() => {
-
-    const res = await Gorgon.get('sample5', async() => {
-      return 'failure';
-    }, 1000);
+  it('clears all cache items', async () => {
+    const res = await Gorgon.get(
+      'sample5',
+      async () => {
+        return 'failure';
+      },
+      1000,
+    );
 
     await Gorgon.clear();
 
-    const res2 = await Gorgon.get('sample5', async() => {
-      return 'success';
-    }, 1000);
+    const res2 = await Gorgon.get(
+      'sample5',
+      async () => {
+        return 'success';
+      },
+      1000,
+    );
 
     expect(res2).toEqual('success');
-
   });
 
-
-  it('clears a single item that has a permenant cache', async() => {
-
-    const res = await Gorgon.get('sample9', async() => {
+  it('clears a single item that has a permenant cache', async () => {
+    const res = await Gorgon.get('sample9', async () => {
       return 'success';
     });
 
     expect(res).toEqual('success');
 
-    const res2 = await Gorgon.get('sample10', async() => {
+    const res2 = await Gorgon.get('sample10', async () => {
       return 'failure';
     });
 
@@ -146,18 +165,16 @@ describe('basic storage', () => {
 
     await Gorgon.clear('sample10');
 
-    const res3 = await Gorgon.get('sample9', async() => {
+    const res3 = await Gorgon.get('sample9', async () => {
       return 'failure';
     });
 
     expect(res3).toEqual('success');
 
-    const res4 = await Gorgon.get('sample10', async() => {
+    const res4 = await Gorgon.get('sample10', async () => {
       return 'success2';
     });
 
     expect(res4).toEqual('success2');
-
   });
-
 });

package/__tests__/clearmany.test.ts

@@ -2,63 +2,90 @@ import { describe, it, expect } from 'vitest';
 import Gorgon from '../index';
 
 describe('Clear many from storage', () => {
-
-  it('clears many based on wildcard', async() => {
-
-    const res = await Gorgon.get('clearmany1', async() => {
-      return 'success';
-    }, 1000);
+  it('clears many based on wildcard', async () => {
+    const res = await Gorgon.get(
+      'clearmany1',
+      async () => {
+        return 'success';
+      },
+      1000,
+    );
 
     expect(res).toEqual('success');
 
-    const res2 = await Gorgon.get('clearmany2', async() => {
-      return 'success';
-    }, 1000);
+    const res2 = await Gorgon.get(
+      'clearmany2',
+      async () => {
+        return 'success';
+      },
+      1000,
+    );
 
     expect(res2).toEqual('success');
 
     await Gorgon.clear('clearmany*');
 
-    const res3 = await Gorgon.get('clearmany1', async() => {
-      return 'success2';
-    }, 1000);
+    const res3 = await Gorgon.get(
+      'clearmany1',
+      async () => {
+        return 'success2';
+      },
+      1000,
+    );
 
     expect(res3).toEqual('success2');
 
-    const res4 = await Gorgon.get('clearmany2', async() => {
-      return 'success2';
-    }, 1000);
+    const res4 = await Gorgon.get(
+      'clearmany2',
+      async () => {
+        return 'success2';
+      },
+      1000,
+    );
 
     expect(res4).toEqual('success2');
-
-
   });
 
-  it('clears every item in the cache', async() => {
-
-    const res = await Gorgon.get('clearall1', async() => {
-      return 'success';
-    }, 1000);
+  it('clears every item in the cache', async () => {
+    const res = await Gorgon.get(
+      'clearall1',
+      async () => {
+        return 'success';
+      },
+      1000,
+    );
 
     expect(res).toEqual('success');
 
-    const res2 = await Gorgon.get('clearall2', async() => {
-      return 'success';
-    }, 1000);
+    const res2 = await Gorgon.get(
+      'clearall2',
+      async () => {
+        return 'success';
+      },
+      1000,
+    );
 
     expect(res2).toEqual('success');
 
     await Gorgon.clearAll();
 
-    const res3 = await Gorgon.get('clearall1', async() => {
-      return 'success2';
-    }, 1000);
+    const res3 = await Gorgon.get(
+      'clearall1',
+      async () => {
+        return 'success2';
+      },
+      1000,
+    );
 
     expect(res3).toEqual('success2');
 
-    const res4 = await Gorgon.get('clearall2', async() => {
-      return 'success2';
-    }, 1000);
+    const res4 = await Gorgon.get(
+      'clearall2',
+      async () => {
+        return 'success2';
+      },
+      1000,
+    );
 
     expect(res4).toEqual('success2');
 
@@ -66,7 +93,5 @@ describe('Clear many from storage', () => {
 
     const keys = await Gorgon.providers['memory'].keys();
     expect(keys.length).toEqual(0);
-
   });
-
 });

package/__tests__/concurrency.test.ts

@@ -1,19 +1,17 @@
 import { describe, it, expect, vi } from 'vitest';
 import Gorgon from '../index';
 
-Gorgon.settings({retry: 10});
+Gorgon.settings({ retry: 10 });
 
 vi.useRealTimers();
 
 describe('concurrency', () => {
-
-  it('Only calls the function once, when the call is slow', async() => {
-
+  it('Only calls the function once, when the call is slow', async () => {
     let calledCount = 0;
 
-    const incrementor = async() => {
+    const incrementor = async () => {
       return new Promise((resolve: (value: boolean) => void) => {
-        setTimeout(()=> {
+        setTimeout(() => {
           calledCount += 1;
           resolve(true);
         }, 200);
@@ -24,33 +22,29 @@ describe('concurrency', () => {
     const res2 = await Gorgon.get('concur1', incrementor, 50);
 
     return expect(calledCount).toEqual(1);
-
   });
 
-  it('Only calls the function once, but rejects both', async() => {
-
+  it('Only calls the function once, but rejects both', async () => {
     let calledCount = 0;
 
-    const incrementor = async() => {
+    const incrementor = async () => {
       return new Promise((resolve, rej) => {
-        setTimeout(()=> {
+        setTimeout(() => {
           calledCount += 1;
           rej(true);
         }, 200);
       });
     };
 
-    try{
-      const res = Gorgon.get('concur2', incrementor, 50).catch(e => {
+    try {
+      const res = Gorgon.get('concur2', incrementor, 50).catch((e) => {
         // error
       });
       const res2 = await Gorgon.get('concur2', incrementor, 50);
-    }catch(e) {
+    } catch (e) {
       // error?
     }
 
     return expect(calledCount).toEqual(1);
-
   });
-
 });

package/__tests__/datePolicy.test.ts

@@ -2,19 +2,19 @@ import { describe, it, expect } from 'vitest';
 import Gorgon from '../index';
 
 describe('basic storage - date policy', () => {
-
-  it('gets the results of a promise, Date Policy', async() => {
-
+  it('gets the results of a promise, Date Policy', async () => {
     var x = new Date();
 
     x = new Date(x.getTime() + 1000 * 1000);
 
-    const res = await  Gorgon.get('datepolicy1', async() => {
-      return 'success';
-    }, x);
+    const res = await Gorgon.get(
+      'datepolicy1',
+      async () => {
+        return 'success';
+      },
+      x,
+    );
 
     return expect(res).toEqual('success');
-
   });
-
 });