befly 3.76.0 → 3.76.2

package/libs/mysql/mysql.js

@@ -0,0 +1,43 @@
+import { SQL } from "bun";
+
+import { Logger } from "../logger/index.js";
+import { DbHelper } from "./dbHelper.js";
+import { MysqlError } from "./error.js";
+
+/**
+ * 创建并验证 Bun.SQL MySQL 客户端，返回保持 DbHelper API 的运行时实例。
+ */
+export async function createMysql(options) {
+    const sql = new SQL({
+        adapter: "mysql",
+        hostname: options.hostname,
+        port: options.port,
+        database: options.database,
+        username: options.username,
+        password: options.password,
+        max: options.max,
+        bigint: true,
+        idleTimeout: options.idleTimeout,
+        maxLifetime: options.maxLifetime,
+        connectionTimeout: options.connectionTimeout,
+        onclose: (client, error) => {
+            if (error) Logger.warn(`MySQL 连接关闭：${error.message ?? error}`);
+        }
+    });
+
+    try {
+        await sql`SELECT 1`;
+    } catch (error) {
+        await sql.close();
+        throw new MysqlError(`Mysql 连接失败 (${options.hostname})`, { cause: error, operation: "connect" });
+    }
+
+    return new DbHelper({
+        dbName: options.database,
+        sql: sql,
+        close: () => sql.close(),
+        beflyMode: options.beflyMode,
+        queryTimeout: options.queryTimeout,
+        tables: options.tables
+    });
+}

package/libs/mysql/sql/identifier.js

@@ -0,0 +1,85 @@
+function isString(value) {
+    return typeof value === "string";
+}
+
+function isQuotedIdentPaired(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2) return false;
+
+    const first = trimmed[0];
+    const last = trimmed.at(-1);
+    return (first === "`" && last === "`") || (first === '"' && last === '"');
+}
+
+function startsWithIdentifierQuote(value) {
+    const trimmed = value.trim();
+    return trimmed.startsWith("`") || trimmed.startsWith('"');
+}
+
+/**
+ * 解析 SQL 标识符引用函数，默认使用 MySQL 反引号。
+ */
+export function resolveQuoteIdent(options) {
+    if (options?.quoteIdent) return options.quoteIdent;
+
+    return (identifier) => {
+        const trimmed = isString(identifier) ? identifier.trim() : String(identifier).trim();
+        return `\`${trimmed.replace(/`/g, "``")}\``;
+    };
+}
+
+/**
+ * 转义字段引用，支持 qualifier.field、* 与单空格别名。
+ */
+export function escapeField(field, quoteIdent) {
+    if (!isString(field)) return field;
+
+    const trimmed = field.trim();
+    if (!trimmed || trimmed === "*" || isQuotedIdentPaired(trimmed)) return trimmed;
+    if (startsWithIdentifierQuote(trimmed) && !isQuotedIdentPaired(trimmed) && !trimmed.includes(".")) return trimmed;
+    if (trimmed.includes("(") || trimmed.includes(")") || /\s+AS\s+/i.test(trimmed)) return trimmed;
+
+    const aliasMatch = trimmed.match(/^([^\s]+)\s+([^\s]+)$/);
+    if (aliasMatch) return `${escapeField(aliasMatch[1].trim(), quoteIdent)} ${aliasMatch[2].trim()}`;
+
+    if (trimmed.includes(".")) {
+        return trimmed
+            .split(".")
+            .map((part) => {
+                const cleanPart = part.trim();
+                if (!cleanPart || cleanPart === "*" || isQuotedIdentPaired(cleanPart) || startsWithIdentifierQuote(cleanPart)) return cleanPart;
+                return quoteIdent(cleanPart);
+            })
+            .join(".");
+    }
+
+    return quoteIdent(trimmed);
+}
+
+/**
+ * 转义表引用，支持 schema.table 与单个别名。
+ */
+export function escapeTable(table, quoteIdent) {
+    if (!isString(table)) return table;
+
+    const trimmed = table.trim();
+    if (!trimmed || isQuotedIdentPaired(trimmed)) return trimmed;
+    if (startsWithIdentifierQuote(trimmed) && !isQuotedIdentPaired(trimmed) && !trimmed.includes(".")) return trimmed;
+
+    const parts = trimmed.split(/\s+/).filter((part) => part.length > 0);
+    if (parts.length > 2) return trimmed;
+
+    const namePart = parts[0].trim();
+    if (namePart.split(".").some((part) => startsWithIdentifierQuote(part.trim()) && !isQuotedIdentPaired(part.trim()))) return trimmed;
+
+    const escapedName = namePart
+        .split(".")
+        .map((part) => {
+            const cleanPart = part.trim();
+            if (!cleanPart || isQuotedIdentPaired(cleanPart) || startsWithIdentifierQuote(cleanPart)) return cleanPart;
+            return quoteIdent(cleanPart);
+        })
+        .join(".");
+
+    return parts.length === 2 ? `${escapedName} ${parts[1].trim()}` : escapedName;
+}

