@domain.js/main 1.0.0-arpha.7 → 1.0.0

package/dist/defaults.d.ts

@@ -1,7 +1,7 @@
 import * as ajv from "ajv";
 import * as ajvFormats from "ajv-formats";
 import ajvKeywords from "ajv-keywords";
-import * as cronParser from "cron-parser";
+import { CronExpressionParser } from "cron-parser";
 import humanInterval from "human-interval";
 import IORedis from "ioredis";
 import LRU from "lru-cache";
@@ -27,7 +27,7 @@ export interface Defaults {
      * It includes support for timezones and DST transitions.
      * @link https://www.npmjs.com/package/cron-parser
      */
-    cronParser: typeof cronParser;
+    cronParser: typeof CronExpressionParser;
     /**
      * Human-readable interval parser for Javascript.
      * @link https://www.npmjs.com/package/human-interval

package/dist/defaults.js

@@ -40,7 +40,7 @@ exports.defaults = void 0;
 const ajv = __importStar(require("ajv"));
 const ajvFormats = __importStar(require("ajv-formats"));
 const ajv_keywords_1 = __importDefault(require("ajv-keywords"));
-const cronParser = __importStar(require("cron-parser"));
+const cron_parser_1 = require("cron-parser");
 const human_interval_1 = __importDefault(require("human-interval"));
 const ioredis_1 = __importDefault(require("ioredis"));
 const lru_cache_1 = __importDefault(require("lru-cache"));
@@ -52,7 +52,7 @@ exports.defaults = {
     ajv,
     ajvFormats,
     ajvKeywords: ajv_keywords_1.default,
-    cronParser,
+    cronParser: cron_parser_1.CronExpressionParser,
     humanInterval: human_interval_1.default,
     IORedis: ioredis_1.default,
     LRU: lru_cache_1.default,

package/dist/deps/aes/index.js

@@ -1,81 +1,68 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Main = Main;
-const crypto = __importStar(require("crypto"));
+const node_crypto_1 = require("node:crypto");
+const OPENSSL_MAGIC = Buffer.from("Salted__", "ascii");
+const SALT_LEN = 8;
+const KEY_LEN = 32;
+const IV_LEN = 16;
+/**
+ * EVP_BytesToKey compatible with OpenSSL / crypto-js:
+ * MD5, one iteration, D_i = MD5(D_{i-1} || password || salt); key then iv.
+ */
+function evpBytesToKey(password, salt) {
+    let keyLen = KEY_LEN;
+    let ivLen = IV_LEN;
+    const key = Buffer.alloc(KEY_LEN);
+    const iv = Buffer.alloc(IV_LEN);
+    let block = Buffer.alloc(0);
+    while (keyLen > 0 || ivLen > 0) {
+        const h = (0, node_crypto_1.createHash)("md5");
+        h.update(block);
+        h.update(password);
+        h.update(salt);
+        block = h.digest();
+        let used = 0;
+        if (keyLen > 0) {
+            const toCopy = Math.min(keyLen, block.length);
+            block.copy(key, KEY_LEN - keyLen, 0, toCopy);
+            used = toCopy;
+            keyLen -= toCopy;
+        }
+        if (used < block.length && ivLen > 0) {
+            const toCopy = Math.min(ivLen, block.length - used);
+            block.copy(iv, IV_LEN - ivLen, used, used + toCopy);
+            ivLen -= toCopy;
+        }
+    }
+    return { key, iv };
+}
 function Main() {
-    // aes-256-cbc encrypt
+    // aes-256-cbc encrypt (OpenSSL / crypto-js compatible: Salted__ + salt + ciphertext, base64)
     const encrypt = (message, key) => {
-        // 生成随机 IV
-        const iv = crypto.randomBytes(16);
-        // 使用 PBKDF2 从密钥生成固定长度的密钥
-        const derivedKey = crypto.pbkdf2Sync(key, "salt", 1000, 32, "sha256");
-        // 创建加密器
-        const cipher = crypto.createCipheriv("aes-256-cbc", derivedKey, iv);
-        cipher.setAutoPadding(true);
-        // 加密
-        let encrypted = cipher.update(message, "utf8", "hex");
-        encrypted += cipher.final("hex");
-        // 返回 IV + 加密数据的组合
-        const result = iv.toString("hex") + ":" + encrypted;
-        return result;
+        const salt = (0, node_crypto_1.randomBytes)(SALT_LEN);
+        const pass = Buffer.from(key, "utf8");
+        const { key: keyBuf, iv } = evpBytesToKey(pass, salt);
+        const cipher = (0, node_crypto_1.createCipheriv)("aes-256-cbc", keyBuf, iv);
+        const ciphertext = Buffer.concat([cipher.update(message, "utf8"), cipher.final()]);
+        return Buffer.concat([OPENSSL_MAGIC, salt, ciphertext]).toString("base64");
     };
     // aes-256-cbc decrypt
     const decrypt = (message, key) => {
-        try {
-            // 分离 IV 和加密数据
-            const parts = message.split(":");
-            if (parts.length !== 2) {
-                throw new Error("Invalid encrypted message format");
-            }
-            const iv = Buffer.from(parts[0], "hex");
-            const encrypted = parts[1];
-            // 使用相同的 PBKDF2 生成密钥
-            const derivedKey = crypto.pbkdf2Sync(key, "salt", 1000, 32, "sha256");
-            // 创建解密器
-            const decipher = crypto.createDecipheriv("aes-256-cbc", derivedKey, iv);
-            decipher.setAutoPadding(true);
-            // 解密
-            let decrypted = decipher.update(encrypted, "hex", "utf8");
-            decrypted += decipher.final("utf8");
-            return decrypted;
+        const raw = Buffer.from(message, "base64");
+        if (raw.length < OPENSSL_MAGIC.length + SALT_LEN) {
+            throw new Error("Invalid ciphertext: too short");
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "Unknown error";
-            throw new Error("Decryption failed: " + errorMessage);
+        const magic = raw.subarray(0, OPENSSL_MAGIC.length);
+        if (!magic.equals(OPENSSL_MAGIC)) {
+            throw new Error("Invalid ciphertext: missing OpenSSL Salted__ prefix");
         }
+        const salt = raw.subarray(OPENSSL_MAGIC.length, OPENSSL_MAGIC.length + SALT_LEN);
+        const ciphertext = raw.subarray(OPENSSL_MAGIC.length + SALT_LEN);
+        const pass = Buffer.from(key, "utf8");
+        const { key: keyBuf, iv } = evpBytesToKey(pass, salt);
+        const decipher = (0, node_crypto_1.createDecipheriv)("aes-256-cbc", keyBuf, iv);
+        return decipher.update(ciphertext).toString("utf8") + decipher.final("utf8");
     };
     return Object.freeze({
         encrypt,

package/dist/deps/cache/index.d.ts

@@ -16,6 +16,10 @@ export interface DepsDef {
 }
 export interface Cache extends LRUCache<{}, {}, unknown> {
     caching: <T extends (...args: any[]) => Promise<any>>(func: T, life: number, getKey: (...args: Parameters<T>) => string, hit?: (hited: boolean) => void) => T;
+    /**
+     * @deprecated use delete instead of del
+     */
+    del: (key: string) => boolean;
     hitCount: () => {
         hits: number;
         misseds: number;

package/dist/deps/cache/index.js

@@ -62,6 +62,7 @@ function Main(cnf, deps) {
         });
     }
     const cache = Object.assign(lru, {
+        del: lru.delete.bind(lru),
         caching,
         hitCount,
         needToBroad: Boolean(cnf.cache.isMulti),

package/dist/deps/defines.d.ts

@@ -9,6 +9,7 @@ import * as logger from "./logger";
 import * as myCia from "./myCia";
 import * as parallel from "./parallel";
 import * as redis from "./redis";
+import * as request from "./request";
 import * as rest from "./rest";
 import * as schema from "./schema";
 import * as sequelize from "./sequelize";
@@ -25,6 +26,7 @@ declare const _default: {
     myCia: typeof myCia;
     parallel: typeof parallel;
     redis: typeof redis;
+    request: typeof request;
     rest: typeof rest;
     schema: typeof schema;
     sequelize: typeof sequelize;

package/dist/deps/defines.js

@@ -44,6 +44,7 @@ const logger = __importStar(require("./logger"));
 const myCia = __importStar(require("./myCia"));
 const parallel = __importStar(require("./parallel"));
 const redis = __importStar(require("./redis"));
+const request = __importStar(require("./request"));
 const rest = __importStar(require("./rest"));
 const schema = __importStar(require("./schema"));
 const sequelize = __importStar(require("./sequelize"));
@@ -60,6 +61,7 @@ module.exports = {
     myCia: myCia,
     parallel: parallel,
     redis: redis,
+    request: request,
     rest: rest,
     schema: schema,
     sequelize: sequelize,

package/dist/deps/request/index.d.ts

@@ -0,0 +1,34 @@
+import axios, { AxiosInstance } from "axios";
+import { Main as Logger } from "../logger";
+interface Cnf {
+    /** axios config */
+    axios?: {
+        /** auto record log methods list */
+        loggers?: string[];
+        /** auto retry methods list */
+        retrys?: string[];
+        /** retry max times */
+        retryTimes?: number;
+        /** retry interval millisecond */
+        retryIntervalMS?: number;
+        /** axios.create the first argument */
+        conf?: Parameters<typeof axios.create>[0];
+    };
+}
+interface Deps {
+    logger: ReturnType<typeof Logger>;
+}
+/**
+ * axios module
+ * @link https://www.npmjs.com/package/axios
+ *
+ * @param cnf module initialize config
+ * @param deps module initalize dependents
+ * @returns returns of axios.create
+ */
+export declare function Main(cnf: Cnf, deps: Deps): AxiosInstance & {
+    /** Original Axios module */
+    origin?: typeof axios;
+};
+export declare const Deps: string[];
+export {};

package/dist/deps/request/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deps = void 0;
+exports.Main = Main;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("../../utils");
+/**
+ * axios module
+ * @link https://www.npmjs.com/package/axios
+ *
+ * @param cnf module initialize config
+ * @param deps module initalize dependents
+ * @returns returns of axios.create
+ */
+function Main(cnf, deps) {
+    const axiosError = (e) => (() => {
+        if (!e.response)
+            return ["no-response", e.message];
+        const r = e.response;
+        if (!r.data)
+            return [r.status, r.statusText];
+        const d = r.data;
+        if (typeof d === "string")
+            return [r.status, d];
+        return [d.code || r.status, d.message || JSON.stringify(d)];
+    })().join("\t");
+    if (!cnf.axios)
+        cnf.axios = {};
+    const { loggers, retrys, retryTimes = 3, retryIntervalMS = 3000, conf } = cnf.axios;
+    const { logger } = deps;
+    const retryAble = (fn, times, interval) => {
+        const exec = async (args, no) => {
+            try {
+                const res = await fn(...args);
+                return res;
+            }
+            catch (e) {
+                if (e.code === "ETIMEDOUT") {
+                    if (interval)
+                        await (0, utils_1.sleep)(interval);
+                    if (times <= no)
+                        throw e;
+                    return exec(args, no + 1);
+                }
+                throw e;
+            }
+        };
+        return ((...args) => exec(args, 1));
+    };
+    const instance = axios_1.default.create(conf);
+    instance.origin = axios_1.default;
+    if (loggers) {
+        for (const x of loggers) {
+            if (typeof instance[x] !== "function")
+                continue;
+            const method = logger.logger(instance[x], `axios.${x}`, true, (res) => res.data, axiosError);
+            instance[x] = method;
+        }
+    }
+    if (retrys) {
+        for (const x of retrys) {
+            if (typeof instance[x] !== "function")
+                continue;
+            instance[x] = retryAble(instance[x], retryTimes, retryIntervalMS);
+        }
+    }
+    return instance;
+}
+exports.Deps = ["logger"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domain.js/main",
-  "version": "1.0.0-arpha.7",
+  "version": "1.0.0",
   "description": "DDD framework",
   "main": "dist/index.js",
   "bin": {
@@ -16,9 +16,20 @@
   },
   "author": "Redstone Zhao",
   "license": "MIT",
+  "prettier": {
+    "printWidth": 100,
+    "trailingComma": "all"
+  },
+  "lint-staged": {
+    "src/**/*.{js,ts}": [
+      "prettier --write",
+      "eslint --fix"
+    ]
+  },
   "devDependencies": {
     "@babel/eslint-parser": "^7.28.6",
     "@eslint/js": "^10.0.1",
+    "@fastify/multipart": "^9.4.0",
     "@types/async": "^3.2.25",
     "@types/jest": "^30.0.0",
     "@types/lodash": "^4.17.24",
@@ -27,6 +38,8 @@
     "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^8.56.0",
     "@typescript-eslint/parser": "^8.56.0",
+    "async": "^3.2.6",
+    "axios": "^1.13.5",
     "eslint": "^10.0.1",
     "eslint-config-airbnb": "^19.0.4",
     "eslint-config-alloy": "^5.1.2",
@@ -37,42 +50,41 @@
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "eslint-plugin-unused-imports": "^4.4.1",
+    "fastify": "^5.7.4",
     "husky": "^9.1.7",
+    "ioredis": "^5.9.3",
     "jest": "^30.2.0",
     "lint-staged": "^16.2.7",
+    "lodash": "^4.17.23",
+    "mysql2": "^3.17.4",
     "prettier": "^3.8.1",
+    "sequelize": "^6.37.5",
+    "socket.io": "^4.8.3",
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   },
-  "prettier": {
-    "printWidth": 100,
-    "trailingComma": "all"
-  },
-  "lint-staged": {
-    "src/**/*.{js,ts}": [
-      "prettier --write",
-      "eslint --fix"
-    ]
-  },
   "dependencies": {
-    "@fastify/multipart": "^9.4.0",
     "ajv": "^8.18.0",
     "ajv-formats": "^3.0.1",
     "ajv-keywords": "^5.1.0",
-    "async": "^3.2.6",
     "cron-parser": "^5.5.0",
     "csv-stringify": "^6.6.0",
     "dayjs": "^1.11.19",
-    "fastify": "^5.7.4",
     "fastify-socket.io": "^5.1.0",
     "human-interval": "^2.0.1",
+    "lru-cache": "^11.2.6",
+    "xlsx": "^0.18.5"
+  },
+  "peerDependencies": {
+    "@fastify/multipart": "^9.4.0",
+    "async": "^3.2.6",
+    "axios": "^1.13.5",
+    "fastify": "^5.7.4",
     "ioredis": "^5.9.3",
     "lodash": "^4.17.23",
-    "lru-cache": "^11.2.6",
     "mysql2": "^3.17.4",
-    "sequelize": "^6.37.7",
-    "socket.io": "^4.8.3",
-    "xlsx": "^0.18.5"
+    "sequelize": "^6.37.5",
+    "socket.io": "^4.8.3"
   }
 }