291 lines
9.4 KiB
TypeScript
291 lines
9.4 KiB
TypeScript
import { query, withTransaction } from '../../db/client.js'
|
|
import { canonicalizeInternalSku, containsCjk } from './internal-sku-resolver.js'
|
|
import { createHttpError } from '../../utils/http.js'
|
|
|
|
export type InternalSkuMappingMatchType =
|
|
| 'sku_code'
|
|
| 'sku_nick'
|
|
| 'out_sku_sn'
|
|
| 'spec'
|
|
| 'sku_name'
|
|
|
|
export type InternalSkuMappingCandidate = {
|
|
matchType: InternalSkuMappingMatchType
|
|
value: unknown
|
|
}
|
|
|
|
const INTERNAL_SKU_MAPPING_MATCH_TYPES = new Set<InternalSkuMappingMatchType>([
|
|
'sku_code',
|
|
'sku_nick',
|
|
'out_sku_sn',
|
|
'spec',
|
|
'sku_name',
|
|
])
|
|
|
|
export type ResolvedInternalSkuMapping = {
|
|
id: number
|
|
internalSku: string
|
|
source: string
|
|
}
|
|
|
|
export type InternalSkuMappingRow = {
|
|
id: number
|
|
provider: string
|
|
shop_id: string
|
|
match_type: InternalSkuMappingMatchType
|
|
match_value: string
|
|
internal_sku: string
|
|
priority: number
|
|
enabled: boolean
|
|
source: string
|
|
note: string
|
|
updated_at: string
|
|
}
|
|
|
|
export function normalizeInternalSkuMappingValue(value: unknown): string {
|
|
return canonicalizeInternalSku(value)
|
|
}
|
|
|
|
/**
|
|
* 按平台字段候选值查内部中文 SKU 映射。
|
|
*
|
|
* 优先级:精确 provider/shop > 全局;同范围按候选字段顺序、priority、id 升序。
|
|
* 返回 null 表示没有映射,调用方回退 manual_sku_key 生成列。
|
|
*/
|
|
export async function resolveInternalSkuMapping(input: {
|
|
provider?: string | null
|
|
shopId?: string | null
|
|
candidates: InternalSkuMappingCandidate[]
|
|
}): Promise<ResolvedInternalSkuMapping | null> {
|
|
const provider = String(input.provider || '').trim()
|
|
const shopId = String(input.shopId || '').trim()
|
|
const pairs = input.candidates
|
|
.map((candidate, candidatePriority) => ({
|
|
matchType: candidate.matchType,
|
|
matchValue: normalizeInternalSkuMappingValue(candidate.value),
|
|
candidatePriority,
|
|
}))
|
|
.filter((candidate) => candidate.matchValue !== '')
|
|
if (pairs.length === 0) return null
|
|
|
|
const result = await query<{ id: number; internal_sku: string; source: string }>(
|
|
`
|
|
SELECT m.id, m.internal_sku, m.source
|
|
FROM internal_sku_mappings m
|
|
JOIN unnest($3::text[], $4::text[], $5::int[])
|
|
AS c(match_type, match_value, candidate_priority)
|
|
ON m.match_type = c.match_type
|
|
AND canonicalize_internal_sku(m.match_value) = c.match_value
|
|
WHERE m.enabled = TRUE
|
|
AND (m.provider = '' OR m.provider = $1)
|
|
AND (m.shop_id = '' OR m.shop_id = $2)
|
|
ORDER BY
|
|
CASE WHEN m.provider = $1 AND m.shop_id = $2 THEN 0
|
|
WHEN m.provider = $1 THEN 1
|
|
WHEN m.shop_id = $2 THEN 2
|
|
ELSE 3 END,
|
|
c.candidate_priority ASC,
|
|
m.priority ASC,
|
|
m.id ASC
|
|
LIMIT 1
|
|
`,
|
|
[
|
|
provider,
|
|
shopId,
|
|
pairs.map((pair) => pair.matchType),
|
|
pairs.map((pair) => pair.matchValue),
|
|
pairs.map((pair) => pair.candidatePriority),
|
|
],
|
|
)
|
|
const row = result.rows[0]
|
|
if (!row) return null
|
|
return {
|
|
id: Number(row.id),
|
|
internalSku: canonicalizeInternalSku(row.internal_sku),
|
|
source: String(row.source || 'manual'),
|
|
}
|
|
}
|
|
|
|
export async function upsertInternalSkuMapping(input: {
|
|
provider?: string | null
|
|
shopId?: string | null
|
|
matchType: InternalSkuMappingMatchType
|
|
matchValue: string
|
|
internalSku: string
|
|
priority?: number
|
|
source?: string
|
|
note?: string
|
|
enabled?: boolean
|
|
}): Promise<number> {
|
|
const provider = String(input.provider || '').trim()
|
|
const shopId = String(input.shopId || '').trim()
|
|
if (!INTERNAL_SKU_MAPPING_MATCH_TYPES.has(input.matchType)) {
|
|
throw createHttpError('映射类型无效', {
|
|
statusCode: 400,
|
|
errorCode: 'internal_sku_mapping_type_invalid',
|
|
})
|
|
}
|
|
const matchValue = normalizeInternalSkuMappingValue(input.matchValue)
|
|
const internalSku = canonicalizeInternalSku(input.internalSku)
|
|
const priority = Number.isFinite(Number(input.priority)) ? Number(input.priority) : 100
|
|
const source = String(input.source || 'manual').trim() || 'manual'
|
|
const note = String(input.note || '').trim()
|
|
const enabled = input.enabled !== false
|
|
if (!matchValue || !internalSku || !containsCjk(internalSku)) {
|
|
throw createHttpError('内部 SKU 和匹配值不能为空,且内部 SKU 必须包含中文', {
|
|
statusCode: 400,
|
|
errorCode: 'internal_sku_mapping_invalid',
|
|
})
|
|
}
|
|
|
|
return withTransaction(async (client) => {
|
|
const existing = await client.query<{ id: number }>(
|
|
`SELECT id FROM internal_sku_mappings
|
|
WHERE provider = $1 AND shop_id = $2 AND match_type = $3
|
|
AND canonicalize_internal_sku(match_value) = $4
|
|
ORDER BY id
|
|
FOR UPDATE`,
|
|
[provider, shopId, input.matchType, matchValue],
|
|
)
|
|
if (existing.rows.length > 1) {
|
|
throw createHttpError('同一平台/店铺/字段存在多条规范化重复映射', {
|
|
statusCode: 409,
|
|
errorCode: 'internal_sku_mapping_ambiguous',
|
|
})
|
|
}
|
|
const existingId = Number(existing.rows[0]?.id || 0)
|
|
const result = existingId
|
|
? await client.query<{ id: number }>(
|
|
`UPDATE internal_sku_mappings
|
|
SET match_value = $2, internal_sku = $3, priority = $4,
|
|
enabled = $5, source = $6, note = $7, updated_at = NOW()
|
|
WHERE id = $1
|
|
RETURNING id`,
|
|
[existingId, matchValue, internalSku, priority, enabled, source, note],
|
|
)
|
|
: await client.query<{ id: number }>(
|
|
`INSERT INTO internal_sku_mappings (
|
|
provider, shop_id, match_type, match_value, internal_sku,
|
|
priority, enabled, source, note, created_at, updated_at
|
|
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW(), NOW())
|
|
RETURNING id`,
|
|
[
|
|
provider,
|
|
shopId,
|
|
input.matchType,
|
|
matchValue,
|
|
internalSku,
|
|
priority,
|
|
enabled,
|
|
source,
|
|
note,
|
|
],
|
|
)
|
|
return Number(result.rows[0]?.id || 0)
|
|
})
|
|
}
|
|
|
|
export async function listInternalSkuMappingsPage(input: {
|
|
keyword?: string
|
|
provider?: string
|
|
shopId?: string
|
|
matchType?: string
|
|
page?: number
|
|
pageSize?: number
|
|
}): Promise<{ items: InternalSkuMappingRow[]; total: number; page: number; pageSize: number }> {
|
|
const page = Math.max(1, Math.trunc(Number(input.page) || 1))
|
|
const pageSize = Math.min(200, Math.max(1, Math.trunc(Number(input.pageSize) || 30)))
|
|
const params: unknown[] = []
|
|
const clauses: string[] = []
|
|
const keyword = String(input.keyword || '').trim()
|
|
if (keyword) {
|
|
params.push(`%${keyword}%`)
|
|
clauses.push(
|
|
`(match_value ILIKE $${params.length} OR internal_sku ILIKE $${params.length} OR note ILIKE $${params.length})`,
|
|
)
|
|
}
|
|
if (input.provider) {
|
|
params.push(String(input.provider).trim())
|
|
clauses.push(`provider = $${params.length}`)
|
|
}
|
|
if (input.shopId) {
|
|
params.push(String(input.shopId).trim())
|
|
clauses.push(`shop_id = $${params.length}`)
|
|
}
|
|
if (input.matchType) {
|
|
params.push(String(input.matchType).trim())
|
|
clauses.push(`match_type = $${params.length}`)
|
|
}
|
|
const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : ''
|
|
const pageParams = [...params, pageSize, (page - 1) * pageSize]
|
|
const [countResult, rows] = await Promise.all([
|
|
query<{ total: number }>(
|
|
`SELECT COUNT(*)::int AS total FROM internal_sku_mappings ${where}`,
|
|
params,
|
|
),
|
|
query<InternalSkuMappingRow>(
|
|
`SELECT id, provider, shop_id, match_type, match_value, internal_sku,
|
|
priority, enabled, source, note, updated_at
|
|
FROM internal_sku_mappings
|
|
${where}
|
|
ORDER BY enabled DESC, priority ASC, id DESC
|
|
LIMIT $${pageParams.length - 1} OFFSET $${pageParams.length}`,
|
|
pageParams,
|
|
),
|
|
])
|
|
return {
|
|
items: rows.rows.map((row) => ({
|
|
...row,
|
|
id: Number(row.id),
|
|
priority: Number(row.priority),
|
|
})),
|
|
total: Number(countResult.rows[0]?.total || 0),
|
|
page,
|
|
pageSize,
|
|
}
|
|
}
|
|
|
|
export async function deleteInternalSkuMapping(mappingId: number): Promise<boolean> {
|
|
const id = Math.trunc(Number(mappingId) || 0)
|
|
if (id <= 0) return false
|
|
const result = await query(`DELETE FROM internal_sku_mappings WHERE id = $1`, [id])
|
|
return (result.rowCount || 0) > 0
|
|
}
|
|
|
|
/**
|
|
* 订单项级内部 SKU 补全:
|
|
* - 明确的 skuNick/outSkuSn/skuCode 已有中文 → 不查库;
|
|
* - 否则先查 internal_sku_mappings,避免中文长标题抢占内部 SKU;
|
|
* - 没有映射时才由调用方回退中文标题。
|
|
*/
|
|
export async function resolveInternalSkuForOrderItem(input: {
|
|
provider?: string | null
|
|
shopId?: string | null
|
|
spec?: Record<string, unknown> | null
|
|
skuCode?: unknown
|
|
skuName?: unknown
|
|
}): Promise<{ internalSku: string; source: string; mappingId: number } | null> {
|
|
const spec = input.spec && typeof input.spec === 'object' ? input.spec : {}
|
|
const directCandidates = [spec.skuNick, spec.outSkuSn, input.skuCode]
|
|
.map(normalizeInternalSkuMappingValue)
|
|
.filter(Boolean)
|
|
if (directCandidates.some(containsCjk)) return null
|
|
|
|
const mapping = await resolveInternalSkuMapping({
|
|
provider: input.provider ?? null,
|
|
shopId: input.shopId ?? null,
|
|
candidates: [
|
|
{ matchType: 'sku_nick', value: spec.skuNick },
|
|
{ matchType: 'out_sku_sn', value: spec.outSkuSn },
|
|
{ matchType: 'sku_code', value: input.skuCode },
|
|
{ matchType: 'sku_name', value: input.skuName },
|
|
],
|
|
})
|
|
if (!mapping) return null
|
|
return {
|
|
internalSku: canonicalizeInternalSku(mapping.internalSku),
|
|
source: mapping.source,
|
|
mappingId: mapping.id,
|
|
}
|
|
}
|