package/libs/mysql/sql/index.js

@@ -0,0 +1,2 @@
+export { escapeField, escapeTable, resolveQuoteIdent } from "./identifier.js";
+export { SqlBuilder } from "./sqlBuilder.js";

package/{lib → libs/mysql/sql}/sqlBuilder.js

@@ -24,8 +24,7 @@
  * - 本类不校验节点合法性（信任上层），仅负责编译
  */
 
-import { isNonEmptyString } from "../utils/is.js";
-import { escapeField, escapeTable, resolveQuoteIdent } from "./dbUtil.js";
+import { escapeField, escapeTable, resolveQuoteIdent } from "./identifier.js";
 
 /**
  * SQL 构建器类
@@ -429,7 +428,7 @@ export class SqlBuilder {
             setSqlList.push(`${quotedField} = CASE ${quotedId} ${whenList.join(" ")} ELSE ${quotedField} END`);
         }
 
-        if (isNonEmptyString(options.updatedAtField)) {
+        if (typeof options.updatedAtField === "string" && options.updatedAtField.trim().length > 0) {
             setSqlList.push(`${options.quoteIdent(options.updatedAtField)} = ?`);
             args.push(options.updatedAtValue);
         }

package/libs/mysql/util.js

@@ -0,0 +1,44 @@
+import { isPlainObject } from "./is.js";
+
+function toWordParts(input) {
+    const normalized = String(input)
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[^a-zA-Z0-9]+/g, " ")
+        .trim();
+    return normalized ? normalized.split(/\s+/) : [];
+}
+
+export function camelCase(input) {
+    const parts = toWordParts(input);
+    if (parts.length === 0) return "";
+    return (
+        parts[0].toLowerCase() +
+        parts
+            .slice(1)
+            .map((part) => part[0].toUpperCase() + part.slice(1).toLowerCase())
+            .join("")
+    );
+}
+
+export function snakeCase(input) {
+    return toWordParts(input)
+        .map((part) => part.toLowerCase())
+        .join("_");
+}
+
+export function keysToSnake(obj) {
+    if (!isPlainObject(obj)) return obj;
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [snakeCase(key), value]));
+}
+
+export function canConvertToNumber(value) {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(Number.MIN_SAFE_INTEGER)) return null;
+    const number = Number(value);
+    return Number.isSafeInteger(number) ? number : null;
+}
+
+export function fieldClear(data, options = {}) {
+    if (!isPlainObject(data)) return data;
+    return Object.fromEntries(Object.entries(data).filter(([, value]) => !options.excludeValues?.includes(value)));
+}

package/libs/redis/index.js

@@ -0,0 +1,2 @@
+export { createRedis, RedisHelper } from "./redis.js";
+export { RedisError } from "./redisError.js";

package/libs/redis/redis.js

@@ -0,0 +1,204 @@
+import { RedisClient } from "bun";
+
+import { Logger } from "../logger/index.js";
+import { RedisError } from "./redisError.js";
+
+function buildRedisUrl(config) {
+    if (config.username) {
+        return `redis://${encodeURIComponent(config.username)}:${encodeURIComponent(config.password || "")}@${config.hostname}:${config.port}/${config.db}`;
+    }
+    if (config.password) {
+        return `redis://:${encodeURIComponent(config.password)}@${config.hostname}:${config.port}/${config.db}`;
+    }
+    return `redis://${config.hostname}:${config.port}/${config.db}`;
+}
+
+/**
+ * Bun RedisClient 高层操作封装。除 ping 外，操作失败记录日志并返回约定 fallback。
+ */
+export class RedisHelper {
+    constructor(options) {
+        this.client = options.client;
+        this.prefix = options.prefix ? `${options.prefix}:` : "";
+    }
+
+    async safeCall(label, operation, fallback) {
+        try {
+            return await operation();
+        } catch (error) {
+            Logger.error(`Redis ${label} 错误`, error);
+            return fallback;
+        }
+    }
+
+    async setObject(key, obj, ttl = null) {
+        return this.safeCall(
+            "setObject",
+            async () => {
+                const data = JSON.stringify(obj);
+                const pkey = `${this.prefix}${key}`;
+                return ttl ? this.client.setex(pkey, ttl, data) : this.client.set(pkey, data);
+            },
+            null
+        );
+    }
+
+    async getObject(key) {
+        return this.safeCall(
+            "getObject",
+            async () => {
+                const data = await this.client.get(`${this.prefix}${key}`);
+                return data ? JSON.parse(data) : null;
+            },
+            null
+        );
+    }
+
+    async delObject(key) {
+        return this.safeCall("delObject", async () => {
+            await this.client.del(`${this.prefix}${key}`);
+        });
+    }
+
+    async setString(key, value, ttl = null) {
+        return this.safeCall(
+            "setString",
+            async () => {
+                const pkey = `${this.prefix}${key}`;
+                return ttl ? this.client.setex(pkey, ttl, value) : this.client.set(pkey, value);
+            },
+            null
+        );
+    }
+
+    async getString(key) {
+        return this.safeCall("getString", () => this.client.get(`${this.prefix}${key}`), null);
+    }
+
+    async exists(key) {
+        return this.safeCall("exists", () => this.client.exists(`${this.prefix}${key}`), false);
+    }
+
+    async incr(key) {
+        return this.safeCall("incr", () => this.client.incr(`${this.prefix}${key}`), 0);
+    }
+
+    async incrWithExpire(key, seconds) {
+        return this.safeCall(
+            "incrWithExpire",
+            async () => {
+                const pkey = `${this.prefix}${key}`;
+                const result = await this.client.incr(pkey);
+                if (result === 1) await this.client.expire(pkey, seconds);
+                return result;
+            },
+            0
+        );
+    }
+
+    async expire(key, seconds) {
+        return this.safeCall("expire", () => this.client.expire(`${this.prefix}${key}`, seconds), 0);
+    }
+
+    async ttl(key) {
+        return this.safeCall("ttl", () => this.client.ttl(`${this.prefix}${key}`), -1);
+    }
+
+    async sadd(key, members) {
+        return this.safeCall(
+            "sadd",
+            async () => {
+                if (members.length === 0) return 0;
+                return this.client.sadd(`${this.prefix}${key}`, ...members);
+            },
+            0
+        );
+    }
+
+    async sismember(key, member) {
+        return this.safeCall("sismember", () => this.client.sismember(`${this.prefix}${key}`, member), false);
+    }
+
+    async scard(key) {
+        return this.safeCall("scard", () => this.client.scard(`${this.prefix}${key}`), 0);
+    }
+
+    async smembers(key) {
+        return this.safeCall("smembers", () => this.client.smembers(`${this.prefix}${key}`), []);
+    }
+
+    async saddBatch(items) {
+        return this.safeCall(
+            "saddBatch",
+            async () => {
+                if (items.length === 0) return 0;
+                const results = await Promise.all(items.map((item) => this.sadd(item.key, item.members)));
+                return results.reduce((sum, count) => sum + count, 0);
+            },
+            0
+        );
+    }
+
+    async del(key) {
+        return this.safeCall("del", () => this.client.del(`${this.prefix}${key}`), 0);
+    }
+
+    async delBatch(keys) {
+        return this.safeCall(
+            "delBatch",
+            async () => {
+                if (keys.length === 0) return 0;
+                const results = await Promise.all(keys.map((key) => this.client.del(`${this.prefix}${key}`)));
+                return results.reduce((sum, count) => sum + count, 0);
+            },
+            0
+        );
+    }
+
+    async info(section) {
+        return this.safeCall(
+            "info",
+            async () => {
+                if (typeof this.client.info === "function") return this.client.info(section);
+                if (typeof this.client.send === "function") return this.client.send("INFO", section ? [String(section)] : []);
+                throw new RedisError("Redis info 不支持", { operation: "info" });
+            },
+            ""
+        );
+    }
+
+    async ping() {
+        try {
+            return await this.client.ping();
+        } catch (error) {
+            Logger.error("Redis ping 错误", error);
+            throw new RedisError("Redis ping 错误", { cause: error, operation: "ping" });
+        }
+    }
+
+    async close() {
+        await this.client.close();
+    }
+}
+
+/**
+ * 创建并验证 Bun RedisClient，返回带前缀和生命周期能力的 RedisHelper。
+ */
+export async function createRedis(options) {
+    const client = new RedisClient(buildRedisUrl(options));
+    client.onclose = (error) => {
+        Logger.warn(error ? `Redis 断开连接：${error.message ?? error}` : "Redis 断开连接");
+    };
+
+    try {
+        await client.ping();
+    } catch (error) {
+        await client.close();
+        throw new RedisError(`Redis 连接失败 (${options.hostname})`, { cause: error, operation: "connect" });
+    }
+
+    return new RedisHelper({
+        client: client,
+        prefix: options.prefix
+    });
+}

