john
9b4a25799f
Replace fixed ackText with a rule-based AckProvider that picks response templates by message type and intent (translate, summary, rewrite, poster, ppt, mindmap, code, search, schedule). Pure sync, zero I/O, auto-falls back to config.ackText on any error. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
560 lines
21 KiB
JavaScript
560 lines
21 KiB
JavaScript
import fs from 'node:fs';
|
|
import mysql from 'mysql2/promise';
|
|
import path from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { ensureDefaultSpaces } from './mindspace.mjs';
|
|
|
|
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
|
|
|
export function isDatabaseConfigured() {
|
|
return Boolean(
|
|
process.env.DATABASE_URL ||
|
|
(process.env.MYSQL_HOST && process.env.MYSQL_DATABASE),
|
|
);
|
|
}
|
|
|
|
export function createDbPool() {
|
|
if (!isDatabaseConfigured()) {
|
|
throw new Error('MySQL 未配置，请设置 DATABASE_URL 或 MYSQL_* 环境变量');
|
|
}
|
|
|
|
if (process.env.DATABASE_URL) {
|
|
return mysql.createPool(process.env.DATABASE_URL);
|
|
}
|
|
|
|
return mysql.createPool({
|
|
host: process.env.MYSQL_HOST ?? 'localhost',
|
|
port: Number(process.env.MYSQL_PORT ?? 3306),
|
|
user: process.env.MYSQL_USER ?? 'boot',
|
|
password: process.env.MYSQL_PASSWORD ?? '',
|
|
database: process.env.MYSQL_DATABASE ?? 'tkmind',
|
|
waitForConnections: true,
|
|
connectionLimit: 10,
|
|
});
|
|
}
|
|
|
|
async function columnExists(pool, table, column) {
|
|
const [rows] = await pool.query(
|
|
`SELECT 1 FROM information_schema.COLUMNS
|
|
WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? AND COLUMN_NAME = ?
|
|
LIMIT 1`,
|
|
[table, column],
|
|
);
|
|
return rows.length > 0;
|
|
}
|
|
|
|
async function indexExists(pool, table, index) {
|
|
const [rows] = await pool.query(
|
|
`SELECT 1 FROM information_schema.STATISTICS
|
|
WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? AND INDEX_NAME = ?
|
|
LIMIT 1`,
|
|
[table, index],
|
|
);
|
|
return rows.length > 0;
|
|
}
|
|
|
|
async function foreignKeyDeleteRule(pool, table, constraint) {
|
|
const [rows] = await pool.query(
|
|
`SELECT DELETE_RULE
|
|
FROM information_schema.REFERENTIAL_CONSTRAINTS
|
|
WHERE CONSTRAINT_SCHEMA = DATABASE()
|
|
AND TABLE_NAME = ?
|
|
AND CONSTRAINT_NAME = ?
|
|
LIMIT 1`,
|
|
[table, constraint],
|
|
);
|
|
return rows[0]?.DELETE_RULE ?? null;
|
|
}
|
|
|
|
async function ensureForeignKeyDeleteRule(
|
|
pool,
|
|
{ table, constraint, column, referencedTable, referencedColumn = 'id', deleteRule },
|
|
) {
|
|
const currentRule = await foreignKeyDeleteRule(pool, table, constraint);
|
|
if (currentRule === deleteRule) return;
|
|
if (currentRule) {
|
|
await pool.query(`ALTER TABLE \`${table}\` DROP FOREIGN KEY \`${constraint}\``);
|
|
}
|
|
await pool.query(
|
|
`ALTER TABLE \`${table}\`
|
|
ADD CONSTRAINT \`${constraint}\`
|
|
FOREIGN KEY (\`${column}\`) REFERENCES \`${referencedTable}\`(\`${referencedColumn}\`)
|
|
ON DELETE ${deleteRule}`,
|
|
);
|
|
}
|
|
|
|
export async function migrateSchema(pool) {
|
|
const renames = [
|
|
['h5_user_sessions', 'goose_session_id', 'agent_session_id'],
|
|
['h5_session_billing_state', 'goose_session_id', 'agent_session_id'],
|
|
['h5_usage_records', 'goose_session_id', 'agent_session_id'],
|
|
];
|
|
for (const [table, oldCol, newCol] of renames) {
|
|
if (await columnExists(pool, table, oldCol)) {
|
|
await pool.query(
|
|
`ALTER TABLE \`${table}\` CHANGE \`${oldCol}\` \`${newCol}\` VARCHAR(128) NOT NULL`,
|
|
);
|
|
}
|
|
}
|
|
|
|
const userColumns = [
|
|
['slug', 'VARCHAR(64) NULL AFTER username'],
|
|
['email', 'VARCHAR(255) NULL AFTER slug'],
|
|
[
|
|
'password_algorithm',
|
|
"VARCHAR(32) NOT NULL DEFAULT 'pbkdf2-sha512' AFTER password_hash",
|
|
],
|
|
['plan_type', "VARCHAR(32) NOT NULL DEFAULT 'free' AFTER status"],
|
|
];
|
|
for (const [column, definition] of userColumns) {
|
|
if (!(await columnExists(pool, 'h5_users', column))) {
|
|
await pool.query(`ALTER TABLE h5_users ADD COLUMN \`${column}\` ${definition}`);
|
|
}
|
|
}
|
|
|
|
await pool.query(`UPDATE h5_users SET slug = username WHERE slug IS NULL OR slug = ''`);
|
|
if (!(await indexExists(pool, 'h5_users', 'uq_h5_users_slug'))) {
|
|
await pool.query(`ALTER TABLE h5_users ADD UNIQUE KEY uq_h5_users_slug (slug)`);
|
|
}
|
|
if (!(await indexExists(pool, 'h5_users', 'uq_h5_users_email'))) {
|
|
await pool.query(`ALTER TABLE h5_users ADD UNIQUE KEY uq_h5_users_email (email)`);
|
|
}
|
|
|
|
const assetForeignKeys = [
|
|
{
|
|
table: 'h5_assets',
|
|
constraint: 'fk_h5_asset_category',
|
|
column: 'category_id',
|
|
referencedTable: 'h5_space_categories',
|
|
deleteRule: 'CASCADE',
|
|
},
|
|
{
|
|
table: 'h5_assets',
|
|
constraint: 'fk_h5_asset_parent',
|
|
column: 'parent_id',
|
|
referencedTable: 'h5_assets',
|
|
deleteRule: 'SET NULL',
|
|
},
|
|
{
|
|
table: 'h5_asset_versions',
|
|
constraint: 'fk_h5_asset_version_user',
|
|
column: 'created_by',
|
|
referencedTable: 'h5_users',
|
|
deleteRule: 'CASCADE',
|
|
},
|
|
{
|
|
table: 'h5_upload_sessions',
|
|
constraint: 'fk_h5_upload_category',
|
|
column: 'category_id',
|
|
referencedTable: 'h5_space_categories',
|
|
deleteRule: 'CASCADE',
|
|
},
|
|
{
|
|
table: 'h5_page_versions',
|
|
constraint: 'fk_h5_page_version_content',
|
|
column: 'content_asset_id',
|
|
referencedTable: 'h5_assets',
|
|
deleteRule: 'CASCADE',
|
|
},
|
|
];
|
|
for (const foreignKey of assetForeignKeys) {
|
|
await ensureForeignKeyDeleteRule(pool, foreignKey);
|
|
}
|
|
|
|
await pool.query(
|
|
`ALTER TABLE h5_assets
|
|
MODIFY source_type ENUM('upload', 'chat', 'agent', 'template', 'generated', 'workspace')
|
|
NOT NULL DEFAULT 'upload'`,
|
|
);
|
|
|
|
const llmColumns = [
|
|
['provider_kind', "ENUM('builtin','custom') NOT NULL DEFAULT 'builtin' AFTER provider_id"],
|
|
['api_url', 'VARCHAR(512) NULL AFTER provider_kind'],
|
|
['base_path', 'VARCHAR(256) NULL AFTER api_url'],
|
|
['models_json', 'TEXT NULL AFTER base_path'],
|
|
['goosed_provider_id', 'VARCHAR(64) NULL AFTER models_json'],
|
|
['engine', "VARCHAR(32) NOT NULL DEFAULT 'openai' AFTER goosed_provider_id"],
|
|
['relay_provider', 'VARCHAR(64) NULL AFTER engine'],
|
|
['is_vision_selected', 'TINYINT(1) NOT NULL DEFAULT 0 AFTER is_selected'],
|
|
];
|
|
for (const [column, definition] of llmColumns) {
|
|
if (!(await columnExists(pool, 'h5_llm_provider_keys', column))) {
|
|
await pool.query(`ALTER TABLE h5_llm_provider_keys ADD COLUMN \`${column}\` ${definition}`);
|
|
}
|
|
}
|
|
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_llm_executor_bindings (
|
|
id CHAR(36) PRIMARY KEY,
|
|
executor ENUM('goose', 'aider', 'openhands') NOT NULL,
|
|
purpose VARCHAR(32) NOT NULL DEFAULT 'default',
|
|
provider_key_id CHAR(36) NULL,
|
|
model VARCHAR(128) NOT NULL,
|
|
enabled TINYINT(1) NOT NULL DEFAULT 1,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at BIGINT NOT NULL,
|
|
UNIQUE KEY uq_h5_llm_executor_binding (executor, purpose),
|
|
KEY idx_h5_llm_executor_provider (provider_key_id),
|
|
CONSTRAINT fk_h5_llm_executor_provider FOREIGN KEY (provider_key_id) REFERENCES h5_llm_provider_keys(id) ON DELETE SET NULL
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
const publishColumns = [
|
|
['plaza_view_count', 'BIGINT NOT NULL DEFAULT 0'],
|
|
['plaza_like_count', 'BIGINT NOT NULL DEFAULT 0'],
|
|
];
|
|
for (const [column, definition] of publishColumns) {
|
|
if (!(await columnExists(pool, 'h5_publish_records', column))) {
|
|
await pool.query(`ALTER TABLE h5_publish_records ADD COLUMN \`${column}\` ${definition}`);
|
|
}
|
|
}
|
|
|
|
const plazaUserColumns = [
|
|
['plaza_post_count', 'INT UNSIGNED NOT NULL DEFAULT 0'],
|
|
['plaza_follower_count', 'INT UNSIGNED NOT NULL DEFAULT 0'],
|
|
['plaza_following_count', 'INT UNSIGNED NOT NULL DEFAULT 0'],
|
|
['plaza_verified', 'TINYINT(1) NOT NULL DEFAULT 0'],
|
|
['plaza_post_banned', 'TINYINT(1) NOT NULL DEFAULT 0'],
|
|
['plaza_comment_banned', 'TINYINT(1) NOT NULL DEFAULT 0'],
|
|
[
|
|
'ops_role',
|
|
"ENUM('none','reviewer','editor','ops_admin') NOT NULL DEFAULT 'none'",
|
|
],
|
|
];
|
|
for (const [column, definition] of plazaUserColumns) {
|
|
if (!(await columnExists(pool, 'h5_users', column))) {
|
|
await pool.query(`ALTER TABLE h5_users ADD COLUMN \`${column}\` ${definition}`);
|
|
}
|
|
}
|
|
|
|
if (!(await columnExists(pool, 'h5_users', 'signup_source'))) {
|
|
await pool.query(
|
|
`ALTER TABLE h5_users ADD COLUMN signup_source VARCHAR(32) NULL DEFAULT 'password' AFTER workspace_root`,
|
|
);
|
|
}
|
|
|
|
if (!(await columnExists(pool, 'h5_user_sessions', 'goosed_node'))) {
|
|
await pool.query(
|
|
`ALTER TABLE h5_user_sessions ADD COLUMN goosed_node TINYINT UNSIGNED NOT NULL DEFAULT 0`,
|
|
);
|
|
}
|
|
|
|
const oauthStateColumns = [
|
|
['intent', "VARCHAR(16) NOT NULL DEFAULT 'login' AFTER utm_campaign"],
|
|
['bind_user_id', 'CHAR(36) NULL AFTER intent'],
|
|
['auth_mode', "VARCHAR(8) NOT NULL DEFAULT 'mp' AFTER bind_user_id"],
|
|
['status', "VARCHAR(16) NOT NULL DEFAULT 'pending' AFTER auth_mode"],
|
|
['result_kind', 'VARCHAR(32) NULL AFTER status'],
|
|
['result_token', 'VARCHAR(512) NULL AFTER result_kind'],
|
|
['result_message', 'VARCHAR(255) NULL AFTER result_token'],
|
|
];
|
|
for (const [column, definition] of oauthStateColumns) {
|
|
if (!(await columnExists(pool, 'h5_wechat_oauth_states', column))) {
|
|
await pool.query(
|
|
`ALTER TABLE h5_wechat_oauth_states ADD COLUMN \`${column}\` ${definition}`,
|
|
);
|
|
}
|
|
}
|
|
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_wechat_pending_binds (
|
|
token VARCHAR(64) PRIMARY KEY,
|
|
app_id VARCHAR(32) NOT NULL,
|
|
openid VARCHAR(64) NOT NULL,
|
|
unionid VARCHAR(64) NULL,
|
|
nickname VARCHAR(128) NULL,
|
|
avatar_url VARCHAR(512) NULL,
|
|
return_to VARCHAR(512) NULL,
|
|
utm_source VARCHAR(64) NULL,
|
|
utm_medium VARCHAR(64) NULL,
|
|
utm_campaign VARCHAR(64) NULL,
|
|
expires_at BIGINT NOT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
KEY idx_wechat_pending_expires (expires_at)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_wechat_mp_messages (
|
|
app_id VARCHAR(32) NOT NULL,
|
|
openid VARCHAR(64) NOT NULL,
|
|
msg_id VARCHAR(128) NOT NULL,
|
|
status ENUM('processing', 'done', 'failed') NOT NULL DEFAULT 'processing',
|
|
agent_session_id VARCHAR(128) NULL,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at BIGINT NOT NULL,
|
|
PRIMARY KEY (app_id, openid, msg_id),
|
|
KEY idx_wechat_mp_messages_updated (updated_at),
|
|
KEY idx_wechat_mp_messages_session (agent_session_id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_wechat_mp_message_details (
|
|
id CHAR(36) PRIMARY KEY,
|
|
app_id VARCHAR(32) NOT NULL,
|
|
openid VARCHAR(64) NOT NULL,
|
|
user_id CHAR(36) NULL,
|
|
msg_id VARCHAR(128) NULL,
|
|
msg_type VARCHAR(32) NOT NULL,
|
|
display_text TEXT NULL,
|
|
agent_text TEXT NULL,
|
|
media_id VARCHAR(256) NULL,
|
|
media_url TEXT NULL,
|
|
media_public_url TEXT NULL,
|
|
media_format VARCHAR(64) NULL,
|
|
location_lat DECIMAL(10,7) NULL,
|
|
location_lng DECIMAL(10,7) NULL,
|
|
location_label VARCHAR(255) NULL,
|
|
link_url TEXT NULL,
|
|
link_title VARCHAR(255) NULL,
|
|
raw_xml_hash CHAR(40) NULL,
|
|
raw_json JSON NULL,
|
|
created_at BIGINT NOT NULL,
|
|
KEY idx_wechat_mp_message_details_user (app_id, openid, created_at),
|
|
KEY idx_wechat_mp_message_details_msg (msg_id),
|
|
KEY idx_wechat_mp_message_details_type (msg_type, created_at),
|
|
CONSTRAINT fk_wechat_mp_message_details_user FOREIGN KEY (user_id) REFERENCES h5_users(id) ON DELETE SET NULL
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_schedule_items (
|
|
id CHAR(36) PRIMARY KEY,
|
|
user_id CHAR(36) NOT NULL,
|
|
kind ENUM('task', 'event') NOT NULL,
|
|
title VARCHAR(255) NOT NULL,
|
|
description TEXT NULL,
|
|
status ENUM('active', 'completed', 'cancelled', 'deleted') NOT NULL DEFAULT 'active',
|
|
start_at BIGINT NULL,
|
|
end_at BIGINT NULL,
|
|
due_at BIGINT NULL,
|
|
all_day TINYINT(1) NOT NULL DEFAULT 0,
|
|
timezone VARCHAR(64) NOT NULL DEFAULT 'Asia/Shanghai',
|
|
location VARCHAR(255) NULL,
|
|
source_channel ENUM('h5', 'wechat', 'agent', 'api') NOT NULL DEFAULT 'agent',
|
|
source_session_id VARCHAR(128) NULL,
|
|
source_message_id VARCHAR(128) NULL,
|
|
source_text TEXT NULL,
|
|
metadata_json JSON NULL,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at BIGINT NOT NULL,
|
|
deleted_at BIGINT NULL,
|
|
KEY idx_schedule_user_time (user_id, status, start_at, due_at),
|
|
KEY idx_schedule_user_updated (user_id, updated_at),
|
|
CONSTRAINT fk_schedule_item_user FOREIGN KEY (user_id) REFERENCES h5_users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_schedule_reminders (
|
|
id CHAR(36) PRIMARY KEY,
|
|
user_id CHAR(36) NOT NULL,
|
|
item_id CHAR(36) NOT NULL,
|
|
remind_at BIGINT NOT NULL,
|
|
offset_minutes INT NULL,
|
|
channel ENUM('wechat', 'in_app') NOT NULL DEFAULT 'wechat',
|
|
status ENUM('pending', 'locked', 'sent', 'failed', 'cancelled') NOT NULL DEFAULT 'pending',
|
|
attempts INT NOT NULL DEFAULT 0,
|
|
last_error VARCHAR(500) NULL,
|
|
locked_until BIGINT NULL,
|
|
sent_at BIGINT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at BIGINT NOT NULL,
|
|
UNIQUE KEY uq_schedule_item_remind_at (item_id, remind_at, channel),
|
|
KEY idx_reminder_due (status, remind_at),
|
|
KEY idx_reminder_user (user_id, status, remind_at),
|
|
CONSTRAINT fk_schedule_reminder_user FOREIGN KEY (user_id) REFERENCES h5_users(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_schedule_reminder_item FOREIGN KEY (item_id) REFERENCES h5_schedule_items(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_schedule_digest_subscriptions (
|
|
id CHAR(36) PRIMARY KEY,
|
|
user_id CHAR(36) NOT NULL,
|
|
digest_type ENUM('todo_day') NOT NULL DEFAULT 'todo_day',
|
|
hour TINYINT UNSIGNED NOT NULL,
|
|
minute TINYINT UNSIGNED NOT NULL DEFAULT 0,
|
|
timezone VARCHAR(64) NOT NULL DEFAULT 'Asia/Shanghai',
|
|
channel ENUM('wechat', 'in_app') NOT NULL DEFAULT 'wechat',
|
|
status ENUM('active', 'locked', 'failed', 'cancelled') NOT NULL DEFAULT 'active',
|
|
next_run_at BIGINT NOT NULL,
|
|
last_run_at BIGINT NULL,
|
|
attempts INT NOT NULL DEFAULT 0,
|
|
locked_until BIGINT NULL,
|
|
last_error VARCHAR(500) NULL,
|
|
source_channel ENUM('h5', 'wechat', 'agent', 'api') NOT NULL DEFAULT 'agent',
|
|
source_session_id VARCHAR(128) NULL,
|
|
source_message_id VARCHAR(128) NULL,
|
|
source_text TEXT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at BIGINT NOT NULL,
|
|
UNIQUE KEY uq_schedule_digest_user_type_channel (user_id, digest_type, channel),
|
|
KEY idx_schedule_digest_due (status, next_run_at),
|
|
CONSTRAINT fk_schedule_digest_user FOREIGN KEY (user_id) REFERENCES h5_users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_balance_alert_subscriptions (
|
|
id CHAR(36) PRIMARY KEY,
|
|
user_id CHAR(36) NOT NULL,
|
|
threshold_cents BIGINT NOT NULL,
|
|
channel ENUM('wechat', 'in_app') NOT NULL DEFAULT 'wechat',
|
|
status ENUM('active', 'locked', 'failed', 'cancelled') NOT NULL DEFAULT 'active',
|
|
next_run_at BIGINT NOT NULL,
|
|
last_run_at BIGINT NULL,
|
|
last_notified_balance_cents BIGINT NULL,
|
|
attempts INT NOT NULL DEFAULT 0,
|
|
locked_until BIGINT NULL,
|
|
last_error VARCHAR(500) NULL,
|
|
source_channel ENUM('h5', 'wechat', 'agent', 'api') NOT NULL DEFAULT 'agent',
|
|
source_session_id VARCHAR(128) NULL,
|
|
source_message_id VARCHAR(128) NULL,
|
|
source_text TEXT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at BIGINT NOT NULL,
|
|
UNIQUE KEY uq_balance_alert_user_channel (user_id, channel),
|
|
KEY idx_balance_alert_due (status, next_run_at),
|
|
KEY idx_balance_alert_user (user_id, status, next_run_at),
|
|
CONSTRAINT fk_balance_alert_user FOREIGN KEY (user_id) REFERENCES h5_users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_schedule_delivery_logs (
|
|
id CHAR(36) PRIMARY KEY,
|
|
reminder_id CHAR(36) NULL,
|
|
subscription_id CHAR(36) NULL,
|
|
user_id CHAR(36) NOT NULL,
|
|
channel ENUM('wechat', 'in_app') NOT NULL,
|
|
status ENUM('success', 'failed') NOT NULL,
|
|
provider_message_id VARCHAR(128) NULL,
|
|
error_code VARCHAR(64) NULL,
|
|
error_message VARCHAR(500) NULL,
|
|
created_at BIGINT NOT NULL,
|
|
KEY idx_delivery_reminder (reminder_id, created_at),
|
|
KEY idx_delivery_subscription (subscription_id, created_at),
|
|
KEY idx_delivery_user (user_id, created_at),
|
|
CONSTRAINT fk_schedule_delivery_reminder FOREIGN KEY (reminder_id) REFERENCES h5_schedule_reminders(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_schedule_delivery_subscription FOREIGN KEY (subscription_id) REFERENCES h5_schedule_digest_subscriptions(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_schedule_delivery_user FOREIGN KEY (user_id) REFERENCES h5_users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_user_notifications (
|
|
id CHAR(36) PRIMARY KEY,
|
|
user_id CHAR(36) NOT NULL,
|
|
channel ENUM('web', 'wechat') NOT NULL DEFAULT 'web',
|
|
notification_type VARCHAR(64) NOT NULL,
|
|
title VARCHAR(255) NOT NULL,
|
|
body TEXT NOT NULL,
|
|
data_json JSON NULL,
|
|
status ENUM('unread', 'read') NOT NULL DEFAULT 'unread',
|
|
read_at BIGINT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at BIGINT NOT NULL,
|
|
KEY idx_user_notifications_user_status_created (user_id, status, created_at),
|
|
KEY idx_user_notifications_user_created (user_id, created_at),
|
|
CONSTRAINT fk_user_notifications_user FOREIGN KEY (user_id) REFERENCES h5_users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
await pool.query(
|
|
`ALTER TABLE h5_payment_orders
|
|
MODIFY pay_mode ENUM('native', 'h5', 'jsapi') NOT NULL DEFAULT 'native'`,
|
|
);
|
|
|
|
// Session snapshot cache table (additive, no existing-data impact).
|
|
// Rollback: DROP TABLE h5_session_snapshots — safe, no dependants.
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_session_snapshots (
|
|
agent_session_id VARCHAR(128) NOT NULL PRIMARY KEY,
|
|
user_id CHAR(36) NOT NULL,
|
|
name VARCHAR(512) NOT NULL DEFAULT '',
|
|
working_dir VARCHAR(1024) NOT NULL DEFAULT '',
|
|
created_at_str VARCHAR(64) NOT NULL DEFAULT '',
|
|
updated_at_str VARCHAR(64) NOT NULL DEFAULT '',
|
|
user_set_name TINYINT(1) NOT NULL DEFAULT 0,
|
|
recipe_json TEXT NULL,
|
|
synced_msg_count INT NOT NULL DEFAULT 0,
|
|
source_updated_at VARCHAR(64) NOT NULL DEFAULT '',
|
|
messages_json LONGTEXT NOT NULL,
|
|
synced_at BIGINT NOT NULL,
|
|
KEY idx_h5_snapshots_user (user_id),
|
|
KEY idx_h5_snapshots_synced (synced_at),
|
|
CONSTRAINT fk_h5_snapshot_user FOREIGN KEY (user_id) REFERENCES h5_users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
// Subscription plan table for tiered monthly billing.
|
|
// Rollback: DROP TABLE h5_subscriptions — safe, no dependants.
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS h5_subscriptions (
|
|
id CHAR(36) PRIMARY KEY,
|
|
user_id CHAR(36) NOT NULL,
|
|
plan_type VARCHAR(32) NOT NULL DEFAULT 'free',
|
|
status ENUM('active', 'expired', 'cancelled') NOT NULL DEFAULT 'active',
|
|
period_tokens_limit BIGINT NOT NULL DEFAULT 0,
|
|
period_tokens_used BIGINT NOT NULL DEFAULT 0,
|
|
period_start BIGINT NOT NULL,
|
|
period_end BIGINT NOT NULL,
|
|
expires_at BIGINT NOT NULL,
|
|
overage_rate DECIMAL(4,2) NOT NULL DEFAULT 1.00,
|
|
operator_id CHAR(36) NULL,
|
|
note VARCHAR(512) NULL,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at BIGINT NOT NULL,
|
|
KEY idx_h5_sub_user_status (user_id, status),
|
|
KEY idx_h5_sub_expires (expires_at, status),
|
|
CONSTRAINT fk_h5_sub_user FOREIGN KEY (user_id) REFERENCES h5_users(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
// Back-fill free subscriptions for existing users who pre-date the subscription system.
|
|
// Idempotent: only inserts where no active subscription exists.
|
|
await pool.query(`
|
|
INSERT INTO h5_subscriptions
|
|
(id, user_id, plan_type, status,
|
|
period_tokens_limit, period_tokens_used,
|
|
period_start, period_end, expires_at, overage_rate,
|
|
operator_id, note, created_at, updated_at)
|
|
SELECT
|
|
UUID(),
|
|
u.id,
|
|
'free',
|
|
'active',
|
|
150000, 0,
|
|
UNIX_TIMESTAMP() * 1000,
|
|
(UNIX_TIMESTAMP() + 30 * 86400) * 1000,
|
|
(UNIX_TIMESTAMP() + 30 * 86400) * 1000,
|
|
1.00,
|
|
NULL,
|
|
'系统迁移补建免费套餐',
|
|
UNIX_TIMESTAMP() * 1000,
|
|
UNIX_TIMESTAMP() * 1000
|
|
FROM h5_users u
|
|
WHERE NOT EXISTS (
|
|
SELECT 1 FROM h5_subscriptions s
|
|
WHERE s.user_id = u.id AND s.status = 'active'
|
|
)
|
|
`);
|
|
}
|
|
|
|
export async function initSchema(pool) {
|
|
const schemaPath = path.join(__dirname, 'schema.sql');
|
|
const sql = fs.readFileSync(schemaPath, 'utf8');
|
|
for (const statement of sql.split(';')) {
|
|
const trimmed = statement.trim();
|
|
if (trimmed) {
|
|
await pool.query(trimmed);
|
|
}
|
|
}
|
|
await migrateSchema(pool);
|
|
await ensureDefaultSpaces(pool, {
|
|
quotaBytes: Number(process.env.MINDSPACE_FREE_QUOTA_BYTES ?? 5 * 1024 * 1024),
|
|
});
|
|
}
|