diff --git a/services/targo-hub/lib/address-db.js b/services/targo-hub/lib/address-db.js new file mode 100644 index 0000000..098fc81 --- /dev/null +++ b/services/targo-hub/lib/address-db.js @@ -0,0 +1,124 @@ +'use strict' +/** + * address-db.js — recherche d'adresses LOCALE (Postgres ERPNext), remplace le Supabase cloud externe. + * + * Source : `rqa_addresses` (5,24M adresses du Québec, search_text désaccentué, index trigram GIN) + * LEFT JOIN `fiber_availability` (couverture fibre Targo, joint par address_id) — toutes deux DÉJÀ + * locales dans la db ERPNext `_eb65bdc0c4b1b2d6`. Le hub est sur le réseau erpnext_erpnext + a `pg`. + * + * Deux phases (comme l'autocomplete de dispo) : + * Phase 1 — civique présent : filtre `numero` (btree) + mots de rue (LIKE), tri fibre→J0L/J0S→similarité. ~20 ms. + * Phase 2 — sans civique / phase 1 vide : `word_similarity` (`<%`, indexable GIN), tri idem. ~700 ms. + * (NB : le `%`/similarity() plein sur 5,24M = 24-76 s → on utilise `<%` qui est sélectif et indexé.) + * + * Retourne une forme compatible avec l'ancien Supabase (adresse_formatee, numero_municipal, + * odonyme_recompose_normal, nom_municipalite, latitude, longitude, fiber_available, zone_tarifaire, + * max_speed, similarity_score) → consommateurs hub inchangés (pont, onboarding, checkout, site). + */ +const { Pool } = require('pg') +const { log } = require('./helpers') + +const norm = (s) => (s || '').toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '').replace(/\s+/g, ' ').trim() + +let _pool +function pool () { + if (!_pool) { + _pool = new Pool({ + host: process.env.ADDR_DB_HOST || 'erpnext-db-1', + port: +(process.env.ADDR_DB_PORT || 5432), + user: process.env.ADDR_DB_USER || 'postgres', + password: process.env.ADDR_DB_PASS || '123', + database: process.env.ADDR_DB_NAME || '_eb65bdc0c4b1b2d6', + max: 4, idleTimeoutMillis: 30000, connectionTimeoutMillis: 6000, + }) + _pool.on('error', (e) => log('address-db pool error:', e.message)) + } + return _pool +} + +const COLS = `a.id, a.address_full, a.numero, a.rue, a.ville, a.code_postal, a.longitude, a.latitude, + (f.id IS NOT NULL) AS fiber_available, COALESCE(f.zone_tarifaire,0) AS zone_tarifaire, COALESCE(f.max_speed,0) AS max_speed` +const ORDER = `(f.id IS NOT NULL) DESC, (a.code_postal LIKE 'J0L%' OR a.code_postal LIKE 'J0S%') DESC, sim DESC` + +function mapRow (r) { + return { + identifiant_unique_adresse: String(r.id), + adresse_formatee: r.address_full || [r.numero, r.rue].filter(Boolean).join(' ') + (r.ville ? ', ' + r.ville : '') + (r.code_postal ? ' ' + r.code_postal : ''), + numero_municipal: r.numero, + numero_unite: null, + code_postal: r.code_postal, + odonyme_recompose_normal: r.rue, + nom_municipalite: r.ville, + latitude: r.latitude, + longitude: r.longitude, + fiber_available: !!r.fiber_available, + zone_tarifaire: r.zone_tarifaire, + max_speed: r.max_speed, + similarity_score: r.sim != null ? +r.sim : null, + } +} + +// Forme BRUTE (colonnes de la fonction search_addresses : id, address_full, numero, rue, ville, +// code_postal, longitude, latitude, fiber_available, zone_tarifaire, max_speed, similarity_score) +// → consommée telle quelle par l'autocomplete du site web (endpoint /rpc/search_addresses). +function toRaw (r) { + return { + id: r.id, address_full: r.address_full, numero: r.numero, rue: r.rue, ville: r.ville, + code_postal: r.code_postal, longitude: r.longitude, latitude: r.latitude, + fiber_available: !!r.fiber_available, zone_tarifaire: r.zone_tarifaire, max_speed: r.max_speed, + similarity_score: r.sim != null ? +r.sim : null, + } +} + +// Recherche principale (lignes brutes DB). term = texte tapé ("2338 rue rené-vinet" ou "rené-vinet ..."). +async function searchRows (term, limit = 8) { + const clean = norm(term) + if (clean.length < 3) return [] + const lim = Math.min(Math.max(parseInt(limit) || 8, 1), 25) + const civic = (clean.match(/^\s*(\d+)/) || [])[1] || null + const streetPart = clean.replace(/^\s*\d+\s*/, '').trim() + const words = streetPart ? streetPart.split(' ').filter(w => w.length >= 2) : [] + const p = pool() + + // ── Phase 1 : civique présent (rapide, btree numero) ── + if (civic) { + const sql = `SELECT ${COLS}, similarity(a.search_text, $3) AS sim + FROM rqa_addresses a LEFT JOIN fiber_availability f ON f.address_id = a.id + WHERE a.numero = $1 + AND (array_length($2::text[], 1) IS NULL OR NOT EXISTS ( + SELECT 1 FROM unnest($2::text[]) w WHERE a.search_text NOT LIKE '%' || w || '%')) + ORDER BY ${ORDER}, a.numero + LIMIT $4` + const r = await p.query(sql, [civic, words, clean, lim]) + if (r.rows.length) return r.rows + } + + // ── Phase 2 : word_similarity (sans civique, ou phase 1 vide) ── + // `<%` (indexable GIN) au lieu de `%`/similarity() plein (24-76 s sur 5,24M). Seuil + statement_timeout + // posés en SET LOCAL dans une transaction (déterministe + auto-reset au COMMIT ; borne le pire cas). + const sql2 = `SELECT ${COLS}, word_similarity($1, a.search_text) AS sim + FROM rqa_addresses a LEFT JOIN fiber_availability f ON f.address_id = a.id + WHERE $1 <% a.search_text + ORDER BY ${ORDER} + LIMIT $2` + const client = await p.connect() + try { + await client.query('BEGIN') + await client.query('SET LOCAL pg_trgm.word_similarity_threshold = 0.6') // ~700 ms ; 0.5 plus large/lent + await client.query('SET LOCAL statement_timeout = 4000') // garde-fou anti-hang (sécurité) + const r2 = await client.query(sql2, [clean, lim]) + await client.query('COMMIT') + return r2.rows + } catch (e) { + try { await client.query('ROLLBACK') } catch (_) {} + log('searchRows phase2:', e.message) + return [] + } finally { client.release() } +} + +// Forme MAPPÉE (compat Supabase historique) → consommée par les services hub (pont, onboarding, checkout). +async function searchLocal (term, limit = 8) { return (await searchRows(term, limit)).map(mapRow) } +// Forme BRUTE (colonnes de la fonction) → consommée par l'autocomplete du site web. +async function searchRaw (term, limit = 8) { return (await searchRows(term, limit)).map(toRaw) } + +module.exports = { searchLocal, searchRaw, pool, norm } diff --git a/services/targo-hub/lib/address-search.js b/services/targo-hub/lib/address-search.js index 25dc321..e250507 100644 --- a/services/targo-hub/lib/address-search.js +++ b/services/targo-hub/lib/address-search.js @@ -1,65 +1,24 @@ 'use strict' -const { httpRequest } = require('./helpers') - -const SUPABASE_URL = 'https://rddrjzptzhypltuzmere.supabase.co' -const SUPABASE_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InJkZHJqenB0emh5cGx0dXptZXJlIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzA4MTY4NTYsImV4cCI6MjA4NjM5Mjg1Nn0.EluFlKBze8BYM6AFx88G7kt21EvR18EI3uw1zgCXVzs' - -function wordsToIlike (str) { - const words = str.split(/\s+/).filter(w => w.length >= 2) - if (!words.length) return '' - return '*' + words.map(w => encodeURIComponent(w)).join('*') + '*' -} +/** + * address-search.js — façade de recherche d'adresses. + * + * Depuis 2026-06 la source est 100% LOCALE (Postgres ERPNext : rqa_addresses + fiber_availability, + * via ./address-db) — PLUS aucune dépendance au Supabase cloud externe. Les noms d'export restent + * stables pour les consommateurs existants : address-validate (/address/*), checkout (/api/address-search), + * legacy-dispatch-sync (géocodage du pont). + */ +const { searchLocal } = require('./address-db') +// Recherche d'adresses — forme historique (adresse_formatee, numero_municipal, numero_unite, +// odonyme_recompose_normal, nom_municipalite, code_postal, latitude, longitude, +// identifiant_unique_adresse, fiber_available, zone_tarifaire, max_speed, similarity_score). async function searchAddresses (term, limit = 8) { - const clean = term.trim() - if (clean.length < 3) return [] - - const numMatch = clean.match(/^\s*(\d+)\s*(.*)/) - const headers = { apikey: SUPABASE_KEY, Authorization: 'Bearer ' + SUPABASE_KEY } - const select = 'adresse_formatee,numero_municipal,numero_unite,code_postal,odonyme_recompose_normal,nom_municipalite,latitude,longitude,identifiant_unique_adresse' - const base = `${SUPABASE_URL}/rest/v1/addresses?select=${select}&limit=${limit}` - - let results = [] - - if (numMatch) { - const num = numMatch[1] - const street = numMatch[2].trim() - let url = `${base}&numero_municipal=eq.${num}` - if (street) url += `&odonyme_recompose_normal=ilike.${wordsToIlike(street)}` - url += '&order=nom_municipalite' - const res = await httpRequest(url, '', { headers }) - results = Array.isArray(res.data) ? res.data : [] - - if (!results.length && num.length >= 2) { - let url2 = `${base}&numero_municipal=like.${num}*` - if (street) url2 += `&odonyme_recompose_normal=ilike.${wordsToIlike(street)}` - url2 += '&order=nom_municipalite' - const res2 = await httpRequest(url2, '', { headers }) - results = Array.isArray(res2.data) ? res2.data : [] - } - } else { - const pattern = wordsToIlike(clean) - if (!pattern) return [] - const url = `${base}&odonyme_recompose_normal=ilike.${pattern}&order=nom_municipalite` - const res = await httpRequest(url, '', { headers }) - results = Array.isArray(res.data) ? res.data : [] - } - - return results.map(a => ({ ...a, fiber_available: false })) + try { return await searchLocal(term, limit) } catch (e) { return [] } } -// RECHERCHE TRIGRAM (RPC Postgres `search_addresses`) — bien plus robuste que l'ilike ci-dessus : -// phase 1 = numéro civique + mots de rue (sur odonyme normal/court/LONG[avec générique]/municipalité/CP), -// phase 2 = trigram complet (`%`, pg_trgm). Priorise les CP J0L/J0S (territoire). Renvoie aussi -// fiber_available/zone_tarifaire/max_speed/similarity_score. C'est ce qui propulse l'autocomplete de dispo. +// Alias historique (anciennement la RPC trigram Supabase) → désormais la même recherche locale. async function searchAddressesRpc (term, limit = 8) { - const clean = (term || '').trim() - if (clean.length < 3) return [] - const headers = { apikey: SUPABASE_KEY, Authorization: 'Bearer ' + SUPABASE_KEY, 'Content-Type': 'application/json' } - const res = await httpRequest(`${SUPABASE_URL}/rest/v1/rpc/search_addresses`, '', { - method: 'POST', body: JSON.stringify({ search_term: clean, result_limit: limit }), headers, - }) - return Array.isArray(res.data) ? res.data : [] + return searchLocal(term, limit) } -module.exports = { searchAddresses, searchAddressesRpc, wordsToIlike } +module.exports = { searchAddresses, searchAddressesRpc } diff --git a/services/targo-hub/lib/address-validate.js b/services/targo-hub/lib/address-validate.js index 7760e47..a01eb07 100644 --- a/services/targo-hub/lib/address-validate.js +++ b/services/targo-hub/lib/address-validate.js @@ -19,6 +19,16 @@ const { json, parseBody, log } = require('./helpers') const { searchAddresses } = require('./address-search') +const { searchLocal, searchRaw } = require('./address-db') + +// CORS pour l'endpoint public /address/search (appelé par le site web depuis un autre domaine). +// Données publiques (adresses RQA + dispo fibre) → ouverture large, lecture seule. +function cors (res) { + res.setHeader('Access-Control-Allow-Origin', '*') + res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS') + res.setHeader('Access-Control-Allow-Headers', 'Content-Type') + res.setHeader('Cache-Control', 'public, max-age=60') +} // Normalize for fuzzy comparison: lowercase, strip diacritics, collapse // whitespace, drop punctuation. Used to score how close a typed address @@ -65,6 +75,38 @@ function scoreMatch (typed, rqaRow) { } async function handle (req, res, method, path) { + // POST /rpc/search_addresses — COMPAT Supabase RPC (forme attendue par l'autocomplete du site web : + // body { search_term, result_limit } → tableau direct de lignes { id, address_full, numero, rue, ville, + // code_postal, longitude, latitude, fiber_available, zone_tarifaire, max_speed, similarity_score }). + // Sert depuis la base LOCALE → on débranche le Supabase cloud (juste basculer VITE_API_BASE côté site). + if (path === '/rpc/search_addresses') { + if (method === 'OPTIONS') { cors(res); res.writeHead(204); res.end(); return } + if (method === 'POST') { + const body = await parseBody(req) + const term = (body.search_term || body.q || '').toString().trim() + const limit = body.result_limit || body.limit || 8 + let rows = [] + try { rows = await searchRaw(term, limit) } catch (e) { log('rpc/search_addresses:', e.message) } + cors(res) + return json(res, 200, rows) + } + } + + // GET /address/search?q=&limit= — autocomplete PUBLIC (site web) : adresses + disponibilité fibre, + // depuis la base LOCALE (rqa_addresses + fiber_availability). Remplace l'appel direct au Supabase. + if (path.startsWith('/address/search')) { + if (method === 'OPTIONS') { cors(res); res.writeHead(204); res.end(); return } + if (method === 'GET') { + const u = new URL(req.url, 'http://localhost') + const q = (u.searchParams.get('q') || '').trim() + const limit = u.searchParams.get('limit') || 8 + let results = [] + try { results = await searchLocal(q, limit) } catch (e) { log('address/search error:', e.message) } + cors(res) + return json(res, 200, { ok: true, query: q, count: results.length, results }) + } + } + // POST /address/validate — score-rank RQA results for a free-text address. if (path === '/address/validate' && method === 'POST') { const body = await parseBody(req) diff --git a/services/targo-hub/server.js b/services/targo-hub/server.js index 3fbd67b..98f9222 100644 --- a/services/targo-hub/server.js +++ b/services/targo-hub/server.js @@ -98,7 +98,7 @@ const server = http.createServer(async (req, res) => { if (path.startsWith('/auth/')) return auth.handle(req, res, method, path, url) if (path.startsWith('/conversations')) return conversation.handle(req, res, method, path, url) if (path.startsWith('/traccar')) return traccar.handle(req, res, method, path) - if (path.startsWith('/address/')) return require('./lib/address-validate').handle(req, res, method, path) + if (path.startsWith('/address/') || path.startsWith('/rpc/')) return require('./lib/address-validate').handle(req, res, method, path) if (path.startsWith('/magic-link')) return require('./lib/magic-link').handle(req, res, method, path) if (path.startsWith('/portal/')) return require('./lib/portal-auth').handle(req, res, method, path) // Lightweight tech mobile page: /t/{token}[/action]