fdb2 1.0.0

package/src/platform/database/utils/helpers.ts

@@ -0,0 +1,437 @@
+// 数据库平台通用工具函数
+
+// 格式化文件大小
+export function formatFileSize(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return Math.round(bytes / Math.pow(1024, i) * 100) / 100 + ' ' + sizes[i];
+}
+
+// 格式化时间
+export function formatTime(timestamp: Date): string {
+  const now = new Date();
+  const diff = now.getTime() - timestamp.getTime();
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+  
+  if (minutes < 1) return '刚刚';
+  if (minutes < 60) return `${minutes}分钟前`;
+  if (hours < 24) return `${hours}小时前`;
+  if (days < 7) return `${days}天前`;
+  
+  return timestamp.toLocaleDateString('zh-CN');
+}
+
+// 格式化日期时间
+export function formatDateTime(date: Date): string {
+  return date.toLocaleString('zh-CN', {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit'
+  });
+}
+
+// 格式化执行时间
+export function formatExecutionTime(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(2)}s`;
+  return `${(ms / 60000).toFixed(2)}min`;
+}
+
+// 获取执行时间状态类
+export function getExecutionTimeClass(time: number): string {
+  if (time < 100) return 'fast';
+  if (time < 1000) return 'normal';
+  if (time < 2000) return 'slow';
+  return 'very-slow';
+}
+
+// 截断SQL语句
+export function truncateSql(sql: string, maxLength = 80): string {
+  if (sql.length <= maxLength) return sql;
+  return sql.substring(0, maxLength) + '...';
+}
+
+// 格式化SQL语句
+export function formatSql(sql: string): string {
+  return sql
+    .replace(/\s+/g, ' ')
+    .replace(/,/g, ',\n    ')
+    .replace(/\bFROM\b/gi, '\nFROM')
+    .replace(/\bWHERE\b/gi, '\nWHERE')
+    .replace(/\bORDER BY\b/gi, '\nORDER BY')
+    .replace(/\bGROUP BY\b/gi, '\nGROUP BY')
+    .replace(/\bHAVING\b/gi, '\nHAVING')
+    .replace(/\bLIMIT\b/gi, '\nLIMIT')
+    .trim();
+}
+
+// 获取SQL类型
+export function getSqlType(sql: string): string {
+  const trimmed = sql.trim().toUpperCase();
+  if (trimmed.startsWith('SELECT')) return 'SELECT';
+  if (trimmed.startsWith('INSERT')) return 'INSERT';
+  if (trimmed.startsWith('UPDATE')) return 'UPDATE';
+  if (trimmed.startsWith('DELETE')) return 'DELETE';
+  if (trimmed.startsWith('CREATE')) return 'CREATE';
+  if (trimmed.startsWith('ALTER')) return 'ALTER';
+  if (trimmed.startsWith('DROP')) return 'DROP';
+  if (trimmed.startsWith('TRUNCATE')) return 'TRUNCATE';
+  return 'OTHER';
+}
+
+// 验证SQL语句
+export function validateSql(sql: string): { valid: boolean; error?: string } {
+  if (!sql || sql.trim() === '') {
+    return { valid: false, error: 'SQL语句不能为空' };
+  }
+  
+  // 基本的SQL注入检查
+  const dangerousPatterns = [
+    /DROP\s+DATABASE/i,
+    /DROP\s+TABLE/i,
+    /TRUNCATE/i,
+    /DELETE\s+FROM.*WHERE\s+1\s*=\s*1/i,
+    /UPDATE.*SET.*WHERE\s+1\s*=\s*1/i
+  ];
+  
+  for (const pattern of dangerousPatterns) {
+    if (pattern.test(sql)) {
+      return { valid: false, error: '检测到潜在的危险SQL操作' };
+    }
+  }
+  
+  return { valid: true };
+}
+
+// 生成UUID
+export function generateUUID(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  });
+}
+
+// 深拷贝对象
+export function deepClone<T>(obj: T): T {
+  if (obj === null || typeof obj !== 'object') return obj;
+  if (obj instanceof Date) return new Date(obj.getTime()) as unknown as T;
+  if (obj instanceof Array) return obj.map(item => deepClone(item)) as unknown as T;
+  if (typeof obj === 'object') {
+    const cloned = {} as T;
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        cloned[key] = deepClone(obj[key]);
+      }
+    }
+    return cloned;
+  }
+  return obj;
+}
+
+// 防抖函数
+export function debounce<T extends (...args: any[]) => any>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeout: NodeJS.Timeout;
+  return (...args: Parameters<T>) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => func(...args), wait);
+  };
+}
+
+// 节流函数
+export function throttle<T extends (...args: any[]) => any>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let inThrottle: boolean;
+  return (...args: Parameters<T>) => {
+    if (!inThrottle) {
+      func(...args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, wait);
+    }
+  };
+}
+
+// 复制到剪贴板
+export async function copyToClipboard(text: string): Promise<boolean> {
+  try {
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch (error) {
+    // 降级方案
+    const textArea = document.createElement('textarea');
+    textArea.value = text;
+    textArea.style.position = 'fixed';
+    textArea.style.opacity = '0';
+    document.body.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+    
+    try {
+      document.execCommand('copy');
+      document.body.removeChild(textArea);
+      return true;
+    } catch (error) {
+      document.body.removeChild(textArea);
+      return false;
+    }
+  }
+}
+
+// 下载文件
+export function downloadFile(content: string, filename: string, contentType = 'text/plain') {
+  const blob = new Blob([content], { type: contentType });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+
+// 导出为CSV
+export function exportToCSV(data: any[], filename: string) {
+  if (data.length === 0) return;
+  
+  const headers = Object.keys(data[0]);
+  const csvContent = [
+    headers.join(','),
+    ...data.map(row => 
+      headers.map(header => {
+        const value = row[header];
+        if (value === null || value === undefined) return '';
+        if (typeof value === 'object') return JSON.stringify(value);
+        return `"${String(value).replace(/"/g, '""')}"`;
+      }).join(',')
+    )
+  ].join('\n');
+  
+  downloadFile(csvContent, filename, 'text/csv;charset=utf-8;');
+}
+
+// 导出为JSON
+export function exportToJSON(data: any[], filename: string) {
+  const jsonContent = JSON.stringify(data, null, 2);
+  downloadFile(jsonContent, filename, 'application/json;charset=utf-8;');
+}
+
+// 获取数据库类型图标
+export function getDbTypeIcon(type: string): string {
+  const iconMap: Record<string, string> = {
+    mysql: 'bi-database',
+    postgres: 'bi-database',
+    postgresql: 'bi-database',
+    sqlite: 'bi-database',
+    mssql: 'bi-database',
+    sqlserver: 'bi-database',
+    oracle: 'bi-database',
+    mongodb: 'bi-diagram-3'
+  };
+  return iconMap[type.toLowerCase()] || 'bi-database';
+}
+
+// 获取数据库类型标签
+export function getDbTypeLabel(type: string): string {
+  const labelMap: Record<string, string> = {
+    mysql: 'MySQL',
+    postgres: 'PostgreSQL',
+    postgresql: 'PostgreSQL',
+    sqlite: 'SQLite',
+    mssql: 'SQL Server',
+    sqlserver: 'SQL Server',
+    oracle: 'Oracle',
+    mongodb: 'MongoDB'
+  };
+  return labelMap[type.toLowerCase()] || type;
+}
+
+// 获取数据库类型样式类
+export function getDbTypeClass(type: string): string {
+  const classMap: Record<string, string> = {
+    mysql: 'db-mysql',
+    postgres: 'db-postgres',
+    postgresql: 'db-postgres',
+    sqlite: 'db-sqlite',
+    mssql: 'db-mssql',
+    sqlserver: 'db-mssql',
+    oracle: 'db-oracle',
+    mongodb: 'db-mongodb'
+  };
+  return classMap[type.toLowerCase()] || 'db-default';
+}
+
+// 计算百分比
+export function calculatePercentage(value: number, total: number): number {
+  if (total === 0) return 0;
+  return Math.round((value / total) * 100);
+}
+
+// 格式化数字
+export function formatNumber(num: number): string {
+  if (num >= 1000000) {
+    return (num / 1000000).toFixed(1) + 'M';
+  }
+  if (num >= 1000) {
+    return (num / 1000).toFixed(1) + 'K';
+  }
+  return num.toString();
+}
+
+// 获取颜色值
+export function getColorByValue(value: number, ranges: { threshold: number; color: string }[]): string {
+  for (const range of ranges) {
+    if (value <= range.threshold) {
+      return range.color;
+    }
+  }
+  return ranges[ranges.length - 1].color;
+}
+
+// 创建Toast通知
+export function createToast(message: string, type: 'success' | 'error' | 'warning' | 'info' = 'info', duration = 3000) {
+  const toast = document.createElement('div');
+  toast.className = `toast toast-${type}`;
+  toast.innerHTML = `
+    <div class="toast-content">
+      <i class="bi bi-${getToastIcon(type)}"></i>
+      <span>${message}</span>
+    </div>
+  `;
+  
+  Object.assign(toast.style, {
+    position: 'fixed',
+    top: '20px',
+    right: '20px',
+    background: 'white',
+    border: '1px solid #e5e7eb',
+    borderRadius: '8px',
+    padding: '1rem',
+    boxShadow: '0 4px 12px rgba(0, 0, 0, 0.15)',
+    zIndex: '9999',
+    display: 'flex',
+    alignItems: 'center',
+    gap: '0.5rem',
+    minWidth: '250px',
+    transform: 'translateX(100%)',
+    transition: 'transform 0.3s ease'
+  });
+  
+  document.body.appendChild(toast);
+  
+  // 触发动画
+  setTimeout(() => {
+    toast.style.transform = 'translateX(0)';
+  }, 100);
+  
+  // 自动移除
+  setTimeout(() => {
+    toast.style.transform = 'translateX(100%)';
+    setTimeout(() => {
+      if (toast.parentNode) {
+        toast.parentNode.removeChild(toast);
+      }
+    }, 300);
+  }, duration);
+}
+
+function getToastIcon(type: string): string {
+  const iconMap: Record<string, string> = {
+    success: 'check-circle',
+    error: 'x-circle',
+    warning: 'exclamation-triangle',
+    info: 'info-circle'
+  };
+  return iconMap[type] || 'info-circle';
+}
+
+// 数组去重
+export function uniqueArray<T>(array: T[], key?: keyof T): T[] {
+  if (!key) return [...new Set(array)];
+  
+  const seen = new Set();
+  return array.filter(item => {
+    const value = item[key];
+    if (seen.has(value)) {
+      return false;
+    }
+    seen.add(value);
+    return true;
+  });
+}
+
+// 数组分组
+export function groupBy<T>(array: T[], key: keyof T): Record<string, T[]> {
+  return array.reduce((groups, item) => {
+    const groupKey = String(item[key]);
+    if (!groups[groupKey]) {
+      groups[groupKey] = [];
+    }
+    groups[groupKey].push(item);
+    return groups;
+  }, {} as Record<string, T[]>);
+}
+
+// 数组排序
+export function sortBy<T>(array: T[], key: keyof T, direction: 'asc' | 'desc' = 'asc'): T[] {
+  return [...array].sort((a, b) => {
+    const aVal = a[key];
+    const bVal = b[key];
+    
+    if (aVal === null || aVal === undefined) return direction === 'asc' ? 1 : -1;
+    if (bVal === null || bVal === undefined) return direction === 'asc' ? -1 : 1;
+    
+    let comparison = 0;
+    if (typeof aVal === 'number' && typeof bVal === 'number') {
+      comparison = aVal - bVal;
+    } else {
+      comparison = String(aVal).localeCompare(String(bVal));
+    }
+    
+    return direction === 'asc' ? comparison : -comparison;
+  });
+}
+
+// 检查对象是否为空
+export function isEmpty(obj: any): boolean {
+  if (obj == null) return true;
+  if (Array.isArray(obj)) return obj.length === 0;
+  if (typeof obj === 'object') return Object.keys(obj).length === 0;
+  return false;
+}
+
+// 合并对象
+export function mergeObjects<T extends Record<string, any>>(...objects: Partial<T>[]): T {
+  return objects.reduce((result, obj) => {
+    return { ...result, ...obj };
+  }, {} as T);
+}
+
+// 获取嵌套对象属性
+export function getNestedProperty(obj: any, path: string): any {
+  return path.split('.').reduce((current, key) => current?.[key], obj);
+}
+
+// 设置嵌套对象属性
+export function setNestedProperty(obj: any, path: string, value: any): void {
+  const keys = path.split('.');
+  const lastKey = keys.pop()!;
+  const target = keys.reduce((current, key) => {
+    if (!current[key] || typeof current[key] !== 'object') {
+      current[key] = {};
+    }
+    return current[key];
+  }, obj);
+  target[lastKey] = value;
+}

