Merge pull request #18648 from BendingBender/redlock

[redlock] add typings for v3, enable linting & strictNullChecks

types/redlock/index.d.ts

@@ -1,24 +1,22 @@
-// Type definitions for Redlock
+// Type definitions for redlock 3.0
 // Project: https://github.com/mike-marcacci/node-redlock
 // Definitions by: Ilya Mochalov <https://github.com/chrootsu>
+//                 BendingBender <https://github.com/BendingBender>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
-import * as redis from 'redis';
 import * as Promise from 'bluebird';
+import { EventEmitter } from 'events';
 
 export = Redlock;
 
 declare namespace Redlock {
-    interface Callback<T> {
-        (err: any, value?: T): void;
-    }
+    type Callback<T> = (err: any, value?: T) => void;
 
     interface Lock {
-
         redlock: Redlock;
         resource: string;
-        value: any;
+        value: string | null;
         expiration: number;
 
         unlock(callback?: Callback<void>): Promise<void>;
@@ -30,30 +28,50 @@ declare namespace Redlock {
         driftFactor?: number;
         retryCount?: number;
         retryDelay?: number;
+        retryJitter?: number;
+        lockScript?(origLockScript: string): string;
+        unlockScript?(origUnlockScript: string): string;
+        extendScript?(origExtendScript: string): string;
     }
 
-    interface LockError extends Error { }
+    interface LockErrorConstructor {
+        new(message?: string): LockError;
+        (message?: string): LockError;
+        readonly prototype: LockError;
+    }
+
+    interface LockError extends Error {
+        readonly name: 'LockError';
+    }
+
+    interface CompatibleRedisClient {
+        eval(args: any[], callback?: (err: Error | null, res: any) => void): any;
+        eval(...args: any[]): any;
+    }
 }
 
-declare class Redlock {
-    LockError: Redlock.LockError;
-
+declare class Redlock extends EventEmitter {
+    LockError: Redlock.LockErrorConstructor;
     driftFactor: number;
     retryCount: number;
     retryDelay: number;
+    retryJitter: number;
+    servers: Redlock.CompatibleRedisClient[];
 
-    servers: redis.RedisClient[];
-
-    constructor(clients: any[], options?: Redlock.Options);
+    constructor(clients: Redlock.CompatibleRedisClient[], options?: Redlock.Options);
 
     acquire(resource: string, ttl: number, callback?: Redlock.Callback<Redlock.Lock>): Promise<Redlock.Lock>;
     lock(resource: string, ttl: number, callback?: Redlock.Callback<Redlock.Lock>): Promise<Redlock.Lock>;
 
-    disposer(resource: string, ttl: number, errorHandler?: Redlock.Callback<void>): any; // bluebird Disposer
+    disposer(resource: string, ttl: number, errorHandler?: Redlock.Callback<void>): Promise.Disposer<Redlock.Lock>;
 
     release(lock: Redlock.Lock, callback?: Redlock.Callback<void>): Promise<void>;
     unlock(lock: Redlock.Lock, callback?: Redlock.Callback<void>): Promise<void>;
 
     extend(lock: Redlock.Lock, ttl: number, callback?: Redlock.Callback<Redlock.Lock>): Promise<Redlock.Lock>;
-    _lock(resource: string, value: string, ttl: number, callback?: Redlock.Callback<Redlock.Lock>): Promise<Redlock.Lock>;
+
+    addListener(event: 'clientError', listener: (err: any) => void): this;
+    on(event: 'clientError', listener: (err: any) => void): this;
+    once(event: 'clientError', listener: (err: any) => void): this;
+    removeListener(event: 'clientError', listener: (err: any) => void): this;
 }

types/redlock/redlock-tests.ts

@@ -1,38 +1,97 @@
-import * as Redlock from 'redlock';
-import { Callback as NodeifyCallback, Options, Lock } from 'redlock';
-import * as Promise from 'bluebird';
+import Redlock = require('redlock');
+import { Lock } from 'redlock';
 import { RedisClient } from 'redis';
+import IoRedisClient = require('ioredis');
+import { using } from 'bluebird';
 
-let redlock: Redlock;
-let client: RedisClient;
-let lock: Lock;
+let lock: Lock = <Lock> {};
 
-redlock = new Redlock([client]);
-redlock = new Redlock([client], {
-	driftFactor: 0.1,
-	retryCount: 2,
-	retryDelay: 3
+const client1 = new RedisClient({port: 6379, host: 'redis1.example.com'});
+const client2 = new RedisClient({port: 6379, host: 'redis2.example.com'});
+const client3 = new IoRedisClient({port: 6379, host: 'redis3.example.com'});
+
+const redlock = new Redlock(
+    [client1, client2, client3],
+    {
+        driftFactor: 0.01,
+        retryCount: 10,
+        retryDelay: 200,
+        retryJitter: 200
+    }
+);
+
+redlock.on('clientError', (err) => {
+    console.error('A redis error has occurred:', err);
 });
 
-redlock.acquire('resource', 30).then((lock: Lock) => { });
-redlock.acquire('resource', 30, (err: any, lock: Lock) => { });
-redlock.lock('resource', 30).then((lock: Lock) => { });
-redlock.lock('resource', 30, (err: any, lock: Lock) => { });
+redlock.acquire('resource', 30).then((lock: Lock) => {});
+redlock.acquire('resource', 30, (err: any, lock: Lock) => {});
+redlock.lock('resource', 30).then((lock: Lock) => {});
+redlock.lock('resource', 30, (err: any, lock: Lock) => {});
 
-// There is currently no way to test the disposer as the bluebird typings does not
-//	expose the .using method.
-// promise.using(redlock.disposer('resource', 30), (lock: Lock) => {});
+using<Lock, void>(redlock.disposer('locks:account:322456', 1000, err => console.error(err)), (lock) => {
+    return Promise.resolve();
+});
+using<Lock, void>(redlock.disposer('locks:account:322456', 1000, err => console.error(err)), (lock) => {
+    return lock.extend(1000).then((extended: Lock) => {});
+});
 
 redlock.release(lock);
-redlock.release(lock, (err: any) => { });
+redlock.release(lock, (err: any) => {});
 redlock.unlock(lock);
-redlock.unlock(lock, (err: any) => { });
+redlock.unlock(lock, (err: any) => {});
 
-redlock.extend(lock, 30).then((lock: Lock) => { });
-redlock.extend(lock, 30, (err: any, lock: Lock) => { });
+redlock.extend(lock, 30).then((lock: Lock) => {});
+redlock.extend(lock, 30, (err: any, lock: Lock) => {});
 
 lock.unlock();
-lock.unlock((err) => { });
+lock.unlock((err) => {});
 
-lock.extend(30).then((lock: Lock) => { });
-lock.extend(30, (err: any, lock: Lock) => { });
+lock.extend(30).then((lock: Lock) => {});
+lock.extend(30, (err: any, lock: Lock) => {});
+
+redlock.lock('locks:account:322456', 1000).then((lock) => {
+    return lock
+        .unlock()
+        .catch((err) => {
+            console.error(err);
+        });
+});
+
+redlock.lock('locks:account:322456', 1000).then(lock => {
+    return lock
+        .extend(1000)
+        .then(lock => {
+            return lock
+                .unlock()
+                .catch(err => {
+                    console.error(err);
+                });
+        });
+});
+
+redlock.lock('locks:account:322456', 1000, (err, lock) => {
+    if (err || !lock) {
+    } else {
+        lock.unlock(err => {
+            console.error(err);
+        });
+    }
+});
+
+redlock.lock('locks:account:322456', 1000, (err, lock) => {
+    if (err || !lock) {
+    } else {
+        lock.extend(1000, (err, lock) => {
+            if (err || !lock) {
+            } else {
+                lock.unlock();
+            }
+        });
+    }
+});
+
+new Error() instanceof redlock.LockError;
+
+redlock.LockError.prototype;
+const lockError: Redlock.LockError = new redlock.LockError();

types/redlock/tsconfig.json

@@ -6,7 +6,7 @@
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
-        "strictNullChecks": false,
+        "strictNullChecks": true,
         "baseUrl": "../",
         "typeRoots": [
             "../"
@@ -19,4 +19,4 @@
         "index.d.ts",
         "redlock-tests.ts"
     ]
-}
+}

types/redlock/tslint.json

@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }

types/redlock/v2/index.d.ts

@@ -0,0 +1,64 @@
+// Type definitions for redlock 2.x
+// Project: https://github.com/mike-marcacci/node-redlock
+// Definitions by: Ilya Mochalov <https://github.com/chrootsu>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+import * as redis from 'redis';
+import * as Promise from 'bluebird';
+
+export = Redlock;
+
+declare namespace Redlock {
+    type Callback<T> = (err: any, value?: T) => void;
+
+    interface Lock {
+        redlock: Redlock;
+        resource: string;
+        value: any;
+        expiration: number;
+
+        unlock(callback?: Callback<void>): Promise<void>;
+
+        extend(ttl: number, callback?: Callback<Lock>): Promise<Lock>;
+    }
+
+    interface Options {
+        driftFactor?: number;
+        retryCount?: number;
+        retryDelay?: number;
+    }
+
+    interface LockErrorConstructor {
+        new(message?: string): LockError;
+        (message?: string): LockError;
+        readonly prototype: LockError;
+    }
+
+    interface LockError extends Error {
+        readonly name: 'LockError';
+    }
+}
+
+declare class Redlock {
+    LockError: Redlock.LockErrorConstructor;
+
+    driftFactor: number;
+    retryCount: number;
+    retryDelay: number;
+
+    servers: redis.RedisClient[];
+
+    constructor(clients: any[], options?: Redlock.Options);
+
+    acquire(resource: string, ttl: number, callback?: Redlock.Callback<Redlock.Lock>): Promise<Redlock.Lock>;
+    lock(resource: string, ttl: number, callback?: Redlock.Callback<Redlock.Lock>): Promise<Redlock.Lock>;
+
+    disposer(resource: string, ttl: number, errorHandler?: Redlock.Callback<void>): any; // bluebird Disposer
+
+    release(lock: Redlock.Lock, callback?: Redlock.Callback<void>): Promise<void>;
+    unlock(lock: Redlock.Lock, callback?: Redlock.Callback<void>): Promise<void>;
+
+    extend(lock: Redlock.Lock, ttl: number, callback?: Redlock.Callback<Redlock.Lock>): Promise<Redlock.Lock>;
+    _lock(resource: string, value: string, ttl: number, callback?: Redlock.Callback<Redlock.Lock>): Promise<Redlock.Lock>;
+}

types/redlock/v2/redlock-tests.ts

@@ -0,0 +1,37 @@
+import * as Redlock from 'redlock';
+import { Lock } from 'redlock';
+import { RedisClient } from 'redis';
+
+let redlock: Redlock;
+let client: RedisClient = <RedisClient> {};
+let lock: Lock = <Lock> {};
+
+redlock = new Redlock([client]);
+redlock = new Redlock([client], {
+    driftFactor: 0.1,
+    retryCount: 2,
+    retryDelay: 3
+});
+
+redlock.acquire('resource', 30).then((lock: Lock) => {});
+redlock.acquire('resource', 30, (err: any, lock: Lock) => {});
+redlock.lock('resource', 30).then((lock: Lock) => {});
+redlock.lock('resource', 30, (err: any, lock: Lock) => {});
+
+// There is currently no way to test the disposer as the bluebird typings does not
+// expose the .using method.
+// promise.using(redlock.disposer('resource', 30), (lock: Lock) => {});
+
+redlock.release(lock);
+redlock.release(lock, (err: any) => {});
+redlock.unlock(lock);
+redlock.unlock(lock, (err: any) => {});
+
+redlock.extend(lock, 30).then((lock: Lock) => {});
+redlock.extend(lock, 30, (err: any, lock: Lock) => {});
+
+lock.unlock();
+lock.unlock((err) => {});
+
+lock.extend(30).then((lock: Lock) => {});
+lock.extend(30, (err: any, lock: Lock) => {});

types/redlock/v2/tsconfig.json

@@ -0,0 +1,25 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../../",
+        "typeRoots": [
+            "../../"
+        ],
+        "paths": {
+            "redlock": [ "redlock/v2" ]
+        },
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "redlock-tests.ts"
+    ]
+}

types/redlock/v2/tslint.json

@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }