{ setEditingCell(null); load(); }}
+ />
+ );
+ }
+ // 展示态：可点击（进入编辑）
+ const has = p.values && Object.prototype.hasOwnProperty.call(p.values, col.key);
+ const v = has ? p.values[col.key] : fieldDef.def;
+ let shown;
+ if (fieldDef.type === 'boolean') shown = v ? '开' : '关';
+ else if (v === undefined || v === null || v === '') shown = '—';
+ else shown = String(v) + (fieldDef.unit ? fieldDef.unit : ''); // 值后拼单位（可空）
+ const clickable = p.holdingId != null; // 无 holding 锚点（未分配）不可编辑
+ if (!clickable) {
+ return {shown};
+ }
+ return (
+ { e.stopPropagation(); setEditingCell({ code: p.code, key: col.key }); }}
+ >
+ {shown}
+ ✎
+
+ );
+ }
+ // 基础数据列
+ switch (col.key) {
+ case 'lastPrice':
+ return ;
+ case 'pctChange':
+ return {fmtPct(p.pctChange)};
+ case 'lastClose':
+ return {fmtPrice(getPrice(p.code)?.lastClose)};
+ case 'avgPrice':
+ return {fmtPrice(p.avgPrice)};
+ case 'lastTradePrice':
+ return {fmtPrice(p.lastTradePrice)};
+ case 'shares':
+ return {p.shares};
+ default:
+ return null;
+ }
+ };
+
+ /** 表头列 label（排序箭头仅涨幅支持） */
+ const headerCell = (col) => {
+ if (col.key === 'pctChange') {
+ return (
+ |
+ {col.label}{sortKey === 'pctChange' ? (sortDir === 'asc' ? ' ↑' : ' ↓') : ''}
+ |
+ );
+ }
+ return {col.label} | ;
+ };
+
const pctArrow = sortKey === 'pctChange' ? (sortDir === 'desc' ? ' ▼' : ' ▲') : '';
return (
@@ -292,6 +414,22 @@ function StrategyTabInner({ strategyId, strategyName }) {
>
{showAdd ? '取消' : '+ 添加持仓'}
+
+
+ {columnOpen && columns && (
+ setColumnOpen(false)}
+ onSaved={load}
+ />
+ )}
+
@@ -339,12 +477,7 @@ function StrategyTabInner({ strategyId, strategyName }) {
|
代码 |
名称 |
- 现价 |
- 涨幅{pctArrow} |
- 昨收 |
- 成本价 |
- 最后一笔成交价 |
- 策略份额 |
+ {(visibleColumns ?? []).map((col) => headerCell(col))}
操作 |
@@ -393,12 +526,9 @@ function StrategyTabInner({ strategyId, strategyName }) {
{p.code} |
{p.name} |
-
- {fmtPct(p.pctChange)} |
- {fmtPrice(getPrice(p.code)?.lastClose)} |
- {fmtPrice(p.avgPrice)} |
- {fmtPrice(p.lastTradePrice)} |
- {p.shares} |
+ {(visibleColumns ?? []).map((col) => (
+ {renderDataCell(col, p)} |
+ ))}
e.stopPropagation()}>
{removeTarget && removeTarget.code === p.code ? (
@@ -438,7 +568,7 @@ function StrategyTabInner({ strategyId, strategyName }) {
{isExpanded && (
- |
+ |
{isLoading ? (
交易记录加载中...
) : !trades || trades.length === 0 ? (
diff --git a/src/index.js b/src/index.js
index 701e80f..e6df9fb 100644
--- a/src/index.js
+++ b/src/index.js
@@ -14,7 +14,7 @@
*/
import { QmtBridgeRestDataSource } from './data-source/QmtBridgeRestDataSource.js';
-import { registerSettings, resolveStartupConnection } from './settings.js';
+import { registerSettings, resolveStartupConnection, getStrategies } from './settings.js';
import { DataStore } from './storage/DataStore.js';
import { PositionManager } from './position/PositionManager.js';
import { registerApi } from './api/index.js';
@@ -70,7 +70,12 @@ async function apply(ctx, config) {
qmtHealthMonitor.start();
// S5: 分仓逻辑（份额分配/查询）
- const manager = new PositionManager({ dataSource, storage });
+ // R-013：注入策略自定义字段定义读取回调（updateHoldingValues 校验用；settings.getStrategies 已归一化 configSchema）
+ const manager = new PositionManager({
+ dataSource,
+ storage,
+ getStrategySchema: (strategyId) => getStrategies(settings).find((s) => s.id === strategyId)?.configSchema ?? [],
+ });
// R-009：交易记录本地同步（启动预热 + 60s 定时 UPSERT 落库）
const tradeSync = new TradeSync({ runtime: { dataSource, storage }, logger });
diff --git a/src/position/PositionManager.js b/src/position/PositionManager.js
index f332510..2371b7d 100644
--- a/src/position/PositionManager.js
+++ b/src/position/PositionManager.js
@@ -27,10 +27,15 @@ export class PositionManager {
* @param {object} opts
* @param {import('../data-source/data-source-types.js').DataSource} opts.dataSource 数据源（QMT REST）
* @param {DataStore} opts.storage 数据集存储（R-006 DataStore）
+ * @param {Function} [opts.getStrategySchema] 读策略自定义字段定义的回调 (strategyId) => configSchema[]
+ * （R-013：由 index.js 注入，内部经 settings.getStrategies 取；缺省返回 []）
*/
- constructor({ dataSource, storage }) {
+ constructor({ dataSource, storage, getStrategySchema }) {
this.dataSource = dataSource;
this.storage = storage;
+ this.getStrategySchema = typeof getStrategySchema === 'function'
+ ? getStrategySchema
+ : () => [];
}
/** 全量持仓（QMT 真实数据） */
@@ -77,7 +82,8 @@ export class PositionManager {
this.storage.getCurrentHoldings(strategyId), // 含 holding_id（同策略同 code 当前持仓唯一）
]);
const shareMap = new Map(dataset.map((d) => [d.code, d.shares]));
- const holdingMap = new Map(holdings.map((h) => [h.code, h.holdingId]));
+ const holdingMap = new Map(holdings.map((h) => [h.code, h.holdingId])); // code → holdingId
+ const valuesMap = new Map(holdings.map((h) => [h.code, h.values ?? null])); // R-013：code → 自定义字段值
// R-010 Q4：批量取各 holding 的关联委托（查最后一笔成交价）
const holdingIds = [...new Set(holdings.map((h) => h.holdingId).filter((x) => x != null))];
const tradesByHolding = new Map();
@@ -102,7 +108,7 @@ export class PositionManager {
// getOrdersByHolding 已按 insert_ts DESC，第一条即最新
lastTradePrice = +filled[0].tradedPrice;
}
- return { ...p, shares, holdingId, avgPrice, lastTradePrice };
+ return { ...p, shares, holdingId, avgPrice, lastTradePrice, values: valuesMap.get(p.code) ?? null }; // R-013
})
.filter(Boolean);
}
@@ -269,4 +275,69 @@ export class PositionManager {
}
return before.map((h) => h.code);
}
+
+ // ===== 持仓自定义字段值（R-013 迭代 11）=====
+
+ /**
+ * 校验字段值是否符合该策略 configSchema 定义（服务端校验，写回前调用）
+ * 规则（技术约束-015）：
+ * - 空值/缺省允许（undefined/null/'' → 放行，UI 回退显示 def）；
+ * - number → Number(v) 必须有限数（空串已在空值分支放行）；
+ * - enum → 值必须 ∈ enum 选项；
+ * - boolean → typeof 必须为 boolean；
+ * - 未定义 key 的额外键放行（可扩展，Q1 老师确认）。
+ * @param {Array} schema configSchema（该策略定义）
+ * @param {object} values 待校验的键值对
+ * @returns {string[]} 错误信息数组（空 = 通过）
+ */
+ validateHoldingValues(schema, values) {
+ const errors = [];
+ const dict = schema && Array.isArray(schema) ? schema : [];
+ for (const f of dict) {
+ const v = values && typeof values === 'object' ? values[f.key] : undefined;
+ if (v === undefined || v === null || v === '') continue; // 空值放行
+ if (f.type === 'number') {
+ if (!Number.isFinite(Number(v))) errors.push((f.label || f.key) + ' 需为数字');
+ } else if (f.type === 'enum') {
+ const options = Array.isArray(f.enum) ? f.enum : [];
+ if (!options.includes(v)) errors.push((f.label || f.key) + ' 需在选项内: ' + options.join('/'));
+ } else if (f.type === 'boolean') {
+ if (typeof v !== 'boolean') errors.push((f.label || f.key) + ' 需为布尔');
+ }
+ // text：任意字符串放行
+ }
+ return errors;
+ }
+
+ /**
+ * 更新某持仓行的自定义字段值（R-013）
+ * 定位当前持仓（closed_at IS NULL）→ 按所属策略 configSchema 校验 → 整体写回该行 values。
+ * 额外键（未在 configSchema 定义）放行：values 保持用户提交的全量（可扩展）。
+ * @param {number|string} holdingId 持仓 ID
+ * @param {object} values 字段值键值对（key 对齐 configSchema；null/空对象 → 清除整行值）
+ * @returns {Promise<{holdingId: number, values: object|null}>}
+ */
+ async updateHoldingValues(holdingId, values) {
+ const hid = Number(holdingId);
+ const current = await this.storage.getCurrentHoldings();
+ const holding = current.find((h) => h.holdingId === hid);
+ if (!holding) {
+ throw Object.assign(new Error('持仓不存在或已清仓: ' + holdingId), { code: 'holding-not-found' });
+ }
+ const schema = this.getStrategySchema(holding.strategyId);
+ // null/空对象 → 清除该行值
+ if (values == null || (typeof values === 'object' && Object.keys(values).length === 0)) {
+ await this.storage.writeValues(hid, null);
+ return { holdingId: hid, values: null };
+ }
+ if (typeof values !== 'object' || Array.isArray(values)) {
+ throw Object.assign(new Error('字段值格式无效'), { code: 'field-validation' });
+ }
+ const errors = this.validateHoldingValues(schema, values);
+ if (errors.length > 0) {
+ throw Object.assign(new Error('字段校验失败: ' + errors.join('；')), { code: 'field-validation', errors });
+ }
+ await this.storage.writeValues(hid, values);
+ return { holdingId: hid, values };
+ }
}
\ No newline at end of file
diff --git a/src/settings.js b/src/settings.js
index e10f69f..8a0df9a 100644
--- a/src/settings.js
+++ b/src/settings.js
@@ -33,16 +33,46 @@ export const DEFAULT_TABS = BUILTIN_TABS.map((t, i) => ({
/** 默认策略（首次注册时的初始值） */
export const DEFAULT_STRATEGIES = [
- { id: 'grid-supermarket', name: '网格超市' },
- { id: 'manual-t', name: '手动做T' },
+ { id: 'grid-supermarket', name: '网格超市', configSchema: [] },
+ { id: 'manual-t', name: '手动做T', configSchema: [] },
+];
+
+/**
+ * 策略持仓表基础数据列目录（迭代 11 列显隐扩展）
+ * 可配置区基础列：key / label / 默认是否显示（data=固定数据列；自定义字段列由 configSchema 动态合成）
+ * 固定列（不在此目录，锁死）：展开箭头 | 代码 | 名称（最前）| 操作（最后）
+ */
+export const COLUMN_META = [
+ { key: 'lastPrice', label: '现价', fixed: false },
+ { key: 'pctChange', label: '涨幅', fixed: false },
+ { key: 'lastClose', label: '昨收', fixed: false },
+ { key: 'avgPrice', label: '成本价', fixed: false },
+ { key: 'lastTradePrice', label: '最后一笔成交价', fixed: false },
+ { key: 'shares', label: '策略份额', fixed: false },
];
/** 策略设置 schema（schemastery 定义，settings.register 要求 schema 对象） */
+/** @type {import('@deepseek-ai/schemastery').Schema} 策略设置 schema（显式注解：含 z.dict，规避 dts 推断 cosmokit Dict 引用） */
export const strategySchema = z.object({
- // 策略定义表（R-011 收窄：仅 id + name，visible/order 归 tabs 统一管理）
+ // 策略定义表（R-011 收窄 + R-013 扩展 configSchema：id + name + 自定义字段定义）
+ // R-013（技术约束-015）：configSchema = 该策略需要的自定义字段定义（key/label/type/enum/def），
+ // 随策略定义存 settings 不落库；旧策略缺省 []（兼容，Q4）。
strategies: z.array(z.object({
id: z.string().required(),
name: z.string().required(),
+ configSchema: z.array(z.object({
+ key: z.string().required(), // 稳健标识（英文 slug，与字段值 JSON 的 key 对齐）
+ label: z.string(), // UI 展示名（可中文）
+ type: z.union([
+ z.const('text'),
+ z.const('number'),
+ z.const('boolean'),
+ z.const('enum'),
+ ]).required(), // 字段类型
+ enum: z.array(z.string()).default([]), // 仅 type=enum：预设选项
+ def: z.any(), // 默认值（text=string / number=number / boolean=boolean / enum=枚举项）
+ unit: z.string().default(''), // 单位（可为空；如 % / 元 / 手 —— 展示时拼在值后）
+ })).default([]),
})).default(DEFAULT_STRATEGIES),
// 统一 tab 列表（R-011：唯一顺序与显隐来源；内置 + 策略混排）
// union 兼容存量：旧格式为布尔对象（迭代 02），新格式为有序数组；normalizeTabs 读取时归一化
@@ -73,6 +103,14 @@ export const strategySchema = z.object({
activeId: z.string().default(''),
defaultId: z.string().default(''),
}).default({ list: [], activeId: '', defaultId: '' }),
+ // 策略持仓表列配置（迭代 11 扩展：每策略一套，仅存与默认不同的覆盖；读取归一化）
+ // strategyColumns: { [strategyId]: [{ key, visible }] } —— key 覆盖 COLUMN_META 基础列 + 该策略 configSchema 字段列
+ strategyColumns: z.dict(
+ z.array(z.object({
+ key: z.string().required(),
+ visible: z.boolean().default(true),
+ })).default([])
+ ).default({}),
});
@@ -195,21 +233,29 @@ export function registerSettings(ctx, config) {
}
/**
- * 读取策略定义表（R-011 收窄：仅 id + name，无 visible/order）
+ * 读取策略定义表（R-011 收窄 + R-013 扩展：{id, name, configSchema}）
+ * 归一化：旧存量数据缺 configSchema（R-013 前）→ 补空数组（Q4 兼容）。
* @param {ReturnType} scope
*/
export function getStrategies(scope) {
const value = scope?.get() ?? {};
- return Array.isArray(value.strategies) ? value.strategies : DEFAULT_STRATEGIES;
+ const list = Array.isArray(value.strategies) ? value.strategies : DEFAULT_STRATEGIES;
+ return list.map((s) => ({ ...s, configSchema: Array.isArray(s.configSchema) ? s.configSchema : [] }));
}
/**
- * 更新策略（整表更新）
+ * 更新策略（整表更新；R-013：configSchema 随整表携带）
+ * 写入归一化：项缺 configSchema → 补 []（防客户端旧格式整表提交丢定义）。
* @param {ReturnType} scope
* @param {Array} strategies 完整策略列表
*/
export async function updateStrategies(scope, strategies) {
- await scope.update({ strategies });
+ const next = (Array.isArray(strategies) ? strategies : []).map((s) => ({
+ id: s.id,
+ name: s.name,
+ configSchema: Array.isArray(s.configSchema) ? s.configSchema : [],
+ }));
+ await scope.update({ strategies: next });
}
/**
@@ -224,6 +270,7 @@ export async function addStrategy(scope, name) {
const strategy = {
id,
name: String(name ?? '').trim(),
+ configSchema: [], // R-013：新策略默认无自定义字段（定义在设置页配置）
};
await updateStrategies(scope, [...list, strategy]);
// R-011：联动在 tabs 列表末尾追加策略 tab 条目（Q2 追加末尾）
@@ -369,6 +416,75 @@ export async function updateTabConfig(scope, tabs) {
await updateTabs(scope, next);
}
+/**
+ * ============================================================================
+ * 策略持仓表列配置（迭代 11 列显隐扩展；产品约束-011、技术约束-017 待落）
+ * 数据：settings.strategyColumns = { [strategyId]: [{key, visible}] }（仅存覆盖）
+ * 归一化：基础列（COLUMN_META 默认序全显）+ 该策略 configSchema 字段列（configSchema 序全显）
+ * → 应用 strategyColumns 覆盖（visible + 顺序）→ 返回有序列数组 [{key, label, fixed, visible}]
+ * 固定列不在此配置：展开箭头/代码/名称（最前）、操作（最后）。
+ */
+
+/**
+ * 归一化某策略的列配置（基础列 + 自定义字段列，应用覆盖）
+ * @param {ReturnType} scope
+ * @param {string} strategyId
+ * @returns {Array<{key: string, label: string, fixed: boolean, visible: boolean, kind: 'base'|'field'}>}
+ */
+export function normalizeStrategyColumns(scope, strategyId) {
+ const value = scope?.get() ?? {};
+ const strategies = Array.isArray(value.strategies) ? value.strategies : [];
+ const strategy = strategies.find((s) => s.id === strategyId);
+ const configSchema = Array.isArray(strategy?.configSchema) ? strategy.configSchema : [];
+ const raw = (value.strategyColumns && value.strategyColumns[strategyId]) || [];
+
+ // 1. 默认全列（基础列全显默认序 + 字段列全显 configSchema 序）
+ const baseCols = COLUMN_META.map((c) => ({ key: c.key, label: c.label, fixed: false, kind: 'base' }));
+ const fieldCols = configSchema.map((f) => ({ key: f.key, label: f.label || f.key, fixed: false, kind: 'field' }));
+ const defaults = [...baseCols, ...fieldCols];
+
+ // 2. 应用覆盖：visible + 顺序（未覆盖的列保持默认，追加在默认序后）
+ const override = Array.isArray(raw) ? raw : [];
+ const visibleMap = new Map();
+ for (const o of override) visibleMap.set(o.key, o.visible !== false);
+
+ // 覆盖中的自定义字段列若 configSchema 已删除 → 忽略（自动跟随删除）
+ const activeKeys = new Set(defaults.map((c) => c.key));
+ const validOverride = override.filter((o) => activeKeys.has(o.key));
+
+ // 3. 组装：先按覆盖顺序排，未覆盖列追加默认序
+ const ordered = [];
+ const placed = new Set();
+ for (const o of validOverride) {
+ const d = defaults.find((c) => c.key === o.key);
+ if (d) { ordered.push({ ...d, visible: o.visible !== false }); placed.add(d.key); }
+ }
+ for (const d of defaults) {
+ if (!placed.has(d.key)) {
+ ordered.push({ ...d, visible: visibleMap.has(d.key) ? visibleMap.get(d.key) : true });
+ }
+ }
+ return ordered;
+}
+
+/** 读取某策略列配置（归一化结果） */
+export function getStrategyColumns(scope, strategyId) {
+ return normalizeStrategyColumns(scope, strategyId);
+}
+
+/**
+ * 更新某策略列配置（整表覆盖该策略的 columns）
+ * @param {ReturnType} scope
+ * @param {string} strategyId
+ * @param {Array} columns 完整列数组 [{key, visible}]（含不可见列——保留位置，visible 控制显示）
+ */
+export async function updateStrategyColumns(scope, strategyId, columns) {
+ const current = scope?.get() ?? {};
+ const store = current.strategyColumns && typeof current.strategyColumns === 'object' ? current.strategyColumns : {};
+ const next = { ...store, [strategyId]: (Array.isArray(columns) ? columns : []).map((c) => ({ key: c.key, visible: c.visible !== false })) };
+ await scope.update({ ...current, strategyColumns: next });
+}
+
/**
* ============================================================================
* QMT 连接配置（R-004 已定稿；产品约束-005、技术约束-008）
@@ -517,4 +633,4 @@ export async function setDefaultQmtConnection(scope, id) {
const value = scope?.get() ?? {};
await scope.update({ ...value, qmtConnections: { ...state, defaultId: id } });
return { ...state, defaultId: id };
-}
+}
\ No newline at end of file
diff --git a/src/storage/DataStore.js b/src/storage/DataStore.js
index 05f7a05..aff31d2 100644
--- a/src/storage/DataStore.js
+++ b/src/storage/DataStore.js
@@ -87,6 +87,16 @@ export class DataStore {
return this.sqlite.getHoldingHistory(code);
}
+ /** 读取持仓自定义字段值（R-013：委托 SqliteStore） */
+ readValues(holdingId) {
+ return this.sqlite.readValues(holdingId);
+ }
+
+ /** 写入持仓自定义字段值（R-013：整体替换该行 values JSON） */
+ writeValues(holdingId, values) {
+ return this.sqlite.writeValues(holdingId, values);
+ }
+
// ===== 兼容 API（旧调用；PositionManager 迁移后不再使用 setDataset/removeDataset）=====
/** 读取某策略数据集（[{code, shares}]，兼容旧调用） */
diff --git a/src/storage/SqliteStore.js b/src/storage/SqliteStore.js
index f2e7109..d627353 100644
--- a/src/storage/SqliteStore.js
+++ b/src/storage/SqliteStore.js
@@ -98,6 +98,17 @@ CREATE INDEX IF NOT EXISTS idx_trade_fills_order ON trade_fills (order_id);
CREATE INDEX IF NOT EXISTS idx_trade_fills_date ON trade_fills (trade_date);
`;
+/** 解析 strategy_holdings."values" JSON 列（容错：空/脏返回 null；模块级，供 .map(this._mapHolding) 裸调用） */
+function parseValues(raw) {
+ if (raw == null) return null;
+ try {
+ const v = JSON.parse(raw);
+ return v && typeof v === 'object' ? v : null;
+ } catch {
+ return null;
+ }
+}
+
export class SqliteStore {
/**
* @param {object} [options]
@@ -124,6 +135,8 @@ export class SqliteStore {
this.db.exec(SCHEMA_SQL);
// 存量库迁移：trade_orders 补手动归属列（R-009 二次定稿；幂等）
this._ensureTradeAttributionColumns();
+ // 存量库迁移：strategy_holdings 补自定义字段值列（R-013 迭代 11；幂等）
+ this._ensureHoldingValuesColumn();
return this.db;
}
@@ -151,6 +164,57 @@ export class SqliteStore {
}
}
+ /**
+ * 确保 strategy_holdings 存在 values 列（旧库 ALTER 补列，幂等；R-013 迭代 11）。
+ * values = 该持仓行按所属策略 configSchema 存的自定义字段值（JSON 键值对，可含扩展键）。
+ * 只读连接（外部脚本持锁时）抛 readonly → 容忍，真实迁移由插件进程执行。
+ */
+ _ensureHoldingValuesColumn() {
+ try {
+ const cols = new Set(this.db.prepare('PRAGMA table_info(strategy_holdings)').all().map((c) => c.name));
+ if (!cols.has('values')) {
+ this.db.exec('ALTER TABLE strategy_holdings ADD COLUMN "values" TEXT');
+ }
+ } catch (err) {
+ if (String(err?.message ?? '').includes('readonly')) {
+ console.warn('[one-divine-lot] strategy_holdings values 列迁移跳过（只读连接，插件持锁中）');
+ } else {
+ throw err;
+ }
+ }
+ }
+
+ // ===== 持仓自定义字段值（R-013 迭代 11）=====
+
+ /**
+ * 读取某持仓行的自定义字段值（JSON 键值对）
+ * @param {number} holdingId 持仓 ID
+ * @returns {object|null} values 对象（未配置为 null）
+ */
+ readValues(holdingId) {
+ this.init();
+ const row = this.db.prepare('SELECT "values" FROM strategy_holdings WHERE holding_id=?').get(holdingId);
+ if (!row || row.values == null) return null;
+ try {
+ return JSON.parse(row.values);
+ } catch {
+ return null; // 脏数据容忍：解析失败视为无值
+ }
+ }
+
+ /**
+ * 写入某持仓行的自定义字段值（整体替换该行 values JSON；可含扩展键）
+ * @param {number} holdingId 持仓 ID
+ * @param {object} values 字段值键值对（key 对齐 configSchema）
+ * @returns {boolean} 是否更新成功
+ */
+ writeValues(holdingId, values) {
+ this.init();
+ const payload = values && typeof values === 'object' ? JSON.stringify(values) : null;
+ const rres = this.db.prepare('UPDATE strategy_holdings SET "values"=? WHERE holding_id=?').run(payload, holdingId);
+ return rres.changes > 0;
+ }
+
/** 关闭连接 */
close() {
if (this.db) {
@@ -285,7 +349,7 @@ export class SqliteStore {
const r = this.db.prepare(
'INSERT INTO strategy_holdings (strategy_id, code, shares, created_at, closed_at) VALUES (?,?,?,?,NULL)'
).run(strategyId, code, Number(shares), now);
- return { holdingId: Number(r.lastInsertRowid), strategyId, code, shares: Number(shares), createdAt: now, closedAt: null };
+ return { holdingId: Number(r.lastInsertRowid), strategyId, code, shares: Number(shares), createdAt: now, closedAt: null, values: null }; // R-013：新持仓无自定义字段值
}
/** 加仓：当前持仓份额累加 */
@@ -324,7 +388,7 @@ export class SqliteStore {
_getActive(strategyId, code) {
this.init();
const row = this.db.prepare(
- 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at FROM strategy_holdings WHERE strategy_id=? AND code=? AND closed_at IS NULL'
+ 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at, "values" FROM strategy_holdings WHERE strategy_id=? AND code=? AND closed_at IS NULL'
).get(strategyId, code);
return row ? this._mapHolding(row) : null;
}
@@ -334,11 +398,11 @@ export class SqliteStore {
this.init();
if (strategyId) {
return this.db.prepare(
- 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at FROM strategy_holdings WHERE strategy_id=? AND closed_at IS NULL ORDER BY holding_id'
+ 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at, "values" FROM strategy_holdings WHERE strategy_id=? AND closed_at IS NULL ORDER BY holding_id'
).all(strategyId).map(this._mapHolding);
}
return this.db.prepare(
- 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at FROM strategy_holdings WHERE closed_at IS NULL ORDER BY strategy_id, holding_id'
+ 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at, "values" FROM strategy_holdings WHERE closed_at IS NULL ORDER BY strategy_id, holding_id'
).all().map(this._mapHolding);
}
@@ -347,11 +411,11 @@ export class SqliteStore {
this.init();
if (code) {
return this.db.prepare(
- 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at FROM strategy_holdings WHERE code=? ORDER BY holding_id'
+ 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at, "values" FROM strategy_holdings WHERE code=? ORDER BY holding_id'
).all(code).map(this._mapHolding);
}
return this.db.prepare(
- 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at FROM strategy_holdings ORDER BY holding_id'
+ 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at, "values" FROM strategy_holdings ORDER BY holding_id'
).all().map(this._mapHolding);
}
@@ -363,9 +427,12 @@ export class SqliteStore {
shares: row.shares,
createdAt: row.created_at,
closedAt: row.closed_at,
+ values: parseValues(row.values), // R-013：自定义字段值（未配置 null；模块级函数，.map 裸传不依赖 this）
};
}
+
+
// ===== 行情读写（market_quotes_cache）=====
/** 单码行情 */
@@ -552,7 +619,7 @@ export class SqliteStore {
if (codes.length === 0) return out;
const placeholders = codes.map(() => '?').join(',');
const rows = this.db.prepare(
- 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at FROM strategy_holdings WHERE code IN (' + placeholders + ')'
+ 'SELECT holding_id, strategy_id, code, shares, created_at, closed_at, "values" FROM strategy_holdings WHERE code IN (' + placeholders + ')'
).all(...codes);
const holdingsByCode = new Map();
for (const h of rows) {
| |