cacheable 0.2.7 → 0.3.0

package/LICENSE

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,189 +1,218 @@
-# Cacheable
+[<img align="center" src="https://jaredwray.com/images/cacheable_white.svg" alt="keyv">](https://github.com/jaredwray/cacheable)
 
-Cache manager that doesn't suck.
+# cacheable
 
-Make the result of you async functions cacheable, automatically pickle and unpickle the data.
-Manage all cache keys in one place, use a simple `._clearCache()` to purge cache.
+> Simple Caching Engine using Keyv
 
+[![codecov](https://codecov.io/gh/jaredwray/cacheable/branch/master/graph/badge.svg?token=LDLaqe4PsI)](https://codecov.io/gh/jaredwray/cacheable)
+[![tests](https://github.com/jaredwray/cacheable/actions/workflows/tests.yml/badge.svg)](https://github.com/jaredwray/cacheable/actions/workflows/tests.yml)
+[![npm](https://img.shields.io/npm/dm/cacheable.svg)](https://www.npmjs.com/package/cacheable)
+[![npm](https://img.shields.io/npm/v/cacheable)](https://www.npmjs.com/package/cacheable)
 
-## Usage
+`cacheable` is a simple caching engine that uses [Keyv](https://keyv.org) as the storage engine. It is designed to be simple to use and extend. Here are some of the features:
+* Simple to use with robust API
+* Not bloated with additional modules
+* Extendable to your own caching engine
+* Scalable and trusted storage engine by Keyv
+* Statistics built in by default
+* Hooks and Events to extend functionality
+* Comprehensive testing and code coverage
+* Maintained and supported
 
-```javascript
-var Redis = require('redis');
-var Cacheable = require('cacheable');
-
-var client = Redis.createClient();
-var cached = Cacheable({
-  client: client,
-  ttl: 60, // set a default max age of one minute for `cached.set`
-  prefix: 'myapp:' // the prefix for every cache key
-});
+## Getting Started
 
-cached.set(key, value, callback)
-cached.set(key, value, 300, callback)
-cached.get(key, callback)
-cached.del(['abc', 'aba'], callback)
-```
+`cacheable` is primarily used as an extension to you caching engine with a robust storage backend [Keyv](https://keyv.org), Memonization, Hooks, Events, and Statistics.
 
-Wraping an async function:
-
-```javascript
-// Get remote content that expires in 3600 seconds
-var getUrlContent = cached.wrap(function(url, callback) {
-    request(url, function() {
-      // ...
-    })
-}, 'url-{0}', 3600)
+```bash
+npm install cacheable
 ```
 
-Manage cache for your models:
+## Basic Usage
 
 ```javascript
-function User(data) {
-  this.attributes = data
-}
+import { Cacheable } from 'cacheable';
 
-User.prototype.toJSON = function() {
-  return this.attributes
-}
+const cacheable = new Cacheable();
+cacheable.set('key', 'value', 1000);
+const value = cacheable.get('key');
+```
 
-// get user by id
-User.get = function(user_id, callback) {
-  // get the user from data base
-  // ...
-  var user = new User(data)
+## Extending Your own Caching Engine
 
-  callback(err, user);
-}
+```javascript
+import { Cacheable } from 'cacheable';
 
-User.prototype.getPostIds = function(start, limit, callback) {
-  callback(null, [1,2,3...])
+export class MyCache extends Cacheable {
+  constructor() {
+	super();
+  }
 }
-
-// register the constructor first
-cached.register(User)
-
-// enable cache for `User.get` method
-// So when you call `User.get(some_id)`, it will fetch data
-// from cache first, when cache not found, then the original function will be called.
-User.enableCache('get', '{_model_}:{0}') // '{0}' means the `arguments[0]`
-
-// You can also enable cache for an instance method
-User.enableCache('.getPostIds', '{_model_}:posts-{0}-{1}')
 ```
 
-## API
-
-### cached.register(cls, name)
+From here you now how the ability to use the `cacheable` API. You can also extend the API to add your own functionality.
 
-You have to `register` all model constructors, so when cache is hit, the cached manager would know
-how to restore the data as a proper JavaScript Object.
+## Storage Adapters and Keyv
 
-If your model constructor doesn't have a name, you can give a name as the second parameter,
-then cached will use this name.
+To set Keyv as the storage engine, you can do the following:
 
 ```javascript
-var Book = function() {
+import { Cacheable } from 'cacheable';
+import Keyv from 'keyv';
+
+export class MyCache extends Cacheable {
+  constructor() {
+	super(new Keyv('redis://user:pass@localhost:6379'));
+  }
 }
-cached.register(Book, 'Book')
 ```
 
-Your class.prototype must have a `.toJSON` method, so the cache wrapper could know how to save it to cache.
-The `.toJSON` will be extended by `cache.register`, the output object will always have a property `__cachedname`,
-as is the constructor's modelName. You can add a `.toObject = .toJSON`, and use `.toObject` whenever you need a clean object.
-
-
-If an `._unpickle` method is also defined, it will be called each time the object is restored from cache.
-
-That is:
+or you can do it at the property level:
 
 ```javascript
-var item = new User(json)
-item._unpickle()
-return item
-```
-Note that it would be impossible to unpickle a cache if the constructor's name was changed.
+import { Cacheable } from 'cacheable';
+import Keyv from 'keyv';
 
-When registered, the class will have a property `._cacheKeys` and an instance would have
-a method `._clearCache()`.
+export class MyCache extends Cacheable {
+  constructor() {
+	super();
 
-```javascript
-User.prototype.destroy = function(callback) {
-  var self = this
-  // destroy the item from database
-  db.destroy(..., function() {
-    // then clear the cache
-    self._clearCache(callback)
-  })
+	this.store = new Keyv('redis://user:pass@localhost:6379');
+  }
 }
 ```
 
-### cached.wrap(fn, [key], [ttl])
-
-Wrap an standard nodejs async function(which should have a `callback(err, result)` as the last parameter).
-The `ttl` is in seconds. If no `ttl` set, the cache will never automatically expire, even it an `options.ttl`
-is passed when you do `new Cached()`.
+## Statistics
 
-The parameter `key` is a pattern for formatting real cache keys.
+To get statistics on your cache, you can do the following:
 
-The default `key` is:
-
-    {_model_}:{_fn_}
+```javascript
+import { Cacheable } from 'cacheable';
 
-`{_fn_}` is the name of the function `fn`. If not found, an error will throw.
-So you'd better alway name your functions, like this:
+export class MyCache extends Cacheable {
+  constructor() {
+	super();
+  }
 
-```javascript
-User.get = function get(id) {
-  // ...
+  async getStats() {
+	return this.stats.getReport();
+  }
 }
 ```
 
-`{_model_}` equals to `{this.name}`, which is `this.modelName || this.name` in the scope when the function is called.
-For a class method, this usually means the name of a constructor.
+This will generate the following json object:
+
+```json
+{
+  "cacheSize": 100,
+  "currentSize": 80,
+  "hits": 500,
+  "misses": 200,
+  "hitRate": 0.71,
+  "evictions": 50,
+  "averageLoadPenalty": 0.05,
+  "loadSuccessCount": 700,
+  "loadExceptionCount": 10,
+  "totalLoadTime": 3500,
+  "topHits": [
+    {
+      "key": "key1",
+      "value": "value1",
+      "lastAccessed": 1627593600000,
+      "accessCount": 50
+    },
+    {
+      "key": "key2",
+      "value": "value2",
+      "lastAccessed": 1627593600000,
+      "accessCount": 45
+    }
+    // More items...
+  ],
+  "leastUsed": [
+    {
+      "key": "key3",
+      "value": "value3",
+      "lastAccessed": 1627593600000,
+      "accessCount": 5
+    },
+    {
+      "key": "key4",
+      "value": "value4",
+      "lastAccessed": 1627593600000,
+      "accessCount": 4
+    }
+    // More items...
+  ]
+}
+```
 
-Numbers like `{0}` is indexes of arguments when the function is called.
-`%j{0}` mean the first argument value will be converted to json.
+* `cacheSize`: The maximum number of items that can be stored in the cache.
+* `currentSize`: The current number of items in the cache.
+hits: The number of cache hits. A cache hit occurs when the requested data is found in the cache.
+* `misses`: The number of cache misses. A cache miss occurs when the requested data is not found in the cache and needs to be loaded.
+* `hitRate`: The ratio of cache hits to the total number of cache lookups. This is a measure of the cache's effectiveness.
+* `evictions`: The number of items that have been evicted from the cache, typically because the cache is full.
+* `averageLoadPenalty`: The average time spent loading new values into the cache, typically measured in milliseconds. This could be calculated as totalLoadTime / (hits + misses).
+* `loadSuccessCount`: The number of times cache loading has succeeded.
+* `loadExceptionCount`: The number of times cache loading has failed due to exceptions.
+* `totalLoadTime`: The total time spent loading new values into the cache, typically measured in milliseconds.
 
+## Hooks and Events
 
-### cls.enableCache(methodName, [key], [ttl])
+The following hooks are available for you to extend the functionality of `cacheable`:
 
-When a `cls` is registered, you can use `cls.enableCache` to enable cache for class/instance methods.
+* `preSet`: This is called before the `set` method is called.
+* `postSet`: This is called after the `set` method is called.
+* `preSetMany`: This is called before the `setMany` method is called.
+* `postSetMany`: This is called after the `setMany` method is called.
+* `preGet`: This is called before the `get` method is called.
+* `postGet`: This is called after the `get` method is called.
+* `preGetMany`: This is called before the `getMany` method is called.
+* `postGetMany`: This is called after the `getMany` method is called.
 
-If `methodName` starts with a dot `(.)`, it will be considered as an instance method, otherwise,
-it's a class method.
+An example of how to use these hooks:
 
 ```javascript
-/**
- *
- * List all ids
- *
- * Options:
- *
- *    `limit`: limit per page
- *    `offset`: offset 
- * 
- */
-User.getAllIds = function(options, callback) {
-}
-
-User.prototype.getPostIds = function(start, limit, callback) {
-  // get user's posts
-  callback(null, [1,2,3...])
-}
+import { Cacheable } from 'cacheable';
 
-User.enableCache('getAllIds', 'ids-{0.limit}-{0.offset}')
-
-User.enableCache('.getPostIds', 'posts-{0}-{1}')
-
-// You can omit the key, cacheable will automatically use the method name
-User.enableCache('.getPostIds', 3600)
-// KEY: '{_model_}:{id}:getTagsIds', expires in: 3600 seconds
+const cacheable = new Cacheable();
+cacheable.hooks.setHook('preSet', (key, value) => {
+  console.log(`preSet: ${key} ${value}`);
+});
 ```
 
-It is strongly recommended to use this approach to add cache, instead of directly call `cached.wrap`.
+The following events are available for you to extend the functionality of `cacheable`:
 
+* `set`: This is called when the `set` method is called.
+* `setMany`: This is called when the `setMany` method is called.
+* `get`: This is called when the `get` method is called.
+* `getMany`: This is called when the `getMany` method is called.
+* `clear`: This is called when the `clear` method is called.
+* `has`: This is called when the `has` method is called.
+* `disconnect`: This is called when the `disconnect` method is called.
+* `error`: This is called when an error occurs.
 
-## License
+## API
 
-the MIT licence.
+* `set(key, value, ttl?)`: Sets a value in the cache.
+* `setMany([{key, value, ttl?}])`: Sets multiple values in the cache.
+* `get(key)`: Gets a value from the cache.
+* `has(key)`: Checks if a value exists in the cache.
+* `getMany([keys])`: Gets multiple values from the cache.
+* `delete(key)`: Deletes a value from the cache.
+* `clear()`: Clears the cache.
+* `disconnect()`: Disconnects from the cache.
+* `getStats()`: Gets statistics from the cache.
+* `setHook(hook, callback)`: Sets a hook.
+* `deleteHook(hook)`: Removes a hook.
+* `emitEvent(event, data)`: Emits an event.
+* `on(event, callback)`: Listens for an event.
+* `removeListener(event, callback)`: Removes a listener.
+* `store`: The [Keyv](https://keyv.org) storage engine.
+
+## How to Contribute
+
+You can contribute by forking the repo and submitting a pull request. Please make sure to add tests and update the documentation. To learn more about how to contribute go to our main README [https://github.com/jaredwray/cacheable](https://github.com/jaredwray/cacheable). This will talk about how to `Open a Pull Request`, `Ask a Question`, or `Post an Issue`.
+
+## License and Copyright
+MIT © Jared Wray - [https://github.com/jaredwray/cacheable/blob/main/LICENSE](https://github.com/jaredwray/cacheable/blob/main/LICENSE)

package/package.json

@@ -1,33 +1,33 @@
 {
   "name": "cacheable",
-  "version": "0.2.7",
-  "description": "A cache wrapper with redis",
-  "main": "index.js",
-  "scripts": {
-    "test": "./node_modules/.bin/mocha"
+  "version": "0.3.0",
+  "description": "Simple Caching Engine using Keyv",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "repository": "https://github.com/jaredwray/cacheable.git",
+  "author": "Jared Wray <me@jaredwray.com>",
+  "license": "MIT",
+  "private": false,
+  "devDependencies": {
+    "eslint": "^9.9.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4",
+    "xo": "^0.59.3"
   },
   "dependencies": {
-    "debug": "0.7.x",
-    "keyf": "~0.0.1",
-    "storeman": "~0.1.1"
+    "eventemitter3": "^5.0.1",
+    "hookified": "^0.7.0",
+    "keyv": "^5.0.1"
   },
-  "devDependencies": {
-    "mocha": "*",
-    "should": "*",
-    "lru-cache": "*",
-    "istanbul": "*"
+  "xo": {
+    "rules": {
+      "unicorn/prefer-event-target": "off"
+    }
   },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/ktmud/cached.git"
-  },
-  "keywords": [
-    "redis",
-    "redis-cache",
-    "cacheable",
-    "cache",
-    "cached"
-  ],
-  "author": "Jesse Yang <kissmud@gmail.com>",
-  "license": "MIT"
-}
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "xo --fix",
+    "test:ci": "xo",
+    "clean": "rm -rf dist && rm -rf node_modules"
+  }
+}

package/src/index.ts

@@ -0,0 +1,122 @@
+import {Keyv} from 'keyv';
+import {Hookified} from 'hookified';
+
+type CacheableStatsItem = {
+	key: string;
+	lastAccessed: number;
+	accessCount: number;
+};
+
+type CacheableStats = {
+	cacheSize: number;
+	currentSize: number;
+	hits: number;
+	misses: number;
+	hitRate: number;
+	averageLoadPenalty: number;
+	loadSuccessCount: number;
+	loadExceptionCount: number;
+	totalLoadTime: number;
+	topHits: CacheableStatsItem[];
+	leastUsed: CacheableStatsItem[];
+};
+
+export enum CacheableHooks {
+	BEFORE_SET = 'beforeSet',
+	AFTER_SET = 'afterSet',
+	BEFORE_SET_MANY = 'beforeSetMany',
+	AFTER_SET_MANY = 'afterSetMany',
+	BEFORE_GET = 'beforeGet',
+	AFTER_GET = 'afterGet',
+	BEFORE_GET_MANY = 'beforeGetMany',
+	AFTER_GET_MANY = 'afterGetMany',
+}
+
+export enum CacheableEvents {
+	ERROR = 'error',
+}
+
+export enum CacheableTieringModes {
+	PRIMARY_WITH_FAILOVER = 'primarySecondary',
+	ACID = 'allPrimary',
+	PRIMARY_ALL_FAILOVER = 'primaryAllFailover',
+}
+
+export type CacheableOptions = {
+	store?: Keyv;
+	enableStats?: boolean;
+	enableOffline?: boolean;
+	nonBlocking?: boolean;
+};
+
+export class Cacheable extends Hookified {
+	private _store: Keyv = new Keyv();
+	private readonly _stats: CacheableStats = {
+		currentSize: 0, cacheSize: 0, hits: 0, misses: 0, hitRate: 0, averageLoadPenalty: 0, loadSuccessCount: 0, loadExceptionCount: 0, totalLoadTime: 0, topHits: [], leastUsed: [],
+	};
+
+	private _enableStats = false;
+	private _enableOffline = false;
+
+	constructor(keyv?: Keyv) {
+		super();
+
+		if (keyv) {
+			this._store = keyv;
+		}
+	}
+
+	public get enableStats(): boolean {
+		return this._enableStats;
+	}
+
+	public set enableStats(enabled: boolean) {
+		this._enableStats = enabled;
+	}
+
+	public get enableOffline(): boolean {
+		return this._enableOffline;
+	}
+
+	public set enableOffline(enabled: boolean) {
+		this._enableOffline = enabled;
+	}
+
+	public get store(): Keyv {
+		return this._store;
+	}
+
+	public set store(keyv: Keyv) {
+		this._store = keyv;
+	}
+
+	public get stats(): CacheableStats {
+		return this._stats;
+	}
+
+	public async get<T>(key: string): Promise<T | undefined> {
+		let result;
+		try {
+			await this.hook(CacheableHooks.BEFORE_GET, key);
+			result = await this._store.get(key) as T;
+			await this.hook(CacheableHooks.AFTER_GET, {key, result});
+		} catch (error: unknown) {
+			await this.emit(CacheableEvents.ERROR, error);
+		}
+
+		return result;
+	}
+
+	public async set<T>(key: string, value: T, ttl?: number): Promise<boolean> {
+		let result = false;
+		try {
+			await this.hook(CacheableHooks.BEFORE_SET, {key, value, ttl});
+			result = await this._store.set(key, value, ttl);
+			await this.hook(CacheableHooks.AFTER_SET, {key, value, ttl});
+		} catch (error: unknown) {
+			await this.emit(CacheableEvents.ERROR, error);
+		}
+
+		return result;
+	}
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+    "extends": "./tsconfig.json",
+    "include": ["src/**/*"]
+}

package/tsconfig.json

@@ -0,0 +1,109 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}

package/.npmignore

@@ -1,3 +0,0 @@
-node_modules
-coverage.html
-coverage

package/.travis.yml

@@ -1,4 +0,0 @@
-language: node_js
-node_js:
-  - 0.8
-  - 0.10

package/Makefile

@@ -1,7 +0,0 @@
-.PHONY: test coverage
-
-test:
-	@DEBUG= npm test
-
-coverage:
-	@DEBUG= istanbul cover ./node_modules/.bin/_mocha && open ./coverage/lcov-report/index.html

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./lib/cacheable.js');

package/lib/cacheable.js

@@ -1,162 +0,0 @@
-var Storeman = require('storeman');
-var keyf = require('keyf')
-var debug = require('debug')('cacheable:debug')
-
-var log = require('debug')('cacheable:log')
-var __slice = Array.prototype.slice
-
-// all key pattern definations
-var allkeys = {}
-var RE_KEY_PATTERN = /(%j)?{([\w\.]+)}/g
-var _REALNAME = '__cachedname'
-
-/**
- *
- * A cached wrapper for async funtions
- *
- * Options:
- *
- *   - `prefix` prefix for all keys under this cached manager
- *   - `silent` to ignore `storage.get` error
- *
- */
-function Cacheable(options) {
-  if (!(this instanceof Cacheable)) return new Cacheable(options)
-  if (!options.prefix && options.prefix !== '') {
-    options.prefix = 'cached:'
-  }
-  this.silent = options.silent === false ? false : true
-  this.helpers = {}
-  Storeman.call(this, options);
-}
-// Inherit Storeman to get a bunch of `get`, `set` methods
-require('util').inherits(Cacheable, Storeman)
-
-Cacheable.prototype.debug = debug
-// default key for wrapping standalone functions
-Cacheable.prototype.DEFAULT_KEY =  '{_fn_}:%j{0}'
-
-Cacheable.prototype._applykey = function applykey(ctx, key, fn, args) {
-  return Cacheable.keyReplacer.call(ctx, key, fn, args)
-}
-
-/**
-* Wraps an async funtion, automaticly cache the result
-*
-* The async function must have a signature of `fn(arg1, [arg2...,] callback)`.
-* The `arg1` can be an options object, if `options.fresh` is passed as true,
-* cache will not be used.
-*/
-Cacheable.prototype.wrap = function(fn, key, ttl, ctx) {
-  var cached = this
-
-  if ('number' == typeof key) {
-    // second parameter as ttl
-    ctx = ttl
-    ttl = key
-    key = null
-  }
-  if ('function' == typeof key || 'object' == typeof key) {
-    // second parameter as context
-    ctx = key
-    key = null
-  }
-  key = key || cached.DEFAULT_KEY
-
-  if (!getName(fn) && ~key.indexOf('{_fn_}')) {
-    throw new Error('Cache key referred to "{_fn_}", but the function doesn\'t have a name')
-  }
-
-  // try formating the key in advance
-  var uniqkey = cached._applykey(ctx, key, fn, [])
-  if (uniqkey in allkeys) {
-    log('Possible key conflict -> fn: [%s], key: %s', getName(fn), uniqkey)
-  } else {
-    allkeys[uniqkey] = null
-  }
-
-  debug('wrapping `%s`, key: "%s", ttl: %s', getName(fn) || '[anonymous]', uniqkey, ttl)
-
-  return function cacheWrapped() {
-    var self = ctx || this
-    var args = __slice.apply(arguments)
-    var callback = args[args.length - 1]
-    // the real key
-    var _key = cached._applykey(self, key, fn, args)
-
-    // doesn't need a callback
-    // just do the job as there is no cache
-    if (typeof callback !== 'function') {
-      debug('called with no callback, skip "%s"', _key)
-      return run()
-    }
-    // when `options.fresh` is passed as true,
-    // don't use cache
-    if ('object' == typeof args[0] && args[0].fresh) {
-      return run()
-    }
-    // cache key is not fully formatted means some args are not passed in
-    if (_key.match(RE_KEY_PATTERN)) {
-      debug('cache key not fully formatted, skip "%s"', _key)
-      return run()
-    }
-
-    function run() {
-      fn.apply(self, args)
-    }
-
-    function done(err, reply) {
-      return callback.call(self, err, reply)
-    }
-
-    cached.get(_key, function(err, reply) {
-      if (err) {
-        if (!cached.silent) {
-          // ignore cache error unless not silent
-          return done(err)
-        }
-      }
-      // cache found
-      if (reply !== undefined) {
-        return done(null, reply)
-      }
-      // make sure we save cache after callback
-      args[args.length - 1] = function(err, result) {
-        function _done(){
-          callback.call(self, err, result)
-        }
-        if (err || result === undefined) {
-          return _done()
-        }
-        // save the cache
-        cached.set(_key, result, ttl, _done)
-      }
-      run()
-    })
-  }
-}
-
-/**
- * Get function's realname
- */
-function getName(fn) {
-  return fn[_REALNAME] || fn.name
-}
-
-/**
- * How to replace a cache key
- */
-Cacheable.keyReplacer = function(key, fn, args) {
-  var self = this
-  var data = {
-    _fn_: fn && getName(fn),
-    _model_: self[_REALNAME]
-  }
-  return keyf(key, data).call(self, args)
-}
-
-Cacheable._REALNAME = _REALNAME
-
-module.exports = Cacheable
-
-require('./registry')

package/lib/registry.js

@@ -1,164 +0,0 @@
-// Global cache for constructor classes
-var constructors = {}
-var RE_JSON_TIME =  /^[0-9\-]+T[0-9\:\.]+Z$/
-
-var Cacheable = require('./cacheable')
-
-var _REALNAME = Cacheable._REALNAME
-
-// default keys for wrapping model methods
-var DEFAULT_KEY = '{_model_}:{_fn_}'
-var DEFAULT_PROTO_KEY = '{_model_}:{id}:{_fn_}'
-
-function enableCache(cached) {
-  function enableInstCache(method, key, ttl) {
-    var cls = this
-    var fn = isValidFunc(cls.prototype[method], method)
-    key = key || DEFAULT_PROTO_KEY.replace('{_fn_}', method)
-    hiddenProperty(fn, _REALNAME, fn.name || method)
-    cls.addCacheKey(key)
-    cls.prototype['fresh_' + method] = fn
-    cls.prototype[method] = cached.wrap(fn, key, ttl)
-  }
-
-  return function _enableCache(method, key, ttl) {
-    var cls = this, fn
-    // can pass ttl as the second argument
-    if ('number' === typeof key) {
-      ttl = key
-      key = null
-    }
-    if (method[0] === '.') {
-      return enableInstCache.call(this, method.slice(1), key, ttl)
-    }
-    fn = isValidFunc(cls[method], method)
-    key = key || DEFAULT_KEY.replace('{_fn_}', method)
-    hiddenProperty(fn, _REALNAME, fn.name || method)
-    cls['fresh_' + method] = fn
-    cls[method] = cached.wrap(fn, key, ttl, cls)
-    cls.addCacheKey(key, true)
-    return cls[method]
-  }
-}
-
-function clearCache(cached) {
-  return function _clearCache(callback) {
-    cached.del(this._cacheKeys, callback)
-  }
-}
-
-function addCacheKey(key, isClassMethod) {
-  if (isClassMethod) {
-    this.classCacheKeys.push(key)
-  } else {
-    this.itemCacheKeys.push(key)
-  }
-}
-
-/**
- * Revive object from a json string
- */
-function reviver(k, v) {
-  if ('object' == typeof v && v !== null && !Array.isArray(v)) {
-    var cls = v[_REALNAME]
-    if (cls) {
-      if (!(cls in constructors)) {
-        log('Constructor for %s doesn\'t exist anymore.', cls)
-        // return a undefined, mean this object is not available anymore
-        return
-      }
-      cls = constructors[cls]
-      delete v[_REALNAME]
-      v = new cls(v)
-      if (v._unpickle) {
-        v._unpickle()
-      }
-    }
-    return v
-  }
-  if ('string' === typeof v && RE_JSON_TIME.test(v)) {
-    // revive a date object
-    v = new Date(v)
-  }
-  return v
-}
-
-function unpickle(value) {
-  return JSON.parse(value, reviver)
-}
-
-
-Cacheable.prototype._initClassHelper = function() {
-  this.helpers.enableCache = enableCache(this)
-  this.helpers.clearCache = clearCache(this)
-  this.helpers.addCacheKey = addCacheKey
-  this.unpickle = unpickle
-}
-
-/**
- * Register constructor class for unpickle
- */
-Cacheable.prototype.register = function(cls, modelName) {
-  modelName = modelName || cls.modelName || cls.name
-  hiddenProperty(cls, _REALNAME, modelName)
-  hiddenProperty(cls.prototype, _REALNAME, modelName)
-  if (cls[_REALNAME] in constructors) {
-    throw new Error('Class "' + cls[_REALNAME] + '" already defined')
-  }
-  if (!this.helpers.enableCache) {
-    this._initClassHelper()
-  }
-  this._extend(cls)
-  constructors[cls[_REALNAME]] = cls
-}
-
-
-/**
- * Extend Model with methods to enable and clear cache
- */
-Cacheable.prototype._extend = function extendClass(cls) {
-  var cached = this, proto = cls.prototype
-  cls.classCacheKeys = []
-  // default item related cache
-  cls.itemCacheKeys = ['{_model_}:{id}']
-  // instance cache keys
-  Object.defineProperty(proto, '_cacheKeys', {
-    get: function() {
-      var self = this
-      return cls.itemCacheKeys.map(function(item) {
-        return cached._applykey(self, item)
-      })
-    }
-  })
-  cls.enableCache = cached.helpers.enableCache
-  cls.addCacheKey = cached.helpers.addCacheKey
-  proto._clearCache = cached.helpers.clearCache
-
-  if ('function' != typeof proto.toJSON) {
-    throw new Error('Cache-able class must have instance method .toJSON')
-  }
-  proto._toJSON = proto.toJSON
-  proto.toJSON = function toJSON() {
-    var obj = this._toJSON()
-    obj[_REALNAME] = cls[_REALNAME]
-    return obj
-  }
-  return cls
-}
-
-
-function hiddenProperty(where, property, value) {
-  Object.defineProperty(where, property, { value: value });
-}
-
-function isValidFunc(fn, method) {
-  if (!fn) {
-    throw new Error('method "' + method + '" not defined')
-  }
-  if ('function' !== typeof fn) {
-    throw new Error('method "' + method + '" is not a function')
-  }
-  return fn
-}
-
-

package/test/cacheable.test.js

@@ -1,129 +0,0 @@
-var should = require('should')
-var LRU = require('lru-cache')
-
-var Cacheable = require('../')
-
-describe('Public API', function() {
-
-  var client, cache
-
-  describe('initialize', function() {
-    before(function() {
-      client = LRU()
-      cache = new Cacheable({ client: client })
-    })
-
-    it('new and no new', function() {
-      var cache2 = Cacheable({ client: client })
-      cache.should.be.instanceOf(Cacheable)
-      cache2.should.be.instanceOf(Cacheable)
-    })
-
-    it('default options', function() {
-      cache.silent.should.equal(true)
-      cache.prefix.should.equal('cached:')
-    })
-  })
-
-  describe('wrap', function() {
-    var reach = 0
-
-    function foo(callback) {
-      reach += 1
-      return callback(null, 1)
-    }
-
-    beforeEach(function() {
-      reach = 0
-      client.reset()
-    })
-
-    it('fn with only callback', function(done) {
-      var fn = cache.wrap(foo, 'foo')
-      fn(function(err, result) {
-        result.should.equal(1)
-        fn(function(err, result) {
-          result.should.equal(1)
-          // if cache is used, `reach` will not accumulate
-          reach.should.equal(1)
-          done()
-        })
-      })
-    })
-
-    it('should have default key', function(done) {
-      var fn = cache.wrap(function foo(arg, callback) {
-        reach += arg.a
-        callback(null, 1)
-      })
-      var arg = { a: 1 }
-      fn(arg, function(err, result) {
-        result.should.equal(1)
-        // should've wrapped with default cache key: '{_fn_}:%j{0}'
-        should.equal(cache.get('foo:{"a":1}'), result)
-        fn(arg, function(err, result) {
-          result.should.equal(1)
-          reach.should.equal(1)
-          done()
-        })
-      })
-    })
-
-  })
-
-  describe('key replace', function() {
-
-    it('should handle positional', function(done) {
-      var fn = cache.wrap(foo, 'foor-{0}-{1}')
-      var reach = 0
-
-      fn(2, 5, function(err, result) {
-        reach.should.equal(7)
-        result.should.equal(3)
-        should.equal(cache.get('foor-2-5'), result)
-        fn(2, 5, function(err, result) {
-          reach.should.equal(7)
-          result.should.equal(3)
-          done()
-        })
-      })
-
-      function foo(arg1, arg2, callback) {
-        reach += arg1 + arg2
-        return callback(null, 3)
-      }
-    })
-
-    it('should handle context', function(done) {
-      var ctx = { hello: 'abc', again: 'def' }
-      var fn = cache.wrap(foo, 'contexted-{hello}-{this.hello}-{this.again}', null, ctx)
-      var reach = ''
-
-      fn(1, 2, function(err, result) {
-        reach.should.equal('abc')
-        result.should.equal('0')
-        should.equal(cache.get('contexted-abc-abc-def'), result)
-        fn(1, 2, function(err, result) {
-          reach.should.equal('abc')
-          result.should.equal('0')
-          done()
-        })
-      })
-
-      function foo(arg1, arg2, callback) {
-        reach += this.hello
-        return callback(null, '0')
-      }
-
-    })
-
-    it('should handle context', function() {
-    })
-
-  })
-
-})
-
-describe('Registry', function() {
-
-})

package/test/mocha.opts

@@ -1 +0,0 @@
---timeout 200