fib-pool 1.6.0 → 1.6.2

package/.travis.yml

@@ -26,6 +26,15 @@ matrix:
     - os: linux
       env:
         - VERSION=0.27.0
+    - os: linux
+      env:
+        - VERSION=0.28.0
+    - os: linux
+      env:
+        - VERSION=0.29.0
+    - os: linux
+      env:
+        - VERSION=0.30.0
     - os: osx
       osx_image: xcode9
       env:
@@ -58,6 +67,18 @@ matrix:
       osx_image: xcode9
       env:
         - VERSION=0.27.0
+    - os: osx
+      osx_image: xcode9
+      env:
+        - VERSION=0.28.0
+    - os: osx
+      osx_image: xcode9
+      env:
+        - VERSION=0.29.0
+    - os: osx
+      osx_image: xcode9
+      env:
+        - VERSION=0.30.0
 before_install:
   - OS=linux
   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then

package/{README.md → Readme.md}

@@ -103,6 +103,45 @@ var res = p("test", (conn) => {
 
 ```
 
+## Strict mode (default: enabled)
+
+By default, the pool uses strict mode to prevent accessing pooled objects outside of the callback function. This helps prevent resource leaks and ensures proper resource management.
+
+```js
+var Pool = require("fib-pool");
+
+var p = Pool({
+    create: () => {
+        return { value: 1, getValue: function() { return this.value; } };
+    }
+});
+
+var leaked;
+p((obj) => {
+    leaked = obj;
+    // This works inside the pool callback
+    console.log(obj.getValue()); // OK
+});
+
+// This will throw an error: "access object outside of pool scope"
+leaked.getValue(); // Error!
+```
+
+When strict mode is enabled, it also prevents:
+- Setting properties on pooled objects
+- Calling `close()`, `destroy()`, or `dispose()` methods directly
+
+To disable strict mode:
+
+```js
+var p = Pool({
+    create: () => {
+        return { value: 1 };
+    },
+    strict: false
+});
+```
+
 ## Clear a pool
 
 Simple example.

package/appveyor.yml

@@ -9,6 +9,9 @@ environment:
     - VERSION: 0.26.0
     - VERSION: 0.26.1
     - VERSION: 0.27.0
+    - VERSION: 0.28.0
+    - VERSION: 0.29.0
+    - VERSION: 0.30.0
 
 install:
   - ps: Install-Product node $env:nodejs_version

package/lib/index.js

@@ -1,3 +1,4 @@
+"use strict";
 const coroutine = require("coroutine");
 const util = require("util");
 function ensureError(e) {
@@ -5,7 +6,7 @@ function ensureError(e) {
         e = new Error(e);
     return e;
 }
-const GetPool = function (_opt, maxsize, timeout) {
+module.exports = function GetPool(_opt, maxsize, timeout) {
     let opt = _opt;
     if (util.isFunction(_opt)) {
         opt = {
@@ -160,4 +161,3 @@ const GetPool = function (_opt, maxsize, timeout) {
     };
     return pool;
 };
-module.exports = GetPool;

package/package.json

@@ -1,9 +1,10 @@
 {
     "name": "fib-pool",
-    "version": "1.6.0",
+    "version": "1.6.2",
     "description": "Generic resource pooling for fibjs",
-    "main": "./lib",
-    "types": "@types/index.d.ts",
+    "main": "./src",
+    "types": "typings/index.d.ts",
+    "type": "module",
     "repository": "git://github.com/fibjs/fib-pool.git",
     "author": "Liu Hu <lion@9465.net>",
     "contributors": [
@@ -20,15 +21,15 @@
         "fibjs"
     ],
     "scripts": {
-        "build": "fib-typify src -o lib",
         "test": "fibjs test",
-        "ci": "npm run build && npm run test",
-        "prepublishOnly": "npm run build"
+        "typecheck": "tsc --noEmit",
+        "ci": "npm run typecheck && npm run test"
     },
     "devDependencies": {
         "@fibjs/ci": "^2.3.0",
         "@fibjs/types": "^0.27.1",
-        "fib-typify": "^0.6.0"
+        "fib-typify": "^0.8.4",
+        "typescript": "^5.9.3"
     },
     "ci": {
         "type": "travis, appveyor",
@@ -40,7 +41,10 @@
             "0.25.0",
             "0.26.0",
             "0.26.1",
-            "0.27.0"
+            "0.27.0",
+            "0.28.0",
+            "0.29.0",
+            "0.30.0"
         ]
     }
 }

package/src/index.ts

@@ -0,0 +1,287 @@
+import * as coroutine from 'coroutine';
+import * as util from 'util';
+
+declare namespace FibPoolNS {
+    type FirstParameter<T> = T extends (arg: infer T, ...args: any[]) => any ? T : never; 
+
+    interface DippedItemStruct {
+        close?: FibPoolOptionResult['destroy'];
+        destroy?: FibPoolOptionResult['destroy'];
+        dispose?: FibPoolOptionResult['destroy'];
+    }
+
+    interface FibPoolOptionArgs<T extends DippedItemStruct = {}> {
+        create: (name: string) => T
+        destroy?: (item?: T) => any;
+        maxsize?: number
+        timeout?: number
+        retry?: number | boolean
+        strict?: boolean
+    }
+    interface FibPoolOptionResult<T extends DippedItemStruct = {}> {
+        create: FibPoolOptionArgs<T>['create']
+        destroy: FibPoolOptionArgs<T>['destroy']
+        maxsize: FibPoolOptionArgs<T>['maxsize']
+        timeout: FibPoolOptionArgs<T>['timeout']
+        retry: FibPoolOptionArgs<T>['retry']
+        strict: FibPoolOptionArgs<T>['strict']
+    }
+
+    interface FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> {
+        (o: T_CREATED_ITEM): T_POOL_FUNC_RETURN
+    }
+
+    type FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> = {
+        <T_RETURN = T_POOL_FUNC_RETURN>(name: string, func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN
+        <T_RETURN = T_POOL_FUNC_RETURN>(func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN
+    } & {
+        connections?(): number;
+        info?(): {
+            maxsize: number;
+            count: number;
+            running: number;
+            wait: number;
+            timeout: number;
+        }; 
+        clear?(): void;
+    }
+}
+
+function ensureError (e: string | Error) {
+    if (typeof e === 'string')
+        e = new Error(e)
+   
+   return e
+}
+
+export default function GetPool<
+    T_CREATED_ITEM extends FibPoolNS.DippedItemStruct,
+    T_POOL_FUNC_RETURN
+> (
+    _opt: FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM> | FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM>['create'],
+    maxsize?: number,
+    timeout?: number
+): FibPoolNS.FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN> {
+    /* clean input arguments :start */
+    let opt = <FibPoolNS.FibPoolOptionResult<T_CREATED_ITEM>>_opt;
+    if (util.isFunction(_opt)) {
+        opt = <FibPoolNS.FibPoolOptionResult<T_CREATED_ITEM>>{
+            create: _opt,
+            maxsize: maxsize,
+            timeout: timeout
+        };
+    }
+
+    const create = opt.create;
+    const destroy = opt.destroy || ((o: {
+        close?: FibPoolNS.FibPoolOptionResult<T_CREATED_ITEM>['destroy'];
+        destroy?: FibPoolNS.FibPoolOptionResult<T_CREATED_ITEM>['destroy'];
+        dispose?: FibPoolNS.FibPoolOptionResult<T_CREATED_ITEM>['destroy'];
+    }) => {
+        if (util.isFunction(o.close)) o.close();
+        if (util.isFunction(o.destroy)) o.destroy();
+        if (util.isFunction(o.dispose)) o.dispose();
+    });
+
+    maxsize = opt.maxsize || 10;
+    timeout = opt.timeout || 60000;
+    let tm = timeout / 10;
+    if (tm < 10)
+        tm = 10;
+
+    const retry = opt.retry || 1;
+    const _strict = opt.strict === undefined ? true : opt.strict;
+    /* clean input arguments :end */
+
+    let pools = <{
+        o: T_CREATED_ITEM;
+        name: string;
+        time: Date;
+    }[]>[];
+
+    const jobs = <{
+        name: string;
+        ev: Class_Event;
+        o?: T_CREATED_ITEM;
+        e?: Error;
+    }[]>[];
+
+    let count = 0;
+    let running = 0;
+
+    const sem = new coroutine.Semaphore(maxsize);
+    let clearTimer: Class_Timer;
+
+    function clearPool() {
+        let c: typeof pools[any];
+        const d = new Date().getTime();
+
+        while (count) {
+            c = pools[0];
+
+            if (d - c.time.getTime() > timeout) {
+                pools = pools.slice(1);
+                count--;
+
+                if (c.o !== undefined)
+                    coroutine.start(destroy, c.o);
+            } else
+                break;
+        }
+
+        if (!count) {
+            if (clearTimer) {
+                clearTimer.clear();
+                clearTimer = null;
+            }
+        } else if (!clearTimer) {
+            clearTimer = setInterval(clearPool, tm);
+            if (clearTimer && typeof clearTimer.unref === 'function')
+                clearTimer.unref();
+        }
+    }
+
+    function putback(
+        name: typeof jobs[any]['name'],
+        o: T_CREATED_ITEM,
+        e?: Error
+    ) {
+        e = ensureError(e);
+        for (let i = 0; i < jobs.length; i++) {
+            const job = jobs[i];
+            if (job.name === name) {
+                jobs.splice(i, 1);
+                job.o = o;
+                job.e = e;
+                job.ev.set();
+                return;
+            }
+        }
+
+        if (e === undefined)
+            pools[count++] = {
+                o: o,
+                name: name,
+                time: new Date()
+            };
+    }
+
+    function connect(name: string) {
+        let o: T_CREATED_ITEM;
+        let cn = 0;
+        let err: Error;
+
+        while (true) {
+            try {
+                o = create(name);
+                break;
+            } catch (e) {
+                if (++cn >= (retry as number)) {
+                    err = e;
+                    break;
+                }
+            }
+        }
+
+        putback(name, o, err);
+    }
+
+    const pool: FibPoolNS.FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN> = (
+        name: string | FibPoolNS.FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN>,
+        func?: FibPoolNS.FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN>
+    ) => {
+        if (typeof name === 'function') {
+            func = name as any;
+            name = "";
+        }  
+
+        let r: T_POOL_FUNC_RETURN;
+        let o: typeof jobs[any]['o'];
+        let p = false;
+
+        clearPool();
+        sem.acquire();
+
+        if (count) {
+            for (let i = count - 1; i >= 0; i--)
+                if (pools[i].name === name) {
+                    p = true
+                    o = pools[i].o;
+                    pools.splice(i, 1);
+                    count--;
+                    break;
+                }
+        }
+
+        if (!p) {
+            coroutine.start(connect, name);
+
+            const job = <typeof jobs[any]>{
+                name: name,
+                ev: new coroutine.Event()
+            };
+            jobs.push(job);
+
+            job.ev.wait();
+            if (job.e) {
+                sem.post();
+                throw ensureError(job.e);
+            }
+            o = job.o;
+        }
+
+        running++;
+        try {
+            const po = (_strict && typeof o === 'object') ? new Proxy({}, {
+                get: function (target, prop) {
+                    if (prop === 'close' || prop === 'destroy' || prop === 'dispose')
+                        throw new Error("Cannot close/destroy/dispose");
+                    if (o === undefined)
+                        throw new Error("access object outside of pool scope");
+                    const value = o[prop];
+                    if (typeof value === 'function') {
+                        return function () {
+                            return value.apply(o, arguments);
+                        }
+                    }
+                    return value;
+                },
+                set: function (target, prop, value) {
+                    throw new Error("Cannot set property");
+                }
+            }) as any : o;
+
+            r = func(po as T_CREATED_ITEM);
+            putback(name, o);
+            o = undefined;
+        } catch (e) {
+            if (o !== undefined)
+                coroutine.start(destroy, o);
+            o = undefined;
+            throw ensureError(e);
+        } finally {
+            running--;
+            sem.post();
+            clearPool();
+        }
+
+        return r;
+    };
+
+    pool.connections = () => count
+
+    pool.info = () => ({
+        maxsize: maxsize,
+        count: count,
+        running: running,
+        wait: sem.count(),
+        timeout: timeout
+    })
+
+    pool.clear = () => {
+        timeout = -1;
+        clearPool();
+    }
+
+    return pool;
+}

package/tsconfig.json

@@ -4,9 +4,14 @@
         "module": "commonjs",
         "alwaysStrict": false,
         "removeComments": true,
-        "typeRoots": [
-            "node_modules",
-            "types"
+        "noEmit": true,
+        "types": [
+            "@fibjs/types"
         ]
-    }
+    },
+    "exclude": [
+        "test",
+        "typings",
+        "node_modules"
+    ]
 }

package/typings/index.d.ts

@@ -0,0 +1,43 @@
+declare namespace FibPoolNS {
+    type FirstParameter<T> = T extends (arg: infer T, ...args: any[]) => any ? T : never;
+    interface DippedItemStruct {
+        close?: FibPoolOptionResult['destroy'];
+        destroy?: FibPoolOptionResult['destroy'];
+        dispose?: FibPoolOptionResult['destroy'];
+    }
+    interface FibPoolOptionArgs<T extends DippedItemStruct = {}> {
+        create: (name: string) => T;
+        destroy?: (item?: T) => any;
+        maxsize?: number;
+        timeout?: number;
+        retry?: number | boolean;
+        strict?: boolean;
+    }
+    interface FibPoolOptionResult<T extends DippedItemStruct = {}> {
+        create: FibPoolOptionArgs<T>['create'];
+        destroy: FibPoolOptionArgs<T>['destroy'];
+        maxsize: FibPoolOptionArgs<T>['maxsize'];
+        timeout: FibPoolOptionArgs<T>['timeout'];
+        retry: FibPoolOptionArgs<T>['retry'];
+        strict: FibPoolOptionArgs<T>['strict'];
+    }
+    interface FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> {
+        (o: T_CREATED_ITEM): T_POOL_FUNC_RETURN;
+    }
+    type FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> = {
+        <T_RETURN = T_POOL_FUNC_RETURN>(name: string, func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN;
+        <T_RETURN = T_POOL_FUNC_RETURN>(func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN;
+    } & {
+        connections?(): number;
+        info?(): {
+            maxsize: number;
+            count: number;
+            running: number;
+            wait: number;
+            timeout: number;
+        };
+        clear?(): void;
+    };
+}
+declare const _default: <T_CREATED_ITEM extends FibPoolNS.DippedItemStruct, T_POOL_FUNC_RETURN>(_opt: FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM> | ((name: string) => T_CREATED_ITEM), maxsize?: number, timeout?: number) => FibPoolNS.FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN>;
+export = _default;

package/@types/index.d.ts

@@ -1,3 +0,0 @@
-/// <reference path="type.d.ts" />
-
-export = FibPoolNS.FibPoolGenerator

package/@types/type.d.ts

@@ -1,58 +0,0 @@
-/// <reference types="@fibjs/types" />
-
-declare namespace FibPoolNS {
-    type FirstParameter<T> = T extends (arg: infer T, ...args: any[]) => any ? T : never; 
-
-    interface DippedItemStruct {
-        close?: FibPoolOptionResult['destroy'];
-        destroy?: FibPoolOptionResult['destroy'];
-        dispose?: FibPoolOptionResult['destroy'];
-    }
-
-    interface FibPoolOptionArgs<T extends DippedItemStruct = Fibjs.AnyObject> {
-        create: (name: string) => T
-        destroy?: (item?: T) => any;
-        maxsize?: number
-        timeout?: number
-        retry?: number | boolean
-    }
-    interface FibPoolOptionResult<T extends DippedItemStruct = Fibjs.AnyObject> {
-        create: FibPoolOptionArgs<T>['create']
-        destroy: FibPoolOptionArgs<T>['destroy']
-        maxsize: FibPoolOptionArgs<T>['maxsize']
-        timeout: FibPoolOptionArgs<T>['timeout']
-        retry: FibPoolOptionArgs<T>['retry']
-    }
-
-    interface FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> {
-        (o: T_CREATED_ITEM): T_POOL_FUNC_RETURN
-    }
-
-    type FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> = {
-        <T_RETURN = T_POOL_FUNC_RETURN>(name: string, func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN
-        <T_RETURN = T_POOL_FUNC_RETURN>(func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN
-    } & {
-        connections?(): number;
-        info?(): {
-            maxsize: number;
-            count: number;
-            running: number;
-            wait: number;
-            timeout: number;
-        }; 
-        clear?(): void;
-    }
-
-    function FibPoolGenerator<
-        T_CREATED_ITEM extends DippedItemStruct = Fibjs.AnyObject,
-        T_POOL_FUNC_RETURN = any
-    > (
-        opt: FibPoolOptionArgs<T_CREATED_ITEM> | FibPoolOptionArgs<T_CREATED_ITEM>['create'],
-        maxsize?: number,
-        timeout?: number
-    ): FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN>;
-}
-
-declare module "fib-pool" {
-    export = FibPoolNS.FibPoolGenerator
-}