413 lines
14 KiB
TypeScript
413 lines
14 KiB
TypeScript
import { pool } from "./client";
|
|
|
|
export interface SearchParams {
|
|
q?: string;
|
|
form_factor?: string;
|
|
speed?: string;
|
|
speed_gbps?: number;
|
|
category?: string;
|
|
fiber_type?: string;
|
|
reach_min?: number;
|
|
reach_max?: number;
|
|
wdm_type?: string;
|
|
coherent?: boolean;
|
|
market_status?: string;
|
|
vendor?: string;
|
|
verified?: "price" | "image" | "details" | "full";
|
|
limit?: number;
|
|
offset?: number;
|
|
}
|
|
|
|
export async function searchTransceivers(params: SearchParams) {
|
|
const conditions: string[] = [
|
|
`COALESCE(t.data_confidence, 'unknown') != 'garbage'`,
|
|
`COALESCE(t.product_page_url, '') NOT LIKE '%/category/%'`,
|
|
`COALESCE(t.category, '') NOT IN ('NonTransceiver', 'Accessory', 'Adapter / Converter', 'Switch / Media Converter', 'Switch / Network Infrastructure', 'NIC / Adapter', 'Mux / Passive Optical', 'Product Family', 'Loopback / Test Module')`,
|
|
];
|
|
const values: any[] = [];
|
|
let idx = 1;
|
|
|
|
if (params.q) {
|
|
conditions.push(`(search_vector @@ plainto_tsquery('english', $${idx}) OR t.part_number ILIKE '%' || $${idx} || '%' OR t.standard_name ILIKE '%' || $${idx} || '%')`);
|
|
values.push(params.q);
|
|
idx++;
|
|
}
|
|
if (params.form_factor) {
|
|
conditions.push(`form_factor = $${idx}`);
|
|
values.push(params.form_factor);
|
|
idx++;
|
|
}
|
|
if (params.speed) {
|
|
conditions.push(`speed = $${idx}`);
|
|
values.push(params.speed);
|
|
idx++;
|
|
}
|
|
if (params.speed_gbps) {
|
|
conditions.push(`speed_gbps = $${idx}`);
|
|
values.push(params.speed_gbps);
|
|
idx++;
|
|
}
|
|
if (params.category) {
|
|
conditions.push(`category = $${idx}`);
|
|
values.push(params.category);
|
|
idx++;
|
|
}
|
|
if (params.fiber_type) {
|
|
conditions.push(`fiber_type = $${idx}`);
|
|
values.push(params.fiber_type);
|
|
idx++;
|
|
}
|
|
if (params.reach_min) {
|
|
conditions.push(`reach_meters >= $${idx}`);
|
|
values.push(params.reach_min);
|
|
idx++;
|
|
}
|
|
if (params.reach_max) {
|
|
conditions.push(`reach_meters <= $${idx}`);
|
|
values.push(params.reach_max);
|
|
idx++;
|
|
}
|
|
if (params.wdm_type) {
|
|
conditions.push(`wdm_type = $${idx}`);
|
|
values.push(params.wdm_type);
|
|
idx++;
|
|
}
|
|
if (params.coherent !== undefined) {
|
|
conditions.push(`coherent = $${idx}`);
|
|
values.push(params.coherent);
|
|
idx++;
|
|
}
|
|
if (params.market_status) {
|
|
conditions.push(`market_status = $${idx}`);
|
|
values.push(params.market_status);
|
|
idx++;
|
|
}
|
|
if (params.vendor) {
|
|
conditions.push(`v.name ILIKE $${idx}`);
|
|
values.push(`%${params.vendor}%`);
|
|
idx++;
|
|
}
|
|
if (params.verified) {
|
|
const col = params.verified === "full" ? "fully_verified" : params.verified + "_verified";
|
|
conditions.push(`t.${col} = true`);
|
|
}
|
|
|
|
const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
|
|
const limit = params.limit || 50;
|
|
const offset = params.offset || 0;
|
|
|
|
// Add relevance ranking when full-text search is used
|
|
const orderBy = params.q
|
|
? `ORDER BY (t.part_number ILIKE $1) DESC, ts_rank(search_vector, plainto_tsquery('english', $1)) DESC, fully_verified DESC NULLS LAST, has_image DESC NULLS LAST`
|
|
: `ORDER BY fully_verified DESC NULLS LAST, has_image DESC NULLS LAST, speed_gbps DESC NULLS LAST, reach_meters ASC NULLS LAST`;
|
|
|
|
const query = `
|
|
SELECT t.*, v.name as vendor_name
|
|
FROM transceivers t
|
|
LEFT JOIN vendors v ON t.vendor_id = v.id
|
|
${where}
|
|
${orderBy}
|
|
LIMIT ${limit} OFFSET ${offset}
|
|
`;
|
|
|
|
const countQuery = `SELECT COUNT(*) FROM transceivers t LEFT JOIN vendors v ON t.vendor_id = v.id ${where}`;
|
|
|
|
const [dataResult, countResult] = await Promise.all([
|
|
pool.query(query, values),
|
|
pool.query(countQuery, values),
|
|
]);
|
|
|
|
return {
|
|
data: dataResult.rows,
|
|
total: parseInt(countResult.rows[0].count),
|
|
limit,
|
|
offset,
|
|
};
|
|
}
|
|
|
|
export async function getTransceiverById(id: string) {
|
|
const result = await pool.query(
|
|
`SELECT t.*, v.name as vendor_name, s.name as standard_full_name
|
|
FROM transceivers t
|
|
LEFT JOIN vendors v ON t.vendor_id = v.id
|
|
LEFT JOIN standards s ON t.standard_id = s.id
|
|
WHERE t.id::text = $1::text OR t.slug = $1::text`,
|
|
[id]
|
|
);
|
|
return result.rows[0] || null;
|
|
}
|
|
|
|
export interface SwitchSearchParams extends SearchParams {
|
|
whitebox?: boolean;
|
|
sonic_compatible?: boolean;
|
|
asic_vendor?: string;
|
|
nos?: string;
|
|
ocp?: boolean;
|
|
max_speed_gbps?: number;
|
|
}
|
|
|
|
export async function searchSwitches(params: SwitchSearchParams) {
|
|
const conditions: string[] = [];
|
|
const values: any[] = [];
|
|
let idx = 1;
|
|
|
|
if (params.q) {
|
|
conditions.push(`sw.search_vector @@ plainto_tsquery('english', $${idx})`);
|
|
values.push(params.q);
|
|
idx++;
|
|
}
|
|
if (params.category) {
|
|
conditions.push(`sw.category = $${idx}`);
|
|
values.push(params.category);
|
|
idx++;
|
|
}
|
|
if (params.whitebox !== undefined) {
|
|
conditions.push(`sw.is_whitebox = $${idx}`);
|
|
values.push(params.whitebox);
|
|
idx++;
|
|
}
|
|
if (params.sonic_compatible !== undefined) {
|
|
conditions.push(`sw.sonic_compatible = $${idx}`);
|
|
values.push(params.sonic_compatible);
|
|
idx++;
|
|
}
|
|
if (params.asic_vendor) {
|
|
conditions.push(`sw.asic_vendor ILIKE $${idx}`);
|
|
values.push(`%${params.asic_vendor}%`);
|
|
idx++;
|
|
}
|
|
if (params.nos) {
|
|
conditions.push(`$${idx} = ANY(sw.supported_nos)`);
|
|
values.push(params.nos);
|
|
idx++;
|
|
}
|
|
if (params.ocp !== undefined) {
|
|
conditions.push(`sw.is_ocp_accepted = $${idx}`);
|
|
values.push(params.ocp);
|
|
idx++;
|
|
}
|
|
if (params.max_speed_gbps) {
|
|
conditions.push(`sw.max_speed_gbps = $${idx}`);
|
|
values.push(params.max_speed_gbps);
|
|
idx++;
|
|
}
|
|
|
|
const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
|
|
const limit = params.limit || 50;
|
|
const offset = params.offset || 0;
|
|
|
|
const orderBy = params.q
|
|
? `ORDER BY ts_rank(sw.search_vector, plainto_tsquery('english', $1)) DESC`
|
|
: `ORDER BY sw.max_speed_gbps DESC NULLS LAST`;
|
|
|
|
const query = `
|
|
SELECT sw.*, v.name as vendor_name
|
|
FROM switches sw
|
|
LEFT JOIN vendors v ON sw.vendor_id = v.id
|
|
${where}
|
|
${orderBy}
|
|
LIMIT ${limit} OFFSET ${offset}
|
|
`;
|
|
|
|
const countQuery = `SELECT COUNT(*) FROM switches sw ${where}`;
|
|
|
|
const [dataResult, countResult] = await Promise.all([
|
|
pool.query(query, values),
|
|
pool.query(countQuery, values),
|
|
]);
|
|
|
|
return {
|
|
data: dataResult.rows,
|
|
total: parseInt(countResult.rows[0].count),
|
|
limit,
|
|
offset,
|
|
};
|
|
}
|
|
|
|
export async function getSwitchById(id: string) {
|
|
const result = await pool.query(
|
|
`SELECT sw.*, v.name as vendor_name, v.website as vendor_website
|
|
FROM switches sw
|
|
LEFT JOIN vendors v ON sw.vendor_id = v.id
|
|
WHERE sw.id = $1`,
|
|
[id]
|
|
);
|
|
return result.rows[0] || null;
|
|
}
|
|
|
|
export async function getSwitchDocuments(switchId: string) {
|
|
const result = await pool.query(
|
|
`SELECT id, doc_type, title, source_url, download_url, language, version, is_official, vendor_doc_id, page_count, file_size_bytes, r2_key, created_at
|
|
FROM product_documents
|
|
WHERE switch_id = $1
|
|
ORDER BY is_official DESC, doc_type, title`,
|
|
[switchId]
|
|
);
|
|
return result.rows;
|
|
}
|
|
|
|
export async function getSwitchIssues(switchId: string) {
|
|
const result = await pool.query(
|
|
`SELECT id, source_type, source_name, source_url, title, summary, severity,
|
|
issue_tags, affected_firmware, fix_firmware, date_reported, is_resolved, confidence
|
|
FROM product_issues
|
|
WHERE switch_id = $1
|
|
ORDER BY
|
|
CASE severity WHEN 'critical' THEN 0 WHEN 'warning' THEN 1 ELSE 2 END,
|
|
date_reported DESC NULLS LAST`,
|
|
[switchId]
|
|
);
|
|
return result.rows;
|
|
}
|
|
|
|
export async function getTransceiverIssues(transceiverI: string) {
|
|
const result = await pool.query(
|
|
`SELECT id, source_type, source_name, source_url, title, summary, severity,
|
|
issue_tags, affected_firmware, fix_firmware, date_reported, is_resolved, confidence
|
|
FROM product_issues
|
|
WHERE transceiver_id = $1
|
|
ORDER BY
|
|
CASE severity WHEN 'critical' THEN 0 WHEN 'warning' THEN 1 ELSE 2 END,
|
|
date_reported DESC NULLS LAST`,
|
|
[transceiverI]
|
|
);
|
|
return result.rows;
|
|
}
|
|
|
|
export async function getTransceiverDocuments(transceiverI: string) {
|
|
const result = await pool.query(
|
|
`SELECT id, doc_type, title, source_url, download_url, language, version, is_official, vendor_doc_id, page_count, file_size_bytes, r2_key, created_at
|
|
FROM product_documents
|
|
WHERE transceiver_id = $1
|
|
ORDER BY is_official DESC, doc_type, title`,
|
|
[transceiverI]
|
|
);
|
|
return result.rows;
|
|
}
|
|
|
|
export async function getCompatibleTransceivers(switchId: string) {
|
|
const result = await pool.query(
|
|
`SELECT t.*, c.status, c.verified_by, c.verification_method, c.notes as compat_notes,
|
|
v.name AS vendor_name, v.type AS vendor_type, v.website AS vendor_website,
|
|
-- Latest verified price
|
|
COALESCE(t.price_verified_eur,
|
|
(SELECT po.price FROM price_observations po WHERE po.transceiver_id = t.id ORDER BY po.time DESC LIMIT 1)
|
|
) AS latest_price,
|
|
CASE WHEN t.price_verified_eur IS NOT NULL THEN 'EUR'
|
|
ELSE (SELECT po.currency FROM price_observations po WHERE po.transceiver_id = t.id ORDER BY po.time DESC LIMIT 1)
|
|
END AS latest_currency
|
|
FROM compatibility c
|
|
JOIN transceivers t ON c.transceiver_id = t.id
|
|
LEFT JOIN vendors v ON t.vendor_id = v.id
|
|
WHERE c.switch_id = $1 AND c.status = 'compatible'
|
|
ORDER BY
|
|
CASE WHEN LOWER(v.name) = 'flexoptix' THEN 0 ELSE 1 END,
|
|
CASE WHEN c.verification_method = 'vendor_compat' THEN 0
|
|
WHEN c.verification_method = 'vendor_matrix' THEN 1
|
|
ELSE 2 END,
|
|
t.speed_gbps DESC`,
|
|
[switchId]
|
|
);
|
|
return result.rows;
|
|
}
|
|
|
|
/**
|
|
* getFlexoptixSuggestions — returns Flexoptix transceivers that physically fit
|
|
* the switch's port slots, derived from ports_config JSONB keys.
|
|
* Works even before the compat scraper has processed the switch.
|
|
*/
|
|
export async function getFlexoptixSuggestions(switchId: string) {
|
|
const result = await pool.query(
|
|
`WITH switch_form_factors AS (
|
|
SELECT DISTINCT
|
|
CASE
|
|
WHEN k ILIKE '%QSFP-DD800%' THEN 'QSFP-DD800'
|
|
WHEN k ILIKE '%QSFP-DD%' THEN 'QSFP-DD'
|
|
WHEN k ILIKE '%OSFP224%' THEN 'OSFP224'
|
|
WHEN k ILIKE '%OSFP%' THEN 'OSFP'
|
|
WHEN k ILIKE '%QSFP28%' THEN 'QSFP28'
|
|
WHEN k ILIKE '%QSFP+%' THEN 'QSFP+'
|
|
WHEN k ILIKE '%QSFP%' THEN 'QSFP+'
|
|
WHEN k ILIKE '%SFP28%' THEN 'SFP28'
|
|
WHEN k ILIKE '%SFP+%' THEN 'SFP+'
|
|
WHEN k ILIKE '%SFP%' THEN 'SFP+'
|
|
WHEN k ILIKE '%CFP2%' THEN 'CFP2'
|
|
WHEN k ILIKE '%CFP4%' THEN 'CFP4'
|
|
WHEN k ILIKE '%CFP%' THEN 'CFP'
|
|
END AS form_factor
|
|
FROM switches sw,
|
|
jsonb_object_keys(sw.ports_config) AS k
|
|
WHERE sw.id = $1 AND sw.ports_config IS NOT NULL
|
|
)
|
|
SELECT t.id, t.slug, t.part_number, t.standard_name, t.form_factor,
|
|
t.speed, t.speed_gbps, t.reach_meters, t.reach_label,
|
|
t.fiber_type, t.wavelength_nm, t.market_status,
|
|
t.product_page_url, t.image_url,
|
|
t.price_verified_eur, t.price_verified_at, t.price_verified_usd,
|
|
v.name AS vendor_name, v.website AS vendor_website,
|
|
COALESCE(t.price_verified_eur,
|
|
(SELECT po.price FROM price_observations po
|
|
WHERE po.transceiver_id = t.id ORDER BY po.time DESC LIMIT 1)
|
|
) AS latest_price,
|
|
CASE WHEN t.price_verified_eur IS NOT NULL THEN 'EUR'
|
|
ELSE (SELECT po.currency FROM price_observations po
|
|
WHERE po.transceiver_id = t.id ORDER BY po.time DESC LIMIT 1)
|
|
END AS latest_currency
|
|
FROM transceivers t
|
|
JOIN vendors v ON t.vendor_id = v.id
|
|
WHERE LOWER(v.name) = 'flexoptix'
|
|
AND t.form_factor IN (
|
|
SELECT form_factor FROM switch_form_factors WHERE form_factor IS NOT NULL
|
|
)
|
|
ORDER BY t.speed_gbps DESC NULLS LAST, t.reach_meters ASC NULLS LAST`,
|
|
[switchId]
|
|
);
|
|
return result.rows;
|
|
}
|
|
|
|
export async function listVendors(type?: string) {
|
|
const query = type
|
|
? `SELECT v.*,
|
|
(SELECT COUNT(*) FROM transceivers t WHERE t.vendor_id = v.id) as transceiver_count,
|
|
(SELECT COUNT(*) FROM switches s WHERE s.vendor_id = v.id) as switch_count
|
|
FROM vendors v WHERE v.type = $1 ORDER BY v.name`
|
|
: `SELECT v.*,
|
|
(SELECT COUNT(*) FROM transceivers t WHERE t.vendor_id = v.id) as transceiver_count,
|
|
(SELECT COUNT(*) FROM switches s WHERE s.vendor_id = v.id) as switch_count
|
|
FROM vendors v ORDER BY v.name`;
|
|
const result = await pool.query(query, type ? [type] : []);
|
|
return result.rows;
|
|
}
|
|
|
|
export async function listStandards(speed?: string) {
|
|
const base = `
|
|
SELECT s.*,
|
|
COUNT(t.id)::int AS transceiver_count
|
|
FROM standards s
|
|
LEFT JOIN transceivers t ON t.standard_id = s.id`;
|
|
const query = speed
|
|
? `${base} WHERE s.speed = $1 GROUP BY s.id ORDER BY s.speed_gbps DESC NULLS LAST, s.name`
|
|
: `${base} GROUP BY s.id ORDER BY s.speed_gbps DESC NULLS LAST, s.name`;
|
|
const result = await pool.query(query, speed ? [speed] : []);
|
|
return result.rows;
|
|
}
|
|
|
|
export async function getDbStats() {
|
|
const result = await pool.query(`
|
|
SELECT
|
|
(SELECT COUNT(*) FROM vendors) as vendor_count,
|
|
(SELECT COUNT(*) FROM standards) as standard_count,
|
|
(SELECT COUNT(*) FROM transceivers) as transceiver_count,
|
|
(SELECT COUNT(*) FROM switches) as switch_count,
|
|
(SELECT COUNT(*) FROM compatibility) as compatibility_count,
|
|
(SELECT COUNT(*) FROM breakouts) as breakout_count,
|
|
(SELECT COUNT(*) FROM knowledge_base) as kb_count,
|
|
(SELECT COUNT(*) FROM documents) as document_count,
|
|
(SELECT COUNT(*) FROM news_articles) as news_count,
|
|
(SELECT COUNT(*) FROM product_documents) as product_document_count,
|
|
(SELECT COUNT(*) FROM switches WHERE image_url IS NOT NULL) as switches_with_images,
|
|
(SELECT COUNT(*) FROM switches WHERE datasheet_r2_key IS NOT NULL) as switches_with_datasheets
|
|
`);
|
|
return result.rows[0];
|
|
}
|