package/src/platform/index.ts

@@ -0,0 +1,33 @@
+import { createApp } from 'vue';
+import App from './App.vue';
+import router from './router';
+import { createPinia } from 'pinia';
+import piniaPluginPersistedstate from 'pinia-plugin-persistedstate';
+
+// 引入 vconsole 进行调试
+import VConsole from 'vconsole';
+new VConsole();
+
+import 'bootstrap/dist/css/bootstrap.css';
+import 'bootstrap-icons/font/bootstrap-icons.css';
+import '@/assets/database.css';
+import 'bootstrap';
+
+import toastPlugin from '@/components/toast/index';
+import Modal from '@/components/modal/index.vue';
+import DataGrid from '@/components/dataGrid/index.vue';
+import modalPlugin from '@/components/modal/index';
+
+const app = createApp(App);
+const pinia = createPinia();
+pinia.use(piniaPluginPersistedstate);
+
+app.use(router);
+app.use(pinia);
+app.use(toastPlugin);
+app.use(modalPlugin);
+
+app.component('Modal', Modal)
+app.component('DataGrid', DataGrid)
+
+app.mount('#app');

package/src/platform/router.ts

@@ -0,0 +1,41 @@
+import { createRouter, createWebHistory } from 'vue-router';
+import { useTitle } from '@vueuse/core';
+import { abortAllPending } from '@/adapter/ajax';
+import { checkLogin, initLoginState } from '@/service/login';
+
+import databaseRouters from './database/router';
+
+export const router = createRouter({
+    history: createWebHistory(import.meta.env.BASE_URL),
+    routes: [
+        // 数据库管理
+        ...databaseRouters,
+        {
+            path: '/:pathMatch(.*)*',
+            name: 'not-found',
+            redirect: '/database/index',
+        },
+    ],
+});
+
+router.beforeEach(async (to, from, next) => {
+    // 切换路由取消请求
+    abortAllPending();
+    
+    const ret = await initLoginState(to);
+    if(ret === false) return;
+
+    // 校验登陆态
+    if(to.meta?.needAuth) {
+        await checkLogin();
+    }
+    next();
+});
+
+router.afterEach((to) => {
+    if (to.meta?.title) {
+        useTitle(to.meta.title as string);
+    }
+  });
+
+export default router;

