@nbreak/datasources 0.1.0

package/dist/cjs/index.cjs

@@ -0,0 +1,1103 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+let _nbreak_sdk = require("@nbreak/sdk");
+//#region src/adapters/staticAdapter.js
+/**
+* @nbreak/datasources - 静态数据源适配器
+*/
+/**
+* 裸取数函数：返回传入的静态数据，返回 { data, meta }
+* @param {Object} config
+* @returns {Promise<{data: any, meta: Object}>}
+*/
+async function fetchData$5(config) {
+	const { data = [], transform } = config;
+	let result = data;
+	if (typeof transform === "function") result = transform(data);
+	return {
+		data: result,
+		meta: { total: Array.isArray(result) ? result.length : 1 }
+	};
+}
+var StaticAdapter = class {
+	async fetchData(config) {
+		return fetchData$5(config);
+	}
+	async subscribe(_config, callback) {
+		return () => {};
+	}
+	async test() {
+		return {
+			success: true,
+			message: "静态数据源总是可用"
+		};
+	}
+};
+var staticAdapter_default = (0, _nbreak_sdk.defineDataSourceExtension)({
+	type: "static",
+	name: "静态数据",
+	adapter: new StaticAdapter(),
+	configSchema: [{
+		key: "data",
+		label: "数据内容",
+		type: "json",
+		group: "基础",
+		default: [],
+		description: "JSON 格式的静态数据"
+	}],
+	defaults: { data: [] },
+	description: "JSON 静态数据源，适用于测试与简单场景"
+});
+//#endregion
+//#region src/adapters/apiAdapter.js
+/**
+* @nbreak/datasources - REST API 数据源适配器
+*/
+/**
+* 裸取数函数：执行 REST API 请求并返回 { data, meta }
+* 支持 optional signal（外部取消）/ responseType（显式覆盖）/ credentials
+* @param {Object} config
+* @returns {Promise<{data: any, meta: Object}>}
+*/
+async function fetchData(config) {
+	const { url, method = "GET", headers = {}, body, params = {}, timeout = 1e4, transform, signal, responseType, credentials } = config;
+	if (!url) throw new Error("API 数据源需要配置 url");
+	const urlObj = new URL(url, typeof window !== "undefined" ? window.location.origin : "http://localhost");
+	Object.entries(params).forEach(([k, v]) => {
+		if (v !== void 0 && v !== null) urlObj.searchParams.append(k, v);
+	});
+	const controller = signal ? null : new AbortController();
+	const fetchSignal = signal || controller.signal;
+	const timer = setTimeout(signal ? () => signal.abort() : () => controller.abort(), timeout);
+	try {
+		const fetchOptions = {
+			method,
+			headers: {
+				"Content-Type": "application/json",
+				...headers
+			},
+			body: method !== "GET" && body ? JSON.stringify(body) : void 0,
+			signal: fetchSignal
+		};
+		if (credentials) fetchOptions.credentials = credentials;
+		const response = await fetch(urlObj.toString(), fetchOptions);
+		if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+		let data;
+		if (responseType) switch (responseType) {
+			case "json":
+				data = await response.json();
+				break;
+			case "text":
+				data = await response.text();
+				break;
+			case "blob":
+				data = await response.blob();
+				break;
+			case "arrayBuffer":
+				data = await response.arrayBuffer();
+				break;
+			case "formData":
+				data = await response.formData();
+				break;
+			default: data = await response.json();
+		}
+		else if ((response.headers.get("content-type") || "").includes("application/json")) data = await response.json();
+		else data = await response.text();
+		if (typeof transform === "function") data = transform(data);
+		return {
+			data,
+			meta: { status: response.status }
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+}
+var ApiAdapter = class {
+	async fetchData(config) {
+		return fetchData(config);
+	}
+	async subscribe(config, callback) {
+		if (!config.pollInterval || config.pollInterval < 1e3) return () => {};
+		let active = true;
+		const poll = async () => {
+			if (!active) return;
+			try {
+				const { data } = await this.fetchData(config);
+				callback(data);
+			} catch (e) {}
+			if (active) setTimeout(poll, config.pollInterval);
+		};
+		poll();
+		return () => {
+			active = false;
+		};
+	}
+	async test(config) {
+		try {
+			await this.fetchData({
+				...config,
+				timeout: 5e3
+			});
+			return {
+				success: true,
+				message: "连接成功"
+			};
+		} catch (e) {
+			return {
+				success: false,
+				message: e.message
+			};
+		}
+	}
+};
+var apiAdapter_default = (0, _nbreak_sdk.defineDataSourceExtension)({
+	type: "api",
+	name: "REST API",
+	adapter: new ApiAdapter(),
+	configSchema: [
+		{
+			key: "url",
+			label: "接口地址",
+			type: "text",
+			group: "基础",
+			default: "",
+			required: true
+		},
+		{
+			key: "method",
+			label: "请求方法",
+			type: "select",
+			group: "基础",
+			default: "GET",
+			options: [
+				"GET",
+				"POST",
+				"PUT",
+				"DELETE"
+			].map((m) => ({
+				label: m,
+				value: m
+			}))
+		},
+		{
+			key: "headers",
+			label: "请求头",
+			type: "json",
+			group: "高级",
+			default: {}
+		},
+		{
+			key: "body",
+			label: "请求体",
+			type: "json",
+			group: "高级",
+			default: null,
+			visible: (props) => props.method !== "GET"
+		},
+		{
+			key: "params",
+			label: "查询参数",
+			type: "json",
+			group: "高级",
+			default: {}
+		},
+		{
+			key: "pollInterval",
+			label: "轮询间隔(ms)",
+			type: "number",
+			group: "实时",
+			default: 0,
+			min: 0,
+			description: "大于 1000 时启用轮询"
+		},
+		{
+			key: "timeout",
+			label: "超时(ms)",
+			type: "number",
+			group: "高级",
+			default: 1e4,
+			min: 1e3,
+			max: 6e4
+		}
+	],
+	defaults: {
+		url: "",
+		method: "GET",
+		headers: {},
+		params: {},
+		pollInterval: 0,
+		timeout: 1e4
+	},
+	description: "REST API 数据源，支持 GET/POST/PUT/DELETE 与轮询"
+});
+//#endregion
+//#region src/adapters/websocketAdapter.js
+/**
+* @nbreak/datasources - WebSocket 实时数据源适配器
+*/
+/**
+* 裸取数函数：WebSocket 不支持单次拉取，返回 null 标记实时模式
+* @param {Object} _config
+* @returns {Promise<{data: null, meta: Object}>}
+*/
+async function fetchData$6(_config) {
+	return {
+		data: null,
+		meta: { realtime: true }
+	};
+}
+var WebSocketAdapter = class {
+	async fetchData(config) {
+		return fetchData$6(config);
+	}
+	async subscribe(config, callback) {
+		const { url, protocols, reconnect = true, maxRetries = 5 } = config;
+		if (!url) throw new Error("WebSocket 数据源需要配置 url");
+		let ws = null;
+		let retryCount = 0;
+		let closed = false;
+		const connect = () => {
+			if (closed) return;
+			try {
+				ws = new WebSocket(url, protocols);
+				ws.onopen = () => {
+					retryCount = 0;
+				};
+				ws.onmessage = (event) => {
+					try {
+						callback(JSON.parse(event.data));
+					} catch (e) {
+						callback(event.data);
+					}
+				};
+				ws.onclose = () => {
+					if (reconnect && !closed && retryCount < maxRetries) {
+						retryCount++;
+						const delay = Math.min(1e3 * Math.pow(2, retryCount), 3e4);
+						setTimeout(connect, delay);
+					}
+				};
+				ws.onerror = (e) => {
+					console.error("[WebSocket Adapter] error:", e);
+				};
+			} catch (e) {
+				console.error("[WebSocket Adapter] connect failed:", e);
+			}
+		};
+		connect();
+		return () => {
+			closed = true;
+			if (ws) ws.close();
+		};
+	}
+	async test(config) {
+		return new Promise((resolve) => {
+			try {
+				const ws = new WebSocket(config.url);
+				const timer = setTimeout(() => {
+					ws.close();
+					resolve({
+						success: false,
+						message: "连接超时"
+					});
+				}, 5e3);
+				ws.onopen = () => {
+					clearTimeout(timer);
+					ws.close();
+					resolve({
+						success: true,
+						message: "WebSocket 连接成功"
+					});
+				};
+				ws.onerror = () => {
+					clearTimeout(timer);
+					resolve({
+						success: false,
+						message: "WebSocket 连接失败"
+					});
+				};
+			} catch (e) {
+				resolve({
+					success: false,
+					message: e.message
+				});
+			}
+		});
+	}
+};
+var websocketAdapter_default = (0, _nbreak_sdk.defineDataSourceExtension)({
+	type: "websocket",
+	name: "WebSocket 实时",
+	adapter: new WebSocketAdapter(),
+	configSchema: [
+		{
+			key: "url",
+			label: "WebSocket 地址",
+			type: "text",
+			group: "基础",
+			default: "",
+			required: true,
+			placeholder: "ws://localhost:8080/ws"
+		},
+		{
+			key: "protocols",
+			label: "子协议",
+			type: "text",
+			group: "高级",
+			default: ""
+		},
+		{
+			key: "reconnect",
+			label: "自动重连",
+			type: "switch",
+			group: "高级",
+			default: true
+		},
+		{
+			key: "maxRetries",
+			label: "最大重试次数",
+			type: "number",
+			group: "高级",
+			default: 5,
+			min: 0,
+			max: 100
+		}
+	],
+	defaults: {
+		url: "",
+		protocols: "",
+		reconnect: true,
+		maxRetries: 5
+	},
+	description: "WebSocket 实时数据源，支持自动重连与指数退避"
+});
+//#endregion
+//#region src/adapters/excelAdapter.js
+/**
+* @nbreak/datasources - Excel 文件数据源适配器
+*
+* 基于 xlsx 库解析 Excel 文件，支持 .xlsx/.xls 格式
+*/
+/**
+* 读取文件内容为 ArrayBuffer
+* @param {string|Blob|ArrayBuffer|Uint8Array} file - 文件源
+* @returns {Promise<ArrayBuffer>}
+*/
+async function readFile(file) {
+	if (typeof file === "string") return await (await fetch(file)).arrayBuffer();
+	if (file instanceof ArrayBuffer || file instanceof Uint8Array) return file;
+	if (file instanceof Blob) return await file.arrayBuffer();
+	throw new Error("不支持的 file 类型");
+}
+/**
+* 裸取数函数：基于 xlsx 库解析 Excel 文件，返回 { data, meta }
+* @param {Object} config
+* @returns {Promise<{data: Array, meta: Object}>}
+*/
+async function fetchData$3(config) {
+	const { file, sheetName, range, transform } = config;
+	if (!file && !config.fileContent) throw new Error("Excel 数据源需要配置 file（File 对象）或 fileContent（ArrayBuffer/base64 字符串）");
+	let XLSX;
+	try {
+		XLSX = (await import("xlsx")).default || await import("xlsx");
+	} catch (e) {
+		throw new Error("未安装 xlsx 库，请运行 pnpm add xlsx");
+	}
+	const data = config.fileContent || await readFile(file);
+	let workbook;
+	if (typeof data === "string") workbook = XLSX.read(data, { type: "base64" });
+	else if (data instanceof ArrayBuffer || data instanceof Uint8Array) workbook = XLSX.read(data, { type: "array" });
+	else throw new Error("fileContent 无法解析（旧配置中的文件内容已丢失，请重新上传 Excel 文件）");
+	const sheet = sheetName ? workbook.Sheets[sheetName] : workbook.Sheets[workbook.SheetNames[0]];
+	if (!sheet) throw new Error(`工作表 "${sheetName || "[默认]"}" 不存在`);
+	const options = {};
+	if (range) options.range = range;
+	let result = XLSX.utils.sheet_to_json(sheet, options);
+	if (typeof transform === "function") result = transform(result);
+	return {
+		data: result,
+		meta: {
+			total: result.length,
+			sheetName: sheetName || workbook.SheetNames[0],
+			sheets: workbook.SheetNames
+		}
+	};
+}
+var ExcelAdapter = class {
+	async fetchData(config) {
+		return fetchData$3(config);
+	}
+	async _readFile(file) {
+		return readFile(file);
+	}
+	async subscribe(_config, _callback) {
+		return () => {};
+	}
+	async test(config) {
+		try {
+			if (!config.file && !config.fileContent) return {
+				success: false,
+				message: "需要配置 file"
+			};
+			return {
+				success: true,
+				message: "Excel 数据源配置有效"
+			};
+		} catch (e) {
+			return {
+				success: false,
+				message: e.message
+			};
+		}
+	}
+};
+var excelAdapter_default = (0, _nbreak_sdk.defineDataSourceExtension)({
+	type: "excel",
+	name: "Excel 文件",
+	adapter: new ExcelAdapter(),
+	configSchema: [
+		{
+			key: "file",
+			label: "Excel 文件",
+			type: "text",
+			group: "基础",
+			default: "",
+			description: "文件 URL 或 File 对象"
+		},
+		{
+			key: "sheetName",
+			label: "工作表名",
+			type: "text",
+			group: "基础",
+			default: "",
+			placeholder: "留空使用第一个工作表"
+		},
+		{
+			key: "range",
+			label: "数据范围",
+			type: "text",
+			group: "高级",
+			default: "",
+			placeholder: "A1:D100"
+		}
+	],
+	defaults: {
+		file: "",
+		sheetName: "",
+		range: ""
+	},
+	description: "Excel 文件数据源，支持 .xlsx/.xls 格式解析"
+});
+//#endregion
+//#region src/adapters/csvAdapter.js
+/**
+* @nbreak/datasources - CSV 文本数据源适配器
+*
+* 解析 CSV 文本为对象数组，支持自定义分隔符与表头
+*/
+/**
+* 解析 CSV 文本为二维数组
+* @param {string} text - CSV 文本
+* @param {string} delimiter - 分隔符
+* @param {string} quote - 引号字符
+* @returns {Array<Array<string>>}
+*/
+function parseCsv(text, delimiter, quote) {
+	const rows = [];
+	let currentRow = [];
+	let currentField = "";
+	let inQuotes = false;
+	for (let i = 0; i < text.length; i++) {
+		const char = text[i];
+		const nextChar = text[i + 1];
+		if (inQuotes) if (char === quote) if (nextChar === quote) {
+			currentField += quote;
+			i++;
+		} else inQuotes = false;
+		else currentField += char;
+		else if (char === quote) inQuotes = true;
+		else if (char === delimiter) {
+			currentRow.push(currentField);
+			currentField = "";
+		} else if (char === "\n" || char === "\r") {
+			if (char === "\r" && nextChar === "\n") i++;
+			currentRow.push(currentField);
+			currentField = "";
+			if (currentRow.length > 1 || currentRow[0] !== "") rows.push(currentRow);
+			currentRow = [];
+		} else currentField += char;
+	}
+	if (currentField !== "" || currentRow.length > 0) {
+		currentRow.push(currentField);
+		rows.push(currentRow);
+	}
+	return rows;
+}
+/**
+* 裸取数函数：解析 CSV 文本为对象数组，返回 { data, meta }
+* @param {Object} config
+* @returns {Promise<{data: Array, meta: Object}>}
+*/
+async function fetchData$1(config) {
+	const { content = "", url = "", delimiter = ",", hasHeader = true, quote = "\"", transform } = config;
+	let csvText = content;
+	if (!csvText && url) csvText = await (await fetch(url)).text();
+	if (!csvText) return {
+		data: [],
+		meta: { total: 0 }
+	};
+	const rows = parseCsv(csvText, delimiter, quote);
+	if (rows.length === 0) return {
+		data: [],
+		meta: { total: 0 }
+	};
+	let result;
+	if (hasHeader) {
+		const headers = rows[0];
+		result = rows.slice(1).map((row) => {
+			const obj = {};
+			headers.forEach((h, i) => {
+				obj[h] = row[i] !== void 0 ? row[i] : "";
+			});
+			return obj;
+		});
+	} else result = rows.map((row) => ({ values: row }));
+	if (typeof transform === "function") result = transform(result);
+	return {
+		data: result,
+		meta: { total: result.length }
+	};
+}
+var CsvAdapter = class {
+	async fetchData(config) {
+		return fetchData$1(config);
+	}
+	_parse(text, delimiter, quote) {
+		return parseCsv(text, delimiter, quote);
+	}
+	async subscribe(_config, _callback) {
+		return () => {};
+	}
+	async test(config) {
+		if (!config.content && !config.url) return {
+			success: false,
+			message: "需要配置 content 或 url"
+		};
+		return {
+			success: true,
+			message: "CSV 数据源配置有效"
+		};
+	}
+};
+var csvAdapter_default = (0, _nbreak_sdk.defineDataSourceExtension)({
+	type: "csv",
+	name: "CSV 文本",
+	adapter: new CsvAdapter(),
+	configSchema: [
+		{
+			key: "content",
+			label: "CSV 内容",
+			type: "textarea",
+			group: "基础",
+			default: "",
+			description: "直接粘贴 CSV 文本"
+		},
+		{
+			key: "url",
+			label: "文件 URL",
+			type: "text",
+			group: "基础",
+			default: "",
+			description: "远程 CSV 文件地址（content 为空时使用）"
+		},
+		{
+			key: "delimiter",
+			label: "分隔符",
+			type: "select",
+			group: "解析",
+			default: ",",
+			options: [
+				{
+					label: "逗号 (,)",
+					value: ","
+				},
+				{
+					label: "分号 (;)",
+					value: ";"
+				},
+				{
+					label: "制表符 (\\t)",
+					value: "	"
+				},
+				{
+					label: "竖线 (|)",
+					value: "|"
+				}
+			]
+		},
+		{
+			key: "hasHeader",
+			label: "首行表头",
+			type: "switch",
+			group: "解析",
+			default: true
+		},
+		{
+			key: "quote",
+			label: "引号字符",
+			type: "text",
+			group: "高级",
+			default: "\""
+		}
+	],
+	defaults: {
+		content: "",
+		url: "",
+		delimiter: ",",
+		hasHeader: true,
+		quote: "\""
+	},
+	description: "CSV 文本数据源，支持自定义分隔符与表头解析"
+});
+//#endregion
+//#region src/adapters/mockAdapter.js
+/**
+* @nbreak/datasources - Mock 模拟数据源适配器
+*
+* 用于开发测试，支持生成随机数据与定时刷新
+*/
+/**
+* 生成单个对象
+* @param {Array} schema - 数据结构
+* @param {Function} random - 随机数生成函数
+* @param {number} index - 索引
+* @returns {Object}
+*/
+function generateObject(schema, random, index = 0) {
+	if (!schema || schema.length === 0) return {
+		id: index,
+		label: `项目 ${index + 1}`,
+		value: Math.floor(random() * 1e3)
+	};
+	const obj = {};
+	for (const field of schema) {
+		const { key, type = "number" } = field;
+		switch (type) {
+			case "number":
+				obj[key] = Math.floor(random() * (field.max || 1e3));
+				break;
+			case "string":
+				obj[key] = `${field.prefix || "item"}_${index}`;
+				break;
+			case "boolean":
+				obj[key] = random() > .5;
+				break;
+			case "date":
+				obj[key] = (/* @__PURE__ */ new Date(Date.now() - random() * 30 * 24 * 60 * 60 * 1e3)).toISOString();
+				break;
+			case "category":
+				obj[key] = field.options ? field.options[Math.floor(random() * field.options.length)] : `类别${Math.floor(random() * 5)}`;
+				break;
+			default: obj[key] = random();
+		}
+	}
+	return obj;
+}
+/**
+* 生成 Mock 数据
+* @param {string} dataType - 数据类型 (array/object)
+* @param {number} count - 数据条数
+* @param {Array} schema - 数据结构
+* @param {number} seed - 随机种子
+* @returns {any}
+*/
+function generate(dataType, count, schema, seed) {
+	let s = seed;
+	const random = () => {
+		s = (s * 9301 + 49297) % 233280;
+		return s / 233280;
+	};
+	if (dataType === "object") return generateObject(schema, random);
+	const arr = [];
+	for (let i = 0; i < count; i++) arr.push(generateObject(schema, random, i));
+	return arr;
+}
+/**
+* 裸取数函数：生成 Mock 数据，返回 { data, meta }
+* @param {Object} config
+* @returns {Promise<{data: any, meta: Object}>}
+*/
+async function fetchData$4(config) {
+	const { type: dataType = "array", count = 10, interval = 0, schema = [], seed = 42 } = config;
+	const data = generate(dataType, count, schema, seed);
+	return {
+		data,
+		meta: {
+			total: Array.isArray(data) ? data.length : 1,
+			generatedAt: Date.now()
+		}
+	};
+}
+var MockAdapter = class {
+	async fetchData(config) {
+		return fetchData$4(config);
+	}
+	_generate(dataType, count, schema, seed) {
+		return generate(dataType, count, schema, seed);
+	}
+	_generateObject(schema, random, index = 0) {
+		return generateObject(schema, random, index);
+	}
+	async subscribe(config, callback) {
+		if (!config.interval || config.interval < 500) return () => {};
+		let active = true;
+		const poll = async () => {
+			if (!active) return;
+			try {
+				const { data } = await this.fetchData(config);
+				callback(data);
+			} catch (e) {}
+			if (active) setTimeout(poll, config.interval);
+		};
+		poll();
+		return () => {
+			active = false;
+		};
+	}
+	async test() {
+		return {
+			success: true,
+			message: "Mock 数据源总是可用"
+		};
+	}
+};
+var mockAdapter_default = (0, _nbreak_sdk.defineDataSourceExtension)({
+	type: "mock",
+	name: "Mock 模拟数据",
+	adapter: new MockAdapter(),
+	configSchema: [
+		{
+			key: "type",
+			label: "数据类型",
+			type: "select",
+			group: "基础",
+			default: "array",
+			options: [{
+				label: "数组",
+				value: "array"
+			}, {
+				label: "对象",
+				value: "object"
+			}]
+		},
+		{
+			key: "count",
+			label: "数据条数",
+			type: "slider",
+			group: "基础",
+			default: 10,
+			min: 1,
+			max: 100
+		},
+		{
+			key: "seed",
+			label: "随机种子",
+			type: "number",
+			group: "基础",
+			default: 42,
+			description: "相同种子生成相同数据"
+		},
+		{
+			key: "interval",
+			label: "刷新间隔(ms)",
+			type: "number",
+			group: "实时",
+			default: 0,
+			min: 0,
+			description: "大于 500 时启用定时刷新"
+		},
+		{
+			key: "schema",
+			label: "数据结构",
+			type: "json",
+			group: "高级",
+			default: [],
+			description: "定义每条数据的字段结构"
+		}
+	],
+	defaults: {
+		type: "array",
+		count: 10,
+		seed: 42,
+		interval: 0,
+		schema: []
+	},
+	description: "Mock 模拟数据源，支持随机数据生成与定时刷新，适用于开发测试"
+});
+//#endregion
+//#region src/adapters/databaseAdapter.js
+/**
+* @nbreak/datasources - 数据库直连数据源适配器
+*
+* 浏览器无法直连 MySQL/PostgreSQL，本适配器通过 HTTP 调用后端代理
+* （默认 /api/db/query）完成取数。后端持有真实驱动与连接池。
+*/
+var DEFAULT_PROXY_URL = "/api/db/query";
+var DEFAULT_TEST_URL = "/api/db/test";
+/**
+* 裸取数函数：调用后端代理执行 SQL 查询，返回 { data, meta }
+* @param {Object} config
+* @param {string} config.dbType - 数据库类型：mysql | postgresql
+* @param {string} config.host - 主机地址
+* @param {number} config.port - 端口
+* @param {string} config.database - 数据库名
+* @param {string} config.username - 用户名
+* @param {string} config.password - 密码
+* @param {string} config.query - SQL 查询语句（仅允许 SELECT）
+* @param {Array}  config.params - 参数化查询占位符
+* @param {string} [config.proxyUrl] - 自定义代理地址
+* @param {number} [config.timeout] - 超时(ms)
+* @param {AbortSignal} [config.signal] - 外部取消信号
+* @returns {Promise<{data: any, meta: Object}>}
+*/
+async function fetchData$2(config) {
+	const { dbType, host, port, database, username, password, query, params = [], proxyUrl = DEFAULT_PROXY_URL, timeout = 3e4, connectionOptions = {}, signal } = config;
+	if (!dbType) throw new Error("数据库数据源需要配置 dbType");
+	if (!query) throw new Error("数据库数据源需要配置 query (SQL 语句)");
+	const controller = signal ? null : new AbortController();
+	const fetchSignal = signal || controller.signal;
+	const timer = setTimeout(signal ? () => signal.abort() : () => controller.abort(), timeout);
+	try {
+		const response = await fetch(proxyUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				dbType,
+				host,
+				port,
+				database,
+				username,
+				password,
+				query,
+				params,
+				connectionOptions
+			}),
+			signal: fetchSignal
+		});
+		if (!response.ok) {
+			let errMsg = `HTTP ${response.status}: ${response.statusText}`;
+			try {
+				const errBody = await response.json();
+				if (errBody.error) errMsg = errBody.error;
+			} catch (_) {}
+			throw new Error(errMsg);
+		}
+		const result = await response.json();
+		return {
+			data: result.data,
+			meta: result.meta || { rowCount: Array.isArray(result.data) ? result.data.length : 0 }
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+}
+var DatabaseAdapter = class {
+	async fetchData(config) {
+		return fetchData$2(config);
+	}
+	async test(config) {
+		try {
+			const testUrl = config.testUrl || DEFAULT_TEST_URL;
+			const response = await fetch(testUrl, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					dbType: config.dbType,
+					host: config.host,
+					port: config.port,
+					database: config.database,
+					username: config.username,
+					password: config.password,
+					connectionOptions: config.connectionOptions
+				})
+			});
+			if (!response.ok) return {
+				success: false,
+				message: (await response.json().catch(() => ({}))).error || `HTTP ${response.status}`
+			};
+			const result = await response.json();
+			return {
+				success: result.success !== false,
+				message: result.message || "连接成功"
+			};
+		} catch (e) {
+			return {
+				success: false,
+				message: e.message
+			};
+		}
+	}
+};
+var databaseAdapter_default = (0, _nbreak_sdk.defineDataSourceExtension)({
+	type: "database",
+	name: "数据库",
+	adapter: new DatabaseAdapter(),
+	configSchema: [
+		{
+			key: "dbType",
+			label: "数据库类型",
+			type: "select",
+			group: "连接",
+			default: "mysql",
+			required: true,
+			options: [{
+				label: "MySQL",
+				value: "mysql"
+			}, {
+				label: "PostgreSQL",
+				value: "postgresql"
+			}]
+		},
+		{
+			key: "host",
+			label: "主机地址",
+			type: "text",
+			group: "连接",
+			default: "localhost",
+			required: true
+		},
+		{
+			key: "port",
+			label: "端口",
+			type: "number",
+			group: "连接",
+			default: 3306
+		},
+		{
+			key: "database",
+			label: "数据库名",
+			type: "text",
+			group: "连接",
+			default: "",
+			required: true
+		},
+		{
+			key: "username",
+			label: "用户名",
+			type: "text",
+			group: "连接",
+			default: "root",
+			required: true
+		},
+		{
+			key: "password",
+			label: "密码",
+			type: "password",
+			group: "连接",
+			default: ""
+		},
+		{
+			key: "query",
+			label: "SQL 查询",
+			type: "textarea",
+			group: "查询",
+			default: "SELECT 1",
+			required: true,
+			description: "仅允许 SELECT / WITH / SHOW / DESCRIBE / EXPLAIN"
+		},
+		{
+			key: "params",
+			label: "参数化查询",
+			type: "json",
+			group: "查询",
+			default: []
+		},
+		{
+			key: "timeout",
+			label: "超时(ms)",
+			type: "number",
+			group: "高级",
+			default: 3e4,
+			min: 1e3,
+			max: 12e4
+		}
+	],
+	defaults: {
+		dbType: "mysql",
+		host: "localhost",
+		port: 3306,
+		database: "",
+		username: "root",
+		password: "",
+		query: "SELECT 1",
+		params: [],
+		timeout: 3e4
+	},
+	description: "数据库直连数据源，支持 MySQL / PostgreSQL，通过后端代理执行查询"
+});
+//#endregion
+//#region src/index.js
+/**
+* @nbreak/datasources - 入口
+*
+* 导出 7 个内置数据源扩展：
+*   - Static   静态 JSON
+*   - API      RESTful
+*   - WebSocket 实时推送
+*   - Excel    文件解析
+*   - CSV      文本解析
+*   - Mock     模拟数据
+*   - Database 数据库查询
+*
+* 应用方使用方式：
+*   import datasources from '@nbreak/datasources'
+*   app.use(DataScreenVue, { extensions: datasources.extensions })
+*
+* B 层运行态适配器（src/datasources/adapters）可通过命名导出复用 A 层裸取数函数：
+*   import { fetchApiData, fetchCsvData } from '@nbreak/datasources'
+*/
+var extensions = [
+	staticAdapter_default,
+	apiAdapter_default,
+	websocketAdapter_default,
+	excelAdapter_default,
+	csvAdapter_default,
+	mockAdapter_default,
+	databaseAdapter_default
+];
+var adapters = {
+	static: staticAdapter_default.definition.adapter,
+	api: apiAdapter_default.definition.adapter,
+	websocket: websocketAdapter_default.definition.adapter,
+	excel: excelAdapter_default.definition.adapter,
+	csv: csvAdapter_default.definition.adapter,
+	mock: mockAdapter_default.definition.adapter,
+	database: databaseAdapter_default.definition.adapter
+};
+var src_default = { extensions };
+var VERSION = "0.1.0";
+var PACKAGE_NAME = "@nbreak/datasources";
+//#endregion
+exports.PACKAGE_NAME = PACKAGE_NAME;
+exports.VERSION = VERSION;
+exports.adapters = adapters;
+exports.apiAdapter = apiAdapter_default;
+exports.csvAdapter = csvAdapter_default;
+exports.databaseAdapter = databaseAdapter_default;
+exports.default = src_default;
+exports.excelAdapter = excelAdapter_default;
+exports.extensions = extensions;
+exports.fetchApiData = fetchData;
+exports.fetchCsvData = fetchData$1;
+exports.fetchDatabaseData = fetchData$2;
+exports.fetchExcelData = fetchData$3;
+exports.fetchMockData = fetchData$4;
+exports.fetchStaticData = fetchData$5;
+exports.fetchWebSocketData = fetchData$6;
+exports.mockAdapter = mockAdapter_default;
+exports.staticAdapter = staticAdapter_default;
+exports.websocketAdapter = websocketAdapter_default;
+
+//# sourceMappingURL=index.cjs.map