Exclude observations at lat/long 0,0 from all loads and exports (#149) (#152)

* fix(data): filter out observations at lat/long 0,0 from all loads

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* test(export): guard 0,0 exclusion at serialization boundary

Add defense-in-depth 0,0 filtering in observationsToGeoJson and
observationsToCsv so the export serializers drop null-island
observations even if called with an unfiltered source list. Also guard
the by-id getObservation read for consistency with the read-layer
filter from #149.

* refactor(coords): extract isZeroZeroCoord and cover single-zero case

Extract the duplicated !(lat === 0 && lon === 0) predicate into a single
isZeroZeroCoord helper in src/lib/coords.ts, replacing 4 inline copies
across local-repositories.ts (repoGetObservations filter + getObservation
guard) and observation-export.ts (observationsToGeoJson + observationsToCsv
filters).

Add regression tests asserting that real observations on the equator
(lat: 0, lon: -60) or prime meridian (lat: 45, lon: 0) are KEPT — only an
exact 0,0 is excluded. This guards against over-filtering that would drop
legitimate single-zero-coordinate observations.

* refactor(data): drop singular getObservation 0,0 guard

The plural repoGetObservations filter already excludes 0,0 from all
list/map/export reads, so the singular by-id guard was dead code with
zero production callers. It also introduced an 'exists but hidden'
contract (record in Dexie reported as not-found) with no test coverage,
conflicting with the repo's TDD cycle. Reverting keeps the single
source-of-truth filter and closes both pre-merge review nits.

Flagged by Kimi K3 via the production 'PR Review for Merge Readiness'
Langfuse prompt against PR #152.

* fix(storage): exclude 0,0 observations from storage count

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: 3 people

src/lib/coords.ts

@@ -8,3 +8,19 @@ export function isValidCoord(lat: number, lon: number): boolean {
     lon <= 180
   );
 }
+
+/**
+ * Returns true only when BOTH lat and lon are exactly 0.
+ *
+ * This is used to exclude observations at the (0, 0) "null island"
+ * coordinate, which is almost always a sentinel for "no location" rather
+ * than a real observation. A real observation on the equator
+ * (`lat: 0, lon: -60`) or on the prime meridian (`lat: 45, lon: 0`) is
+ * NOT a zero-zero coordinate and must be kept.
+ */
+export function isZeroZeroCoord(
+  lat: number | undefined,
+  lon: number | undefined,
+): boolean {
+  return lat === 0 && lon === 0;
+}

src/lib/local-repositories.ts

@@ -1,3 +1,4 @@
+import { isZeroZeroCoord } from '@/lib/coords';
 import { getDb } from '@/lib/db';
 import type {
   Alert,
@@ -167,6 +168,7 @@ export async function getObservations(
       .where('projectLocalId')
       .equals(projectLocalId)
       .filter((o) => !o.deleted)
+      .filter((o) => !isZeroZeroCoord(o.lat, o.lon))
       .toArray();
   });
 }
@@ -176,7 +178,8 @@ export async function getObservation(
 ): Promise<Observation | undefined> {
   return wrapDb(async () => {
     const db = getDb();
-    return db.observations.get(localId);
+    const observation = await db.observations.get(localId);
+    return observation;
   });
 }
 

src/lib/observation-export.ts

@@ -1,6 +1,6 @@
 import type { Feature, FeatureCollection, Point } from 'geojson';
 
-import { isValidCoord } from '@/lib/coords';
+import { isValidCoord, isZeroZeroCoord } from '@/lib/coords';
 import type { Attachment, Field, FieldOption, Observation } from '@/lib/db';
 
 export type ExportFormat = 'geojson' | 'csv';