package/src/service/base.ts

@@ -0,0 +1,128 @@
+
+import * as requestHelper from '@/utils/request';
+import type { AxiosRequestConfig } from 'axios';
+import * as eventBus from '../base/eventBus';
+import config from '../base/config';
+import { isNWjs } from '@/base/detect';
+
+
+
+export function getRequestUrl(api: string) {
+    if(/^(http(s)?:)?\/\//.test(api)) return api;
+    const apiUrl = config.apiUrl || `${location.protocol}//${location.hostname}${[80,443].includes(Number(location.port))?'':(':'+location.port)}`;
+    return `${apiUrl.trim()}${config.prefix}${api}`;
+}
+
+export async function requestServer(url: string, data?: any, option?: AxiosRequestConfig) {
+    // 检查是否在 nw.js 环境中运行
+    if (isNWjs) {
+        // 在 nw.js 环境中，直接 require 后端服务代码并执行
+        try {
+            // 提取 API 路径，去掉前缀和协议等
+            const apiPath = url.replace(/^(http(s)?:)?\/\//, '').replace(/.*?\/api\//, '/api/');
+            
+            // 在 nw.js 环境中，使用 Node.js 的 require 方法加载服务端代码
+            // 服务端代码现在是 CommonJS 模块，使用 .cjs 扩展名
+            let server;
+            
+            // 尝试使用 Node.js 的 require 方法
+            try {
+                // 路径 1: 直接从项目根目录加载
+                server = require('../server/index.js');
+            } catch (e) {
+                try {
+                    // 路径 2: 使用 Node.js 的 path 模块获取正确路径
+                    const path = require('path');
+                    const fs = require('fs');
+                    const appPath = process.cwd();
+                    const serverFilePath = path.join(appPath, 'server', 'index.js');
+                    
+                    console.log('尝试加载服务端代码:', serverFilePath);
+                    
+                    if (fs.existsSync(serverFilePath)) {
+                        server = require(serverFilePath);
+                    } else {
+                        // 路径 3: 尝试相对路径
+                        server = require('./server/index.js');
+                    }
+                } catch (err) {
+                    console.error('所有路径尝试失败:', err);
+                    throw new Error('无法加载服务端代码');
+                }
+            }
+            
+            const res = await server.handleDatabaseRoutes(apiPath, data);
+            // 模拟 HTTP 响应格式
+            return {
+                status: 200,
+                statusText: 'OK',
+                data: {
+                    ret: 0,
+                    msg: 'success',
+                    data: res
+                }
+            };
+        } catch (error) {
+            console.error('NW.js 环境下执行后端代码失败:', error);
+            // 模拟错误响应
+            return {
+                status: 500,
+                statusText: 'Internal Server Error',
+                data: {
+                    ret: 500,
+                    // @ts-ignore
+                    msg: error.message || '执行失败'
+                }
+            };
+        }
+    } else {
+        // 在浏览器环境中使用 HTTP 请求
+        url = getRequestUrl(url);
+        const res = await requestHelper.request(url, data, option);
+        return res;
+    }
+}
+
+// 请求服务
+export async function request<T = any>(url: string, data?: any, option?: AxiosRequestConfig) {    
+    const res = await requestServer(url, data, option);
+    
+    // 处理服务器直接返回的数据（如数组）
+    if (!res || res instanceof Array) {
+        return res as T;
+    }
+    
+    // 确保res是对象类型
+    if (typeof res !== 'object') {
+        return res as T;
+    }
+    
+    // 检查HTTP状态码
+    if(res.status !== 200) {
+        throw {
+            ret: res.status,
+            msg: res.statusText,
+        };
+    }
+    
+    // 处理新的响应格式 {ret:0,msg:'',data:any}
+    const responseData = res.data;
+    
+        
+    // 特殊处理登录态失效的情况
+    if(responseData.ret === 50001) {
+        console.error('登陆态失效，请重新登陆后再试');
+        eventBus.publish(eventBus.AUTHTIMEOUT, { message: responseData.msg || '登陆态失效，请重新登陆后再试' });
+    }
+    
+    // 返回data字段内容
+    return responseData as T;
+}
+
+// 请求管理端接口代理
+export async function requestBaseServerApi(api: string, data?: any): Promise<any> {
+    return request('/admin/requestBaseServer', {
+        api,
+        data,
+    });
+}