package/libs/redis/redisError.js

@@ -0,0 +1,8 @@
+export class RedisError extends Error {
+    constructor(message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = "RedisError";
+        this.code = options.code || "runtime";
+        this.operation = options.operation;
+    }
+}

package/libs/tableModel.js

@@ -0,0 +1,72 @@
+import { TABLE_AUTO_FIELD_NAMES } from "../configs/constConfig.js";
+import { isPlainObject, isString } from "../utils/is.js";
+import { snakeCase } from "../utils/util.js";
+
+const tableAutoFieldNameSet = new Set(TABLE_AUTO_FIELD_NAMES);
+
+const automaticFields = {
+    id: { name: "主键 ID", paramType: "integer", fieldType: "integer", fieldNullable: false, primary: true, autoIncrement: false, automatic: true },
+    state: { name: "状态", paramType: "integer", fieldType: "integer", fieldNullable: false, fieldDefault: 1, primary: false, autoIncrement: false, automatic: true },
+    createdAt: { name: "创建时间", paramType: "integer", fieldType: "integer", fieldNullable: false, fieldDefault: 0, primary: false, autoIncrement: false, automatic: true },
+    updatedAt: { name: "更新时间", paramType: "integer", fieldType: "integer", fieldNullable: false, fieldDefault: 0, primary: false, autoIncrement: false, automatic: true },
+    deletedAt: { name: "删除时间", paramType: "integer", fieldType: "integer", fieldNullable: true, primary: false, autoIncrement: false, automatic: true }
+};
+
+function parseIndexes(indexDefinitions) {
+    if (indexDefinitions === undefined) return {};
+    if (!isPlainObject(indexDefinitions)) return indexDefinitions;
+    const indexes = {};
+    for (const [indexName, definition] of Object.entries(indexDefinitions)) {
+        if (!isString(definition)) {
+            indexes[indexName] = definition;
+            continue;
+        }
+        const [type, fieldsText] = definition.split("#");
+        indexes[indexName] = {
+            type: type,
+            fields: isString(fieldsText) ? fieldsText.split(",") : []
+        };
+    }
+    return indexes;
+}
+
+/**
+ * 将单个 tables JSON 转换为运行时、检查与数据库同步共用的唯一标准模型。
+ */
+export function buildTableModel(tableDefinition, options) {
+    if (options.source === "app" && options.fileName.toLowerCase().startsWith("befly")) throw new TypeError(`App Table 禁止使用 befly 保留前缀：${options.fileName}`);
+    const auto = options.source === "core" || options.beflyMode !== "manual";
+    const primary = auto ? "id" : tableDefinition?.$tablePrimary;
+    const businessFields = {};
+    if (isPlainObject(tableDefinition)) {
+        for (const [key, value] of Object.entries(tableDefinition)) {
+            if (!key.startsWith("$")) {
+                businessFields[key] = isPlainObject(value)
+                    ? {
+                          fieldNullable: false,
+                          ...value,
+                          primary: key === primary,
+                          autoIncrement: !auto && key === primary,
+                          automatic: false
+                      }
+                    : value;
+            }
+        }
+    }
+
+    const codeName = options.source === "core" ? `befly${options.fileName.charAt(0).toUpperCase()}${options.fileName.slice(1)}` : options.fileName;
+    return {
+        name: tableDefinition?.$tableName,
+        source: options.source,
+        fileName: options.fileName,
+        codeName: codeName,
+        dbName: snakeCase(codeName),
+        primary: primary,
+        indexes: parseIndexes(tableDefinition?.$tableIndexes),
+        fields: auto ? { ...automaticFields, ...businessFields } : businessFields
+    };
+}
+
+export function isTableAutoFieldName(fieldName) {
+    return tableAutoFieldNameSet.has(fieldName);
+}

package/libs/tool.js

@@ -0,0 +1,33 @@
+import { genId } from "../utils/id.js";
+import { isNumber, isString } from "../utils/is.js";
+
+export function Yes(msg, data = {}, other = {}) {
+    return { code: 0, msg: msg, data: data, ...other };
+}
+
+export function No(msg, data = null, other = {}) {
+    return { code: 1, msg: msg, data: data, ...other };
+}
+
+export function Fail(msg, data = null, other = {}) {
+    const error = new Error(msg);
+    error.isBeflyResponse = true;
+    error.payload = No(msg, data, other);
+    throw error;
+}
+
+export function Raw(ctx, data, options = {}) {
+    const contentType = options.contentType || (isString(data) ? (data.trim().startsWith("<") ? "application/xml" : "text/plain") : "application/json");
+    const body = isString(data) ? data : JSON.stringify(data);
+
+    return new Response(body, {
+        status: isNumber(options.status) ? options.status : 200,
+        headers: {
+            ...ctx.corsHeaders,
+            "Content-Type": contentType,
+            ...options.headers
+        }
+    });
+}
+
+export const tool = { Yes: Yes, No: No, Fail: Fail, Raw: Raw, genId: genId };