596 lines
19 KiB
TypeScript
596 lines
19 KiB
TypeScript
// app/api/postgrest-client.ts
|
|
import { apiRequest, type QueryParams } from './client';
|
|
import { handleApiError } from './error-handler';
|
|
|
|
/**
|
|
* PostgresREST 特定的查询参数接口
|
|
*/
|
|
export interface PostgrestParams {
|
|
select?: string;
|
|
order?: string;
|
|
limit?: number;
|
|
offset?: number;
|
|
filter?: Record<string, unknown>;
|
|
schema?: string; // 指定 PostgreSQL schema
|
|
or?: Array<Record<string, unknown>> | string; // 支持OR条件查询
|
|
[key: string]: unknown; // 允许添加其他参数
|
|
headers?: Record<string, string>;
|
|
}
|
|
|
|
/**
|
|
* 打印 PostgREST 查询日志
|
|
* @param endpoint 端点
|
|
* @param params 参数
|
|
* @param method HTTP 方法
|
|
*/
|
|
function logPostgrestQuery(endpoint: string, params?: QueryParams, method: string = 'GET'): void {
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
// const baseUrl = 'http://172.16.0.119:9000/admin';
|
|
// const baseUrl = 'http://172.18.0.100:3000';
|
|
const baseUrl = 'http://nas.7bm.co:3000';
|
|
|
|
// 确保 endpoint 格式正确
|
|
const normalizedEndpoint = endpoint.startsWith('/') ? endpoint.substring(1) : endpoint;
|
|
|
|
console.log('\n📦 PostgREST 查询日志 ========================');
|
|
console.log(`📦 HTTP 方法: ${method}`);
|
|
console.log(`📦 API 端点: ${baseUrl}/${normalizedEndpoint}`);
|
|
|
|
if (params && Object.keys(params).length > 0) {
|
|
console.log('📦 查询参数:');
|
|
|
|
// 以可读格式单独打印每个参数
|
|
Object.entries(params).forEach(([key, value]) => {
|
|
if (value !== undefined) {
|
|
if (key === 'select' && typeof value === 'string') {
|
|
// 美化 select 参数，使其看起来像 SQL 查询
|
|
console.log(` - ${key}:`);
|
|
const fields = value.replace(/\s+/g, ' ').trim().split(',');
|
|
fields.forEach(field => {
|
|
console.log(` ${field.trim()}`);
|
|
});
|
|
} else if (key === 'order' && typeof value === 'string') {
|
|
// 格式化排序参数
|
|
console.log(` - ${key}: ${value.replace(/\./g, ' ')}`); // 例如：created_at desc
|
|
} else if (key === 'or' && typeof value === 'string') {
|
|
// 格式化OR条件
|
|
console.log(` - ${key}: ${value.replace(/\./g, ' -> ').replace(/,/g, ' 或 ')}`);
|
|
} else {
|
|
console.log(` - ${key}: ${JSON.stringify(value)}`);
|
|
}
|
|
}
|
|
});
|
|
|
|
// 构建人类可读的简化URL
|
|
const readableQueryString = Object.entries(params)
|
|
.filter(([, value]) => value !== undefined)
|
|
.map(([key, value]) => {
|
|
if (key === 'select' && typeof value === 'string') {
|
|
// 简化select查询
|
|
return `${key}=...`;
|
|
}
|
|
return `${key}=${value}`;
|
|
})
|
|
.join('&');
|
|
|
|
console.log(`\n📦 可读URL: ${baseUrl}/${normalizedEndpoint}${readableQueryString ? '?' + readableQueryString : ''}`);
|
|
|
|
// 格式化查询为 PostgreSQL 风格的查询
|
|
let postgrestQuery = `${method.toUpperCase()} `;
|
|
|
|
if (params.select && typeof params.select === 'string') {
|
|
postgrestQuery += params.select.replace(/\s+/g, ' ').trim();
|
|
} else {
|
|
postgrestQuery += '*';
|
|
}
|
|
|
|
postgrestQuery += ` FROM ${normalizedEndpoint}`;
|
|
|
|
const conditions: string[] = [];
|
|
|
|
// 添加过滤条件
|
|
if (params.filter) {
|
|
Object.entries(params.filter).forEach(([key, value]) => {
|
|
if (value !== undefined && typeof value === 'string') {
|
|
// 解析 eq.X, neq.X, gt.X 等
|
|
const parts = value.toString().split('.');
|
|
if (parts.length >= 2) {
|
|
const operator = parts[0];
|
|
const operatorMap: Record<string, string> = {
|
|
'eq': '=',
|
|
'neq': '!=',
|
|
'gt': '>',
|
|
'gte': '>=',
|
|
'lt': '<',
|
|
'lte': '<=',
|
|
'like': 'LIKE',
|
|
'ilike': 'ILIKE'
|
|
};
|
|
|
|
const sqlOperator = operatorMap[operator] || operator;
|
|
const value = parts.slice(1).join('.');
|
|
conditions.push(`${key} ${sqlOperator} '${value}'`);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// 添加 OR 条件
|
|
if (params.or) {
|
|
if (typeof params.or === 'string') {
|
|
if (params.or.startsWith('(') && params.or.endsWith(')')) {
|
|
// 处理 or=(cond1,cond2) 格式
|
|
const orConditions = params.or.slice(1, -1).split(',').map(cond => {
|
|
const [field, operator] = cond.split('.');
|
|
return `${field} ${operator.replace(/ilike/i, 'ILIKE')}`;
|
|
});
|
|
|
|
if (orConditions.length > 0) {
|
|
conditions.push(`(${orConditions.join(' OR ')})`);
|
|
}
|
|
} else {
|
|
// 简单 or 条件
|
|
conditions.push(params.or);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 添加WHERE子句
|
|
if (conditions.length > 0) {
|
|
postgrestQuery += ` WHERE ${conditions.join(' AND ')}`;
|
|
}
|
|
|
|
// 添加ORDER BY
|
|
if (params.order && typeof params.order === 'string') {
|
|
const [field, direction] = params.order.split('.');
|
|
postgrestQuery += ` ORDER BY ${field} ${direction.toUpperCase()}`;
|
|
}
|
|
|
|
// 添加LIMIT和OFFSET
|
|
if (params.limit !== undefined) {
|
|
postgrestQuery += ` LIMIT ${params.limit}`;
|
|
}
|
|
|
|
if (params.offset !== undefined) {
|
|
postgrestQuery += ` OFFSET ${params.offset}`;
|
|
}
|
|
|
|
console.log('\n📦 等效SQL查询:');
|
|
console.log(postgrestQuery);
|
|
console.log('=========================================\n');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 将通用查询参数转换为 PostgresREST 支持的格式
|
|
* @param params 查询参数
|
|
* @returns 转换后的 PostgresREST 参数
|
|
*/
|
|
export function transformParams(params: PostgrestParams): QueryParams {
|
|
const result: QueryParams = {};
|
|
|
|
// 处理 select 参数
|
|
if (params.select) {
|
|
result.select = params.select;
|
|
}
|
|
|
|
// 处理 order 参数
|
|
if (params.order) {
|
|
result.order = params.order;
|
|
}
|
|
|
|
// 处理 limit 和 offset 参数
|
|
if (params.limit !== undefined) {
|
|
result.limit = params.limit;
|
|
}
|
|
|
|
if (params.offset !== undefined) {
|
|
result.offset = params.offset;
|
|
}
|
|
|
|
// 处理 schema 参数
|
|
if (params.schema) {
|
|
result.schema = params.schema;
|
|
}
|
|
|
|
// 处理或条件 (OR) - 两种格式支持
|
|
if (params.or) {
|
|
// 如果是字符串格式 (例如 "name.ilike.*keyword*,code.ilike.*keyword*")
|
|
if (typeof params.or === 'string') {
|
|
result.or = params.or;
|
|
}
|
|
// 如果是数组格式, 转换为 PostgREST 的 or=(condition1,condition2) 格式
|
|
else if (Array.isArray(params.or)) {
|
|
const orConditions: string[] = [];
|
|
|
|
params.or.forEach(condition => {
|
|
const entries = Object.entries(condition);
|
|
if (entries.length === 1) {
|
|
const [field, operator] = entries[0];
|
|
orConditions.push(`${field}.${operator}`);
|
|
}
|
|
});
|
|
|
|
if (orConditions.length > 0) {
|
|
result.or = `(${orConditions.join(',')})`;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 处理过滤条件 - PostgresREST 格式
|
|
if (params.filter) {
|
|
Object.entries(params.filter).forEach(([key, value]) => {
|
|
// 如果值不为 undefined，则添加到查询参数中
|
|
if (value !== undefined) {
|
|
// 支持 PostgreSQL 的比较操作符 (eq, gt, lt, gte, lte, like, ilike 等)
|
|
result[key] = value as string | number | boolean;
|
|
}
|
|
});
|
|
}
|
|
|
|
// 处理其他额外参数
|
|
Object.entries(params).forEach(([key, value]) => {
|
|
// 跳过已处理的特殊参数
|
|
if (!['select', 'order', 'limit', 'offset', 'filter', 'schema', 'or'].includes(key) && value !== undefined) {
|
|
result[key] = value as string | number | boolean;
|
|
}
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* 发送 GET 请求到 PostgresREST 接口
|
|
* @param endpoint 端点
|
|
* @param params 查询参数
|
|
* @returns 响应数据
|
|
*/
|
|
export async function postgrestGet<T>(endpoint: string, params?: PostgrestParams): Promise<{data: T; headers?: Record<string, string>; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
const queryParams = params ? transformParams(params) : {};
|
|
// 确保端点没有前导斜杠，因为API_BASE_URL已经包含了路径前缀
|
|
const apiEndpoint = endpoint.startsWith('/') ? endpoint.substring(1) : endpoint;
|
|
|
|
// 打印查询信息
|
|
logPostgrestQuery(apiEndpoint, queryParams, 'GET');
|
|
|
|
// 提取并移除自定义头部参数
|
|
const headers: Record<string, string> = params?.headers || {};
|
|
|
|
// 清除查询参数中的headers属性，避免将其作为URL参数
|
|
if (queryParams.headers) {
|
|
delete queryParams.headers;
|
|
}
|
|
|
|
const response = await apiRequest<T>(
|
|
apiEndpoint,
|
|
{
|
|
method: 'GET',
|
|
headers: headers
|
|
},
|
|
queryParams
|
|
);
|
|
|
|
if (response.error) {
|
|
throw new Error(response.error);
|
|
}
|
|
|
|
// 返回数据和响应头
|
|
return {
|
|
data: response.data as T,
|
|
headers: response.headers // 假设apiRequest函数已返回响应头
|
|
};
|
|
} catch (error) {
|
|
const apiError = handleApiError(error);
|
|
return { error: apiError.message, status: apiError.status };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 处理 PostgreSQL 特定错误
|
|
* @param error 错误对象或消息
|
|
* @param responseText 原始响应文本
|
|
* @returns 格式化的错误信息
|
|
*/
|
|
function handlePostgresError(error: unknown, responseText?: string): { message: string, status?: number } {
|
|
let errorMessage = error instanceof Error ? error.message : String(error);
|
|
let statusCode: number | undefined = undefined;
|
|
|
|
// 如果有原始响应文本，尝试从中提取更详细的错误信息
|
|
if (responseText) {
|
|
try {
|
|
const errorData = JSON.parse(responseText);
|
|
|
|
// 处理 PostgreSQL 错误码
|
|
if (errorData.code) {
|
|
switch (errorData.code) {
|
|
case '23505': // 唯一约束冲突
|
|
errorMessage = '记录已存在，无法创建重复数据';
|
|
if (errorData.details) {
|
|
// 尝试提取冲突的字段名
|
|
const match = errorData.details.match(/Key \((.+?)\)=/);
|
|
if (match && match[1]) {
|
|
const field = match[1];
|
|
errorMessage = `${field} 已存在，请使用不同的值`;
|
|
}
|
|
}
|
|
statusCode = 409; // Conflict
|
|
break;
|
|
|
|
case '23503': // 外键约束失败
|
|
errorMessage = '引用的记录不存在';
|
|
if (errorData.details) {
|
|
// 尝试提取外键字段
|
|
const match = errorData.details.match(/Key \((.+?)\)=/);
|
|
if (match && match[1]) {
|
|
const field = match[1];
|
|
errorMessage = `所引用的 ${field} 不存在或无效`;
|
|
}
|
|
}
|
|
statusCode = 400; // Bad Request
|
|
break;
|
|
|
|
case '42P01': // 表不存在
|
|
errorMessage = '所请求的数据表不存在';
|
|
statusCode = 404; // Not Found
|
|
break;
|
|
|
|
case '42703': // 列不存在
|
|
errorMessage = '所引用的字段不存在';
|
|
if (errorData.details) {
|
|
const match = errorData.details.match(/column "(.+?)"/);
|
|
if (match && match[1]) {
|
|
const column = match[1];
|
|
errorMessage = `字段 "${column}" 不存在`;
|
|
}
|
|
}
|
|
statusCode = 400; // Bad Request
|
|
break;
|
|
|
|
default:
|
|
// 使用 PostgreSQL 提供的错误消息
|
|
if (errorData.message) {
|
|
errorMessage = errorData.message;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 处理 HTTP 状态码
|
|
if (errorData.status) {
|
|
statusCode = errorData.status;
|
|
}
|
|
|
|
} catch (e) {
|
|
console.error('解析错误响应失败:', e);
|
|
// 如果解析失败，尝试直接使用响应文本
|
|
if (responseText && responseText.length < 200) {
|
|
errorMessage = responseText;
|
|
}
|
|
}
|
|
}
|
|
|
|
return { message: errorMessage, status: statusCode };
|
|
}
|
|
|
|
/**
|
|
* 发送 POST 请求到 PostgresREST 接口
|
|
* @param endpoint 端点（表名）
|
|
* @param data 请求体数据
|
|
* @returns 响应数据
|
|
*/
|
|
export async function postgrestPost<T, D = Record<string, unknown>>(endpoint: string, data: D): Promise<{data: T; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
// 确保端点没有前导斜杠
|
|
const apiEndpoint = endpoint.startsWith('/') ? endpoint.substring(1) : endpoint;
|
|
|
|
// 打印查询信息（POST请求只打印端点）
|
|
logPostgrestQuery(apiEndpoint, undefined, 'POST');
|
|
|
|
// 预处理数据，确保所有字段类型符合 PostgreSQL 要求
|
|
const processedData = preprocessData(data as Record<string, unknown>);
|
|
|
|
// 确保数据是合法的JSON对象
|
|
const requestBody = JSON.stringify(processedData);
|
|
console.log(`准备发送 PostgreSQL 插入请求到: ${apiEndpoint}`);
|
|
console.log(`请求体: ${requestBody}`);
|
|
|
|
try {
|
|
const response = await apiRequest<T>(
|
|
apiEndpoint,
|
|
{
|
|
method: 'POST',
|
|
body: requestBody,
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Accept': 'application/json',
|
|
'Prefer': 'return=representation'
|
|
}
|
|
}
|
|
);
|
|
|
|
if (response.error) {
|
|
console.error(`POST请求失败: ${response.error}`);
|
|
throw new Error(response.error);
|
|
}
|
|
|
|
console.log(`POST请求成功，响应: `, response.data);
|
|
return { data: response.data as T };
|
|
} catch (error) {
|
|
// 捕获并处理 API 请求错误
|
|
let errorText = '';
|
|
|
|
// 如果错误对象中包含响应文本，尝试提取更详细的错误信息
|
|
if (error instanceof Error && 'responseText' in error) {
|
|
errorText = (error as {responseText: string}).responseText;
|
|
}
|
|
|
|
// 处理 PostgreSQL 特定错误
|
|
const pgError = handlePostgresError(error, errorText);
|
|
|
|
console.error(`POST请求错误: ${pgError.message}`);
|
|
return {
|
|
error: pgError.message,
|
|
status: pgError.status || 500
|
|
};
|
|
}
|
|
} catch (error) {
|
|
console.error(`POST请求处理错误: ${error instanceof Error ? error.message : String(error)}`);
|
|
const apiError = handleApiError(error);
|
|
return { error: apiError.message, status: apiError.status };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 预处理数据，确保类型与 PostgreSQL 兼容
|
|
* @param data 原始数据
|
|
* @returns 处理后的数据
|
|
*/
|
|
function preprocessData(data: Record<string, unknown>): Record<string, unknown> {
|
|
const processed: Record<string, unknown> = {};
|
|
|
|
for (const [key, value] of Object.entries(data)) {
|
|
// 确保 null 值被正确处理
|
|
if (value === null) {
|
|
processed[key] = null;
|
|
continue;
|
|
}
|
|
|
|
// 处理字符串可能被错误解析为数字的情况
|
|
if (typeof value === 'string' && /^\d+$/.test(value) && key !== 'code' && !key.endsWith('_id')) {
|
|
// 对于可能需要保持字符串格式的值，我们不进行数字转换
|
|
processed[key] = value;
|
|
}
|
|
// 将字符串 'true'/'false' 转为布尔值
|
|
else if (typeof value === 'string' && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
|
|
processed[key] = value.toLowerCase() === 'true';
|
|
}
|
|
// 尝试转换 '0'/'1' 为 boolean （如果字段名暗示是布尔值）
|
|
else if (typeof value === 'string' && (value === '0' || value === '1') &&
|
|
(key.startsWith('is_') || key.startsWith('has_') || key.endsWith('_enabled'))) {
|
|
processed[key] = value === '1';
|
|
}
|
|
// 对于ID字段确保使用正确的类型
|
|
else if ((key === 'id' || key.endsWith('_id') || key === 'pid') && value !== undefined) {
|
|
try {
|
|
const numValue = Number(value);
|
|
if (!isNaN(numValue)) {
|
|
processed[key] = numValue;
|
|
} else {
|
|
processed[key] = value;
|
|
}
|
|
} catch {
|
|
processed[key] = value;
|
|
}
|
|
}
|
|
// 其他值保持不变
|
|
else {
|
|
processed[key] = value;
|
|
}
|
|
}
|
|
|
|
return processed;
|
|
}
|
|
|
|
/**
|
|
* 发送 PUT 请求到 PostgresREST 接口
|
|
* @param endpoint 端点
|
|
* @param data 请求体数据
|
|
* @param filters 过滤条件
|
|
* @returns 响应数据
|
|
*/
|
|
export async function postgrestPut<T, D extends object>(
|
|
endpoint: string,
|
|
data: D,
|
|
filters?: Record<string | number, string | number>
|
|
): Promise<{data: T; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
// 确保端点没有前导斜杠
|
|
const apiEndpoint = endpoint.startsWith('/') ? endpoint.substring(1) : endpoint;
|
|
|
|
// 构建完整的URL，包含过滤条件
|
|
let fullEndpoint = apiEndpoint;
|
|
if (filters) {
|
|
const filterString = Object.entries(filters)
|
|
.map(([key, value]) => `${key}=eq.${value}`)
|
|
.join('&');
|
|
fullEndpoint = `${apiEndpoint}?${filterString}`;
|
|
}
|
|
|
|
// 打印查询信息（PUT请求只打印端点）
|
|
logPostgrestQuery(fullEndpoint, undefined, 'PATCH');
|
|
|
|
const response = await apiRequest<T>(
|
|
fullEndpoint,
|
|
{
|
|
method: 'PATCH',
|
|
body: JSON.stringify(data),
|
|
headers: {
|
|
'Prefer': 'return=representation'
|
|
}
|
|
}
|
|
);
|
|
|
|
if (response.error) {
|
|
throw new Error(response.error);
|
|
}
|
|
|
|
if (!response.data) {
|
|
throw new Error('更新成功但未返回数据');
|
|
}
|
|
|
|
return { data: response.data };
|
|
} catch (error) {
|
|
const apiError = handleApiError(error);
|
|
return { error: apiError.message, status: apiError.status };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 发送 DELETE 请求到 PostgresREST 接口
|
|
* @param endpoint 端点
|
|
* @param params 查询参数，用于指定要删除的记录
|
|
* @returns 响应数据
|
|
*/
|
|
export async function postgrestDelete<T>(endpoint: string, params?: PostgrestParams): Promise<{data: T; error?: never} | {data?: never; error: string; status?: number}> {
|
|
try {
|
|
// 确保端点没有前导斜杠
|
|
const apiEndpoint = endpoint.startsWith('/') ? endpoint.substring(1) : endpoint;
|
|
|
|
// 转换查询参数
|
|
const queryParams = params ? transformParams(params) : {};
|
|
|
|
// 提取并移除自定义头部参数
|
|
const headers: Record<string, string> = {
|
|
'Prefer': 'return=representation', // 默认请求返回被删除的记录
|
|
...(params?.headers || {})
|
|
};
|
|
|
|
// 清除查询参数中的headers属性，避免将其作为URL参数
|
|
if (queryParams.headers) {
|
|
delete queryParams.headers;
|
|
}
|
|
|
|
// 打印查询信息
|
|
logPostgrestQuery(apiEndpoint, queryParams, 'DELETE');
|
|
|
|
const response = await apiRequest<T>(
|
|
apiEndpoint,
|
|
{
|
|
method: 'DELETE',
|
|
headers
|
|
},
|
|
queryParams
|
|
);
|
|
|
|
if (response.error) {
|
|
throw new Error(response.error);
|
|
}
|
|
|
|
return { data: response.data as T };
|
|
} catch (error) {
|
|
const apiError = handleApiError(error);
|
|
return { error: apiError.message, status: apiError.status };
|
|
}
|
|
} |