@@ -47,32 +47,34 @@ export function observationsToGeoJson(
   observations: Observation[],
   context: ObservationExportContext = {},
 ): FeatureCollection {
-  const features: Array<Feature<Point | null>> = observations.map((obs) => {
-    const hasValidCoords =
-      obs.lat !== undefined &&
-      obs.lon !== undefined &&
-      isValidCoord(obs.lat, obs.lon);
-
-    const tags = buildExportTags(obs, context);
-
-    return {
-      type: 'Feature' as const,
-      geometry: hasValidCoords
-        ? { type: 'Point' as const, coordinates: [obs.lon!, obs.lat!] }
-        : null,
-      properties: {
-        ...tags,
-        docId: obs.localId,
-        remoteId: obs.remoteId,
-        category:
-          context.displayNamesByObservationId?.get(obs.localId) ??
-          tags.category,
-        presetRefDocId: obs.presetRefDocId ?? tags.presetRefDocId,
-        createdAt: obs.createdAt,
-        updatedAt: obs.updatedAt,
-      },
-    };
-  });
+  const features: Array<Feature<Point | null>> = observations
+    .filter((o) => !isZeroZeroCoord(o.lat, o.lon))
+    .map((obs) => {
+      const hasValidCoords =
+        obs.lat !== undefined &&
+        obs.lon !== undefined &&
+        isValidCoord(obs.lat, obs.lon);
+
+      const tags = buildExportTags(obs, context);
+
+      return {
+        type: 'Feature' as const,
+        geometry: hasValidCoords
+          ? { type: 'Point' as const, coordinates: [obs.lon!, obs.lat!] }
+          : null,
+        properties: {
+          ...tags,
+          docId: obs.localId,
+          remoteId: obs.remoteId,
+          category:
+            context.displayNamesByObservationId?.get(obs.localId) ??
+            tags.category,
+          presetRefDocId: obs.presetRefDocId ?? tags.presetRefDocId,
+          createdAt: obs.createdAt,
+          updatedAt: obs.updatedAt,
+        },
+      };
+    });
 
   return {
     type: 'FeatureCollection',
@@ -119,32 +121,34 @@ export function observationsToCsv(
   const header = CSV_COLUMNS.join(',');
   if (observations.length === 0) return header;
 
-  const rows = observations.map((obs) => {
-    const tags = buildExportTags(obs, context);
-    const photoUrls = tags.photoUrls ?? '';
-    const category =
-      context.displayNamesByObservationId?.get(obs.localId) ??
-      tags.category ??
-      '';
-
-    const hasValidCoords =
-      obs.lat !== undefined &&
-      obs.lon !== undefined &&
-      isValidCoord(obs.lat, obs.lon);
-
-    const values: string[] = [
-      csvEscape(obs.localId),
-      csvEscape(category),
-      hasValidCoords ? String(obs.lat) : '',
-      hasValidCoords ? String(obs.lon) : '',
-      csvEscape(obs.createdAt),
-      csvEscape(obs.updatedAt),
-      csvEscape(JSON.stringify(tags)),
-      csvEscape(photoUrls),
-    ];
-
-    return values.join(',');
-  });
+  const rows = observations
+    .filter((o) => !isZeroZeroCoord(o.lat, o.lon))
+    .map((obs) => {
+      const tags = buildExportTags(obs, context);
+      const photoUrls = tags.photoUrls ?? '';
+      const category =
+        context.displayNamesByObservationId?.get(obs.localId) ??
+        tags.category ??
+        '';
+
+      const hasValidCoords =
+        obs.lat !== undefined &&
+        obs.lon !== undefined &&
+        isValidCoord(obs.lat, obs.lon);
+
+      const values: string[] = [
+        csvEscape(obs.localId),
+        csvEscape(category),
+        hasValidCoords ? String(obs.lat) : '',
+        hasValidCoords ? String(obs.lon) : '',
+        csvEscape(obs.createdAt),
+        csvEscape(obs.updatedAt),
+        csvEscape(JSON.stringify(tags)),
+        csvEscape(photoUrls),
+      ];
+
+      return values.join(',');
+    });
 
   return [header, ...rows].join('\n');
 }

src/lib/storage.ts

@@ -1,3 +1,4 @@
+import { isZeroZeroCoord } from '@/lib/coords';
 import { getDb } from '@/lib/db';
 
 // ---------------------------------------------------------------------------
@@ -67,7 +68,7 @@ export async function getStorageStats(): Promise<StorageStats> {
     syncMetadata,
   ] = await Promise.all([
     db.projects.count(),
-    db.observations.count(),
+    db.observations.filter((o) => !isZeroZeroCoord(o.lat, o.lon)).count(),
     db.alerts.count(),
     db.presets.count(),
     db.attachments.count(),

tests/unit/lib/data-layer-points.test.ts

@@ -116,6 +116,32 @@ describe('getProjectPoints', () => {
     const featureCollection = await getProjectPoints(project.localId);
     expect(featureCollection.features).toHaveLength(0);
   });
+
+  it('filters out observations at lat/lon 0,0', async () => {
+    const project = await createProject({ name: 'Test' });
+
+    await createObservation({
+      projectLocalId: project.localId,
+      lat: -3.1,
+      lon: -60.5,
+    });
+    await createObservation({
+      projectLocalId: project.localId,
+      lat: 0,
+      lon: 0,
+    });
+    await createObservation({
+      projectLocalId: project.localId,
+    });
+
+    const featureCollection = await getProjectPoints(project.localId);
+
+    // Should only include the valid observation, not the 0,0 or the one without coords
+    expect(featureCollection.features).toHaveLength(1);
+    expect(featureCollection.features[0]!.geometry.coordinates).toEqual([
+      -60.5, -3.1,
+    ]);
+  });
 });
 
 describe('importGeoJsonPoints', () => {

tests/unit/lib/local-repositories-fns.test.ts

@@ -259,6 +259,76 @@ describe('local-repositories functions — observations', () => {
       expect((err as DbError).code).toBe('FK_VIOLATION');
     }
   });
+
+  it('getObservations — filters out observations at lat/lon 0,0', async () => {
+    const project = await createProject({ name: 'FilterZeroZero' });
+
+    // Create valid observation
+    await createObservation({
+      projectLocalId: project.localId,
+      lat: -3.1,
+      lon: -60.5,
+    });
+
+    // Create 0,0 observation (should be filtered)
+    await createObservation({
+      projectLocalId: project.localId,
+      lat: 0,
+      lon: 0,
+    });
+
+    // Create observation with no coords (should be kept)
+    await createObservation({
+      projectLocalId: project.localId,
+    });
+
+    const observations = await getObservations(project.localId);
+
+    // Should only get the valid observation and the one without coords
+    expect(observations).toHaveLength(2);
+
+    // Verify the 0,0 observation is not in the results
+    const hasZeroZero = observations.some((o) => o.lat === 0 && o.lon === 0);
+    expect(hasZeroZero).toBe(false);
+
+    // Verify we have the valid observation
+    const hasValid = observations.some(
+      (o) => o.lat === -3.1 && o.lon === -60.5,
+    );
+    expect(hasValid).toBe(true);
+
+    // Verify we have the observation without coords
+    const hasNoCoords = observations.some(
+      (o) => o.lat === undefined && o.lon === undefined,
+    );
+    expect(hasNoCoords).toBe(true);
+  });
+
+  it('getObservations — keeps observations with a single zero coordinate (equator)', async () => {
+    const project = await createProject({ name: 'SingleZero' });
+
+    // A real observation on the equator (lat: 0, lon: -60) — must be KEPT
+    await createObservation({
+      projectLocalId: project.localId,
+      lat: 0,
+      lon: -60,
+    });
+
+    // A normal observation
+    await createObservation({
+      projectLocalId: project.localId,
+      lat: -3.1,
+      lon: -60.5,
+    });
+
+    const observations = await getObservations(project.localId);
+
+    // Both observations are returned — only an exact 0,0 is excluded
+    expect(observations).toHaveLength(2);
+
+    const hasEquator = observations.some((o) => o.lat === 0 && o.lon === -60);
+    expect(hasEquator).toBe(true);
+  });
 });
 
 // ---------------------------------------------------------------------------