@wener/common 1.0.5 → 2.0.1

package/lib/password/Password.test.js

@@ -0,0 +1,362 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    }
+    catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    }
+    else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function () {
+        var self = this, args = arguments;
+        return new Promise(function (resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _object_without_properties(source, excluded) {
+    if (source == null)
+        return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for (i = 0; i < sourceSymbolKeys.length; i++) {
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0)
+                continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key))
+                continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null)
+        return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for (i = 0; i < sourceKeys.length; i++) {
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0)
+            continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function () {
+            if (t[0] & 1)
+                throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+        return this;
+    }), g;
+    function verb(n) {
+        return function (v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f)
+            throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _)
+            try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                    return t;
+                if (y = 0, t)
+                    op = [
+                        op[0] & 2,
+                        t.value
+                    ];
+                switch (op[0]) {
+                    case 0:
+                    case 1:
+                        t = op;
+                        break;
+                    case 4:
+                        _.label++;
+                        return {
+                            value: op[1],
+                            done: false
+                        };
+                    case 5:
+                        _.label++;
+                        y = op[1];
+                        op = [
+                            0
+                        ];
+                        continue;
+                    case 7:
+                        op = _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                            _ = 0;
+                            continue;
+                        }
+                        if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                            _.label = op[1];
+                            break;
+                        }
+                        if (op[0] === 6 && _.label < t[1]) {
+                            _.label = t[1];
+                            t = op;
+                            break;
+                        }
+                        if (t && _.label < t[2]) {
+                            _.label = t[2];
+                            _.ops.push(op);
+                            break;
+                        }
+                        if (t[2])
+                            _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) {
+                op = [
+                    6,
+                    e
+                ];
+                y = 0;
+            }
+            finally {
+                f = t = 0;
+            }
+        if (op[0] & 5)
+            throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { describe, expect, test } from "vitest";
+import { createArgon2PasswordAlgorithm } from "./createArgon2PasswordAlgorithm.js";
+import { createBase64PasswordAlgorithm } from "./createBase64PasswordAlgorithm.js";
+import { createBcryptPasswordAlgorithm } from "./createBcryptPasswordAlgorithm.js";
+import { Password } from "./Password.js";
+describe("Password", function () {
+    var check = function (_param) {
+        return _async_to_generator(function () {
+            var _param_password, password, rest, out, result;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        _param_password = _param.password, password = _param_password === void 0 ? "1" : _param_password, rest = _object_without_properties(_param, [
+                            "password"
+                        ]);
+                        return [
+                            4,
+                            Password.hash(password, rest)
+                        ];
+                    case 1:
+                        out = _state.sent();
+                        console.log("".concat(rest.algorithm || "default", ": hash ").concat(out));
+                        return [
+                            4,
+                            Password.verify(password, out)
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        expect(result).toBe(true);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    };
+    Password.addAlgorithm(createBcryptPasswordAlgorithm());
+    Password.addAlgorithm(createBase64PasswordAlgorithm());
+    Password.addAlgorithm(createArgon2PasswordAlgorithm({
+        provide: import("argon2")
+    }));
+    // Password.addAlgorithm(createScryptPasswordAlgorithm());
+    test("base", function () {
+        return _async_to_generator(function () {
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        return [
+                            4,
+                            check({})
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            4,
+                            check({
+                                algorithm: "bcrypt"
+                            })
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            4,
+                            check({
+                                algorithm: "base64"
+                            })
+                        ];
+                    case 3:
+                        _state.sent();
+                        // invalid base 64
+                        return [
+                            4,
+                            check({
+                                algorithm: "base64",
+                                password: "\u4F60\u597D"
+                            })
+                        ];
+                    case 4:
+                        _state.sent();
+                        return [
+                            4,
+                            check({
+                                algorithm: "5"
+                            })
+                        ];
+                    case 5:
+                        _state.sent();
+                        return [
+                            4,
+                            check({
+                                algorithm: "6"
+                            })
+                        ];
+                    case 6:
+                        _state.sent();
+                        return [
+                            4,
+                            check({
+                                algorithm: "7"
+                            })
+                        ];
+                    case 7:
+                        _state.sent();
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    test("should verify manual created hash", function () {
+        return _async_to_generator(function () {
+            var tests, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, _step_value_password, password, hash, err;
+            return _ts_generator(this, function (_state) {
+                switch (_state.label) {
+                    case 0:
+                        tests = [
+                            {
+                                hash: "$2y$10$MQ057tMbDG6/lVkGFWrNwOR9kh/5rzbkhBPrwNPTPuZ5wBpGNbWLa"
+                            },
+                            {
+                                hash: "$argon2i$v=19$m=16,t=2,p=1$SDZBU29LRUp0eTJyRDJqZg$76L95nAjG4SjjdoR0YZyFw"
+                            },
+                            {
+                                hash: "$argon2d$v=19$m=16,t=2,p=1$SDZBU29LRUp0eTJyRDJqZg$+cB2R45sauVlfxbGslAmOw"
+                            },
+                            {
+                                hash: "$argon2id$v=19$m=16,t=2,p=1$SDZBU29LRUp0eTJyRDJqZg$iP9HYuSDXgG2lW7KARBuQQ"
+                            }
+                        ];
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            6,
+                            7,
+                            8
+                        ]);
+                        _iterator = tests[Symbol.iterator]();
+                        _state.label = 2;
+                    case 2:
+                        if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done))
+                            return [
+                                3,
+                                5
+                            ];
+                        _step_value = _step.value, _step_value_password = _step_value.password, password = _step_value_password === void 0 ? "1" : _step_value_password, hash = _step_value.hash;
+                        return [
+                            4,
+                            Password.verify(password, hash)
+                        ];
+                    case 3:
+                        expect.apply(void 0, [
+                            _state.sent()
+                        ]).toBe(true);
+                        _state.label = 4;
+                    case 4:
+                        _iteratorNormalCompletion = true;
+                        return [
+                            3,
+                            2
+                        ];
+                    case 5:
+                        return [
+                            3,
+                            8
+                        ];
+                    case 6:
+                        err = _state.sent();
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                        return [
+                            3,
+                            8
+                        ];
+                    case 7:
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        }
+                        finally {
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                        return [
+                            7
+                        ];
+                    case 8:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+});

package/lib/password/createArgon2PasswordAlgorithm.js

@@ -1,30 +1,157 @@
-import { maybeFunction } from "@wener/utils";
-export function createArgon2PasswordAlgorithm({ type, provide = async ()=>{
-    throw new Error('Please provide argon2');
-// const { default: wasm } = await import('argon2-browser/dist/argon2.wasm');
-// const argon2 = await WebAssembly.instantiateStreaming(fetch(wasm), {
-//   env: {
-//     memoryBase: 0,
-//     tableBase: 0,
-//     memory: new WebAssembly.Memory({ initial: 256 }),
-//     table: new WebAssembly.Table({ initial: 0, element: 'anyfunc' }),
-//     __memory_base: 0,
-//     __table_base: 0,
-//   },
-// });
-// console.log(argon2.instance.exports);
-// const { hash } = argon2.instance.exports as any as typeof import('argon2-browser');
-} } = {}) {
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { maybeFunction } from '@wener/utils';
+export function createArgon2PasswordAlgorithm() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, type = _ref.type, _ref_provide = _ref.provide, provide = _ref_provide === void 0 ? function() {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                throw new Error('Please provide argon2');
+            });
+        // const { default: wasm } = await import('argon2-browser/dist/argon2.wasm');
+        // const argon2 = await WebAssembly.instantiateStreaming(fetch(wasm), {
+        //   env: {
+        //     memoryBase: 0,
+        //     tableBase: 0,
+        //     memory: new WebAssembly.Memory({ initial: 256 }),
+        //     table: new WebAssembly.Table({ initial: 0, element: 'anyfunc' }),
+        //     __memory_base: 0,
+        //     __table_base: 0,
+        //   },
+        // });
+        // console.log(argon2.instance.exports);
+        // const { hash } = argon2.instance.exports as any as typeof import('argon2-browser');
+        })();
+    } : _ref_provide;
     // 0=Argon2d, 1=Argon2i, 2=Argon2id
-    const toType = {
+    var toType = {
         argon2d: 0,
         argon2i: 1,
         argon2id: 2
     };
-    let mod;
-    const resolve = ()=>{
+    var mod;
+    var resolve = function() {
         if (mod) return mod;
-        return Promise.resolve(maybeFunction(provide)).then((v)=>mod = v);
+        return Promise.resolve(maybeFunction(provide)).then(function(v) {
+            return mod = v;
+        });
     };
     return {
         name: 'argon2',
@@ -33,21 +160,50 @@ export function createArgon2PasswordAlgorithm({ type, provide = async ()=>{
             'argon2d',
             'argon2id'
         ],
-        async hash (password, opts) {
-            // const { hash } = await import('argon2');
-            const { hash } = await resolve();
-            const id = opts?.id;
-            return hash(password, {
-                salt: opts?.salt ? Buffer.from(opts.salt) : undefined,
-                raw: false,
-                type: toType[id || ''] ?? toType[type || '']
-            });
+        hash: function hash(password, opts) {
+            return _async_to_generator(function() {
+                var hash, id, _toType_;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                resolve()
+                            ];
+                        case 1:
+                            hash = _state.sent().hash;
+                            id = opts === null || opts === void 0 ? void 0 : opts.id;
+                            return [
+                                2,
+                                hash(password, {
+                                    salt: (opts === null || opts === void 0 ? void 0 : opts.salt) ? Buffer.from(opts.salt) : undefined,
+                                    raw: false,
+                                    type: (_toType_ = toType[id || '']) !== null && _toType_ !== void 0 ? _toType_ : toType[type || '']
+                                })
+                            ];
+                    }
+                });
+            })();
         },
-        async verify (password, hash) {
-            const { verify } = await resolve();
-            return verify(hash, password);
+        verify: function verify(password, hash) {
+            return _async_to_generator(function() {
+                var verify;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                resolve()
+                            ];
+                        case 1:
+                            verify = _state.sent().verify;
+                            return [
+                                2,
+                                verify(hash, password)
+                            ];
+                    }
+                });
+            })();
         }
     };
 }
-
-//# sourceMappingURL=createArgon2PasswordAlgorithm.js.map