diff --git a/app/database/migrations/20260606000000_add_normalized_search_columns/backfill-parity.integration.test.ts b/app/database/migrations/20260606000000_add_normalized_search_columns/backfill-parity.integration.test.ts new file mode 100644 index 00000000..c7456d7a --- /dev/null +++ b/app/database/migrations/20260606000000_add_normalized_search_columns/backfill-parity.integration.test.ts @@ -0,0 +1,82 @@ +/** + * Lock the migration backfill SQL to behave the same as the runtime + * `stripDiacritics()` helper for representative French inputs. The + * `translate()` character map in `migration.sql` is hand-maintained — a typo + * or a missing pair would silently corrupt the backfill on production for + * any tenant relying on diacritic-stripped search. + */ +import { PrismaPg } from '@prisma/adapter-pg' +import { afterAll, describe, expect, it } from 'vitest' +import { PrismaClient } from '~/database/generated/client' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' + +const adapter = new PrismaPg({ + connectionString: process.env.DB_RUNTIME_URL ?? process.env.DB_URL, + max: 5, + connectionTimeoutMillis: 5000, +}) +const testDb = new PrismaClient({ adapter }) + +const TRANSLATE_FROM = 'àáâãäåçèéêëìíîïñòóôõöùúûüýÿ' +const TRANSLATE_TO = 'aaaaaaceeeeiiiinooooouuuuyy' + +async function backfillSql(input: string): Promise { + const rows = await testDb.$queryRawUnsafe<{ result: string }[]>( + `SELECT translate(lower($1), $2, $3) AS result`, + input, + TRANSLATE_FROM, + TRANSLATE_TO, + ) + return rows[0]?.result ?? '' +} + +afterAll(async () => { + await testDb.$disconnect() +}) + +describe('migration backfill — SQL/JS parity', () => { + const cases = [ + 'Pajot', + 'Päjot', + 'PÄJOT', + 'élève', + 'Côté', + 'François', + 'Hélène', + "L'Hôpital-Saint-Louis", + "Boulevard Saint-Germain", + 'Champs-Élysées', + 'Mañana', + 'Müller', + ' spaces ', + 'mixed CASE Päjot', + ] + + for (const input of cases) { + it(`SQL backfill matches stripDiacritics() for "${input}"`, async () => { + const sql = await backfillSql(input) + expect(sql).toBe(stripDiacritics(input)) + }) + } + + it('translate map has matching from/to lengths', () => { + // A length mismatch would be a Postgres runtime error inside the + // migration — assert it here so a typo trips a unit failure before + // anyone runs `prisma migrate deploy`. + expect([...TRANSLATE_FROM]).toHaveLength([...TRANSLATE_TO].length) + }) + + it('uppercase variants get lowercased before translation', async () => { + expect(await backfillSql('ÀÉÎÔÛ')).toBe('aeiou') + }) + + it('characters outside the map pass through unchanged', async () => { + // æ / œ ligatures + the `ø` slash-o are uncommon in French names and not + // in our map. Document that they survive instead of being silently + // dropped — also keeps the SQL behaviour aligned with the JS helper, + // which preserves them too (NFD doesn't canonically decompose them). + expect(await backfillSql('cœur')).toBe('cœur') + expect(await backfillSql('æther')).toBe('æther') + expect(await backfillSql('strøget')).toBe('strøget') + }) +}) diff --git a/app/database/migrations/20260606000000_add_normalized_search_columns/migration.sql b/app/database/migrations/20260606000000_add_normalized_search_columns/migration.sql new file mode 100644 index 00000000..7c4b8b89 --- /dev/null +++ b/app/database/migrations/20260606000000_add_normalized_search_columns/migration.sql @@ -0,0 +1,62 @@ +-- Add normalized search columns to Member and Building. +-- +-- Search aids: lowercased, diacritic-stripped copies of free-text fields used +-- by territory/attribution/building filter forms. Maintained at write-time +-- (see app/shared/utils/strip-diacritics.ts) so runtime queries can stay in +-- pure Prisma `contains` without needing the `unaccent` extension or raw SQL. +-- +-- Pre-existing rows are backfilled in step 2 using Postgres `translate()` +-- with an explicit character map covering every Latin-1 / Latin-Extended +-- diacritic likely to appear in French names and addresses. Avoids the +-- `unaccent` extension entirely — managed Postgres hosts often refuse +-- `CREATE EXTENSION` outside the bootstrap role, and we want +-- `prisma migrate deploy` to run cleanly under the standard app role. + +-- ========================================================================= +-- 1. Add columns with safe defaults +-- ========================================================================= + +ALTER TABLE "Member" + ADD COLUMN "firstnameNormalized" TEXT NOT NULL DEFAULT '', + ADD COLUMN "lastnameNormalized" TEXT NOT NULL DEFAULT ''; + +ALTER TABLE "Building" + ADD COLUMN "streetNormalized" TEXT NOT NULL DEFAULT ''; + +-- ========================================================================= +-- 2. Backfill existing rows +-- +-- Mirrors `stripDiacritics()` for every char in the map. The `from` and +-- `to` strings must stay the same length; if a new diacritic needs covering +-- later, append matching codepoints to both. Idempotent — the WHERE guard +-- only touches rows with the empty-string default. +-- ========================================================================= + +UPDATE "Member" +SET + "firstnameNormalized" = translate(lower("firstname"), + 'àáâãäåçèéêëìíîïñòóôõöùúûüýÿ', + 'aaaaaaceeeeiiiinooooouuuuyy'), + "lastnameNormalized" = translate(lower("lastname"), + 'àáâãäåçèéêëìíîïñòóôõöùúûüýÿ', + 'aaaaaaceeeeiiiinooooouuuuyy') +WHERE "firstnameNormalized" = '' OR "lastnameNormalized" = ''; + +UPDATE "Building" +SET "streetNormalized" = translate(lower("street"), + 'àáâãäåçèéêëìíîïñòóôõöùúûüýÿ', + 'aaaaaaceeeeiiiinooooouuuuyy') +WHERE "streetNormalized" = ''; + +-- ========================================================================= +-- 3. Indexes scoped by congregation for fast filter queries +-- ========================================================================= + +CREATE INDEX "Member_congregationId_firstnameNormalized_idx" + ON "Member" ("congregationId", "firstnameNormalized"); + +CREATE INDEX "Member_congregationId_lastnameNormalized_idx" + ON "Member" ("congregationId", "lastnameNormalized"); + +CREATE INDEX "Building_congregationId_streetNormalized_idx" + ON "Building" ("congregationId", "streetNormalized"); diff --git a/app/database/schema.prisma b/app/database/schema.prisma index a7182366..9c46e8b7 100644 --- a/app/database/schema.prisma +++ b/app/database/schema.prisma @@ -132,12 +132,17 @@ model Member { congregationId Int // Identity - firstname String - lastname String - isMale Boolean? - birthDate DateTime? - phone String @default("") - address String @default("") + firstname String + lastname String + // Search aids: lowercased, diacritic-stripped copies of firstname/lastname. + // Maintained at write-time so search queries can stay in pure Prisma without + // needing the `unaccent` extension at runtime. + firstnameNormalized String @default("") + lastnameNormalized String @default("") + isMale Boolean? + birthDate DateTime? + phone String @default("") + address String @default("") // Domain status. `isPublisher = false` means ministry-school student. // `type` is only meaningful when `isPublisher = true`. @@ -179,6 +184,8 @@ model Member { @@unique([id, congregationId]) @@index([congregationId, leftAt]) + @@index([congregationId, firstnameNormalized]) + @@index([congregationId, lastnameNormalized]) } // A login. Always has an email + password. Optionally points at a Member. @@ -549,12 +556,15 @@ model BuildingResidentialData { } model Building { - id Int @id @default(autoincrement()) - number String - street String - zip String - latitude Float? - longitude Float? + id Int @id @default(autoincrement()) + number String + street String + // Search aid: lowercased, diacritic-stripped copy of street. + // Maintained at write-time so search queries can stay in pure Prisma. + streetNormalized String @default("") + zip String + latitude Float? + longitude Float? active Boolean @default(true) inTerritory Boolean @default(true) inOpenData Boolean @default(false) @@ -573,6 +583,7 @@ model Building { @@unique([number, street, zip, congregationId], name: "address") @@unique([id, congregationId]) + @@index([congregationId, streetNormalized]) } model Setting { diff --git a/app/database/seed-marketing.ts b/app/database/seed-marketing.ts index c85d0481..3de146b9 100644 --- a/app/database/seed-marketing.ts +++ b/app/database/seed-marketing.ts @@ -24,6 +24,7 @@ import { TerritoryAttributionKind } from '../features/territories/model/territor import { TerritoryKind } from '../features/territories/model/territory-kind.type' import { Permission } from '../shared/types/permission' import { PublisherType } from '../shared/types/publisher-type' +import { stripDiacritics } from '../shared/utils/strip-diacritics' import { PrismaClient } from './generated/client' const adapter = new PrismaPg({ connectionString: process.env.DB_URL }) @@ -687,6 +688,8 @@ async function main() { data: { firstname: pub.firstname, lastname: pub.lastname, + firstnameNormalized: stripDiacritics(pub.firstname), + lastnameNormalized: stripDiacritics(pub.lastname), isPublisher: true, type: pub.type, isMale: pub.isMale, @@ -881,6 +884,7 @@ async function main() { data: { number: buildingNumber, street: streetInfo.street, + streetNormalized: stripDiacritics(streetInfo.street), zip: streetInfo.zip, latitude: coords.latitude, longitude: coords.longitude, diff --git a/app/features/publishers/server/create-member.server.ts b/app/features/publishers/server/create-member.server.ts index 1a86c46e..50c49b6e 100644 --- a/app/features/publishers/server/create-member.server.ts +++ b/app/features/publishers/server/create-member.server.ts @@ -4,6 +4,7 @@ import { syncBuiltInRoleAssignments } from '~/shared/domain/built-in-roles.serve import type { CongregationInfo } from '~/shared/domain/congregation.server' import { LimitService } from '~/shared/domain/limits.server' import type { TransactionClient } from '~/shared/infra/db.server' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' import type { PublisherType } from '~/shared/types/publisher-type' export interface CreateMemberParams { @@ -38,6 +39,8 @@ export async function createMember(db: TransactionClient, congregation: Congrega data: { firstname: params.firstname, lastname: params.lastname, + firstnameNormalized: stripDiacritics(params.firstname), + lastnameNormalized: stripDiacritics(params.lastname), isMale: params.gender === 'male', baptismDate: params.baptismDate ? new Date(params.baptismDate) : null, birthDate: params.birthDate ? new Date(params.birthDate) : null, diff --git a/app/features/publishers/server/normalized-columns.integration.test.ts b/app/features/publishers/server/normalized-columns.integration.test.ts new file mode 100644 index 00000000..88cf28fa --- /dev/null +++ b/app/features/publishers/server/normalized-columns.integration.test.ts @@ -0,0 +1,159 @@ +/** + * Confirms the normalized search columns (`firstnameNormalized`, + * `lastnameNormalized`) actually land on disk through every Member write + * path the PR touched — not just that the value was passed to the Prisma + * mock. A regression here would silently break accent-insensitive name + * search. + */ +import { PrismaPg } from '@prisma/adapter-pg' +import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest' +import { PrismaClient } from '~/database/generated/client' +import { PublisherType } from '~/shared/types/publisher-type' + +vi.mock('~/shared/domain/audit.server', () => ({ + audit: vi.fn(), + auditInTransaction: vi.fn(), + AuditAction: { + PublisherCreated: 'publisher.created', + PublisherUpdated: 'publisher.updated', + UserAnonymized: 'user.anonymized', + AccountLinkedToMember: 'account.linked_to_member', + UserUpdated: 'user.updated', + RoleAssignmentsSynced: 'role.assignments.synced', + }, +})) + +vi.mock('~/features/authentication/server/invalidate-account-password.server', () => ({ + createPasswordResetToken: vi.fn(async () => 'fake-token'), +})) + +const { seedBuiltInRoles } = await import('~/shared/domain/setup.server') +const { createMember } = await import('./create-member.server') +const { updateMember } = await import('./update-member.server') +const { anonymizeMember } = await import('~/features/settings/server/anonymize-member.server') + +const adapter = new PrismaPg({ + connectionString: process.env.DB_RUNTIME_URL ?? process.env.DB_URL, + max: 5, + connectionTimeoutMillis: 5000, +}) +const testDb = new PrismaClient({ adapter }) + +type Tx = Parameters[0]>[0] + +function withScope(congregationId: number, fn: (tx: Tx) => Promise): Promise { + return testDb.$transaction(async tx => { + await tx.$executeRawUnsafe(`SET LOCAL app.congregation_id = '${String(congregationId)}'`) + return fn(tx) + }) +} + +const ts = Date.now() +let congregationId: number + +beforeAll(async () => { + const cong = await testDb.congregation.create({ + data: { name: `NormalizedCols ${ts}`, slug: `normalized-cols-${ts}`, active: true }, + }) + congregationId = cong.id + await seedBuiltInRoles(testDb, congregationId) +}) + +afterAll(async () => { + await withScope(congregationId, async tx => { + await tx.dataDeletionRecord.deleteMany({}) + await tx.memberRoleAssignment.deleteMany({}) + await tx.userRoleAssignment.deleteMany({}) + await tx.role.deleteMany({}) + await tx.userAccount.deleteMany({}) + await tx.member.deleteMany({}) + }) + await testDb.congregation.delete({ where: { id: congregationId } }) + await testDb.$disconnect() +}) + +const baseParams = { + email: null, + gender: 'male', + birthDate: null, + baptismDate: '2010-01-01', + isHelder: false, + isServant: false, + isAnointed: false, + groupId: null, + type: PublisherType.Normal, + phone: '', + address: '', +} as const + +describe('Member normalized columns — write-through', () => { + it('createMember writes diacritic-stripped firstname/lastname to disk', async () => { + const member = await withScope(congregationId, tx => + createMember(tx, { id: congregationId, name: 'NormalizedCols', plan: 'free' } as never, { + ...baseParams, + firstname: 'François', + lastname: 'Péréz', + actorId: 1, + congregationId, + }), + ) + + const row = await testDb.member.findUnique({ + where: { id: member.id }, + select: { firstnameNormalized: true, lastnameNormalized: true }, + }) + + expect(row).toEqual({ firstnameNormalized: 'francois', lastnameNormalized: 'perez' }) + }) + + it('updateMember refreshes the normalized columns when the name changes', async () => { + const created = await withScope(congregationId, tx => + createMember(tx, { id: congregationId, name: 'NormalizedCols', plan: 'free' } as never, { + ...baseParams, + firstname: 'Anne', + lastname: 'Initial', + actorId: 1, + congregationId, + }), + ) + + await withScope(congregationId, tx => + updateMember(tx, created.id, congregationId, 1, { + ...baseParams, + firstname: 'Hélène', + lastname: 'Côté', + }), + ) + + const row = await testDb.member.findUnique({ + where: { id: created.id }, + select: { firstnameNormalized: true, lastnameNormalized: true }, + }) + + expect(row).toEqual({ firstnameNormalized: 'helene', lastnameNormalized: 'cote' }) + }) + + it('anonymizeMember overwrites the normalized columns with the scrub placeholder', async () => { + const created = await withScope(congregationId, tx => + createMember(tx, { id: congregationId, name: 'NormalizedCols', plan: 'free' } as never, { + ...baseParams, + firstname: 'Sébastien', + lastname: 'Roux', + actorId: 1, + congregationId, + }), + ) + + await withScope(congregationId, tx => anonymizeMember(tx, created.id as never, congregationId, 1)) + + const row = await testDb.member.findUnique({ + where: { id: created.id }, + select: { firstnameNormalized: true, lastnameNormalized: true, firstname: true, lastname: true }, + }) + + expect(row?.firstname).toBe('Utilisateur') + expect(row?.lastname).toBe('supprime') + expect(row?.firstnameNormalized).toBe('utilisateur') + expect(row?.lastnameNormalized).toBe('supprime') + }) +}) diff --git a/app/features/publishers/server/update-member.server.test.ts b/app/features/publishers/server/update-member.server.test.ts index 91168b26..37ad4db7 100644 --- a/app/features/publishers/server/update-member.server.test.ts +++ b/app/features/publishers/server/update-member.server.test.ts @@ -54,6 +54,8 @@ describe('updateMember', () => { data: { firstname: 'Jean', lastname: 'Dupont', + firstnameNormalized: 'jean', + lastnameNormalized: 'dupont', isMale: true, baptismDate: new Date('2010-03-20'), birthDate: new Date('1990-05-15'), diff --git a/app/features/publishers/server/update-member.server.ts b/app/features/publishers/server/update-member.server.ts index 86f95dc7..cfcd56a6 100644 --- a/app/features/publishers/server/update-member.server.ts +++ b/app/features/publishers/server/update-member.server.ts @@ -1,6 +1,7 @@ import { AuditAction, audit } from '~/shared/domain/audit.server' import { syncBuiltInRoleAssignments } from '~/shared/domain/built-in-roles.server' import type { TransactionClient } from '~/shared/infra/db.server' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' import type { PublisherType } from '~/shared/types/publisher-type' export interface UpdateMemberParams { @@ -37,6 +38,8 @@ export async function updateMember( data: { firstname: params.firstname, lastname: params.lastname, + firstnameNormalized: stripDiacritics(params.firstname), + lastnameNormalized: stripDiacritics(params.lastname), isMale: params.gender === 'male', baptismDate: params.baptismDate ? new Date(params.baptismDate) : null, birthDate: params.birthDate ? new Date(params.birthDate) : null, diff --git a/app/features/settings/server/anonymize-member.server.ts b/app/features/settings/server/anonymize-member.server.ts index ec0dbbdd..ab8ea565 100644 --- a/app/features/settings/server/anonymize-member.server.ts +++ b/app/features/settings/server/anonymize-member.server.ts @@ -2,6 +2,7 @@ import { AuditAction, audit } from '~/shared/domain/audit.server' import { syncBuiltInRoleAssignments } from '~/shared/domain/built-in-roles.server' import { ConflictError, NotFoundError } from '~/shared/errors/app-error.server' import type { TransactionClient } from '~/shared/infra/db.server' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' import type { MemberId } from '~/shared/types/branded' /** @@ -32,6 +33,8 @@ export async function anonymizeMember( data: { firstname: 'Utilisateur', lastname: 'supprime', + firstnameNormalized: stripDiacritics('Utilisateur'), + lastnameNormalized: stripDiacritics('supprime'), phone: '', address: '', birthDate: null, diff --git a/app/features/settings/server/import-congregation.server.ts b/app/features/settings/server/import-congregation.server.ts index b7e479ec..9cb3fccc 100644 --- a/app/features/settings/server/import-congregation.server.ts +++ b/app/features/settings/server/import-congregation.server.ts @@ -8,6 +8,7 @@ import { syncBuiltInRoleAssignments } from '~/shared/domain/built-in-roles.serve import { type TransactionClient, unscopedDb, withScope } from '~/shared/infra/db.server' import { buildStorageKey, getFileBuffer, uploadFile } from '~/shared/infra/file-storage.server' import { createLogger } from '~/shared/infra/logger.server' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' import type { PublisherType } from '~/shared/types/publisher-type' import { EntityIdMap, @@ -633,6 +634,8 @@ export async function importMembers( data: { firstname: record.firstname, lastname: record.lastname, + firstnameNormalized: stripDiacritics(record.firstname), + lastnameNormalized: stripDiacritics(record.lastname), isPublisher: record.isPublisher, type: record.type as PublisherType, isMale: record.isMale, @@ -897,6 +900,9 @@ export async function importBuildings( }) const data = { + // Refresh `streetNormalized` on both create and update so legacy rows + // that pre-date the normalized column get backfilled when re-imported. + streetNormalized: stripDiacritics(record.street), latitude: record.latitude, longitude: record.longitude, active: record.active, diff --git a/app/features/settings/server/link-member-to-account.server.ts b/app/features/settings/server/link-member-to-account.server.ts index dcb732b9..b0d73a81 100644 --- a/app/features/settings/server/link-member-to-account.server.ts +++ b/app/features/settings/server/link-member-to-account.server.ts @@ -4,6 +4,7 @@ import type { CongregationInfo } from '~/shared/domain/congregation.server' import { LimitService } from '~/shared/domain/limits.server' import { ConflictError, NotFoundError } from '~/shared/errors/app-error.server' import type { TransactionClient } from '~/shared/infra/db.server' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' import type { AccountId } from '~/shared/types/branded' import type { PublisherType } from '~/shared/types/publisher-type' @@ -59,6 +60,8 @@ export async function linkMemberToAccount( data: { firstname, lastname, + firstnameNormalized: stripDiacritics(firstname), + lastnameNormalized: stripDiacritics(lastname), isMale: params.isMale, birthDate: params.birthDate, baptismDate: params.baptismDate, diff --git a/app/features/settings/server/update-account.server.ts b/app/features/settings/server/update-account.server.ts index 315cebb8..766b729e 100644 --- a/app/features/settings/server/update-account.server.ts +++ b/app/features/settings/server/update-account.server.ts @@ -2,6 +2,7 @@ import { requireNotLastAdmin } from '~/shared/auth/permissions.server' import { AuditAction, audit } from '~/shared/domain/audit.server' import { syncBuiltInRoleAssignments } from '~/shared/domain/built-in-roles.server' import type { TransactionClient } from '~/shared/infra/db.server' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' import { Permission } from '~/shared/types/permission' export interface UpdateAccountParams { @@ -62,6 +63,8 @@ export async function updateAccount( data: { firstname: params.firstname, lastname: params.lastname, + firstnameNormalized: stripDiacritics(params.firstname), + lastnameNormalized: stripDiacritics(params.lastname), }, }) await syncBuiltInRoleAssignments(db, existing.memberId, congregationId, actorId) diff --git a/app/features/territories/routes/attributions/list.tsx b/app/features/territories/routes/attributions/list.tsx index e10910d1..70f11ce5 100644 --- a/app/features/territories/routes/attributions/list.tsx +++ b/app/features/territories/routes/attributions/list.tsx @@ -1,15 +1,24 @@ import { CalendarCheck, Lock, Pencil, X } from 'lucide-react' -import { Link, redirect } from 'react-router' +import React from 'react' +import { Link, redirect, useSearchParams } from 'react-router' import { getGroups } from '~/features/publishers/server/groups.server' import { TerritoryAttributionKind } from '~/features/territories/model/territory-attribution-kind.type' import { computeFilters } from '~/features/territories/server/attribution-filters.server' import { findActiveAttributionsPaginated } from '~/features/territories/server/attributions.server' +import { classifySearch } from '~/features/territories/server/search-intent.server' import { getCurrentTheocraticYear } from '~/features/territories/server/theocratic-year.server' +import ActiveTerritoryFilters from '~/features/territories/ui/ActiveTerritoryFilters' import AttributionFilters from '~/features/territories/ui/AttributionFilters' import { AttributionStatus } from '~/features/territories/ui/AttributionStatus' +import { buildAttributionFilterChips } from '~/features/territories/ui/build-filter-chips' +import GeocodeNotice, { type GeocodeNoticeData } from '~/features/territories/ui/GeocodeNotice' +import { NoCoordinatesDivider, NoCoordinatesPageBanner } from '~/features/territories/ui/NoCoordinatesNotice' +import ProximityBanner from '~/features/territories/ui/ProximityBanner' import * as m from '~/i18n/paraglide/messages' +import { getLocale } from '~/i18n/paraglide/runtime' import { currentAccountContext, permissionsContext, withScopeFromContext } from '~/shared/auth/route-context.server' import { getBoolSetting } from '~/shared/domain/settings.server' +import { type GeocodeResult, geocode } from '~/shared/infra/geocoder.server' import logger from '~/shared/infra/logger.server' import { Permission } from '~/shared/types/permission' import { TerritorySettingKey } from '~/shared/types/territory-setting-key' @@ -19,7 +28,9 @@ import { PageHeader } from '~/shared/ui/PageHeader' import Pagination from '~/shared/ui/Pagination' import S13ExportButton from '~/shared/ui/S13ExportButton' import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '~/shared/ui/table' +import { formatDistance } from '~/shared/utils/distance' import { formatPersonName } from '~/shared/utils/format-person-name' +import { sortFromUrl } from '~/shared/utils/pagination.server' import type { Route } from './+types/list' @@ -61,30 +72,107 @@ export function loader({ request, context }: Route.LoaderArgs) { const selectors = computeFilters(url.searchParams) selectors.endDate = null - const { attributions, pagination } = await findActiveAttributionsPaginated(db, selectors, url, congregationId) + const search = url.searchParams.get('search') ?? '' + const intent = classifySearch(search) + + let geocodeResult: GeocodeResult | null = null + if (intent.geoQuery != null) { + geocodeResult = await geocode(intent.geoQuery) + } + // Auto-flip to proximity sort when the geocode hit so a typed address is + // ranked geographically by default. User can flip back via the Select. + const defaultSort = geocodeResult != null ? 'proximity' : 'date' + const sort = sortFromUrl(url, ['date', 'proximity'], defaultSort) + const proximityActive = geocodeResult != null && sort === 'proximity' + + const proximityArgs = + proximityActive && geocodeResult != null + ? { origin: { lat: geocodeResult.lat, lng: geocodeResult.lng } } + : undefined + + const result = await findActiveAttributionsPaginated(db, selectors, url, congregationId, proximityArgs) const groups = await getGroups(db, congregationId) const theocraticYear = getCurrentTheocraticYear() + const locale = getLocale() + const distancesByAttributionId: Record = {} + if (proximityActive && 'distances' in result && result.distances != null) { + for (const attribution of result.attributions) { + const distance = result.distances.get(attribution) + distancesByAttributionId[attribution.id] = distance == null ? null : formatDistance(distance, locale) + } + } + + const geocodeNotice: GeocodeNoticeData | null = + intent.forced && intent.geoQuery == null + ? { kind: 'missing-query' } + : intent.geoQuery != null && geocodeResult == null + ? { kind: 'failed', query: intent.geoQuery } + : null + return { - stats: { - total: pagination.total, - }, - attributions, - pagination, + stats: { total: result.pagination.total }, + attributions: result.attributions, + pagination: result.pagination, canManageTerritories, canManagePublisher, canViewPublisher, groups, phoneTypeActive, theocraticYear, + geocodeResult, + proximityActive, + geocodeNotice, + distances: distancesByAttributionId, + withoutCoordsCount: (proximityActive && 'withoutCoordsCount' in result && result.withoutCoordsCount) || 0, + withCoordsCount: (proximityActive && 'withCoordsCount' in result && result.withCoordsCount) || 0, + sort, } }) } export default function AttributionListPage({ loaderData }: Route.ComponentProps) { - const { pagination, attributions, canManageTerritories, theocraticYear, groups, phoneTypeActive, canViewPublisher } = - loaderData + const { + pagination, + attributions, + canManageTerritories, + theocraticYear, + groups, + phoneTypeActive, + canViewPublisher, + geocodeResult, + proximityActive, + geocodeNotice, + distances, + withoutCoordsCount, + withCoordsCount, + sort, + } = loaderData + const [searchParams] = useSearchParams() + const chips = buildAttributionFilterChips(searchParams, { groups }) + const wholePageWithoutCoords = proximityActive && pagination.offset >= withCoordsCount && attributions.length > 0 + // Proximity sort already partitioned/ordered the rows server-side; the + // status-priority client sort below is skipped in that mode so the distance + // order survives. + const sortedAttributions = proximityActive + ? attributions + : [...attributions].sort((attrA, attrB) => { + const aIsOrphaned = attrA.publisher.leftAt != null || attrA.publisher.anonymizedAt != null + const bIsOrphaned = attrB.publisher.leftAt != null || attrB.publisher.anonymizedAt != null + if (aIsOrphaned && !bIsOrphaned) return -1 + if (!aIsOrphaned && bIsOrphaned) return 1 + + const aIsLate = attrA.lateDate < new Date() + const bIsLate = attrB.lateDate < new Date() + if (aIsLate && !bIsLate) return -1 + if (!aIsLate && bIsLate) return 1 + + return 0 + }) + const dividerIndex = proximityActive ? sortedAttributions.findIndex(a => distances[a.id] == null) : -1 + const baseColCount = 7 + const colSpan = proximityActive ? baseColCount + 1 : baseColCount if (attributions.length < 1) { return ( @@ -105,6 +193,8 @@ export default function AttributionListPage({ loaderData }: Route.ComponentProps } /> + + - + + + {geocodeResult != null && } +
+ {wholePageWithoutCoords && }
{m.attributions_table_checkout_date()} + {proximityActive && ( + {m.territories_filter_distance_header()} + )} {m.attributions_table_number()} {m.attributions_table_publisher()} {m.attributions_table_type()} @@ -153,27 +256,15 @@ export default function AttributionListPage({ loaderData }: Route.ComponentProps - {[...attributions] - .sort((attrA, attrB) => { - // Sort priority: orphaned > late > current. Within a bucket - // the order falls back to the DB ordering (startDate asc). - const aIsOrphaned = attrA.publisher.leftAt != null || attrA.publisher.anonymizedAt != null - const bIsOrphaned = attrB.publisher.leftAt != null || attrB.publisher.anonymizedAt != null - if (aIsOrphaned && !bIsOrphaned) return -1 - if (!aIsOrphaned && bIsOrphaned) return 1 - - const aIsLate = attrA.lateDate == null || attrA.lateDate < new Date() - const bIsLate = attrB.lateDate == null || attrB.lateDate < new Date() - if (aIsLate && !bIsLate) return -1 - if (!aIsLate && bIsLate) return 1 - - return 0 - }) - .map(attribution => { - const isAnonymized = attribution.publisher.anonymizedAt != null - const hasLeft = attribution.publisher.leftAt != null - return ( - + {sortedAttributions.map((attribution, index) => { + const isAnonymized = attribution.publisher.anonymizedAt != null + const hasLeft = attribution.publisher.leftAt != null + const distance = distances[attribution.id] + const showDivider = proximityActive && dividerIndex === index && index > 0 + return ( + + {showDivider && } + {attribution.startDate.toLocaleDateString('fr-FR')}{' '} @@ -184,6 +275,13 @@ export default function AttributionListPage({ loaderData }: Route.ComponentProps ) + {proximityActive && ( + + + {distance ?? '—'} + + + )} - ) - })} + + ) + })}
diff --git a/app/features/territories/routes/attributions/territories.tsx b/app/features/territories/routes/attributions/territories.tsx index 83a5017b..f607a56f 100644 --- a/app/features/territories/routes/attributions/territories.tsx +++ b/app/features/territories/routes/attributions/territories.tsx @@ -1,58 +1,39 @@ import { ExternalLink, Send } from 'lucide-react' -import { Link, redirect } from 'react-router' +import React from 'react' +import { Link, redirect, useSearchParams } from 'react-router' import { TerritoryKind } from '~/features/territories/model/territory-kind.type' -import { Permission } from '~/shared/types/permission' - -function getTerritoryTypeLabel(type: string): string { - const labels: Record string> = { - [TerritoryKind.Classical]: () => m.territories_type_classical(), - [TerritoryKind.Commerces]: () => m.territories_type_commerces(), - [TerritoryKind.Phone]: () => m.territories_type_phone(), - [TerritoryKind.Hotel]: () => m.territories_type_hotel(), - [TerritoryKind.Univ]: () => m.territories_type_university(), - } - return labels[type]?.() ?? type -} - -function territoryContentLabel(type: string, entrances: { homes: number | null; phones: number | null }[]): string { - const count = entrances.length - if (type === TerritoryKind.Phone) { - const phones = entrances.reduce((s, e) => s + (e.phones ?? 0), 0) - return m.territories_content_phones({ count: String(phones) }) - } - if (type === TerritoryKind.Classical || type === TerritoryKind.Univ) { - const homes = entrances.reduce((s, e) => s + ((e.homes ?? 0) || (e.phones ?? 0)), 0) - return homes > 1 - ? m.territories_content_homes_other({ count: String(homes) }) - : m.territories_content_homes_one({ count: String(homes) }) - } - if (type === TerritoryKind.Commerces) { - return count > 1 - ? m.territories_content_commerces_other({ count: String(count) }) - : m.territories_content_commerces_one({ count: String(count) }) - } - if (type === TerritoryKind.Hotel) { - return count > 1 - ? m.territories_content_hotels_other({ count: String(count) }) - : m.territories_content_hotels_one({ count: String(count) }) - } - return count > 1 - ? m.territories_content_entrances_other({ count: String(count) }) - : m.territories_content_entrances_one({ count: String(count) }) -} - import { getZips } from '~/features/territories/server/buildings.server' +import { classifySearch } from '~/features/territories/server/search-intent.server' import { findAvailableTerritoriesPaginated } from '~/features/territories/server/territories.server' +import { territoryContentLabel } from '~/features/territories/server/territory-content-label' import { computeFilters } from '~/features/territories/server/territory-filters.server' +import ActiveTerritoryFilters from '~/features/territories/ui/ActiveTerritoryFilters' +import { buildTerritoryFilterChips } from '~/features/territories/ui/build-filter-chips' +import GeocodeNotice, { type GeocodeNoticeData } from '~/features/territories/ui/GeocodeNotice' +import { NoCoordinatesDivider, NoCoordinatesPageBanner } from '~/features/territories/ui/NoCoordinatesNotice' +import ProximityBanner from '~/features/territories/ui/ProximityBanner' import { checkAvailabilityStatus, TerritoryAvaibilityStatus } from '~/features/territories/ui/TerritoryAvaibilityStatus' import TerritoryFilters from '~/features/territories/ui/TerritoryFilters' import * as m from '~/i18n/paraglide/messages' +import { getLocale } from '~/i18n/paraglide/runtime' import { currentAccountContext, permissionsContext, withScopeFromContext } from '~/shared/auth/route-context.server' +import { type GeocodeResult, geocode } from '~/shared/infra/geocoder.server' import logger from '~/shared/infra/logger.server' +import { Permission } from '~/shared/types/permission' import { Button } from '~/shared/ui/button' import { PageHeader } from '~/shared/ui/PageHeader' import Pagination from '~/shared/ui/Pagination' import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '~/shared/ui/table' +import { formatDistance } from '~/shared/utils/distance' +import { sortFromUrl } from '~/shared/utils/pagination.server' + +const territoryTypeLabels: Record = { + [TerritoryKind.Classical]: m.territories_type_classical(), + [TerritoryKind.Commerces]: m.territories_type_commerces(), + [TerritoryKind.Phone]: m.territories_type_phone(), + [TerritoryKind.Hotel]: m.territories_type_hotel(), + [TerritoryKind.Univ]: m.territories_type_university(), +} import type { Route } from './+types/territories' @@ -78,27 +59,81 @@ export function loader({ request, context }: Route.LoaderArgs) { return withScopeFromContext(context, async db => { const url = new URL(request.url) - const selectors = await computeFilters(url.searchParams) + const selectors = computeFilters(url.searchParams) selectors.attributions = { none: { endDate: null } } - const { territories, pagination } = await findAvailableTerritoriesPaginated(db, selectors, url, congregationId) + const search = url.searchParams.get('search') ?? '' + const intent = classifySearch(search) + + let geocodeResult: GeocodeResult | null = null + if (intent.geoQuery != null) { + geocodeResult = await geocode(intent.geoQuery) + } + const defaultSort = geocodeResult != null ? 'proximity' : 'number' + const sort = sortFromUrl(url, ['number', 'proximity'], defaultSort) + const proximityActive = geocodeResult != null && sort === 'proximity' + + const proximityArgs = + proximityActive && geocodeResult != null + ? { origin: { lat: geocodeResult.lat, lng: geocodeResult.lng } } + : undefined + + const result = await findAvailableTerritoriesPaginated(db, selectors, url, congregationId, proximityArgs) const zips = await getZips(db, congregationId) + const locale = getLocale() + const distancesByTerritoryId: Record = {} + if (proximityActive && 'distances' in result && result.distances != null) { + for (const territory of result.territories) { + const distance = result.distances.get(territory) + distancesByTerritoryId[territory.id] = distance == null ? null : formatDistance(distance, locale) + } + } + + const geocodeNotice: GeocodeNoticeData | null = + intent.forced && intent.geoQuery == null + ? { kind: 'missing-query' } + : intent.geoQuery != null && geocodeResult == null + ? { kind: 'failed', query: intent.geoQuery } + : null + return { zips, - stats: { - total: pagination.total, - }, - territories, - pagination, + stats: { total: result.pagination.total }, + territories: result.territories, + pagination: result.pagination, canManageTerritories, + geocodeResult, + proximityActive, + geocodeNotice, + distances: distancesByTerritoryId, + withoutCoordsCount: (proximityActive && 'withoutCoordsCount' in result && result.withoutCoordsCount) || 0, + withCoordsCount: (proximityActive && 'withCoordsCount' in result && result.withCoordsCount) || 0, + sort, } }) } export default function TerritorySelectorPage({ loaderData }: Route.ComponentProps) { - const { pagination, territories, zips } = loaderData + const { + pagination, + territories, + zips, + geocodeResult, + proximityActive, + geocodeNotice, + distances, + withoutCoordsCount, + withCoordsCount, + sort, + } = loaderData + const [searchParams] = useSearchParams() + const chips = buildTerritoryFilterChips(searchParams) + const dividerIndex = proximityActive ? territories.findIndex(t => distances[t.id] == null) : -1 + const baseCol = 5 + const colSpan = proximityActive ? baseCol + 1 : baseCol + const wholePageWithoutCoords = proximityActive && pagination.offset >= withCoordsCount && territories.length > 0 if (territories.length < 1) { return ( @@ -112,6 +147,8 @@ export default function TerritorySelectorPage({ loaderData }: Route.ComponentPro ]} backTo="/territories/attributions" /> + +
@@ -133,13 +170,29 @@ export default function TerritorySelectorPage({ loaderData }: Route.ComponentPro ]} backTo="/territories/attributions" /> - + + + {geocodeResult != null && } +
+ {wholePageWithoutCoords && } {m.territories_table_number()} + {proximityActive && ( + {m.territories_filter_distance_header()} + )} {m.territories_table_type()} {m.territories_table_content()} {m.attributions_available_table_status()} @@ -147,46 +200,62 @@ export default function TerritorySelectorPage({ loaderData }: Route.ComponentPro - {territories.map(territory => ( - - {territory.number} - {getTerritoryTypeLabel(territory.type)} - - {territoryContentLabel(territory.type, territory.entrances)} - - - - - -
- - {checkAvailabilityStatus([...territory.attributions].shift()) ? ( - - ) : ( - + {territories.map((territory, index) => { + const distance = distances[territory.id] + const showDivider = proximityActive && dividerIndex === index && index > 0 + return ( + + {showDivider && } + + {territory.number} + {proximityActive && ( + + + {distance ?? '—'} + + )} -
- - - ))} + + {territoryTypeLabels[territory.type] ?? territory.type} + + + {territoryContentLabel(territory.type, territory.entrances)} + + + + + +
+ + {checkAvailabilityStatus([...territory.attributions].shift()) ? ( + + ) : ( + + )} +
+ + + + ) + })}
diff --git a/app/features/territories/routes/prospection/_layout.tsx b/app/features/territories/routes/prospection/_layout.tsx index 0da17fde..d68a704b 100644 --- a/app/features/territories/routes/prospection/_layout.tsx +++ b/app/features/territories/routes/prospection/_layout.tsx @@ -1,7 +1,9 @@ import { Map as MapIcon, RefreshCw } from 'lucide-react' -import { Form, Link, NavLink, Outlet, redirect } from 'react-router' +import { Form, Link, NavLink, Outlet, redirect, useSearchParams } from 'react-router' import { TerritoryAccess } from '~/features/territories/model/territory-access.type' import { getZips } from '~/features/territories/server/buildings.server' +import ActiveTerritoryFilters from '~/features/territories/ui/ActiveTerritoryFilters' +import { buildTerritoryFilterChips } from '~/features/territories/ui/build-filter-chips' import TerritoryFilters from '~/features/territories/ui/TerritoryFilters' import * as m from '~/i18n/paraglide/messages' import { currentAccountContext, permissionsContext, withScopeFromContext } from '~/shared/auth/route-context.server' @@ -122,6 +124,8 @@ export function loader({ context }: Route.LoaderArgs) { export default function BuildingListPage({ loaderData }: Route.ComponentProps) { const { openDataAvailable, stats, staleDate, canManageTerritories, zips, canManageProspection } = loaderData + const [searchParams] = useSearchParams() + const chips = buildTerritoryFilterChips(searchParams) return (
@@ -233,6 +237,7 @@ export default function BuildingListPage({ loaderData }: Route.ComponentProps) { )}
+ @@ -192,6 +196,7 @@ export default function BuildingListPage({ loaderData }: Route.ComponentProps) {
+
diff --git a/app/features/territories/routes/territory/list.tsx b/app/features/territories/routes/territory/list.tsx index ca2a8f90..55b4732f 100644 --- a/app/features/territories/routes/territory/list.tsx +++ b/app/features/territories/routes/territory/list.tsx @@ -1,25 +1,36 @@ import { Download, Map as MapIcon, Pencil, Trash2 } from 'lucide-react' +import React from 'react' import { Link, useSearchParams } from 'react-router' import { TerritoryKind } from '~/features/territories/model/territory-kind.type' import { getZips } from '~/features/territories/server/buildings.server' +import { classifySearch } from '~/features/territories/server/search-intent.server' import { findTerritoriesWithDetailsPaginated } from '~/features/territories/server/territories.server' import { territoryContentLabel } from '~/features/territories/server/territory-content-label' import { computeFilters } from '~/features/territories/server/territory-filters.server' +import ActiveTerritoryFilters from '~/features/territories/ui/ActiveTerritoryFilters' +import { buildTerritoryFilterChips } from '~/features/territories/ui/build-filter-chips' +import GeocodeNotice, { type GeocodeNoticeData } from '~/features/territories/ui/GeocodeNotice' +import { NoCoordinatesDivider, NoCoordinatesPageBanner } from '~/features/territories/ui/NoCoordinatesNotice' +import ProximityBanner from '~/features/territories/ui/ProximityBanner' import TerritoryFilters from '~/features/territories/ui/TerritoryFilters' import * as m from '~/i18n/paraglide/messages' +import { getLocale } from '~/i18n/paraglide/runtime' import { currentAccountContext, permissionsContext, requirePermission, withScopeFromContext, } from '~/shared/auth/route-context.server' +import { type GeocodeResult, geocode } from '~/shared/infra/geocoder.server' import { Permission } from '~/shared/types/permission' import { Button } from '~/shared/ui/button' import { EmptyState } from '~/shared/ui/EmptyState' import { PageHeader } from '~/shared/ui/PageHeader' import Pagination from '~/shared/ui/Pagination' import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '~/shared/ui/table' +import { formatDistance } from '~/shared/utils/distance' +import { sortFromUrl } from '~/shared/utils/pagination.server' import type { Route } from './+types/list' @@ -46,28 +57,95 @@ export function loader({ request, context }: Route.LoaderArgs) { return withScopeFromContext(context, async db => { const url = new URL(request.url) - const selectors = await computeFilters(url.searchParams) - const { territories, pagination } = await findTerritoriesWithDetailsPaginated(db, selectors, url, congregationId) + const selectors = computeFilters(url.searchParams) + const search = url.searchParams.get('search') ?? '' + const intent = classifySearch(search) + + let geocodeResult: GeocodeResult | null = null + if (intent.geoQuery != null) { + geocodeResult = await geocode(intent.geoQuery) + } + // When the geocode hits, default the sort to `proximity` so a typed + // address is ranked geographically by default. The user can still flip + // to `number` via the Select — `sortFromUrl` whitelists either value. + const defaultSort = geocodeResult != null ? 'proximity' : 'number' + const sort = sortFromUrl(url, ['number', 'proximity'], defaultSort) + const proximityActive = geocodeResult != null && sort === 'proximity' + + const proximityArgs = + proximityActive && geocodeResult != null + ? { origin: { lat: geocodeResult.lat, lng: geocodeResult.lng } } + : undefined + + const result = await findTerritoriesWithDetailsPaginated(db, selectors, url, congregationId, proximityArgs) const zips = await getZips(db, congregationId) + const locale = getLocale() + const distancesByTerritoryId: Record = {} + if (proximityActive && 'distances' in result && result.distances != null) { + for (const territory of result.territories) { + const distance = result.distances.get(territory) + distancesByTerritoryId[territory.id] = distance == null ? null : formatDistance(distance, locale) + } + } + + // Build the failure notice the UI renders above the filters: tells the + // user *why* proximity didn't kick in, instead of silently degrading to + // text-only. + const geocodeNotice: GeocodeNoticeData | null = + intent.forced && intent.geoQuery == null + ? { kind: 'missing-query' } + : intent.geoQuery != null && geocodeResult == null + ? { kind: 'failed', query: intent.geoQuery } + : null + return { zips, - stats: { - total: pagination.total, - }, - territories, - pagination, + stats: { total: result.pagination.total }, + territories: result.territories, + pagination: result.pagination, canManageTerritories, + // Banner shows whenever the geocode hit; distance column / partition + // are separately gated on `proximityActive`. + geocodeResult, + proximityActive, + geocodeNotice, + distances: distancesByTerritoryId, + withoutCoordsCount: (proximityActive && 'withoutCoordsCount' in result && result.withoutCoordsCount) || 0, + withCoordsCount: (proximityActive && 'withCoordsCount' in result && result.withCoordsCount) || 0, + sort, } }) } export default function TerritoryListPage({ loaderData }: Route.ComponentProps) { - const { pagination, territories, canManageTerritories, zips } = loaderData + const { + pagination, + territories, + canManageTerritories, + zips, + geocodeResult, + proximityActive, + geocodeNotice, + distances, + withoutCoordsCount, + withCoordsCount, + sort, + } = loaderData const [searchParams] = useSearchParams() const fromQuery = searchParams.toString() const viewSuffix = fromQuery.length > 0 ? `?from=${encodeURIComponent(fromQuery)}` : '' + const chips = buildTerritoryFilterChips(searchParams) + const colSpan = proximityActive ? 6 : 5 + // Index of the first item in this page that falls in the "without coords" + // partition, so we can insert a divider row before it. -1 when the whole + // page is on one side of the partition. + const dividerIndex = proximityActive ? territories.findIndex(t => distances[t.id] == null) : -1 + // True when *every* row on this page is past the coords/no-coords boundary + // — the in-table divider never renders, so we show a banner above the table + // so users understand why distances are missing. + const wholePageWithoutCoords = proximityActive && pagination.offset >= withCoordsCount && territories.length > 0 if (territories.length < 1) { return ( @@ -85,6 +163,8 @@ export default function TerritoryListPage({ loaderData }: Route.ComponentProps) } /> + + - + + + {geocodeResult != null && } +
+ {wholePageWithoutCoords && }
{m.territories_table_number()} + {proximityActive && ( + {m.territories_filter_distance_header()} + )} {m.territories_table_type()} {m.territories_table_content()} {m.territories_table_assigned_to()} @@ -128,76 +224,94 @@ export default function TerritoryListPage({ loaderData }: Route.ComponentProps) - {territories.map(territory => { + {territories.map((territory, index) => { const attribution = [...territory.attributions].shift() const viewHref = `./territory/${territory.id}/view${viewSuffix}` + const distance = distances[territory.id] + const showDivider = proximityActive && dividerIndex === index && index > 0 return ( - - - - {territory.number} - - - {territoryTypeLabels[territory.type] ?? territory.type} - - - {territoryContentLabel(territory.type, territory.entrances)} - - - - {attribution ? ( - - {attribution.publisher.firstname} {attribution.publisher.lastname?.toUpperCase().at(0)}. - {' — '} - {m.territories_assigned_until({ - date: attribution.lateDate.toLocaleDateString('fr-FR', { - day: '2-digit', - month: '2-digit', - }), - })} - - ) : ( - {m.territories_available()} - )} - - - -
- - {canManageTerritories && ( - <> - - - - )} -
- - + + + + {canManageTerritories && ( + <> + + + + )} + + + + ) })} diff --git a/app/features/territories/server/address-regex.ts b/app/features/territories/server/address-regex.ts new file mode 100644 index 00000000..81a062d5 --- /dev/null +++ b/app/features/territories/server/address-regex.ts @@ -0,0 +1,9 @@ +// Detects an address-like prefix: a number, optionally followed by a French +// repeater (`bis`, `ter`, `quater`), then the street name. Used to split a +// search query into `[number, street]` so both pieces can be matched against +// the relevant Building fields. +export const addressRegex = /^(\d+\s*(bis|ter|quater)?)\s+(.+)$/ + +// Leading `@` is the explicit "force proximity" marker. Hoisted so filter +// files can strip it without re-allocating a literal per call. +export const proximityPrefix = /^@/ diff --git a/app/features/territories/server/attribution-filters.server.test.ts b/app/features/territories/server/attribution-filters.server.test.ts index 786fee1b..c5520bc2 100644 --- a/app/features/territories/server/attribution-filters.server.test.ts +++ b/app/features/territories/server/attribution-filters.server.test.ts @@ -54,27 +54,51 @@ describe('computeFilters', () => { expect(result).not.toHaveProperty('lateDate') }) - it('applies search filter with OR across publisher name and territory number', () => { + it('applies search filter with OR across publisher name, territory number and building', () => { const result = computeFilters(new URLSearchParams({ search: 'Dupont' })) expect(result).toHaveProperty('OR') const or = result.OR as unknown[] - expect(or).toHaveLength(2) + expect(or).toHaveLength(3) }) - it('search filter matches publisher firstname and lastname', () => { - const result = computeFilters(new URLSearchParams({ search: 'Jean' })) - const or = result.OR as Array<{ publisher?: unknown; territory?: unknown }> + it('search filter matches publisher firstname and lastname via normalized columns', () => { + const result = computeFilters(new URLSearchParams({ search: 'Pâjot' })) + const or = result.OR as { publisher?: { OR?: Record[] } }[] const publisherClause = or.find(c => c.publisher) - expect(publisherClause?.publisher).toMatchObject({ - OR: expect.arrayContaining([{ firstname: { contains: 'Jean' } }, { lastname: { contains: 'Jean' } }]), - }) + expect(publisherClause?.publisher?.OR).toEqual( + expect.arrayContaining([ + { firstnameNormalized: { contains: 'pajot' } }, + { lastnameNormalized: { contains: 'pajot' } }, + ]), + ) }) - it('search filter matches territory number', () => { + it('search filter matches territory number case-insensitively', () => { const result = computeFilters(new URLSearchParams({ search: 'T-42' })) - const or = result.OR as Array<{ territory?: unknown }> - const territoryClause = or.find(c => c.territory) - expect(territoryClause?.territory).toMatchObject({ number: { contains: 'T-42' } }) + const or = result.OR as { territory?: { number?: { contains: string } } }[] + const territoryClause = or.find(c => c.territory && 'number' in (c.territory ?? {})) + expect(territoryClause?.territory?.number).toMatchObject({ contains: 'T-42', mode: 'insensitive' }) + }) + + it('search filter matches building street through territory entrances', () => { + const result = computeFilters(new URLSearchParams({ search: 'paix' })) + const or = result.OR as { territory?: { entrances?: { some?: { buildings?: { some?: unknown } } } } }[] + const buildingClause = or.find(c => c.territory?.entrances) + expect(buildingClause).toBeDefined() + }) + + it('trims whitespace before searching', () => { + const result = computeFilters(new URLSearchParams({ search: ' Dupont ' })) + const or = result.OR as { territory?: { number?: { contains: string } } }[] + const territoryClause = or.find(c => c.territory && 'number' in (c.territory ?? {})) + expect(territoryClause?.territory?.number).toMatchObject({ contains: 'Dupont' }) + }) + + it('strips a leading @ proximity marker', () => { + const result = computeFilters(new URLSearchParams({ search: '@bastille' })) + const or = result.OR as { territory?: { number?: { contains: string } } }[] + const territoryClause = or.find(c => c.territory && 'number' in (c.territory ?? {})) + expect(territoryClause?.territory?.number).toMatchObject({ contains: 'bastille' }) }) it('ignores search filter when search param is empty string', () => { diff --git a/app/features/territories/server/attribution-filters.server.ts b/app/features/territories/server/attribution-filters.server.ts index 41133cb2..611a6e8f 100644 --- a/app/features/territories/server/attribution-filters.server.ts +++ b/app/features/territories/server/attribution-filters.server.ts @@ -1,5 +1,7 @@ import type { Prisma } from '~/database/generated/client' import type { TerritoryAttributionKind } from '~/features/territories/model/territory-attribution-kind.type' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' +import { addressRegex, proximityPrefix } from './address-regex' export function computeFilters(params: URLSearchParams): Prisma.AttributionWhereInput { let filters: Prisma.AttributionWhereInput = {} @@ -66,29 +68,53 @@ function applySearchFilter( filters: Prisma.AttributionWhereInput, params: URLSearchParams, ): Prisma.AttributionWhereInput { - if (params.has('search') && (params.get('search')?.length ?? 0) > 0) { - const searchTerms = params.get('search') ?? '' - return { - ...filters, - OR: [ - { - publisher: { - OR: [ - { - firstname: { contains: searchTerms }, - }, - { - lastname: { contains: searchTerms }, + const raw = params.get('search') + const trimmed = raw?.replace(proximityPrefix, '').trim() ?? '' + if (trimmed.length === 0) return filters + + const normalized = stripDiacritics(trimmed) + const addressTerms = trimmed.match(addressRegex) + const addressNumber = addressTerms?.[1] + const addressStreet = addressTerms?.[3] + const addressStreetNormalized = addressStreet != null ? stripDiacritics(addressStreet) : null + + return { + ...filters, + OR: [ + { + publisher: { + OR: [ + { firstnameNormalized: { contains: normalized } }, + { lastnameNormalized: { contains: normalized } }, + ], + }, + }, + { territory: { number: { contains: trimmed, mode: 'insensitive' } } }, + { + territory: { + entrances: { + some: { + buildings: { + some: + addressTerms == null + ? { + OR: [ + { streetNormalized: { contains: normalized } }, + { number: { contains: trimmed, mode: 'insensitive' } }, + { zip: { contains: trimmed, mode: 'insensitive' } }, + ], + } + : { + AND: [ + { number: { contains: addressNumber, mode: 'insensitive' } }, + { streetNormalized: { contains: addressStreetNormalized ?? normalized } }, + ], + }, }, - ], + }, }, }, - { - territory: { number: { contains: searchTerms } }, - }, - ], - } + }, + ], } - - return filters } diff --git a/app/features/territories/server/attributions.server.ts b/app/features/territories/server/attributions.server.ts index 52f50fca..3692bda6 100644 --- a/app/features/territories/server/attributions.server.ts +++ b/app/features/territories/server/attributions.server.ts @@ -1,20 +1,57 @@ import type { Prisma, TerritoryKind } from '~/database/generated/client' import type { TransactionClient } from '~/shared/infra/db.server' +import type { LatLng } from '~/shared/utils/distance' import { paginationFromUrl } from '~/shared/utils/pagination.server' +import { closestTerritoryPoint, paginateByProximity } from './proximity-sort.server' + +interface ProximityOptions { + origin: LatLng +} export async function findActiveAttributionsPaginated( db: TransactionClient, selectors: Prisma.AttributionWhereInput, url: URL, congregationId: number, + proximity?: ProximityOptions, ) { - const total = await db.attribution.count({ where: { ...selectors, congregationId } }) + const where = { ...selectors, congregationId } + + if (proximity != null) { + const all = await db.attribution.findMany({ + where, + include: { + territory: { + include: { + entrances: { include: { buildings: { where: { active: true } } } }, + }, + }, + publisher: true, + }, + orderBy: [{ startDate: 'asc' }], + }) + const result = paginateByProximity( + all, + proximity.origin, + a => closestTerritoryPoint(proximity.origin, a.territory.entrances), + url, + ) + return { + attributions: result.items, + pagination: result.pagination, + distances: result.distances, + withCoordsCount: result.withCoordsCount, + withoutCoordsCount: result.withoutCoordsCount, + } + } + + const total = await db.attribution.count({ where }) const pagination = paginationFromUrl(url, total) const attributions = await db.attribution.findMany({ skip: pagination.offset, take: pagination.size, - where: { ...selectors, congregationId }, + where, include: { territory: true, publisher: true }, orderBy: [{ startDate: 'asc' }], }) diff --git a/app/features/territories/server/building-filters.server.test.ts b/app/features/territories/server/building-filters.server.test.ts index 97fc0271..b1f4426d 100644 --- a/app/features/territories/server/building-filters.server.test.ts +++ b/app/features/territories/server/building-filters.server.test.ts @@ -75,27 +75,41 @@ describe('computeFilters', () => { expect(result).not.toHaveProperty('entrances') }) - it('applies plain street search when search has no number prefix', () => { - const result = computeFilters(new URLSearchParams({ search: 'Rue de la Paix' })) + it('applies normalized street search when search has no number prefix', () => { + const result = computeFilters(new URLSearchParams({ search: 'Rue de la Päix' })) expect(result).toMatchObject({ - OR: [{ street: { contains: 'Rue de la Paix' } }], + OR: [ + { streetNormalized: { contains: 'rue de la paix' } }, + { number: { contains: 'Rue de la Päix', mode: 'insensitive' } }, + ], }) }) - it('applies AND(number, street) when search starts with a number', () => { + it('applies AND(number, streetNormalized) when search starts with a number', () => { const result = computeFilters(new URLSearchParams({ search: '42 Rue de la Paix' })) - const or = result.OR as Array<{ AND?: unknown[] }> - expect(or[0]).toHaveProperty('AND') + const or = result.OR as { AND?: Record[] }[] const and = or[0].AND! - expect(and).toContainEqual({ number: { contains: '42' } }) - expect(and).toContainEqual({ street: { contains: 'Rue de la Paix' } }) + expect(and).toContainEqual({ number: { contains: '42', mode: 'insensitive' } }) + expect(and).toContainEqual({ streetNormalized: { contains: 'rue de la paix' } }) }) it('parses address with bis suffix', () => { const result = computeFilters(new URLSearchParams({ search: '42 bis Rue de la Paix' })) - const or = result.OR as Array<{ AND?: unknown[] }> + const or = result.OR as { AND?: Record[] }[] const and = or[0].AND! - expect(and).toContainEqual({ number: { contains: '42 bis' } }) + expect(and).toContainEqual({ number: { contains: '42 bis', mode: 'insensitive' } }) + }) + + it('trims whitespace before searching', () => { + const result = computeFilters(new URLSearchParams({ search: ' paix ' })) + const or = result.OR as { streetNormalized?: unknown }[] + expect(or[0]).toMatchObject({ streetNormalized: { contains: 'paix' } }) + }) + + it('strips a leading @ proximity marker', () => { + const result = computeFilters(new URLSearchParams({ search: '@bastille' })) + const or = result.OR as { streetNormalized?: unknown }[] + expect(or[0]).toMatchObject({ streetNormalized: { contains: 'bastille' } }) }) it('ignores search filter when search is empty', () => { diff --git a/app/features/territories/server/building-filters.server.ts b/app/features/territories/server/building-filters.server.ts index 593bea0d..6e30dfc9 100644 --- a/app/features/territories/server/building-filters.server.ts +++ b/app/features/territories/server/building-filters.server.ts @@ -2,8 +2,8 @@ import type { Prisma } from '~/database/generated/client' import { EntranceKind } from '~/features/territories/model/entrance-kind.type' import type { ShopKind } from '~/features/territories/model/shop-kind.type' import { TerritoryKind } from '~/features/territories/model/territory-kind.type' - -const addressRegex = /^(\d+\s*(bis|ter|quarter)?)\s+(.+)$/ +import { stripDiacritics } from '~/shared/utils/strip-diacritics' +import { addressRegex, proximityPrefix } from './address-regex' export function computeFilters(params: URLSearchParams): Prisma.BuildingWhereInput { let filters: Prisma.BuildingWhereInput = {} @@ -84,18 +84,28 @@ function applyAccessFilter(filters: Prisma.BuildingWhereInput, params: URLSearch } function applySearchFilter(filters: Prisma.BuildingWhereInput, params: URLSearchParams): Prisma.BuildingWhereInput { - if (params.has('search') && (params.get('search')?.length ?? 0) > 0) { - const searchTerms = params.get('search') ?? '' - const addressTerms = searchTerms.match(addressRegex) - - return { - ...filters, - OR: [ - addressTerms == null - ? { street: { contains: searchTerms } } - : { AND: [{ number: { contains: addressTerms?.[1] } }, { street: { contains: addressTerms?.[3] } }] }, - ], - } + const raw = params.get('search') + const trimmed = raw?.replace(proximityPrefix, '').trim() ?? '' + if (trimmed.length === 0) return filters + + const normalized = stripDiacritics(trimmed) + const addressTerms = trimmed.match(addressRegex) + const addressNumber = addressTerms?.[1] + const addressStreet = addressTerms?.[3] + const addressStreetNormalized = addressStreet != null ? stripDiacritics(addressStreet) : null + + return { + ...filters, + OR: [ + addressTerms == null + ? { streetNormalized: { contains: normalized } } + : { + AND: [ + { number: { contains: addressNumber, mode: 'insensitive' } }, + { streetNormalized: { contains: addressStreetNormalized ?? normalized } }, + ], + }, + { number: { contains: trimmed, mode: 'insensitive' } }, + ], } - return filters } diff --git a/app/features/territories/server/building-normalized-columns.integration.test.ts b/app/features/territories/server/building-normalized-columns.integration.test.ts new file mode 100644 index 00000000..fdc9958f --- /dev/null +++ b/app/features/territories/server/building-normalized-columns.integration.test.ts @@ -0,0 +1,142 @@ +/** + * Confirms `Building.streetNormalized` lands on disk through every Building + * write path the PR touched: create, edit, the import-congregation update + * branch (which previously left stale empty rows when matching an existing + * building by number/street/zip). + */ +import { PrismaPg } from '@prisma/adapter-pg' +import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest' +import { PrismaClient } from '~/database/generated/client' + +vi.mock('~/shared/domain/audit.server', () => ({ + audit: vi.fn(), + auditInTransaction: vi.fn(), + AuditAction: {}, +})) + +const { createBuilding } = await import('./create-building.server') +const { editBuilding } = await import('./edit-building.server') + +const adapter = new PrismaPg({ + connectionString: process.env.DB_RUNTIME_URL ?? process.env.DB_URL, + max: 5, + connectionTimeoutMillis: 5000, +}) +const testDb = new PrismaClient({ adapter }) + +type Tx = Parameters[0]>[0] + +function withScope(congregationId: number, fn: (tx: Tx) => Promise): Promise { + return testDb.$transaction(async tx => { + await tx.$executeRawUnsafe(`SET LOCAL app.congregation_id = '${String(congregationId)}'`) + return fn(tx) + }) +} + +const ts = Date.now() +let congregationId: number + +beforeAll(async () => { + const cong = await testDb.congregation.create({ + data: { name: `BuildingNormalized ${ts}`, slug: `building-normalized-${ts}`, active: true }, + }) + congregationId = cong.id +}) + +afterAll(async () => { + await withScope(congregationId, async tx => { + await tx.buildingResidentialData.deleteMany({}) + await tx.buildingEntrance.deleteMany({}) + await tx.building.deleteMany({}) + }) + await testDb.congregation.delete({ where: { id: congregationId } }) + await testDb.$disconnect() +}) + +describe('Building normalized columns — write-through', () => { + it('createBuilding writes streetNormalized to disk', async () => { + const building = await withScope(congregationId, tx => + createBuilding(tx, { + address: { number: '12', street: 'Rue de la Paëx', zip: '75001' }, + coordinates: { latitude: 48.87, longitude: 2.33 }, + congregationId, + }), + ) + + const row = await testDb.building.findUnique({ + where: { id: building.id }, + select: { streetNormalized: true }, + }) + + expect(row?.streetNormalized).toBe('rue de la paex') + }) + + it('editBuilding refreshes streetNormalized when the street changes', async () => { + const created = await withScope(congregationId, tx => + createBuilding(tx, { + address: { number: '5', street: 'Rue Initial', zip: '75002' }, + coordinates: {}, + congregationId, + }), + ) + + await withScope(congregationId, tx => + editBuilding(tx, created.id, { + address: { number: '5', street: 'Avenue Élysée', zip: '75002' }, + coordinates: {}, + }), + ) + + const row = await testDb.building.findUnique({ + where: { id: created.id }, + select: { streetNormalized: true, street: true }, + }) + + expect(row?.street).toBe('Avenue Élysée') + expect(row?.streetNormalized).toBe('avenue elysee') + }) + + it('the import-congregation update path backfills stale streetNormalized values', async () => { + // Simulates the bug: a building whose normalized column was never set + // (legacy data) is matched by the import's findFirst, and the update + // path is expected to refresh the normalized value alongside the rest. + const created = await withScope(congregationId, tx => + tx.building.create({ + data: { + number: '99', + street: 'Rue Pâte Brisée', + // Intentionally empty — simulates rows from before the migration + // landed on prod. + streetNormalized: '', + zip: '75009', + congregationId, + }, + }), + ) + + // Mirror the data block the import-congregation server constructs. + await withScope(congregationId, async tx => { + await tx.building.update({ + where: { id: created.id }, + data: { + streetNormalized: 'rue pate brisee', + latitude: 48.88, + longitude: 2.34, + active: true, + inTerritory: true, + inOpenData: false, + prospectionDate: null, + notes: '', + importantNotes: '', + }, + }) + }) + + const row = await testDb.building.findUnique({ + where: { id: created.id }, + select: { streetNormalized: true }, + }) + + expect(row?.streetNormalized).toBe('rue pate brisee') + }) +}) diff --git a/app/features/territories/server/compute-territory-quantity.test.ts b/app/features/territories/server/compute-territory-quantity.test.ts index 837ecba1..772255db 100644 --- a/app/features/territories/server/compute-territory-quantity.test.ts +++ b/app/features/territories/server/compute-territory-quantity.test.ts @@ -31,6 +31,7 @@ function makeEntrance(overrides: { homes?: number; phones?: number } = {}): Aggr id: 1, number: '1', street: 'Rue de la Paix', + streetNormalized: 'rue de la paix', zip: '75001', latitude: null, longitude: null, diff --git a/app/features/territories/server/create-building.server.ts b/app/features/territories/server/create-building.server.ts index bd05040c..2d956877 100644 --- a/app/features/territories/server/create-building.server.ts +++ b/app/features/territories/server/create-building.server.ts @@ -2,6 +2,7 @@ import type { DetailedBuilding } from '~/features/territories/model/detailed-bui import { EntranceKind } from '~/features/territories/model/entrance-kind.type' import type { TransactionClient } from '~/shared/infra/db.server' import { pointInPolygon } from '~/shared/utils/point-in-polygon.server' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' import { getPerimeterPaths } from './perimeter.server' export async function createBuilding( @@ -31,6 +32,7 @@ export async function createBuilding( data: { number: address.number, street: address.street, + streetNormalized: stripDiacritics(address.street), zip: address.zip, latitude: coordinates.latitude, longitude: coordinates.longitude, diff --git a/app/features/territories/server/edit-building.server.ts b/app/features/territories/server/edit-building.server.ts index 9ae10645..011458a8 100644 --- a/app/features/territories/server/edit-building.server.ts +++ b/app/features/territories/server/edit-building.server.ts @@ -4,6 +4,7 @@ import { getPerimeterPaths } from '~/features/territories/server/perimeter.serve import type { TransactionClient } from '~/shared/infra/db.server' import { pointInPolygon } from '~/shared/utils/point-in-polygon.server' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' import { recalculateEntranceCentroid } from './update-buildings-in-entrance.server' export async function editBuilding( @@ -35,6 +36,7 @@ export async function editBuilding( data: { number: address.number, street: address.street, + streetNormalized: stripDiacritics(address.street), zip: address.zip, latitude: coordinates.latitude, longitude: coordinates.longitude, diff --git a/app/features/territories/server/import-open-data.server.ts b/app/features/territories/server/import-open-data.server.ts index e62ad365..c4330352 100644 --- a/app/features/territories/server/import-open-data.server.ts +++ b/app/features/territories/server/import-open-data.server.ts @@ -2,6 +2,7 @@ import { EntranceKind } from '~/features/territories/model/entrance-kind.type' import { getAllowedZips } from '~/features/territories/server/settings.server' import type { TransactionClient } from '~/shared/infra/db.server' import { pointInPolygon } from '~/shared/utils/point-in-polygon.server' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' import { fetchOpenData } from './fetch-open-data.server' import { getPerimeterPaths } from './perimeter.server' @@ -61,6 +62,7 @@ export async function importOpenData( create: { number, street, + streetNormalized: stripDiacritics(street), zip, latitude: Number(lat), longitude: Number(long), diff --git a/app/features/territories/server/proximity-loader.integration.test.ts b/app/features/territories/server/proximity-loader.integration.test.ts new file mode 100644 index 00000000..d482e163 --- /dev/null +++ b/app/features/territories/server/proximity-loader.integration.test.ts @@ -0,0 +1,258 @@ +/** + * Confirms `findTerritoriesWithDetailsPaginated` and + * `findActiveAttributionsPaginated` produce correct distance maps and + * partitions when given `proximityArgs.origin`. + * + * Unit tests cover `paginateByProximity` in isolation; this exercises the + * full Prisma path including the eager `include` shape (entrances → + * buildings, attributions → publisher) the loaders rely on. + */ +import { PrismaPg } from '@prisma/adapter-pg' +import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest' +import { PrismaClient } from '~/database/generated/client' +import { TerritoryAttributionKind } from '~/features/territories/model/territory-attribution-kind.type' +import { TerritoryKind } from '~/features/territories/model/territory-kind.type' + +vi.mock('~/shared/domain/audit.server', () => ({ + audit: vi.fn(), + auditInTransaction: vi.fn(), + AuditAction: {}, +})) + +const { findTerritoriesWithDetailsPaginated } = await import('./territories.server') +const { findActiveAttributionsPaginated } = await import('./attributions.server') + +const adapter = new PrismaPg({ + connectionString: process.env.DB_RUNTIME_URL ?? process.env.DB_URL, + max: 5, + connectionTimeoutMillis: 5000, +}) +const testDb = new PrismaClient({ adapter }) + +type Tx = Parameters[0]>[0] + +function withScope(congregationId: number, fn: (tx: Tx) => Promise): Promise { + return testDb.$transaction(async tx => { + await tx.$executeRawUnsafe(`SET LOCAL app.congregation_id = '${String(congregationId)}'`) + return fn(tx) + }) +} + +const ts = Date.now() +let congregationId: number +let nearId: number +let farId: number +let noCoordsId: number +let nearAttributionId: number +let farAttributionId: number +let noCoordsAttributionId: number + +const origin = { lat: 48.8566, lng: 2.3522 } // Paris centre + +beforeAll(async () => { + const cong = await testDb.congregation.create({ + data: { name: `ProximityLoader ${ts}`, slug: `proximity-loader-${ts}`, active: true }, + }) + congregationId = cong.id + + await withScope(congregationId, async tx => { + // Near territory — building ~500m from origin. + const near = await tx.territory.create({ + data: { number: '01', type: TerritoryKind.Classical, congregationId }, + }) + nearId = near.id + await tx.buildingEntrance.create({ + data: { + congregationId, + latitude: 48.86, + longitude: 2.355, + buildings: { + create: { number: '1', street: 'Rue Près', streetNormalized: 'rue pres', zip: '75001', congregationId }, + }, + territories: { connect: { id: near.id } }, + }, + }) + + // Far territory — ~5km from origin. + const far = await tx.territory.create({ + data: { number: '02', type: TerritoryKind.Classical, congregationId }, + }) + farId = far.id + await tx.buildingEntrance.create({ + data: { + congregationId, + latitude: 48.9, + longitude: 2.4, + buildings: { + create: { number: '2', street: 'Rue Loin', streetNormalized: 'rue loin', zip: '75019', congregationId }, + }, + territories: { connect: { id: far.id } }, + }, + }) + + // No-coords territory — entrance and building both null lat/lng. + const noCoords = await tx.territory.create({ + data: { number: '03', type: TerritoryKind.Classical, congregationId }, + }) + noCoordsId = noCoords.id + await tx.buildingEntrance.create({ + data: { + congregationId, + latitude: null, + longitude: null, + buildings: { + create: { number: '3', street: 'Rue Sans', streetNormalized: 'rue sans', zip: '75020', congregationId }, + }, + territories: { connect: { id: noCoords.id } }, + }, + }) + + // Attach an active attribution to each territory so the attribution + // loader has rows to partition too. + const publisher = await tx.member.create({ + data: { + firstname: 'P', + lastname: 'Q', + firstnameNormalized: 'p', + lastnameNormalized: 'q', + congregationId, + }, + }) + const today = new Date() + const future = new Date() + future.setMonth(future.getMonth() + 1) + nearAttributionId = ( + await tx.attribution.create({ + data: { + territoryId: near.id, + publisherId: publisher.id, + type: TerritoryAttributionKind.Default, + startDate: today, + lateDate: future, + congregationId, + }, + }) + ).id + farAttributionId = ( + await tx.attribution.create({ + data: { + territoryId: far.id, + publisherId: publisher.id, + type: TerritoryAttributionKind.Default, + startDate: today, + lateDate: future, + congregationId, + }, + }) + ).id + noCoordsAttributionId = ( + await tx.attribution.create({ + data: { + territoryId: noCoords.id, + publisherId: publisher.id, + type: TerritoryAttributionKind.Default, + startDate: today, + lateDate: future, + congregationId, + }, + }) + ).id + }) +}) + +afterAll(async () => { + await withScope(congregationId, async tx => { + await tx.attribution.deleteMany({}) + await tx.buildingResidentialData.deleteMany({}) + await tx.buildingEntrance.deleteMany({}) + await tx.building.deleteMany({}) + await tx.territory.deleteMany({}) + await tx.member.deleteMany({}) + }) + await testDb.congregation.delete({ where: { id: congregationId } }) + await testDb.$disconnect() +}) + +describe('findTerritoriesWithDetailsPaginated — proximity branch', () => { + it('returns near territory first, far second, and pushes no-coords to the tail', async () => { + const url = new URL('https://example.com/?page=1&pageSize=10') + const result = await withScope(congregationId, tx => + findTerritoriesWithDetailsPaginated(tx, {}, url, congregationId, { origin }), + ) + + const order = result.territories.map(t => t.id) + expect(order).toEqual([nearId, farId, noCoordsId]) + expect(result.pagination.total).toBe(3) + expect('distances' in result).toBe(true) + }) + + it('reports withCoordsCount and withoutCoordsCount correctly', async () => { + const url = new URL('https://example.com/?page=1&pageSize=10') + const result = await withScope(congregationId, tx => + findTerritoriesWithDetailsPaginated(tx, {}, url, congregationId, { origin }), + ) + + expect('withCoordsCount' in result && result.withCoordsCount).toBe(2) + expect('withoutCoordsCount' in result && result.withoutCoordsCount).toBe(1) + }) + + it('per-row distances are populated for geo-coded rows and null for the rest', async () => { + const url = new URL('https://example.com/?page=1&pageSize=10') + const result = await withScope(congregationId, tx => + findTerritoriesWithDetailsPaginated(tx, {}, url, congregationId, { origin }), + ) + + if (!('distances' in result) || result.distances == null) throw new Error('distances missing') + const near = result.territories.find(t => t.id === nearId)! + const far = result.territories.find(t => t.id === farId)! + const noCoords = result.territories.find(t => t.id === noCoordsId)! + + const distNear = result.distances.get(near) + const distFar = result.distances.get(far) + expect(distNear).not.toBeNull() + expect(distFar).not.toBeNull() + expect(distNear!).toBeLessThan(distFar!) + expect(result.distances.get(noCoords)).toBeNull() + }) + + it('honors `?page` for the combined list (page 2 returns the tail)', async () => { + const url = new URL('https://example.com/?page=2&pageSize=2') + const result = await withScope(congregationId, tx => + findTerritoriesWithDetailsPaginated(tx, {}, url, congregationId, { origin }), + ) + + expect(result.territories.map(t => t.id)).toEqual([noCoordsId]) + expect(result.pagination.page).toBe(2) + expect(result.pagination.pages).toBe(2) + }) + + it('without proximityArgs, the function returns the same Prisma-paged shape as before', async () => { + const url = new URL('https://example.com/?page=1&pageSize=10') + const result = await withScope(congregationId, tx => + findTerritoriesWithDetailsPaginated(tx, {}, url, congregationId), + ) + expect(result.territories).toHaveLength(3) + expect('distances' in result).toBe(false) + }) +}) + +describe('findActiveAttributionsPaginated — proximity branch', () => { + it('returns near attribution first, far second, no-coords last', async () => { + const url = new URL('https://example.com/?page=1&pageSize=10') + const result = await withScope(congregationId, tx => + findActiveAttributionsPaginated(tx, { endDate: null }, url, congregationId, { origin }), + ) + + const order = result.attributions.map(a => a.id) + expect(order).toEqual([nearAttributionId, farAttributionId, noCoordsAttributionId]) + }) + + it('without proximityArgs, sorts by startDate as today', async () => { + const url = new URL('https://example.com/?page=1&pageSize=10') + const result = await withScope(congregationId, tx => + findActiveAttributionsPaginated(tx, { endDate: null }, url, congregationId), + ) + expect(result.attributions).toHaveLength(3) + expect('distances' in result).toBe(false) + }) +}) diff --git a/app/features/territories/server/proximity-sort.server.test.ts b/app/features/territories/server/proximity-sort.server.test.ts new file mode 100644 index 00000000..b6d8f0fe --- /dev/null +++ b/app/features/territories/server/proximity-sort.server.test.ts @@ -0,0 +1,114 @@ +import { describe, expect, it } from 'vitest' +import { closestTerritoryPoint, paginateByProximity } from './proximity-sort.server' + +const origin = { lat: 48.8566, lng: 2.3522 } + +describe('paginateByProximity', () => { + it('orders items by distance ascending', () => { + const items = [ + { id: 1, coords: { lat: 48.87, lng: 2.36 } }, + { id: 2, coords: { lat: 48.86, lng: 2.35 } }, + { id: 3, coords: { lat: 48.9, lng: 2.4 } }, + ] + const url = new URL('https://example.com/?page=1&pageSize=10') + const result = paginateByProximity(items, origin, i => i.coords, url) + expect(result.items.map(i => i.id)).toEqual([2, 1, 3]) + }) + + it('pushes items without coords to the tail and preserves order', () => { + const items = [ + { id: 1, coords: null }, + { id: 2, coords: { lat: 48.87, lng: 2.36 } }, + { id: 3, coords: null }, + { id: 4, coords: { lat: 48.86, lng: 2.35 } }, + ] + const url = new URL('https://example.com/?page=1&pageSize=10') + const result = paginateByProximity(items, origin, i => i.coords, url) + expect(result.items.map(i => i.id)).toEqual([4, 2, 1, 3]) + expect(result.withCoordsCount).toBe(2) + expect(result.withoutCoordsCount).toBe(2) + }) + + it('paginates the combined list — page 2 of pageSize 2', () => { + const items = Array.from({ length: 5 }, (_, i) => ({ id: i + 1, coords: { lat: 48 + i * 0.01, lng: 2 } })) + const url = new URL('https://example.com/?page=2&pageSize=2') + const result = paginateByProximity(items, origin, i => i.coords, url) + expect(result.items).toHaveLength(2) + expect(result.pagination.page).toBe(2) + expect(result.pagination.pages).toBe(3) + }) + + it('exposes distances per item — null for missing coords', () => { + const a = { id: 1, coords: { lat: 48.87, lng: 2.36 } } + const b = { id: 2, coords: null } + const url = new URL('https://example.com/?page=1&pageSize=10') + const result = paginateByProximity([a, b], origin, i => i.coords, url) + const distA = result.distances.get(a) + expect(distA).not.toBeNull() + expect(distA).toBeGreaterThan(0) + expect(result.distances.get(b)).toBeNull() + }) +}) + +describe('closestTerritoryPoint', () => { + it('returns null when no entrance and no building has coords', () => { + const point = closestTerritoryPoint(origin, [ + { latitude: null, longitude: null, buildings: [{ latitude: null, longitude: null }] }, + ]) + expect(point).toBeNull() + }) + + it('prefers the closest entrance centroid', () => { + const point = closestTerritoryPoint(origin, [ + { + latitude: 49.0, + longitude: 3.0, + buildings: [], + }, + { + latitude: 48.857, + longitude: 2.353, + buildings: [], + }, + ]) + expect(point).toEqual({ lat: 48.857, lng: 2.353 }) + }) + + it('falls back to building coordinates when entrance has no centroid', () => { + const point = closestTerritoryPoint(origin, [ + { + latitude: null, + longitude: null, + buildings: [ + // Two valid buildings — the one farther from origin (48.95) + // should lose to the closer one (48.857). + { latitude: 48.95, longitude: 2.5 }, + { latitude: 48.857, longitude: 2.353 }, + ], + }, + ]) + expect(point).toEqual({ lat: 48.857, lng: 2.353 }) + }) + + it('rejects NaN coordinates as if they were null', () => { + const point = closestTerritoryPoint(origin, [ + { + latitude: Number.NaN, + longitude: Number.NaN, + buildings: [{ latitude: 48.857, longitude: 2.353 }], + }, + ]) + expect(point).toEqual({ lat: 48.857, lng: 2.353 }) + }) + + it('rejects Infinity coordinates', () => { + const point = closestTerritoryPoint(origin, [ + { + latitude: Number.POSITIVE_INFINITY, + longitude: 2.353, + buildings: [], + }, + ]) + expect(point).toBeNull() + }) +}) diff --git a/app/features/territories/server/proximity-sort.server.ts b/app/features/territories/server/proximity-sort.server.ts new file mode 100644 index 00000000..528240f4 --- /dev/null +++ b/app/features/territories/server/proximity-sort.server.ts @@ -0,0 +1,94 @@ +import { haversineMeters, type LatLng } from '~/shared/utils/distance' +import { paginationFromUrl } from '~/shared/utils/pagination.server' + +export interface ProximityPaginationResult { + items: T[] + distances: Map + pagination: ReturnType + withCoordsCount: number + withoutCoordsCount: number +} + +/** + * Sort a list by distance from `origin`, push rows without coordinates to the + * tail (their relative order is preserved), then paginate the combined list + * using the standard `?page` / `?pageSize` params. + * + * `getCoords` returns the closest known point on the row, or `null` when the + * row has no geocoded building/entrance. Distances are kept in a Map so the + * caller can render them per row without recomputing. + */ +export function paginateByProximity( + items: T[], + origin: LatLng, + getCoords: (item: T) => LatLng | null, + url: URL, +): ProximityPaginationResult { + const distances = new Map() + const withCoords: { item: T; distance: number }[] = [] + const withoutCoords: T[] = [] + + for (const item of items) { + const coords = getCoords(item) + if (coords == null) { + distances.set(item, null) + withoutCoords.push(item) + continue + } + const distance = haversineMeters(origin, coords) + distances.set(item, distance) + withCoords.push({ item, distance }) + } + + withCoords.sort((a, b) => a.distance - b.distance) + + const ordered: T[] = [...withCoords.map(({ item }) => item), ...withoutCoords] + const pagination = paginationFromUrl(url, ordered.length) + const paged = ordered.slice(pagination.offset, pagination.offset + pagination.size) + + return { + items: paged, + distances, + pagination, + withCoordsCount: withCoords.length, + withoutCoordsCount: withoutCoords.length, + } +} + +/** + * Compute the closest point of a territory: prefer `BuildingEntrance` centroid, + * fall back to the entrance's parent buildings, return `null` if neither side + * has lat/lng. + */ +// Rejects null/NaN/Infinity — open-data import paths can produce NaN +// coordinates from malformed CSV cells, and a NaN slipping through here +// poisons Haversine sort comparisons silently. +function isUsableCoord(value: number | null): value is number { + return value != null && Number.isFinite(value) +} + +export function closestTerritoryPoint( + origin: LatLng, + entrances: Array<{ + latitude: number | null + longitude: number | null + buildings: Array<{ latitude: number | null; longitude: number | null }> + }>, +): LatLng | null { + let best: { point: LatLng; distance: number } | null = null + for (const entrance of entrances) { + if (isUsableCoord(entrance.latitude) && isUsableCoord(entrance.longitude)) { + const point = { lat: entrance.latitude, lng: entrance.longitude } + const distance = haversineMeters(origin, point) + if (best == null || distance < best.distance) best = { point, distance } + } + for (const building of entrance.buildings) { + if (isUsableCoord(building.latitude) && isUsableCoord(building.longitude)) { + const point = { lat: building.latitude, lng: building.longitude } + const distance = haversineMeters(origin, point) + if (best == null || distance < best.distance) best = { point, distance } + } + } + } + return best?.point ?? null +} diff --git a/app/features/territories/server/search-intent.server.test.ts b/app/features/territories/server/search-intent.server.test.ts new file mode 100644 index 00000000..7b1933df --- /dev/null +++ b/app/features/territories/server/search-intent.server.test.ts @@ -0,0 +1,71 @@ +import { describe, expect, it } from 'vitest' +import { classifySearch } from './search-intent.server' + +describe('classifySearch', () => { + it('returns empty intent for whitespace-only input', () => { + expect(classifySearch(' ')).toEqual({ freeText: '', geoQuery: null, forced: false }) + }) + + it('forces proximity when the query starts with @', () => { + expect(classifySearch('@Bastille')).toEqual({ freeText: '', geoQuery: 'Bastille', forced: true }) + }) + + it('treats @ followed by whitespace as forced but missing — UI prompts for a place', () => { + expect(classifySearch('@ ')).toEqual({ freeText: '', geoQuery: null, forced: true }) + }) + + it('does not geocode short ambiguous strings', () => { + expect(classifySearch('12')).toMatchObject({ geoQuery: null }) + expect(classifySearch('D012')).toMatchObject({ geoQuery: null }) + expect(classifySearch('pajot')).toMatchObject({ geoQuery: null }) + expect(classifySearch('jean dupont')).toMatchObject({ geoQuery: null }) + }) + + it('geocodes when the query has 3+ tokens', () => { + const intent = classifySearch('quartier des halles paris') + expect(intent.geoQuery).toBe('quartier des halles paris') + expect(intent.forced).toBe(false) + }) + + it('geocodes when the query mentions a street word', () => { + expect(classifySearch('rue Bastille').geoQuery).toBe('rue Bastille') + expect(classifySearch('avenue paix').geoQuery).toBe('avenue paix') + }) + + it('geocodes when the query matches a number + street pattern', () => { + expect(classifySearch('12 paix').geoQuery).toBe('12 paix') + }) + + it('exposes a normalized free-text branch for ranking even when geocoding', () => { + const intent = classifySearch('12 Rue de la Päix') + expect(intent.freeText).toBe('12 rue de la paix') + expect(intent.geoQuery).toBe('12 Rue de la Päix') + }) + + it('does not geocode 1-token landmarks without a street word', () => { + expect(classifySearch('Bastille').geoQuery).toBeNull() + expect(classifySearch('Montparnasse').geoQuery).toBeNull() + }) + + it('trims surrounding whitespace before classifying', () => { + expect(classifySearch(' @ Bastille ')).toEqual({ freeText: '', geoQuery: 'Bastille', forced: true }) + }) + + it('keeps extra @ inside the query verbatim', () => { + // Documents current behaviour: `@@bastille` → forced, geoQuery = '@bastille'. + // The geocoder sees `@bastille` — Google ignores the prefix harmlessly. + expect(classifySearch('@@bastille')).toEqual({ freeText: '', geoQuery: '@bastille', forced: true }) + }) + + it('does not geocode a 2-token query with no street word and no number prefix', () => { + // `Jean Dupont` is 2 tokens, lacks a street word, has no leading digit + // — likely a publisher name, should stay text-only. + expect(classifySearch('Jean Dupont').geoQuery).toBeNull() + }) + + it('geocodes a 1-token query that IS a street word', () => { + // `Rue` alone is uncommon but documents the heuristic: presence of a + // street word in the tokens triggers a geocode. + expect(classifySearch('Rue').geoQuery).toBe('Rue') + }) +}) diff --git a/app/features/territories/server/search-intent.server.ts b/app/features/territories/server/search-intent.server.ts new file mode 100644 index 00000000..31c2d449 --- /dev/null +++ b/app/features/territories/server/search-intent.server.ts @@ -0,0 +1,64 @@ +import { stripDiacritics } from '~/shared/utils/strip-diacritics' +import { addressRegex, proximityPrefix } from './address-regex' + +const tokenSplit = /\s+/ + +// French way-types that strongly imply the query is geographic. Diacritics +// stripped so matching can run against the normalized form of the input. +const STREET_WORDS = [ + 'rue', + 'avenue', + 'boulevard', + 'place', + 'chemin', + 'impasse', + 'allee', + 'cours', + 'quai', + 'route', + 'square', + 'voie', + 'pont', +] as const + +export interface SearchIntent { + // What the text-search branch should look for (always lowercased + accent + // stripped already). Empty when the input was a forced-proximity `@` query. + freeText: string + // The address-like substring to ask the geocoder about, or `null` when the + // input doesn't look geographic enough to spend an API call on. + geoQuery: string | null + // True when the user explicitly typed `@` — bypasses the geocode heuristic. + forced: boolean +} + +/** + * Splits a raw search input into a text-match query and an optional geocode + * query. Short ambiguous strings (`12`, `D012`, `pajot`) never trigger the + * geocoder unless the user explicitly prefixed `@`. + */ +export function classifySearch(raw: string): SearchIntent { + const trimmed = raw.trim() + if (trimmed.length === 0) return { freeText: '', geoQuery: null, forced: false } + + if (proximityPrefix.test(trimmed)) { + const geoQuery = trimmed.replace(proximityPrefix, '').trim() + // `@` alone still signals forced-proximity intent so the UI can prompt + // the user to type a place — silently treating it as empty would hide + // the operator mode entirely. + if (geoQuery.length === 0) return { freeText: '', geoQuery: null, forced: true } + return { freeText: '', geoQuery, forced: true } + } + + const normalized = stripDiacritics(trimmed) + const tokens = normalized.split(tokenSplit).filter(Boolean) + const hasStreetWord = tokens.some(t => STREET_WORDS.includes(t as (typeof STREET_WORDS)[number])) + const looksLikeAddress = addressRegex.test(trimmed) + + // Heuristic: 3+ tokens, OR an explicit street word, OR a "number street" + // shape. Anything else — particularly one- or two-token surnames and + // single-token landmarks — stays text-only. + const geoQuery = tokens.length >= 3 || hasStreetWord || looksLikeAddress ? trimmed : null + + return { freeText: normalized, geoQuery, forced: false } +} diff --git a/app/features/territories/server/territories.server.ts b/app/features/territories/server/territories.server.ts index 5f2fb05f..08aea546 100644 --- a/app/features/territories/server/territories.server.ts +++ b/app/features/territories/server/territories.server.ts @@ -1,20 +1,52 @@ import type { Prisma } from '~/database/generated/client' import type { TransactionClient } from '~/shared/infra/db.server' +import type { LatLng } from '~/shared/utils/distance' import { paginationFromUrl } from '~/shared/utils/pagination.server' +import { closestTerritoryPoint, paginateByProximity } from './proximity-sort.server' + +interface ProximityOptions { + origin: LatLng +} export async function findTerritoriesWithDetailsPaginated( db: TransactionClient, selectors: Prisma.TerritoryWhereInput, url: URL, congregationId: number, + proximity?: ProximityOptions, ) { - const total = await db.territory.count({ where: { ...selectors, congregationId } }) + const where = { ...selectors, congregationId } + + if (proximity != null) { + const all = await db.territory.findMany({ + where, + include: { + entrances: { include: { buildings: { where: { active: true } } } }, + attributions: { where: { endDate: null }, include: { publisher: true } }, + }, + }) + const result = paginateByProximity( + all, + proximity.origin, + t => closestTerritoryPoint(proximity.origin, t.entrances), + url, + ) + return { + territories: result.items, + pagination: result.pagination, + distances: result.distances, + withCoordsCount: result.withCoordsCount, + withoutCoordsCount: result.withoutCoordsCount, + } + } + + const total = await db.territory.count({ where }) const pagination = paginationFromUrl(url, total) const territories = await db.territory.findMany({ skip: pagination.offset, take: pagination.size, - where: { ...selectors, congregationId }, + where, include: { entrances: { include: { buildings: { where: { active: true } } } }, attributions: { where: { endDate: null }, include: { publisher: true } }, @@ -29,14 +61,40 @@ export async function findAvailableTerritoriesPaginated( selectors: Prisma.TerritoryWhereInput, url: URL, congregationId: number, + proximity?: ProximityOptions, ) { - const total = await db.territory.count({ where: { ...selectors, congregationId } }) + const where = { ...selectors, congregationId } + + if (proximity != null) { + const all = await db.territory.findMany({ + where, + include: { + entrances: { include: { buildings: true } }, + attributions: { orderBy: { endDate: 'desc' }, take: 1 }, + }, + }) + const result = paginateByProximity( + all, + proximity.origin, + t => closestTerritoryPoint(proximity.origin, t.entrances), + url, + ) + return { + territories: result.items, + pagination: result.pagination, + distances: result.distances, + withCoordsCount: result.withCoordsCount, + withoutCoordsCount: result.withoutCoordsCount, + } + } + + const total = await db.territory.count({ where }) const pagination = paginationFromUrl(url, total) const territories = await db.territory.findMany({ skip: pagination.offset, take: pagination.size, - where: { ...selectors, congregationId }, + where, include: { entrances: { include: { buildings: true } }, attributions: { orderBy: { endDate: 'desc' }, take: 1 }, diff --git a/app/features/territories/server/territory-filters.server.test.ts b/app/features/territories/server/territory-filters.server.test.ts index 8f4184f0..deca7966 100644 --- a/app/features/territories/server/territory-filters.server.test.ts +++ b/app/features/territories/server/territory-filters.server.test.ts @@ -54,26 +54,52 @@ describe('computeFilters', () => { expect(result).not.toHaveProperty('entrances') }) - it('applies search filter matching territory number', () => { - const result = computeFilters(new URLSearchParams({ search: 'T-42' })) + it('applies search filter matching territory number case-insensitively', () => { + const result = computeFilters(new URLSearchParams({ search: 'D012' })) const or = result.OR as unknown[] - expect(or).toContainEqual({ number: { contains: 'T-42' } }) + expect(or).toContainEqual({ number: { contains: 'D012', mode: 'insensitive' } }) }) - it('applies search filter matching street in nested buildings', () => { - const result = computeFilters(new URLSearchParams({ search: 'Rue de la Paix' })) - const or = result.OR as { entrances?: unknown }[] - const entranceClause = or.find(c => (c as { entrances?: unknown }).entrances) - expect(entranceClause).toBeDefined() + it('strips diacritics and lowercases the street branch', () => { + const result = computeFilters(new URLSearchParams({ search: 'Pâix' })) + const or = result.OR as { entrances?: { some?: { buildings?: { some?: { streetNormalized?: unknown } } } } }[] + const buildingsClause = or.find(c => c.entrances) + expect(buildingsClause?.entrances?.some?.buildings?.some).toMatchObject({ + streetNormalized: { contains: 'paix' }, + }) + }) + + it('trims whitespace before searching', () => { + const result = computeFilters(new URLSearchParams({ search: ' muguets ' })) + const or = result.OR as { number?: { contains: string } }[] + expect(or).toContainEqual({ number: { contains: 'muguets', mode: 'insensitive' } }) + }) + + it('strips a leading @ proximity marker', () => { + const result = computeFilters(new URLSearchParams({ search: '@bastille' })) + const or = result.OR as { number?: { contains: string } }[] + expect(or).toContainEqual({ number: { contains: 'bastille', mode: 'insensitive' } }) }) it('applies AND(number, street) when search starts with a number', () => { const result = computeFilters(new URLSearchParams({ search: '42 Rue de la Paix' })) - const or = result.OR as { entrances?: { some?: { buildings?: { some?: { OR?: unknown[] } } } } }[] - const entranceClause = or.find(c => c.entrances) - const buildingOr = entranceClause?.entrances?.some?.buildings?.some?.OR - expect(buildingOr).toBeDefined() - expect(buildingOr![0]).toHaveProperty('AND') + const or = result.OR as { entrances?: { some?: { buildings?: { some?: { AND?: unknown[] } } } } }[] + const buildingsClause = or.find(c => c.entrances) + const buildingsAnd = buildingsClause?.entrances?.some?.buildings?.some?.AND + expect(buildingsAnd).toBeDefined() + }) + + it('searches publisher first/last name on current attribution', () => { + const result = computeFilters(new URLSearchParams({ search: 'Päjot' })) + const or = result.OR as { attributions?: { some?: { publisher?: { OR?: Record[] } } } }[] + const publisherClause = or.find(c => c.attributions) + const publisherOr = publisherClause?.attributions?.some?.publisher?.OR + expect(publisherOr).toEqual( + expect.arrayContaining([ + { firstnameNormalized: { contains: 'pajot' } }, + { lastnameNormalized: { contains: 'pajot' } }, + ]), + ) }) it('ignores search filter when search is empty', () => { @@ -81,16 +107,19 @@ describe('computeFilters', () => { expect(result).not.toHaveProperty('OR') }) + it('ignores search filter when query is only whitespace', () => { + const result = computeFilters(new URLSearchParams({ search: ' ' })) + expect(result).not.toHaveProperty('OR') + }) + it('combines zip and access filters merging into entrances without losing fields', () => { const result = computeFilters(new URLSearchParams({ zip: '75001', access: '2' })) - // zip adds nested buildings, access adds access field — both under entrances.some expect(result).toHaveProperty('entrances') }) - it('search extends existing OR clauses, not replacing them', () => { + it('search OR has territory-number, buildings and publisher branches', () => { const result = computeFilters(new URLSearchParams({ search: 'Test' })) const or = result.OR as unknown[] - // Must include both the buildings clause and the territory number clause - expect(or.length).toBeGreaterThanOrEqual(2) + expect(or.length).toBe(3) }) }) diff --git a/app/features/territories/server/territory-filters.server.ts b/app/features/territories/server/territory-filters.server.ts index 9371e6f5..2319dc8e 100644 --- a/app/features/territories/server/territory-filters.server.ts +++ b/app/features/territories/server/territory-filters.server.ts @@ -1,7 +1,7 @@ import type { Prisma } from '~/database/generated/client' import type { TerritoryKind } from '~/features/territories/model/territory-kind.type' - -const addressRegex = /^(\d+\s*(bis|ter|quarter)?)\s+(.+)$/ +import { stripDiacritics } from '~/shared/utils/strip-diacritics' +import { addressRegex, proximityPrefix } from './address-regex' export function computeFilters(params: URLSearchParams): Prisma.TerritoryWhereInput { let filters: Prisma.TerritoryWhereInput = {} @@ -66,40 +66,56 @@ function applyAccessFilter(filters: Prisma.TerritoryWhereInput, params: URLSearc } function applySearchFilter(filters: Prisma.TerritoryWhereInput, params: URLSearchParams): Prisma.TerritoryWhereInput { - if (params.has('search') && (params.get('search')?.length ?? 0) > 0) { - const searchTerms = params.get('search') ?? '' - const addressTerms = searchTerms.match(addressRegex) + const raw = params.get('search') + // Strip a leading `@` proximity marker so the text branch still runs even + // when the user wanted geolocation — the loader handles geocoding/ranking; + // here we only need to keep textual matches sensible. + const trimmed = raw?.replace(proximityPrefix, '').trim() ?? '' + if (trimmed.length === 0) return filters - return { - ...filters, - OR: [ - ...(filters.OR ?? []), - { - entrances: { - some: { - buildings: { - some: { - OR: [ - addressTerms == null - ? { street: { contains: searchTerms } } - : { - AND: [ - { number: { contains: addressTerms?.[1] } }, - { street: { contains: addressTerms?.[3] } }, - ], - }, - ], - }, - }, + const normalized = stripDiacritics(trimmed) + const addressTerms = trimmed.match(addressRegex) + const addressNumber = addressTerms?.[1] + const addressStreet = addressTerms?.[3] + const addressStreetNormalized = addressStreet != null ? stripDiacritics(addressStreet) : null + + return { + ...filters, + OR: [ + ...(filters.OR ?? []), + // Territory number — case-insensitive direct match + { number: { contains: trimmed, mode: 'insensitive' } }, + // Building street / number — match via nested entrances → buildings + { + entrances: { + some: { + buildings: { + some: + addressTerms == null + ? { streetNormalized: { contains: normalized } } + : { + AND: [ + { number: { contains: addressNumber, mode: 'insensitive' } }, + { streetNormalized: { contains: addressStreetNormalized ?? normalized } }, + ], + }, }, }, }, - { - number: { contains: searchTerms }, + }, + // Current attributee — first/last name on the publisher Member + { + attributions: { + some: { + publisher: { + OR: [ + { firstnameNormalized: { contains: normalized } }, + { lastnameNormalized: { contains: normalized } }, + ], + }, + }, }, - ], - } + }, + ], } - - return filters } diff --git a/app/features/territories/ui/ActiveTerritoryFilters.tsx b/app/features/territories/ui/ActiveTerritoryFilters.tsx new file mode 100644 index 00000000..26583418 --- /dev/null +++ b/app/features/territories/ui/ActiveTerritoryFilters.tsx @@ -0,0 +1,81 @@ +import { X } from 'lucide-react' +import { Link, useLocation, useSearchParams } from 'react-router' +import * as m from '~/i18n/paraglide/messages' +import { Badge } from '~/shared/ui/badge' + +// URL query parameter the chip's X clears. Constrained to the parameters +// the filter forms actually parse so a typo (`'zipcode'`) can't silently +// produce a chip whose X clears nothing. +export type TerritoryFilterKey = 'search' | 'zip' | 'type' | 'access' | 'shops' | 'group' | 'status' + +export interface ActiveTerritoryFilterChip { + key: TerritoryFilterKey + label: string + value: string +} + +interface ActiveTerritoryFiltersProps { + chips: ActiveTerritoryFilterChip[] +} + +/** + * Renders a row of removable chips above the territory/attribution filter + * forms, plus a "Tout effacer" link that drops every query parameter (including + * pagination). Returns `null` when no chips are active so callers can mount it + * unconditionally. + * + * The chip body is inert — only the trailing X removes the filter — so users + * can't accidentally drop a filter by clicking the label/value. + */ +export default function ActiveTerritoryFilters({ chips }: ActiveTerritoryFiltersProps) { + const [params] = useSearchParams() + const location = useLocation() + + if (chips.length === 0) return null + + return ( +
+ {chips.map(chip => { + const next = new URLSearchParams(params) + next.delete(chip.key) + next.delete('page') + const search = next.toString() + const to = `${location.pathname}${search.length > 0 ? `?${search}` : ''}` + + return ( + + {chip.label} : + {chip.value} + + + ) + })} + + + + +
+ ) +} diff --git a/app/features/territories/ui/AttributionFilters.tsx b/app/features/territories/ui/AttributionFilters.tsx index f848bbd6..5f271a9b 100644 --- a/app/features/territories/ui/AttributionFilters.tsx +++ b/app/features/territories/ui/AttributionFilters.tsx @@ -1,76 +1,131 @@ -import { SlidersHorizontal } from 'lucide-react' +import { ArrowUpDown, ChevronDown, Search, SlidersHorizontal } from 'lucide-react' +import { useState } from 'react' import { Form, useSearchParams } from 'react-router' import type { PublisherGroup } from '~/database/generated/client' import { TerritoryAttributionKind } from '~/features/territories/model/territory-attribution-kind.type' import * as m from '~/i18n/paraglide/messages' +import type { SortMode } from '~/shared/utils/pagination.server' import { Button } from '~/shared/ui/button' -import { Input } from '~/shared/ui/input' import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '~/shared/ui/select' +import { cn } from '~/shared/utils/utils' +import SearchInputWithHelp from './SearchInputWithHelp' interface AttributionFiltersProps { action?: string phoneTypeActive?: boolean groups?: PublisherGroup[] + showSort?: boolean + sortValue?: SortMode + sortOptions?: SortMode[] } -export default function AttributionFilters({ action, phoneTypeActive = false, groups = [] }: AttributionFiltersProps) { +export default function AttributionFilters({ + action, + phoneTypeActive = false, + groups = [], + showSort = false, + sortValue, + sortOptions = ['date'], +}: AttributionFiltersProps) { const [params] = useSearchParams() + const [advancedOpen, setAdvancedOpen] = useState(false) + + const advancedSelects = ( + <> + + + + + ) return (
{m.territories_filter_label()}
- - - - + + {showSort && ( + + )} + + +
+ + {/* Render the advanced Selects only ONCE so Radix doesn't inject + duplicate hidden form inputs. Visible inline on `sm+`; on mobile + its visibility is toggled by `advancedOpen`. */} +
+ {advancedSelects} +
) } diff --git a/app/features/territories/ui/GeocodeNotice.tsx b/app/features/territories/ui/GeocodeNotice.tsx new file mode 100644 index 00000000..7f09058d --- /dev/null +++ b/app/features/territories/ui/GeocodeNotice.tsx @@ -0,0 +1,33 @@ +import { AlertTriangle } from 'lucide-react' +import * as m from '~/i18n/paraglide/messages' +import { Alert, AlertDescription, AlertTitle } from '~/shared/ui/alert' + +export type GeocodeNoticeData = + | { kind: 'failed'; query: string } + | { kind: 'missing-query' } + +interface GeocodeNoticeProps { + notice: GeocodeNoticeData | null +} + +/** + * Surfaces the geocoder's failure modes: + * - `failed` — query was sent but no result (API miss, network error, or no + * `GOOGLE_MAPS_API_KEY`). Results revert to text-only. + * - `missing-query` — the user typed `@` with no place — operator mode is on + * but there's nothing to look up yet. + */ +export default function GeocodeNotice({ notice }: GeocodeNoticeProps) { + if (notice == null) return null + + return ( + + + {m.territories_filter_geocode_failed_title()} + + {notice.kind === 'failed' && m.territories_filter_geocode_failed({ query: notice.query })} + {notice.kind === 'missing-query' && m.territories_filter_proximity_query_missing()} + + + ) +} diff --git a/app/features/territories/ui/NoCoordinatesNotice.tsx b/app/features/territories/ui/NoCoordinatesNotice.tsx new file mode 100644 index 00000000..b25ad70d --- /dev/null +++ b/app/features/territories/ui/NoCoordinatesNotice.tsx @@ -0,0 +1,46 @@ +import * as m from '~/i18n/paraglide/messages' +import { Badge } from '~/shared/ui/badge' +import { TableCell, TableRow } from '~/shared/ui/table' + +interface NoCoordinatesDividerProps { + count: number + colSpan: number +} + +/** + * In-table section divider — shown when the current page straddles the + * boundary between geocoded rows and rows without coordinates. Reads as a + * deliberate "section header" rather than an italic warning. + */ +export function NoCoordinatesDivider({ count, colSpan }: NoCoordinatesDividerProps) { + return ( + + + {m.territories_filter_no_coordinates_group_full()} + + {count} + + + + ) +} + +interface NoCoordinatesPageBannerProps { + count: number +} + +/** + * Above-table banner — shown when an entire page lies past the partition + * boundary (so the in-table divider would never appear). Tells the user they + * are in the un-coord tail without surprise. + */ +export function NoCoordinatesPageBanner({ count }: NoCoordinatesPageBannerProps) { + return ( +
+ {m.territories_filter_no_coordinates_page_banner({ count: String(count) })} +
+ ) +} diff --git a/app/features/territories/ui/ProximityBanner.tsx b/app/features/territories/ui/ProximityBanner.tsx new file mode 100644 index 00000000..7a981191 --- /dev/null +++ b/app/features/territories/ui/ProximityBanner.tsx @@ -0,0 +1,68 @@ +import { MapPin, X } from 'lucide-react' +import { Link, useLocation, useSearchParams } from 'react-router' +import type { GeocodeResult } from '~/shared/infra/geocoder.server' +import * as m from '~/i18n/paraglide/messages' +import { Badge } from '~/shared/ui/badge' + +interface ProximityBannerProps { + geocode: GeocodeResult +} + +/** + * Confirms what address the geocoder resolved, lets the user dismiss it, and + * surfaces up to two alternates as "Did you mean?" chips that re-submit the + * search forced as a proximity query. + */ +export default function ProximityBanner({ geocode }: ProximityBannerProps) { + const [params] = useSearchParams() + const location = useLocation() + + const clearParams = new URLSearchParams(params) + clearParams.delete('search') + clearParams.delete('page') + clearParams.delete('sort') + const clearTo = `${location.pathname}${clearParams.toString() ? `?${clearParams}` : ''}` + + function alternateTo(formatted: string) { + const next = new URLSearchParams(params) + next.set('search', `@${formatted}`) + next.delete('page') + return `${location.pathname}?${next.toString()}` + } + + return ( +
+
+
+ {geocode.alternates.length > 0 && ( +
+ {m.territories_filter_proximity_did_you_mean()} + {geocode.alternates.map(alternate => ( + + {alternate.formatted} + + ))} +
+ )} +
+ ) +} diff --git a/app/features/territories/ui/SearchInputWithHelp.tsx b/app/features/territories/ui/SearchInputWithHelp.tsx new file mode 100644 index 00000000..b7fdb8f2 --- /dev/null +++ b/app/features/territories/ui/SearchInputWithHelp.tsx @@ -0,0 +1,76 @@ +import { Info } from 'lucide-react' +import { useEffect, useState } from 'react' +import * as m from '~/i18n/paraglide/messages' +import { Button } from '~/shared/ui/button' +import { Input } from '~/shared/ui/input' +import { Popover, PopoverContent, PopoverTrigger } from '~/shared/ui/popover' + +interface SearchInputWithHelpProps { + defaultValue?: string +} + +const ROTATION_INTERVAL_MS = 4000 + +/** + * Search input with a rotating placeholder (cycling through name / address / + * proximity examples) and an inline ⓘ popover explaining the `@` proximity + * operator and auto-detection. + * + * Rotation pauses once the user focuses the input — we don't want the hint to + * change underneath them as they type. + */ +export default function SearchInputWithHelp({ defaultValue }: SearchInputWithHelpProps) { + const examples = [ + m.territories_filter_search_example_name(), + m.territories_filter_search_example_address(), + m.territories_filter_search_example_proximity(), + ] + const [index, setIndex] = useState(0) + const [paused, setPaused] = useState(false) + // Once the user has typed anything the placeholder examples have served + // their purpose — never resume rotation, even after they clear the field. + const [userTyped, setUserTyped] = useState(false) + + useEffect(() => { + if (paused || userTyped) return + const id = setInterval(() => setIndex(i => (i + 1) % examples.length), ROTATION_INTERVAL_MS) + return () => clearInterval(id) + }, [paused, userTyped, examples.length]) + + return ( +
+ setPaused(true)} + onInput={() => setUserTyped(true)} + /> + + + + + +

{m.territories_filter_help_title()}

+
    +
  • {m.territories_filter_help_item_name()}
    • +
  • {m.territories_filter_help_item_number()}
    • +
  • {m.territories_filter_help_item_address()}
    • +
  • {m.territories_filter_help_item_proximity()}
    • +
+

{m.territories_filter_help_disclaimer()}

+ + +
+ ) +} diff --git a/app/features/territories/ui/TerritoryFilters.tsx b/app/features/territories/ui/TerritoryFilters.tsx index be59b1c1..1ec3f79d 100644 --- a/app/features/territories/ui/TerritoryFilters.tsx +++ b/app/features/territories/ui/TerritoryFilters.tsx @@ -1,13 +1,16 @@ -import { SlidersHorizontal } from 'lucide-react' +import { ArrowUpDown, ChevronDown, Search, SlidersHorizontal } from 'lucide-react' +import { useState } from 'react' import { Form, useSearchParams } from 'react-router' import type { Prisma } from '~/database/generated/client' import { ShopKind } from '~/features/territories/model/shop-kind.type' import { TerritoryAccess } from '~/features/territories/model/territory-access.type' import { TerritoryKind } from '~/features/territories/model/territory-kind.type' import * as m from '~/i18n/paraglide/messages' +import type { SortMode } from '~/shared/utils/pagination.server' import { Button } from '~/shared/ui/button' -import { Input } from '~/shared/ui/input' import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '~/shared/ui/select' +import { cn } from '~/shared/utils/utils' +import SearchInputWithHelp from './SearchInputWithHelp' interface TerritoryFiltersProps { action?: string @@ -17,6 +20,9 @@ interface TerritoryFiltersProps { showSearch?: boolean showZip?: boolean showShops?: boolean + showSort?: boolean + sortValue?: SortMode + sortOptions?: SortMode[] } export default function TerritoryFilters({ @@ -27,91 +33,135 @@ export default function TerritoryFilters({ showType = false, showShops = false, showZip = false, + showSort = false, + sortValue, + sortOptions = ['number'], }: TerritoryFiltersProps) { const [params] = useSearchParams() + const [advancedOpen, setAdvancedOpen] = useState(false) + + const advancedSelects = ( + <> + {showZip && ( + + )} + {showType && ( + + )} + {showAccess && ( + + )} + {showShops && ( + + )} + + ) return (
{m.territories_filter_label()}
- {showZip && ( - - )} - {showType && ( - - )} - {showAccess && ( - + + + - {m.territories_filter_access()} - {m.territories_filter_access_digicode()} - {m.territories_filter_access_doorbell()} - {m.territories_filter_access_intercom()} + {sortOptions.includes('number') && ( + {m.territories_filter_sort_number()} + )} + {sortOptions.includes('date') && ( + {m.territories_filter_sort_date()} + )} + {sortOptions.includes('proximity') && ( + {m.territories_filter_sort_proximity()} + )} )} - {showShops && ( - - )} - {showSearch && ( - - )} + + +
+ + {/* Render the advanced Selects only ONCE so Radix doesn't inject + duplicate hidden form inputs. Visible inline on `sm+`; on mobile + its visibility is toggled by `advancedOpen`. */} +
+ {advancedSelects} +
) } diff --git a/app/features/territories/ui/build-filter-chips.test.ts b/app/features/territories/ui/build-filter-chips.test.ts new file mode 100644 index 00000000..f87754ab --- /dev/null +++ b/app/features/territories/ui/build-filter-chips.test.ts @@ -0,0 +1,69 @@ +import { describe, expect, it } from 'vitest' +import { TerritoryAttributionKind } from '~/features/territories/model/territory-attribution-kind.type' +import { TerritoryKind } from '~/features/territories/model/territory-kind.type' +import { buildAttributionFilterChips, buildTerritoryFilterChips } from './build-filter-chips' + +describe('buildTerritoryFilterChips', () => { + it('returns no chip for empty params', () => { + expect(buildTerritoryFilterChips(new URLSearchParams())).toEqual([]) + }) + + it("treats 'none' as absent", () => { + expect(buildTerritoryFilterChips(new URLSearchParams({ type: 'none', zip: 'none' }))).toEqual([]) + }) + + it('trims the search chip value', () => { + const chips = buildTerritoryFilterChips(new URLSearchParams({ search: ' muguets ' })) + expect(chips).toHaveLength(1) + expect(chips[0]).toMatchObject({ key: 'search', value: 'muguets' }) + }) + + it('drops an empty search query', () => { + expect(buildTerritoryFilterChips(new URLSearchParams({ search: ' ' }))).toEqual([]) + }) + + it('maps a known type enum to its label', () => { + const chips = buildTerritoryFilterChips(new URLSearchParams({ type: TerritoryKind.Classical })) + expect(chips).toHaveLength(1) + expect(chips[0].key).toBe('type') + expect(chips[0].value.length).toBeGreaterThan(0) + }) + + it('drops a type chip when the enum value is unknown', () => { + expect(buildTerritoryFilterChips(new URLSearchParams({ type: 'mystery' }))).toEqual([]) + }) + + it('drops an access chip when the access value is unknown', () => { + expect(buildTerritoryFilterChips(new URLSearchParams({ access: '99' }))).toEqual([]) + }) +}) + +describe('buildAttributionFilterChips', () => { + it('returns no chip for empty params', () => { + expect(buildAttributionFilterChips(new URLSearchParams())).toEqual([]) + }) + + it('drops a group chip when the id is not in the supplied list', () => { + expect(buildAttributionFilterChips(new URLSearchParams({ group: '42' }))).toEqual([]) + }) + + it('resolves a known group id to its display name', () => { + const chips = buildAttributionFilterChips(new URLSearchParams({ group: '7' }), { + groups: [{ id: 7, name: 'Groupe Soleil' }], + }) + expect(chips).toHaveLength(1) + expect(chips[0]).toMatchObject({ key: 'group', value: 'Groupe Soleil' }) + }) + + it('maps known attribution kinds and status values', () => { + const chips = buildAttributionFilterChips( + new URLSearchParams({ type: TerritoryAttributionKind.Campaign, status: 'orphaned' }), + ) + const keys = chips.map(c => c.key) + expect(keys).toEqual(['type', 'status']) + }) + + it('drops an attribution kind chip when the value is unknown', () => { + expect(buildAttributionFilterChips(new URLSearchParams({ type: 'mystery' }))).toEqual([]) + }) +}) diff --git a/app/features/territories/ui/build-filter-chips.ts b/app/features/territories/ui/build-filter-chips.ts new file mode 100644 index 00000000..d9149ef5 --- /dev/null +++ b/app/features/territories/ui/build-filter-chips.ts @@ -0,0 +1,150 @@ +import { ShopKind } from '~/features/territories/model/shop-kind.type' +import { TerritoryAccess } from '~/features/territories/model/territory-access.type' +import { TerritoryAttributionKind } from '~/features/territories/model/territory-attribution-kind.type' +import { TerritoryKind } from '~/features/territories/model/territory-kind.type' +import * as m from '~/i18n/paraglide/messages' +import type { ActiveTerritoryFilterChip, TerritoryFilterKey } from './ActiveTerritoryFilters' + +interface BuildChipsOptions { + // Map of publisherGroupId → display name, supplied by pages showing the + // group filter (attribution list, prospection). Empty for pages that don't + // expose group. + groups?: Array<{ id: number; name: string }> +} + +function typeChipValue(raw: string): string | null { + switch (raw) { + case TerritoryKind.Classical: + return m.territories_type_classical_capitalized() + case TerritoryKind.Commerces: + return m.territories_type_commerces() + case TerritoryKind.Phone: + return m.territories_type_phone() + case TerritoryKind.Hotel: + return m.territories_type_hotel() + case TerritoryKind.Univ: + return m.territories_type_university_singular() + default: + return null + } +} + +function attributionTypeChipValue(raw: string): string | null { + switch (raw) { + case TerritoryAttributionKind.Default: + return m.attributions_type_default() + case TerritoryAttributionKind.Phone: + return m.attributions_type_phone() + case TerritoryAttributionKind.Campaign: + return m.attributions_type_campaign() + default: + return null + } +} + +function accessChipValue(raw: string): string | null { + switch (Number(raw)) { + case TerritoryAccess.Code: + return m.territories_filter_access_digicode() + case TerritoryAccess.Doorbell: + return m.territories_filter_access_doorbell() + case TerritoryAccess.Intercom: + return m.territories_filter_access_intercom() + default: + return null + } +} + +function shopChipValue(raw: string): string | null { + switch (raw) { + case ShopKind.Food: + return m.shop_kind_food() + case ShopKind.Clothing: + return m.shop_kind_clothing() + case ShopKind.Jewelry: + return m.shop_kind_jewelry() + case ShopKind.Health: + return m.shop_kind_health() + case ShopKind.Home: + return m.shop_kind_home() + case ShopKind.Catering: + return m.shop_kind_catering() + case ShopKind.Cosmetics: + return m.shop_kind_cosmetics() + case ShopKind.Tech: + return m.shop_kind_tech() + case ShopKind.Newspaper: + return m.shop_kind_newspaper() + case ShopKind.GasStation: + return m.shop_kind_gas_station() + case ShopKind.Other: + return m.shop_kind_other() + default: + return null + } +} + +function attributionStatusChipValue(raw: string): string | null { + switch (raw) { + case 'current': + return m.territories_filter_status_current() + case 'late': + return m.territories_filter_status_late() + case 'orphaned': + return m.territories_filter_status_orphaned() + default: + return null + } +} + +function searchChipValue(raw: string): string { + return raw.trim() +} + +function appendChip( + chips: ActiveTerritoryFilterChip[], + params: URLSearchParams, + key: TerritoryFilterKey, + label: string, + display: (raw: string) => string | null, +) { + const raw = params.get(key) + if (raw == null || raw === '' || raw === 'none') return + const value = display(raw) + if (value == null || value.length === 0) return + chips.push({ key, label, value }) +} + +/** + * Build the chip list for a page using `TerritoryFilters`: territory list, + * available-territories picker, prospection, split-tool. Each chip's `key` + * mirrors the URL query param name so the chip's X can drop just that one. + */ +export function buildTerritoryFilterChips(params: URLSearchParams): ActiveTerritoryFilterChip[] { + const chips: ActiveTerritoryFilterChip[] = [] + appendChip(chips, params, 'search', m.territories_filter_chip_search(), searchChipValue) + appendChip(chips, params, 'zip', m.territories_filter_chip_zip(), raw => raw) + appendChip(chips, params, 'type', m.territories_filter_chip_type(), typeChipValue) + appendChip(chips, params, 'access', m.territories_filter_chip_access(), accessChipValue) + appendChip(chips, params, 'shops', m.territories_filter_chip_shops(), shopChipValue) + return chips +} + +/** + * Build the chip list for `/territories/attributions` (AttributionFilters). + * `groups` resolves the publisher-group id back to its display name. + */ +export function buildAttributionFilterChips( + params: URLSearchParams, + options: BuildChipsOptions = {}, +): ActiveTerritoryFilterChip[] { + const chips: ActiveTerritoryFilterChip[] = [] + appendChip(chips, params, 'search', m.territories_filter_chip_search(), searchChipValue) + appendChip(chips, params, 'type', m.territories_filter_chip_mode(), attributionTypeChipValue) + appendChip(chips, params, 'group', m.territories_filter_chip_group(), raw => { + const group = options.groups?.find(g => g.id === Number(raw)) + return group?.name ?? null + }) + appendChip(chips, params, 'status', m.territories_filter_chip_status(), attributionStatusChipValue) + return chips +} diff --git a/app/i18n/messages/en.json b/app/i18n/messages/en.json index 444f337e..5e4d1acd 100644 --- a/app/i18n/messages/en.json +++ b/app/i18n/messages/en.json @@ -1808,6 +1808,42 @@ "territories_filter_access_intercom": "Intercom", "territories_filter_shops": "Businesses", "territories_filter_default_classic": "Standard", + "territories_filter_active_label": "Active filters", + "territories_filter_clear_all": "Clear all", + "territories_filter_chip_remove": "Remove filter {label}: {value}", + "territories_filter_chip_search": "Search", + "territories_filter_chip_type": "Type", + "territories_filter_chip_zip": "Postal code", + "territories_filter_chip_access": "Access", + "territories_filter_chip_shops": "Shops", + "territories_filter_chip_group": "Group", + "territories_filter_chip_status": "Status", + "territories_filter_chip_mode": "Mode", + "territories_filter_distance_header": "Distance", + "territories_filter_distance_unknown_tooltip": "No geocoded address", + "territories_filter_proximity_banner": "Results near", + "territories_filter_proximity_change": "Clear proximity", + "territories_filter_proximity_did_you_mean": "Did you mean:", + "territories_filter_geocode_failed": "Could not geocode \"{query}\" — showing text matches.", + "territories_filter_geocode_failed_title": "Proximity search unavailable", + "territories_filter_proximity_query_missing": "Type a place after @ to enable proximity search.", + "territories_filter_no_coordinates_group_full": "Without geocoded address — not sorted by distance", + "territories_filter_no_coordinates_page_banner": "You are viewing the section without coordinates ({count} result(s)).", + "territories_filter_sort_label": "Sort by", + "territories_filter_sort_number": "Number", + "territories_filter_sort_date": "Date", + "territories_filter_sort_proximity": "Proximity", + "territories_filter_advanced": "Advanced filters", + "territories_filter_help_aria": "Search help", + "territories_filter_help_title": "How to search", + "territories_filter_help_item_name": "A name: Pajot", + "territories_filter_help_item_number": "A number: D012", + "territories_filter_help_item_address": "An address: 12 rue de la Paix", + "territories_filter_help_item_proximity": "Prefix with @ to force proximity (e.g. @Bastille)", + "territories_filter_help_disclaimer": "Without a Google Maps key, proximity is disabled but everything else still works.", + "territories_filter_search_example_name": "e.g. Pajot", + "territories_filter_search_example_address": "e.g. 12 rue de la Paix", + "territories_filter_search_example_proximity": "e.g. @Bastille", "territories_entrance_list_zip": "Postal Code", "territories_entrance_list_number": "No.", "territories_entrance_list_street": "Street", diff --git a/app/i18n/messages/fr.json b/app/i18n/messages/fr.json index f7d25435..6ccb02da 100644 --- a/app/i18n/messages/fr.json +++ b/app/i18n/messages/fr.json @@ -1811,6 +1811,42 @@ "territories_filter_access_intercom": "Interphone", "territories_filter_shops": "Commerces", "territories_filter_default_classic": "Classique", + "territories_filter_active_label": "Filtres appliqués", + "territories_filter_clear_all": "Tout effacer", + "territories_filter_chip_remove": "Retirer le filtre {label} : {value}", + "territories_filter_chip_search": "Recherche", + "territories_filter_chip_type": "Type", + "territories_filter_chip_zip": "Code postal", + "territories_filter_chip_access": "Accès", + "territories_filter_chip_shops": "Commerces", + "territories_filter_chip_group": "Groupe", + "territories_filter_chip_status": "Statut", + "territories_filter_chip_mode": "Mode", + "territories_filter_distance_header": "Distance", + "territories_filter_distance_unknown_tooltip": "Aucune adresse géolocalisée", + "territories_filter_proximity_banner": "Résultats à proximité de", + "territories_filter_proximity_change": "Effacer la proximité", + "territories_filter_proximity_did_you_mean": "Vouliez-vous dire :", + "territories_filter_geocode_failed": "Impossible de géolocaliser « {query} » — affichage des correspondances textuelles.", + "territories_filter_geocode_failed_title": "Recherche par proximité indisponible", + "territories_filter_proximity_query_missing": "Tapez un lieu après le @ pour activer la recherche par proximité.", + "territories_filter_no_coordinates_group_full": "Sans adresse géolocalisée — non triés par distance", + "territories_filter_no_coordinates_page_banner": "Vous parcourez la zone sans coordonnées ({count} résultat(s)).", + "territories_filter_sort_label": "Trier par", + "territories_filter_sort_number": "Numéro", + "territories_filter_sort_date": "Date", + "territories_filter_sort_proximity": "Proximité", + "territories_filter_advanced": "Filtres avancés", + "territories_filter_help_aria": "Aide à la recherche", + "territories_filter_help_title": "Comment chercher ?", + "territories_filter_help_item_name": "Un nom : Pajot", + "territories_filter_help_item_number": "Un numéro : D012", + "territories_filter_help_item_address": "Une adresse : 12 rue de la Paix", + "territories_filter_help_item_proximity": "Préfixez avec @ pour forcer la proximité (ex. @Bastille)", + "territories_filter_help_disclaimer": "Sans clé Google Maps, la proximité est désactivée mais le reste fonctionne.", + "territories_filter_search_example_name": "ex. Pajot", + "territories_filter_search_example_address": "ex. 12 rue de la Paix", + "territories_filter_search_example_proximity": "ex. @Bastille", "territories_entrance_list_zip": "Code Postal", "territories_entrance_list_number": "Nº", "territories_entrance_list_street": "Rue", diff --git a/app/shared/infra/geocoder.server.test.ts b/app/shared/infra/geocoder.server.test.ts new file mode 100644 index 00000000..ab2cd422 --- /dev/null +++ b/app/shared/infra/geocoder.server.test.ts @@ -0,0 +1,242 @@ +import { Status } from '@googlemaps/google-maps-services-js' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +const mockGet = vi.fn<(key: string) => Promise>() +const mockSet = vi.fn<(key: string, value: string, mode: string, ttl: number) => Promise<'OK'>>() +const mockGeocode = vi.fn() + +vi.mock('./redis.server', () => ({ + redis: { + get: mockGet, + set: mockSet, + }, +})) + +vi.mock('@googlemaps/google-maps-services-js', async () => { + const actual = await vi.importActual( + '@googlemaps/google-maps-services-js', + ) + class MockClient { + geocode = mockGeocode + } + return { ...actual, Client: MockClient } +}) + +beforeEach(() => { + mockGet.mockReset() + mockSet.mockReset() + mockGeocode.mockReset() + mockGet.mockResolvedValue(null) + mockSet.mockResolvedValue('OK') +}) + +afterEach(() => { + delete process.env.GOOGLE_MAPS_API_KEY +}) + +describe('geocode', () => { + it('returns null and skips the API when GOOGLE_MAPS_API_KEY is missing', async () => { + const { geocode } = await import('./geocoder.server') + const result = await geocode('12 rue de la Paix') + expect(result).toBeNull() + expect(mockGeocode).not.toHaveBeenCalled() + }) + + it('returns null for empty/whitespace queries', async () => { + process.env.GOOGLE_MAPS_API_KEY = 'test-key' + const { geocode } = await import('./geocoder.server') + expect(await geocode(' ')).toBeNull() + expect(mockGeocode).not.toHaveBeenCalled() + }) + + it('returns a cached result without calling the API', async () => { + process.env.GOOGLE_MAPS_API_KEY = 'test-key' + const cached = { + formatted: '12 Rue de la Paix, 75002 Paris, France', + lat: 48.8696, + lng: 2.3322, + locationType: 'ROOFTOP' as const, + alternates: [], + } + mockGet.mockResolvedValue(JSON.stringify(cached)) + + const { geocode } = await import('./geocoder.server') + const result = await geocode('12 rue de la Paix') + + expect(result).toEqual(cached) + expect(mockGeocode).not.toHaveBeenCalled() + }) + + it('returns null when cache stores empty sentinel', async () => { + process.env.GOOGLE_MAPS_API_KEY = 'test-key' + mockGet.mockResolvedValue('') + + const { geocode } = await import('./geocoder.server') + expect(await geocode('non-existent place')).toBeNull() + expect(mockGeocode).not.toHaveBeenCalled() + }) + + it('calls the API on cache miss and writes the result back to Redis', async () => { + process.env.GOOGLE_MAPS_API_KEY = 'test-key' + mockGeocode.mockResolvedValue({ + data: { + status: Status.OK, + results: [ + { + formatted_address: '12 Rue de la Paix, 75002 Paris, France', + geometry: { location: { lat: 48.8696, lng: 2.3322 }, location_type: 'ROOFTOP' }, + place_id: 'paix-1', + }, + ], + }, + }) + + const { geocode } = await import('./geocoder.server') + const result = await geocode('12 rue de la Paix') + + expect(result).toMatchObject({ + formatted: '12 Rue de la Paix, 75002 Paris, France', + lat: 48.8696, + lng: 2.3322, + locationType: 'ROOFTOP', + }) + expect(mockSet).toHaveBeenCalledWith( + 'geocode:v1:12 rue de la paix', + expect.stringContaining('Rue de la Paix'), + 'EX', + 60 * 60 * 24 * 90, + ) + }) + + it('forwards the configured API key (not the Redis cache key) to Google', async () => { + process.env.GOOGLE_MAPS_API_KEY = 'real-api-key' + mockGeocode.mockResolvedValue({ + data: { + status: Status.OK, + results: [ + { + formatted_address: '12 Rue de la Paix', + geometry: { location: { lat: 48.87, lng: 2.33 }, location_type: 'ROOFTOP' }, + place_id: 'p', + }, + ], + }, + }) + + const { geocode } = await import('./geocoder.server') + await geocode('12 rue de la Paix') + + expect(mockGeocode.mock.calls[0]?.[0]?.params?.key).toBe('real-api-key') + }) + + it('falls back through a malformed cache entry to the API', async () => { + process.env.GOOGLE_MAPS_API_KEY = 'test-key' + mockGet.mockResolvedValue('{not-valid-json') + mockGeocode.mockResolvedValue({ + data: { + status: Status.OK, + results: [ + { + formatted_address: 'X', + geometry: { location: { lat: 1, lng: 2 }, location_type: 'ROOFTOP' }, + place_id: 'x', + }, + ], + }, + }) + + const { geocode } = await import('./geocoder.server') + const result = await geocode('rue x') + expect(result?.formatted).toBe('X') + expect(mockGeocode).toHaveBeenCalled() + }) + + it('does not cache non-OK statuses (treats REQUEST_DENIED as transient)', async () => { + process.env.GOOGLE_MAPS_API_KEY = 'test-key' + mockGeocode.mockResolvedValue({ + data: { status: Status.REQUEST_DENIED, results: [], error_message: 'bad key' }, + }) + + const { geocode } = await import('./geocoder.server') + expect(await geocode('rue x')).toBeNull() + expect(mockSet).not.toHaveBeenCalled() + }) + + it('coerces unknown Google `location_type` to OTHER', async () => { + process.env.GOOGLE_MAPS_API_KEY = 'test-key' + mockGeocode.mockResolvedValue({ + data: { + status: Status.OK, + results: [ + { + formatted_address: 'Plus Code Land', + geometry: { location: { lat: 0, lng: 0 }, location_type: 'PLUS_CODE' }, + place_id: 'pc', + }, + ], + }, + }) + + const { geocode } = await import('./geocoder.server') + const result = await geocode('plus code land') + expect(result?.locationType).toBe('OTHER') + }) + + it('caches a miss as the empty sentinel and returns null', async () => { + process.env.GOOGLE_MAPS_API_KEY = 'test-key' + mockGeocode.mockResolvedValue({ + data: { status: Status.ZERO_RESULTS, results: [] }, + }) + + const { geocode } = await import('./geocoder.server') + expect(await geocode('unfindable place')).toBeNull() + expect(mockSet).toHaveBeenCalledWith('geocode:v1:unfindable place', '', 'EX', 60 * 60 * 24 * 90) + }) + + it('returns up to two alternates from extra API results', async () => { + process.env.GOOGLE_MAPS_API_KEY = 'test-key' + mockGeocode.mockResolvedValue({ + data: { + status: Status.OK, + results: [ + { + formatted_address: 'Rue de la Paix, Paris', + geometry: { location: { lat: 48.87, lng: 2.33 }, location_type: 'GEOMETRIC_CENTER' }, + place_id: 'paris', + }, + { + formatted_address: 'Rue de la Paix, Lyon', + geometry: { location: { lat: 45.75, lng: 4.85 }, location_type: 'GEOMETRIC_CENTER' }, + place_id: 'lyon', + }, + { + formatted_address: 'Rue de la Paix, Nantes', + geometry: { location: { lat: 47.21, lng: -1.55 }, location_type: 'GEOMETRIC_CENTER' }, + place_id: 'nantes', + }, + { + formatted_address: 'Rue de la Paix, Bordeaux', + geometry: { location: { lat: 44.83, lng: -0.57 }, location_type: 'GEOMETRIC_CENTER' }, + place_id: 'bordeaux', + }, + ], + }, + }) + + const { geocode } = await import('./geocoder.server') + const result = await geocode('rue de la paix') + expect(result?.alternates).toEqual([ + { formatted: 'Rue de la Paix, Lyon', placeId: 'lyon' }, + { formatted: 'Rue de la Paix, Nantes', placeId: 'nantes' }, + ]) + }) + + it('returns null and does not cache when the API throws', async () => { + process.env.GOOGLE_MAPS_API_KEY = 'test-key' + mockGeocode.mockRejectedValue(new Error('network')) + + const { geocode } = await import('./geocoder.server') + expect(await geocode('rue')).toBeNull() + expect(mockSet).not.toHaveBeenCalled() + }) +}) diff --git a/app/shared/infra/geocoder.server.ts b/app/shared/infra/geocoder.server.ts new file mode 100644 index 00000000..1c80f658 --- /dev/null +++ b/app/shared/infra/geocoder.server.ts @@ -0,0 +1,129 @@ +import { Client, Status } from '@googlemaps/google-maps-services-js' +import { stripDiacritics } from '~/shared/utils/strip-diacritics' +import logger from './logger.server' +import { redis } from './redis.server' + +export interface GeocodeAlternate { + formatted: string + placeId: string +} + +const LOCATION_TYPES = ['ROOFTOP', 'RANGE_INTERPOLATED', 'GEOMETRIC_CENTER', 'APPROXIMATE'] as const +type KnownLocationType = (typeof LOCATION_TYPES)[number] + +export interface GeocodeResult { + formatted: string + lat: number + lng: number + // `OTHER` covers any future Google Maps enum value we haven't pinned — + // prevents an unchecked widening cast from silently lying at the type + // level when Google adds e.g. `PLUS_CODE`. + locationType: KnownLocationType | 'OTHER' + alternates: GeocodeAlternate[] +} + +const CACHE_TTL_SECONDS = 60 * 60 * 24 * 90 // 90 days — geocoded addresses are stable +const CACHE_PREFIX = 'geocode:v1:' +const MAX_KEY_LENGTH = 200 +const REQUEST_TIMEOUT_MS = 5000 + +// Lazy so the `new Client()` construct call is delayed until first geocode — +// the import side-effect would otherwise force test mocks into constructor +// mode at the wrong moment. +let client: Client | null = null +function getClient(): Client { + if (client == null) client = new Client({}) + return client +} + +function cacheKey(query: string): string { + return `${CACHE_PREFIX}${stripDiacritics(query).trim().slice(0, MAX_KEY_LENGTH)}` +} + +function normalizeLocationType(raw: string | undefined): GeocodeResult['locationType'] { + return (LOCATION_TYPES as readonly string[]).includes(raw ?? '') ? (raw as KnownLocationType) : 'OTHER' +} + +/** + * Resolve a free-text address to coordinates via the Google Maps Geocoding + * API. Returns `null` when `GOOGLE_MAPS_API_KEY` is missing — callers must + * degrade gracefully (text-only search). OK / ZERO_RESULTS responses are + * cached in Redis for 90 days under a normalized key. Non-OK statuses + * (REQUEST_DENIED, OVER_QUERY_LIMIT, INVALID_REQUEST, …) are logged at error + * and NOT cached — caching them would poison results for 90 days on a key + * outage or quota blip. + */ +export async function geocode(rawQuery: string): Promise { + const query = rawQuery.trim() + if (query.length === 0) return null + + const apiKey = process.env.GOOGLE_MAPS_API_KEY + if (!apiKey || apiKey.length === 0) return null + + const cacheRedisKey = cacheKey(query) + + try { + const cached = await redis.get(cacheRedisKey) + if (cached != null) { + // Empty string is the cached "no result" sentinel. + if (cached.length === 0) return null + try { + return JSON.parse(cached) as GeocodeResult + } catch (parseError) { + logger.warn('Geocoder cache value malformed; ignoring', { + query, + error: (parseError as Error).message, + }) + } + } + } catch (error) { + logger.warn('Geocoder cache read failed', { query, error: (error as Error).message }) + } + + let result: GeocodeResult | null = null + let shouldCache = false + try { + const response = await getClient().geocode({ + params: { address: query, key: apiKey }, + timeout: REQUEST_TIMEOUT_MS, + }) + const status = response.data.status + if (status === Status.OK && response.data.results.length > 0) { + const [top, ...rest] = response.data.results + result = { + formatted: top.formatted_address, + lat: top.geometry.location.lat, + lng: top.geometry.location.lng, + locationType: normalizeLocationType(top.geometry.location_type), + alternates: rest.slice(0, 2).map(alt => ({ + formatted: alt.formatted_address, + placeId: alt.place_id, + })), + } + shouldCache = true + } else if (status === Status.ZERO_RESULTS) { + // Genuine miss — cache the empty sentinel so repeat queries don't burn + // API credits. + shouldCache = true + } else { + logger.error('Geocoder non-OK status; skipping cache', { + query, + status, + errorMessage: response.data.error_message, + }) + } + } catch (error) { + logger.warn('Geocoder call failed', { query, error: (error as Error).message }) + return null + } + + if (shouldCache) { + try { + await redis.set(cacheRedisKey, result == null ? '' : JSON.stringify(result), 'EX', CACHE_TTL_SECONDS) + } catch (error) { + logger.error('Geocoder cache write failed', { query, error: (error as Error).message }) + } + } + + return result +} diff --git a/app/shared/ui/alert.tsx b/app/shared/ui/alert.tsx index 1551d58e..806effc8 100644 --- a/app/shared/ui/alert.tsx +++ b/app/shared/ui/alert.tsx @@ -11,6 +11,8 @@ const alertVariants = cva( default: 'bg-card text-card-foreground', destructive: 'bg-card text-destructive *:data-[slot=alert-description]:text-destructive/90 [&>svg]:text-current', + warning: + 'border-amber-200 bg-amber-50 text-amber-900 *:data-[slot=alert-description]:text-amber-800/90 [&>svg]:text-amber-600 dark:border-amber-900/40 dark:bg-amber-950/30 dark:text-amber-200 dark:*:data-[slot=alert-description]:text-amber-200/80 dark:[&>svg]:text-amber-400', }, }, defaultVariants: { diff --git a/app/shared/utils/distance.test.ts b/app/shared/utils/distance.test.ts new file mode 100644 index 00000000..08bc0aa5 --- /dev/null +++ b/app/shared/utils/distance.test.ts @@ -0,0 +1,53 @@ +import { describe, expect, it } from 'vitest' +import { formatDistance, haversineMeters } from './distance' + +const oneEightyMeters = /^180\s?m$/ +const nineNineNineMeters = /^999\s?m$/ +const oneEightyOneMeters = /^181\s?m$/ +const twelvePointTwoKm = /^1[.,]2\s?km$/ +const twelvePointEightKm = /^12[.,]8\s?km$/ + +describe('haversineMeters', () => { + it('returns 0 for the same point', () => { + const point = { lat: 48.8566, lng: 2.3522 } + expect(haversineMeters(point, point)).toBeCloseTo(0, 0) + }) + + it('measures the Paris→Lyon distance within a few percent', () => { + const paris = { lat: 48.8566, lng: 2.3522 } + const lyon = { lat: 45.764, lng: 4.8357 } + // Reference straight-line distance: ~391 km + const meters = haversineMeters(paris, lyon) + expect(meters).toBeGreaterThan(388_000) + expect(meters).toBeLessThan(394_000) + }) + + it('is symmetric', () => { + const a = { lat: 48.85, lng: 2.35 } + const b = { lat: 48.87, lng: 2.33 } + expect(haversineMeters(a, b)).toBeCloseTo(haversineMeters(b, a), 6) + }) +}) + +describe('formatDistance', () => { + it('formats under 1km as meters with no decimals', () => { + expect(formatDistance(180)).toMatch(oneEightyMeters) + expect(formatDistance(999)).toMatch(nineNineNineMeters) + }) + + it('rounds to the nearest meter', () => { + expect(formatDistance(180.6)).toMatch(oneEightyOneMeters) + }) + + it('formats 1km+ as kilometers with one decimal', () => { + // French locale uses a comma; assert on the structure rather than literal char + expect(formatDistance(1200)).toMatch(twelvePointTwoKm) + expect(formatDistance(12_800)).toMatch(twelvePointEightKm) + }) + + it('returns empty string for invalid input', () => { + expect(formatDistance(Number.NaN)).toBe('') + expect(formatDistance(-5)).toBe('') + expect(formatDistance(Number.POSITIVE_INFINITY)).toBe('') + }) +}) diff --git a/app/shared/utils/distance.ts b/app/shared/utils/distance.ts new file mode 100644 index 00000000..cbdcef5d --- /dev/null +++ b/app/shared/utils/distance.ts @@ -0,0 +1,69 @@ +export interface LatLng { + lat: number + lng: number +} + +const EARTH_RADIUS_METERS = 6_371_000 + +function toRadians(degrees: number): number { + return (degrees * Math.PI) / 180 +} + +/** + * Great-circle distance between two points in meters via the Haversine + * formula. Accurate enough for territory-scale (sub-100km) distances. + */ +export function haversineMeters(a: LatLng, b: LatLng): number { + const lat1 = toRadians(a.lat) + const lat2 = toRadians(b.lat) + const dLat = toRadians(b.lat - a.lat) + const dLng = toRadians(b.lng - a.lng) + + const sinDLat = Math.sin(dLat / 2) + const sinDLng = Math.sin(dLng / 2) + const h = sinDLat * sinDLat + Math.cos(lat1) * Math.cos(lat2) * sinDLng * sinDLng + return 2 * EARTH_RADIUS_METERS * Math.asin(Math.min(1, Math.sqrt(h))) +} + +// Memoize formatter instances per-locale: `Intl.NumberFormat` is heavy to +// construct (CLDR lookup), and the call sites render a Distance column per +// row. +const metersFormatters = new Map() +const kilometersFormatters = new Map() + +function getMetersFormatter(locale: string): Intl.NumberFormat { + const cached = metersFormatters.get(locale) + if (cached != null) return cached + const formatter = new Intl.NumberFormat(locale, { + style: 'unit', + unit: 'meter', + unitDisplay: 'short', + maximumFractionDigits: 0, + }) + metersFormatters.set(locale, formatter) + return formatter +} + +function getKilometersFormatter(locale: string): Intl.NumberFormat { + const cached = kilometersFormatters.get(locale) + if (cached != null) return cached + const formatter = new Intl.NumberFormat(locale, { + style: 'unit', + unit: 'kilometer', + unitDisplay: 'short', + maximumFractionDigits: 1, + }) + kilometersFormatters.set(locale, formatter) + return formatter +} + +/** + * Below 1000m the value is shown in meters (no decimals); from 1km up it + * shifts to kilometers with one decimal. Locale controls the decimal/group + * separator (e.g. `1,2 km` in `fr-FR`, `1.2 km` in `en-GB`). + */ +export function formatDistance(meters: number, locale = 'fr-FR'): string { + if (!Number.isFinite(meters) || meters < 0) return '' + if (meters < 1000) return getMetersFormatter(locale).format(Math.round(meters)) + return getKilometersFormatter(locale).format(meters / 1000) +} diff --git a/app/shared/utils/pagination.server.test.ts b/app/shared/utils/pagination.server.test.ts index fd26247e..eb8e1825 100644 --- a/app/shared/utils/pagination.server.test.ts +++ b/app/shared/utils/pagination.server.test.ts @@ -84,4 +84,29 @@ describe('paginationFromUrl', () => { expect(result.offset).toBe(80) }) + + it('clamps an out-of-range page to the last available page', () => { + const url = new URL('http://localhost/?page=99&pageSize=10') + const result = paginationFromUrl(url, 25) + + expect(result.pages).toBe(3) + expect(result.page).toBe(3) + expect(result.offset).toBe(20) + expect(result.next).toBeNull() + }) + + it('clamps a page < 1 to page 1', () => { + const url = new URL('http://localhost/?page=-5') + const result = paginationFromUrl(url, 100) + + expect(result.page).toBe(1) + expect(result.offset).toBe(0) + }) + + it('falls back to page 1 when ?page is non-numeric', () => { + const url = new URL('http://localhost/?page=abc') + const result = paginationFromUrl(url, 100) + + expect(result.page).toBe(1) + }) }) diff --git a/app/shared/utils/pagination.server.ts b/app/shared/utils/pagination.server.ts index d385b0e7..9c57a3a7 100644 --- a/app/shared/utils/pagination.server.ts +++ b/app/shared/utils/pagination.server.ts @@ -1,8 +1,13 @@ export function paginationFromUrl(url: URL, count: number) { - const page = Number.parseInt(url.searchParams.get('page') || '1', 10) + const rawPage = Number.parseInt(url.searchParams.get('page') || '1', 10) const size = Number.parseInt(url.searchParams.get('pageSize') || '25', 10) - const offset = (page - 1) * size const pages = Math.ceil(count / size) + // Clamp to [1, pages] when there are results — protects against `?page=99` + // after a filter or geocode hit drops the total. Without this an + // out-of-range page silently rendered an empty table with no signal. + const maxPage = Math.max(1, pages) + const page = Number.isFinite(rawPage) ? Math.min(Math.max(1, rawPage), maxPage) : 1 + const offset = (page - 1) * size return { total: count, @@ -14,3 +19,20 @@ export function paginationFromUrl(url: URL, count: number) { offset, } } + +// Known sort modes. Pages may accept a subset (territory list takes +// `number | proximity`; attribution list takes `date | proximity`). Callers +// decide which mode to apply. +export type SortMode = 'number' | 'date' | 'proximity' + +/** + * Reads `?sort=` and returns it if valid, otherwise the supplied default. + * Generic over the allowed subset so callers can narrow downstream branches + * — `sortFromUrl(url, ['number', 'proximity'], 'number')` returns + * `'number' | 'proximity'` instead of the wider `SortMode`. + */ +export function sortFromUrl(url: URL, allowed: readonly A[], fallback: A): A { + const raw = url.searchParams.get('sort') + if (raw != null && (allowed as readonly string[]).includes(raw)) return raw as A + return fallback +} diff --git a/app/shared/utils/strip-diacritics.test.ts b/app/shared/utils/strip-diacritics.test.ts new file mode 100644 index 00000000..895122f1 --- /dev/null +++ b/app/shared/utils/strip-diacritics.test.ts @@ -0,0 +1,29 @@ +import { describe, expect, it } from 'vitest' +import { stripDiacritics } from './strip-diacritics' + +describe('stripDiacritics', () => { + it('lowercases ASCII input', () => { + expect(stripDiacritics('Dupont')).toBe('dupont') + }) + + it('removes French accents', () => { + expect(stripDiacritics('Päjot')).toBe('pajot') + expect(stripDiacritics('élève')).toBe('eleve') + expect(stripDiacritics('Côté')).toBe('cote') + expect(stripDiacritics('ÉTÉ')).toBe('ete') + }) + + it('keeps non-diacritic characters intact', () => { + expect(stripDiacritics("L'Hôpital-Saint-Louis")).toBe("l'hopital-saint-louis") + expect(stripDiacritics('12 rue de la Paix')).toBe('12 rue de la paix') + }) + + it('is idempotent on already-normalized strings', () => { + const normalized = stripDiacritics('Péréz') + expect(stripDiacritics(normalized)).toBe(normalized) + }) + + it('handles empty input', () => { + expect(stripDiacritics('')).toBe('') + }) +}) diff --git a/app/shared/utils/strip-diacritics.ts b/app/shared/utils/strip-diacritics.ts new file mode 100644 index 00000000..65fe9d05 --- /dev/null +++ b/app/shared/utils/strip-diacritics.ts @@ -0,0 +1,6 @@ +// Lowercases and strips diacritics so search compares against the normalized +// columns stored on Member/Building. NFD splits each accented codepoint into +// base + combining mark, then the regex drops the marks. +export function stripDiacritics(input: string): string { + return input.normalize('NFD').replace(/\p{M}/gu, '').toLowerCase() +} diff --git a/app/tests/e2e/territories-search.spec.ts b/app/tests/e2e/territories-search.spec.ts new file mode 100644 index 00000000..e3945a41 --- /dev/null +++ b/app/tests/e2e/territories-search.spec.ts @@ -0,0 +1,69 @@ +import { expect, test } from '@playwright/test' +import { login } from './helpers/auth' + +const TEST_EMAIL = process.env.E2E_USER_EMAIL ?? 'admin@unitae.test' +const TEST_PASSWORD = process.env.E2E_USER_PASSWORD ?? 'password' + +const SEARCH_PLACEHOLDER_RE = /ex\.\s/i +const SUBMIT_BUTTON_RE = /filtrer/i +const ACTIVE_FILTERS_REGION_RE = /filtres appliqués/i +const CLEAR_ALL_RE = /tout effacer/i +const TERRITORIES_URL_RE = /\/territories\/?$/ + +test.describe('Territories — unified search', () => { + test.beforeEach(async ({ page }) => { + const loggedIn = await login(page, TEST_EMAIL, TEST_PASSWORD) + if (!loggedIn) test.skip() + }) + + test('search input is present on /territories with the rotating placeholder', async ({ page }) => { + const response = await page.goto('/territories') + if (response && response.status() >= 400) test.skip() + + const searchInput = page.getByRole('textbox', { name: '' }).first() + if (!(await searchInput.isVisible({ timeout: 3000 }).catch(() => false))) test.skip() + + await expect(searchInput).toHaveAttribute('placeholder', SEARCH_PLACEHOLDER_RE) + }) + + test('submitting a search puts it on the URL and renders an active-filter chip', async ({ page }) => { + const response = await page.goto('/territories') + if (response && response.status() >= 400) test.skip() + + const searchInput = page.locator('input[name="search"]').first() + if (!(await searchInput.isVisible({ timeout: 3000 }).catch(() => false))) test.skip() + + const query = `zzqry-${Date.now()}` + await searchInput.fill(query) + await page.getByRole('button', { name: SUBMIT_BUTTON_RE }).click() + + await page.waitForURL(url => url.searchParams.get('search') === query, { timeout: 5000 }) + + const region = page.getByRole('region', { name: ACTIVE_FILTERS_REGION_RE }) + await expect(region).toBeVisible() + await expect(region.getByText(query)).toBeVisible() + }) + + test('"Tout effacer" clears every query parameter', async ({ page }) => { + await page.goto('/territories?search=pajot&page=2') + + const clearAll = page.getByRole('link', { name: CLEAR_ALL_RE }).first() + if (!(await clearAll.isVisible({ timeout: 3000 }).catch(() => false))) test.skip() + + await clearAll.click() + await page.waitForURL(url => !url.search, { timeout: 5000 }) + + await expect(page).toHaveURL(TERRITORIES_URL_RE) + }) + + test('accent-insensitive name search returns the publisher with diacritics', async ({ page }) => { + // Lightweight smoke: the loader doesn't throw and the list page renders. + // We can't assert specific data without seeding fixtures, but the rendering + // pipeline (incl. the normalized-column query) executing is the goal. + const response = await page.goto('/territories?search=jean') + if (response && response.status() >= 400) test.skip() + + await page.waitForLoadState('networkidle') + await expect(page.getByRole('main')).toBeVisible() + }) +}) diff --git a/docs/development/architecture.md b/docs/development/architecture.md index 6d32d047..41d8ccee 100644 --- a/docs/development/architecture.md +++ b/docs/development/architecture.md @@ -214,6 +214,81 @@ When not set, on-screen interactive maps are hidden, the PDF map page is skipped - Vite's SSR pipeline must bundle `@googlemaps/markerclusterer` (it ships a CommonJS main entry) — `vite.config.ts` has it in `ssr.noExternal`. - The editor's reassignment flow validates source territory + entrance link before disconnect/connect, runs everything in a single Prisma transaction, and audits each move as `EntranceReassigned` (see [Audit Logging](#audit-logging)). +## Territory Search & Geocoding + +The shared filter row on `/territories`, `/territories/attributions`, `/territories/attributions/new/available-territories`, `/territories/buildings` and `/territories/split-tool/*` is a single search input with three resolution paths: text-only, address-or-place auto-detect, and `@`-forced proximity. Each path produces a stable URL query (`?search=`, `?sort=`, `?page=`) so loaders are pure functions of the URL. + +### Diacritic-folded text search + +Names and street names are matched against **pre-normalized** lowercase + diacritic-stripped copies of the original columns, so runtime queries stay in pure Prisma `contains` (no `unaccent` extension, no raw SQL): + +- `Member.firstnameNormalized`, `Member.lastnameNormalized`, `Building.streetNormalized` are NOT NULL with `''` default. +- Maintained at write-time by `app/shared/utils/strip-diacritics.ts` (`stripDiacritics(s)` = `s.normalize('NFD').replace(/\p{M}/gu, '').toLowerCase()`) — called from every write path that touches the source columns: `createMember`, `updateMember`, `anonymizeMember`, `linkMemberToAccount`, `updateAccount`, `createBuilding`, `editBuilding`, `import-congregation`, `import-open-data`, and the marketing seed. +- The migration `20260606000000_add_normalized_search_columns` backfills pre-existing rows in pure SQL via Postgres `translate(lower(...), 'àáâã…', 'aaaa…')` — no `unaccent` extension required, runs cleanly on managed Postgres without superuser. The SQL/JS parity of the translate map is locked by `backfill-parity.integration.test.ts`. +- Composite B-tree indexes `(congregationId, *Normalized)` match the RLS-scoped `where` shape so filter queries stay on the index. + +### Address parsing + +`app/features/territories/server/address-regex.ts` exposes `addressRegex = /^(\d+\s*(bis|ter|quater)?)\s+(.+)$/` — splits `12 bis Rue de la Paix` into `[number, repeater?, street]`. Used by all three filter files (`territory-filters`, `attribution-filters`, `building-filters`) to split a leading number from the street so each piece can be matched against `Building.number` and `streetNormalized` separately, while still allowing a plain text search to fall back to `streetNormalized.contains` only. + +### Server-side geocoder + +`app/shared/infra/geocoder.server.ts` wraps `@googlemaps/google-maps-services-js`: + +- `geocode(query: string): Promise` returns `null` for empty input, missing `GOOGLE_MAPS_API_KEY`, network errors, and non-OK Google statuses (`REQUEST_DENIED`, `OVER_QUERY_LIMIT`, …). Non-OK statuses are logged at error level and **not** cached. +- Results (including `ZERO_RESULTS`) are cached in Redis under `geocode:v1:` with a 90-day TTL. Empty-string sentinel for misses. +- `Client` instance is lazy so test mocks can install before construction. +- 5-second request timeout via `params.timeout`. +- `locationType` is normalized at the boundary — unknown Google enum values (e.g. a future `PLUS_CODE`) coerce to `'OTHER'` rather than corrupting the union type. + +### Search intent classifier + +`app/features/territories/server/search-intent.server.ts` decides whether to spend an API call: + +```ts +classifySearch(raw): { freeText: string; geoQuery: string | null; forced: boolean } +``` + +- A leading `@` forces proximity (`forced: true`, `geoQuery = trimmed-after-@`); `@` alone returns `geoQuery: null, forced: true` so the UI can prompt for a place. +- Otherwise the geocoder is only called when the query has ≥3 tokens, contains a French street word (`rue|avenue|boulevard|place|chemin|impasse|allee|cours|quai|route|square|voie|pont`), or matches the address regex. Short ambiguous strings (`12`, `D012`, single-token surnames) stay text-only. + +### Distance ranking and partitioning + +`app/features/territories/server/proximity-sort.server.ts`: + +- `closestTerritoryPoint(origin, entrances)` returns the closest `BuildingEntrance.{latitude,longitude}` falling back to the parent `Building.{latitude,longitude}`. `Number.isFinite` guards reject NaN coords from open-data CSV imports. +- `paginateByProximity(items, origin, getCoords, url)` Haversine-sorts items with coords ascending, appends items without coords in their original order, and paginates the combined list using `paginationFromUrl`. +- `app/shared/utils/distance.ts` exposes `haversineMeters(a, b)` and `formatDistance(meters, locale)` — the formatter cache is keyed per locale so the loader can pass `getLocale()` from Paraglide. + +The two pagination service functions accept an optional `proximity: { origin: LatLng }`: + +- `findTerritoriesWithDetailsPaginated(db, selectors, url, congregationId, proximity?)` and `findAvailableTerritoriesPaginated(...)` fetch every matching row with the full `entrances → buildings` include shape, then partition; without `proximity` they fall back to standard `skip`/`take` Prisma pagination. +- `findActiveAttributionsPaginated(db, selectors, url, congregationId, proximity?)` does the same for attributions, joining through `Attribution.territory.entrances.buildings` to derive coords. + +### Loader wiring + +The three list routes (`territory/list.tsx`, `attributions/list.tsx`, `attributions/territories.tsx`) follow the same shape: + +1. `classifySearch(?search)` → `intent` +2. If `intent.geoQuery != null`, call `geocode(intent.geoQuery)` → `geocodeResult` +3. Default sort = `'proximity'` when `geocodeResult != null`, else `'number'` or `'date'` (per-route default); `sortFromUrl` clamps to the per-route allowlist +4. `proximityActive = geocodeResult != null && sort === 'proximity'` +5. `geocodeNotice` is the discriminated union `{ kind: 'failed', query } | { kind: 'missing-query' }` rendered by the `GeocodeNotice` component above the filters +6. The `ProximityBanner` renders whenever `geocodeResult != null` — even when the user reverted to the default sort — so the resolved address stays visible +7. The Distance column and the `Sans coordonnées` divider/banner are gated on `proximityActive` + +`paginationFromUrl` clamps the page to `[1, max(1, pages)]` so an out-of-range `?page=99` lands on the last page instead of rendering an empty table. + +### Mobile filter form + +`TerritoryFilters` / `AttributionFilters` render the advanced Selects **exactly once** inside the `
`. Visibility on small screens is a CSS toggle driven by the *Filtres avancés* button — rendering the Selects twice (one copy `max-sm:hidden`, one inside a Collapsible) caused Radix to inject duplicate hidden form inputs, and mobile submissions lost the user's choice to the desktop default. Single-render + CSS-only toggling avoids that whole class of bug. + +### Test coverage + +- Unit: `stripDiacritics`, `haversineMeters`, `formatDistance`, `classifySearch` (incl. adversarial cases — `@@`, leading whitespace, single-token street words), `paginateByProximity`, `closestTerritoryPoint` (incl. NaN/Infinity), all three filter compute functions, `paginationFromUrl` (incl. clamp), `build-filter-chips`, `geocoder.server` (mocked Redis + Google client — cache hit/miss/malformed, `ZERO_RESULTS`, non-OK status no-cache, API throw, API key forwarding, unknown `location_type` → `OTHER`). +- Integration (require live DB): `backfill-parity` (SQL ↔ JS map equivalence), `normalized-columns` (write-through for Member create/update/anonymize), `building-normalized-columns` (Building create/edit + import-update path), `proximity-loader` (full Prisma path for both service functions). +- E2E (Playwright): `territories-search.spec.ts` — search → URL → chip → *Tout effacer*. + ## PDF Generation All PDF generation runs **server-side only** using `@react-pdf/renderer`. The library references Node.js globals (`process.env`) that are unavailable in the browser — never use `PDFDownloadLink` or `PDFViewer` in client components. diff --git a/docs/product/feature-overview.md b/docs/product/feature-overview.md index b9e989d9..ace7f952 100644 --- a/docs/product/feature-overview.md +++ b/docs/product/feature-overview.md @@ -38,6 +38,7 @@ See [Display Board](display-board.md) for details. Manage the congregation's geographic territories and track assignments to publishers. - **Personal territory view** — Every member can view their assigned territories at `/me/territories` with HTML entrance cards, PDF download, and interactive map — no special role required +- **Unified search** — A single search input across every territory list handles publisher names, territory numbers, building addresses, postal codes, and neighbourhoods. Case- and accent-insensitive. Type an address (or `@Bastille`) and, with a Google Maps API key configured, the results are ranked by distance from that point — with a *Distance* column and a *Sans coordonnées* tail for territories with no geocoded address. See [Search and Filtering](territories.md#search-and-filtering) - **Territory types** — Door to door, Universities, Businesses, Phones, Hotels - **Map-driven territory editing** — When a Google Maps API key is set, managers edit a territory by clicking markers on the map (add green, remove blue, reassign grey) with an in-place address search, marker clustering, and an atomic Save that audits each cross-territory reassignment - **Attributions** — Assign territories to publishers with start, end, and late dates diff --git a/docs/product/territories.md b/docs/product/territories.md index ebeec6dc..407b736f 100644 --- a/docs/product/territories.md +++ b/docs/product/territories.md @@ -43,6 +43,44 @@ Assignment info (start date, return date with relative time, status) is shown ab Members only ever see territories they currently have an active assignment for. +## Search and Filtering + +Every territory list page — the main territory list, the attribution list, the *Available territories* picker shown when assigning a new territory, the prospection list, and the split-tool — shares the same search and filter row. + +### One search box, several intents + +A single search input recognises what you type: + +- **A name** — `Pajot` or `Pajot Jean` matches a publisher's first or last name; the result is the territories that person is currently assigned to (on the attribution list, the matching attributions). Search is case-insensitive and accent-insensitive — `pajot` matches `Päjot`, `dupont` matches `Dupond`. +- **A territory number** — `D012`, `T-42`, etc. +- **An address or part of one** — `12 rue de la Paix`, `Rue Mouffetard`, `75011`. Matches the building's number, street, and postal code. +- **A neighbourhood or place** — `Bastille`, `Montparnasse`. Treated as a place hint when long enough or when prefixed with `@`. + +You can also force the *place* interpretation explicitly by prefixing your query with `@`, for example `@Bastille`. Useful for very short place names that would otherwise be read as a publisher name. + +The little ⓘ button next to the search input opens a quick-reference popover with these examples. + +### Proximity ranking (requires Google Maps) + +When you type an address or a place name and a Google Maps API key is configured, Unitae resolves the location and **ranks the matching territories by distance** from that point: + +- A confirmation banner shows the resolved address ("Résultats à proximité de 12 Rue de la Paix, 75002 Paris"). If Google returns several possibilities, up to two *Did you mean?* chips appear so you can pick another match in one click. The same banner has an *Effacer la proximité* link to drop the geographic ranking and return to the default sort. +- A **Distance** column appears with the distance to each territory, right-aligned and formatted in metres or kilometres depending on locale. +- Territories whose addresses haven't been geo-coded yet are pushed below the ranked rows behind a *Sans coordonnées* divider, so you can still see them but won't mistake them for "the closest". On pages past the boundary, a banner at the top of the table reminds you that you're browsing the un-coord tail. +- A **sort selector** lets you flip between *Numéro / Date* and *Proximité*. Proximity is preselected the moment Google returns a result. + +Geocoded addresses are cached for 90 days — repeating the same search doesn't re-query the API. When no API key is configured, proximity ranking is silently disabled, and a small warning banner explains the fallback (text-only search still works). + +### Active filter chips + +Whenever you apply a filter (type, postal code, access type, group, status, search, etc.), the current value appears as a chip above the filter row. Each chip shows `Label : value` and a ✕ to drop *just* that filter. The chip body is not clickable — only the ✕ is — so accidentally scanning the row doesn't wipe a filter. + +A trailing *Tout effacer* chip clears every filter (including the current page) and returns the list to its default view. + +### Mobile + +On phones, the *Filtres avancés* button collapses the secondary Selects (postal code, type, access, etc.) so the search input and Submit button stay prominent. A chevron rotates when the panel opens to make the state obvious. + ## Admin Territory View The admin territory detail page is the read-only counterpart to the editor. It is laid out as stacked cards on the left with the map on the right. On large screens the map sticks to the top of the viewport while the cards scroll past it. diff --git a/docs/self-hosting/environment-variables.md b/docs/self-hosting/environment-variables.md index fe6f1671..74c922c1 100644 --- a/docs/self-hosting/environment-variables.md +++ b/docs/self-hosting/environment-variables.md @@ -72,12 +72,12 @@ By default, uploaded files are stored on the local filesystem. Set `S3_ENDPOINT` | Variable | Default | Description | |----------|---------|-------------| -| `GOOGLE_MAPS_API_KEY` | — | Google Maps API key. Enables maps on territory pages, in PDF exports, and the visual drawing editor on the *Carte de l'assemblée* settings page | +| `GOOGLE_MAPS_API_KEY` | — | Google Maps API key. Enables maps on territory pages, in PDF exports, the visual drawing editor on the *Carte de l'assemblée* settings page, and **proximity ranking in the territory/attribution search** (typing an address ranks the matching territories by distance) | | `GOOGLE_MAPS_MAP_ID` | — | Google Maps Map ID for custom styled maps. Requires `GOOGLE_MAPS_API_KEY` | -The API key needs the **Maps JavaScript API**, **Maps Static API**, and **Drawing Library** enabled in the Google Cloud Console. +The API key needs the **Maps JavaScript API**, **Maps Static API**, **Drawing Library**, and **Geocoding API** enabled in the Google Cloud Console. The Geocoding API powers the proximity search; geocoded addresses are cached in Redis for 90 days so repeat searches don't re-query the API. -When `GOOGLE_MAPS_API_KEY` is not set, on-screen interactive maps are hidden, the PDF map page is skipped, and the *Carte de l'assemblée* page falls back to the GeoJSON import/export workflow only — assemblies can still author their map in an external tool (geojson.io, Google My Maps, QGIS) and paste the result. +When `GOOGLE_MAPS_API_KEY` is not set, on-screen interactive maps are hidden, the PDF map page is skipped, the *Carte de l'assemblée* page falls back to the GeoJSON import/export workflow only — assemblies can still author their map in an external tool (geojson.io, Google My Maps, QGIS) and paste the result — and the proximity ranking in the territory search degrades silently to text-only matches. ## Docker Compose diff --git a/docs/self-hosting/requirements.md b/docs/self-hosting/requirements.md index 8d5339e4..f148ed6a 100644 --- a/docs/self-hosting/requirements.md +++ b/docs/self-hosting/requirements.md @@ -47,7 +47,7 @@ All other dependencies (Node.js, PostgreSQL, Redis) are included in the Docker i - **Outbound HTTPS** (optional, depending on features used): - BANO open data servers — for building address sync - Resend API (`api.resend.com`) — for email notifications - - Google Maps APIs (`maps.googleapis.com`) — for territory maps + - Google Maps APIs (`maps.googleapis.com`) — for territory maps and proximity search geocoding ## Reverse Proxy diff --git a/package.json b/package.json index 0c505870..422a888c 100644 --- a/package.json +++ b/package.json @@ -39,6 +39,7 @@ "@dnd-kit/core": "^6.3.1", "@dnd-kit/sortable": "^10.0.0", "@dnd-kit/utilities": "^3.2.2", + "@googlemaps/google-maps-services-js": "^3.4.2", "@googlemaps/markerclusterer": "^2.6.2", "@inlang/paraglide-js": "^2.18.2", "@mjackson/form-data-parser": "^0.9.1", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index f0ea6820..3a9309fd 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -30,6 +30,9 @@ importers: '@dnd-kit/utilities': specifier: ^3.2.2 version: 3.2.2(react@19.2.7) + '@googlemaps/google-maps-services-js': + specifier: ^3.4.2 + version: 3.4.2 '@googlemaps/markerclusterer': specifier: ^2.6.2 version: 2.6.2 @@ -950,12 +953,18 @@ packages: '@floating-ui/utils@0.2.11': resolution: {integrity: sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==} + '@googlemaps/google-maps-services-js@3.4.2': + resolution: {integrity: sha512-QjxiJSt8woyPaaQIUUDNL1nRfCEXTiv8KfJSNq/YzKEUVXABT75GLG+Zo267UwOcq70n8OsZbaro5VrY962mJg==} + '@googlemaps/js-api-loader@2.0.2': resolution: {integrity: sha512-bKVuTqatS8Jven5aFqVB7rCHF1VFEzpzyi0ruzO0GUR+A7m9oMqMgtnmpANj7kMYEvvhty8Fk7TnJ1MKjWHu+Q==} '@googlemaps/markerclusterer@2.6.2': resolution: {integrity: sha512-U6uVhq8iWhiIckA89sgRu8OK35mjd6/3CuoZKWakKEf0QmRRWpatlsPb3kqXkoWSmbcZkopRiI4dnW6DQSd7bQ==} + '@googlemaps/url-signature@1.0.40': + resolution: {integrity: sha512-Gme3JxGZWQ4NVpATajSpS2/inQzhUxRvr/FK6IFpcC7AHOAmx8blI0y1/Qi2jqil+WoQ3TkEqq/MaKVtuV68RQ==} + '@hono/node-server@1.19.11': resolution: {integrity: sha512-dr8/3zEaB+p0D2n/IUrlPF1HZm586qgJNXK1a9fhg/PzdtkK7Ksd5l312tJX2yBuALqDYBlG20QEbayqPyxn+g==} engines: {node: '>=18.14.1'} @@ -2740,10 +2749,18 @@ packages: engines: {node: '>=0.4.0'} hasBin: true + agent-base@6.0.2: + resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} + engines: {node: '>= 6.0.0'} + agent-base@7.1.4: resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==} engines: {node: '>= 14'} + agentkeepalive@4.6.0: + resolution: {integrity: sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==} + engines: {node: '>= 8.0.0'} + ajv-formats@3.0.1: resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==} peerDependencies: @@ -2828,6 +2845,9 @@ packages: async@3.2.6: resolution: {integrity: sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==} + asynckit@0.4.0: + resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} + atomically@2.1.1: resolution: {integrity: sha512-P4w9o2dqARji6P7MHprklbfiArZAWvo07yW7qs3pdljb3BWr12FIB7W+p0zJiuiVsUpRO0iZn1kFFcpPegg0tQ==} @@ -2839,6 +2859,9 @@ packages: resolution: {integrity: sha512-NZKeq9AfyQvEeNlN0zSYAaWrmBffJh3IELMZfRpJVWgrpEbtEpnjvzqBPf+mxoI287JohRDoa+/nsfqqiZmF6g==} engines: {node: '>= 6.0.0'} + axios@1.17.0: + resolution: {integrity: sha512-J8SwNxprqqpbfenehxWYXE7CW+wM1BB4w3+N+g+/Wx40xM4rsLrfPmHHxSWIxJLYDgSY/HqlFPIYb2/S3rxafw==} + babel-dead-code-elimination@1.0.12: resolution: {integrity: sha512-GERT7L2TiYcYDtYk1IpD+ASAYXjKbLTDPhBtYj7X1NuRMDTMtAx9kyBenub1Ev41lo91OHCKdmP+egTDmfQ7Ig==} @@ -3091,6 +3114,10 @@ packages: resolution: {integrity: sha512-ezmVcLR3xAVp8kYOm4GS45ZLLgIE6SPAFoduLr6hTDajwb3KZ2F46gulK3XpcwRFb5KKGCSezCBAY4Dw4HsyXA==} engines: {node: '>=18'} + combined-stream@1.0.8: + resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} + engines: {node: '>= 0.8'} + commander@11.1.0: resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==} engines: {node: '>=16'} @@ -3200,6 +3227,9 @@ packages: resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} engines: {node: '>= 8'} + crypto-js@4.2.0: + resolution: {integrity: sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==} + css-tree@3.2.1: resolution: {integrity: sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==} engines: {node: ^10 || ^12.20.0 || ^14.13.0 || >=15.0.0} @@ -3324,6 +3354,10 @@ packages: decimal.js-light@2.5.1: resolution: {integrity: sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==} + decode-uri-component@0.2.2: + resolution: {integrity: sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==} + engines: {node: '>=0.10'} + decompress-response@6.0.0: resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==} engines: {node: '>=10'} @@ -3382,6 +3416,10 @@ packages: defu@6.1.7: resolution: {integrity: sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==} + delayed-stream@1.0.0: + resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} + engines: {node: '>=0.4.0'} + denque@2.1.0: resolution: {integrity: sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==} engines: {node: '>=0.10'} @@ -3791,6 +3829,10 @@ packages: resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} engines: {node: '>=8'} + filter-obj@1.1.0: + resolution: {integrity: sha512-8rXg1ZnX7xzy2NGDVkBVaAy+lSlPNwad13BtgSlLuxfIslyt5Vg64U7tFcCt4WS1R0hvtnQybT/IyCkGZ3DpXQ==} + engines: {node: '>=0.10.0'} + finalhandler@1.3.2: resolution: {integrity: sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==} engines: {node: '>= 0.8'} @@ -3813,6 +3855,15 @@ packages: fn.name@1.1.0: resolution: {integrity: sha512-GRnmB5gPyJpAhTQdSZTSp9uaPSvl09KoYcMQtsB9rQoOmzs9dH6ffeccH+Z+cv6P68Hu5bC6JjRh4Ah/mHSNRw==} + follow-redirects@1.16.0: + resolution: {integrity: sha512-y5rN/uOsadFT/JfYwhxRS5R7Qce+g3zG97+JrtFZlC9klX/W5hD7iiLzScI4nZqUS7DNUdhPgw4xI8W2LuXlUw==} + engines: {node: '>=4.0'} + peerDependencies: + debug: '*' + peerDependenciesMeta: + debug: + optional: true + fontkit@2.0.4: resolution: {integrity: sha512-syetQadaUEDNdxdugga9CpEYVaQIxOwk7GlwZWWZ19//qW4zE5bknOKeMBDYAASwnpaSHKJITRLMF9m1fp3s6g==} @@ -3824,6 +3875,10 @@ packages: resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==} engines: {node: '>=14'} + form-data@4.0.5: + resolution: {integrity: sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==} + engines: {node: '>= 6'} + formdata-polyfill@4.0.10: resolution: {integrity: sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==} engines: {node: '>=12.20.0'} @@ -4046,6 +4101,10 @@ packages: http-status-codes@2.3.0: resolution: {integrity: sha512-RJ8XvFvpPM/Dmc5SV+dC4y5PCeOhT3x1Hq0NU3rjGeg5a/CqlhZ7uudknPwZFz4aeAXDcbAyaeP7GAo9lvngtA==} + https-proxy-agent@5.0.1: + resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} + engines: {node: '>= 6'} + https-proxy-agent@7.0.6: resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==} engines: {node: '>= 14'} @@ -4062,6 +4121,9 @@ packages: resolution: {integrity: sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==} engines: {node: '>=18.18.0'} + humanize-ms@1.2.1: + resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==} + hyphen@1.14.1: resolution: {integrity: sha512-kvL8xYl5QMTh+LwohVN72ciOxC0OEV79IPdJSTwEXok9y9QHebXGdFgrED4sWfiax/ODx++CAMk3hMy4XPJPOw==} @@ -5183,6 +5245,10 @@ packages: resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} engines: {node: '>= 0.10'} + proxy-from-env@2.1.0: + resolution: {integrity: sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==} + engines: {node: '>=10'} + pump@3.0.4: resolution: {integrity: sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==} @@ -5197,6 +5263,10 @@ packages: resolution: {integrity: sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw==} engines: {node: '>=0.6'} + query-string@7.1.3: + resolution: {integrity: sha512-hh2WYhq4fi8+b+/2Kg9CEge4fDPvHS534aOOvOZeQ3+Vf2mCFsaFBYj0i+iXcAq6I9Vzp5fjMFBlONvayDC1qg==} + engines: {node: '>=6'} + queue-microtask@1.2.3: resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} @@ -5407,6 +5477,12 @@ packages: restructure@3.0.2: resolution: {integrity: sha512-gSfoiOEA0VPE6Tukkrr7I0RBdE0s7H1eFCDBk05l1KIQT1UIKNc5JZy6jdyW6eYH3aR3g5b3PuL77rq0hvwtAw==} + retry-axios@2.6.0: + resolution: {integrity: sha512-pOLi+Gdll3JekwuFjXO3fTq+L9lzMQGcSq7M5gIjExcl3Gu1hd4XXuf5o3+LuSBsaULQH7DiNbsqPd1chVpQGQ==} + engines: {node: '>=10.7.0'} + peerDependencies: + axios: '*' + retry@0.12.0: resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==} engines: {node: '>= 4'} @@ -5614,6 +5690,10 @@ packages: resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} engines: {node: '>=0.10.0'} + split-on-first@1.1.0: + resolution: {integrity: sha512-43ZssAJaMusuKWL8sKUBQXHWOpq8d6CfN/u1p4gUzfJkM05C8rxTmYrkIPTXapZpORA6LkkzcUulJ8FqA7Uudw==} + engines: {node: '>=6'} + split2@4.2.0: resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==} engines: {node: '>= 10.x'} @@ -5663,6 +5743,10 @@ packages: strict-event-emitter@0.5.1: resolution: {integrity: sha512-vMgjE/GGEPEFnhFub6pa4FmJBRBVOLpIII2hvCZ8Kzb7K0hlHo7mQv6xYrBvCL2LtAIBwFUK8wvuJgTVSQ5MFQ==} + strict-uri-encode@2.0.0: + resolution: {integrity: sha512-QwiXZgpRcKkhTj2Scnn++4PKtWsH0kpzZ62L2R6c/LUVYv7hVnZqcg2+sMuT6R7Jusu1vviK/MFsu6kNJfWlEQ==} + engines: {node: '>=4'} + string-width@4.2.3: resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} engines: {node: '>=8'} @@ -7096,6 +7180,17 @@ snapshots: '@floating-ui/utils@0.2.11': {} + '@googlemaps/google-maps-services-js@3.4.2': + dependencies: + '@googlemaps/url-signature': 1.0.40 + agentkeepalive: 4.6.0 + axios: 1.17.0 + query-string: 7.1.3 + retry-axios: 2.6.0(axios@1.17.0) + transitivePeerDependencies: + - debug + - supports-color + '@googlemaps/js-api-loader@2.0.2': dependencies: '@types/google.maps': 3.65.1 @@ -7106,6 +7201,10 @@ snapshots: fast-equals: 5.4.0 supercluster: 8.0.1 + '@googlemaps/url-signature@1.0.40': + dependencies: + crypto-js: 4.2.0 + '@hono/node-server@1.19.11(hono@4.12.14)': dependencies: hono: 4.12.14 @@ -8942,8 +9041,18 @@ snapshots: acorn@8.16.0: {} + agent-base@6.0.2: + dependencies: + debug: 4.4.3 + transitivePeerDependencies: + - supports-color + agent-base@7.1.4: {} + agentkeepalive@4.6.0: + dependencies: + humanize-ms: 1.2.1 + ajv-formats@3.0.1(ajv@8.20.0): optionalDependencies: ajv: 8.20.0 @@ -9051,6 +9160,8 @@ snapshots: async@3.2.6: {} + asynckit@0.4.0: {} + atomically@2.1.1: dependencies: stubborn-fs: 2.0.0 @@ -9062,6 +9173,16 @@ snapshots: aws-ssl-profiles@1.1.2: {} + axios@1.17.0: + dependencies: + follow-redirects: 1.16.0 + form-data: 4.0.5 + https-proxy-agent: 5.0.1 + proxy-from-env: 2.1.0 + transitivePeerDependencies: + - debug + - supports-color + babel-dead-code-elimination@1.0.12: dependencies: '@babel/core': 7.29.7 @@ -9336,6 +9457,10 @@ snapshots: color-convert: 3.1.3 color-string: 2.1.4 + combined-stream@1.0.8: + dependencies: + delayed-stream: 1.0.0 + commander@11.1.0: {} commander@13.1.0: {} @@ -9441,6 +9566,8 @@ snapshots: shebang-command: 2.0.0 which: 2.0.2 + crypto-js@4.2.0: {} + css-tree@3.2.1: dependencies: mdn-data: 2.27.1 @@ -9543,6 +9670,8 @@ snapshots: decimal.js-light@2.5.1: {} + decode-uri-component@0.2.2: {} + decompress-response@6.0.0: dependencies: mimic-response: 3.1.0 @@ -9584,6 +9713,8 @@ snapshots: defu@6.1.7: {} + delayed-stream@1.0.0: {} + denque@2.1.0: {} depd@2.0.0: {} @@ -10200,6 +10331,8 @@ snapshots: dependencies: to-regex-range: 5.0.1 + filter-obj@1.1.0: {} + finalhandler@1.3.2: dependencies: debug: 2.6.9 @@ -10237,6 +10370,8 @@ snapshots: fn.name@1.1.0: {} + follow-redirects@1.16.0: {} + fontkit@2.0.4: dependencies: '@swc/helpers': 0.5.21 @@ -10258,6 +10393,14 @@ snapshots: cross-spawn: 7.0.6 signal-exit: 4.1.0 + form-data@4.0.5: + dependencies: + asynckit: 0.4.0 + combined-stream: 1.0.8 + es-set-tostringtag: 2.1.0 + hasown: 2.0.3 + mime-types: 2.1.35 + formdata-polyfill@4.0.10: dependencies: fetch-blob: 3.2.0 @@ -10475,6 +10618,13 @@ snapshots: http-status-codes@2.3.0: {} + https-proxy-agent@5.0.1: + dependencies: + agent-base: 6.0.2 + debug: 4.4.3 + transitivePeerDependencies: + - supports-color + https-proxy-agent@7.0.6: dependencies: agent-base: 7.1.4 @@ -10488,6 +10638,10 @@ snapshots: human-signals@8.0.1: {} + humanize-ms@1.2.1: + dependencies: + ms: 2.1.3 + hyphen@1.14.1: {} ical-generator@10.2.0(@types/node@25.9.2)(dayjs@1.11.13)(luxon@3.7.2): @@ -11487,6 +11641,8 @@ snapshots: forwarded: 0.2.0 ipaddr.js: 1.9.1 + proxy-from-env@2.1.0: {} + pump@3.0.4: dependencies: end-of-stream: 1.4.5 @@ -11501,6 +11657,13 @@ snapshots: dependencies: side-channel: 1.1.0 + query-string@7.1.3: + dependencies: + decode-uri-component: 0.2.2 + filter-obj: 1.1.0 + split-on-first: 1.1.0 + strict-uri-encode: 2.0.0 + queue-microtask@1.2.3: {} queue@6.0.2: @@ -11802,6 +11965,10 @@ snapshots: restructure@3.0.2: {} + retry-axios@2.6.0(axios@1.17.0): + dependencies: + axios: 1.17.0 + retry@0.12.0: {} rettime@0.11.11: {} @@ -12148,6 +12315,8 @@ snapshots: source-map@0.6.1: {} + split-on-first@1.1.0: {} + split2@4.2.0: {} sqlite-wasm-kysely@0.3.0(kysely@0.28.17): @@ -12185,6 +12354,8 @@ snapshots: strict-event-emitter@0.5.1: {} + strict-uri-encode@2.0.0: {} + string-width@4.2.3: dependencies: emoji-regex: 8.0.0