fix: Feature/mapco 10524 2

src/dal/repositories/layerDataRepository.ts

@@ -1,6 +1,7 @@
 import { trace } from '@opentelemetry/api';
 import { asyncCallWithSpan } from '@map-colonies/tracing-utils';
 import type { ObjectLiteral, Repository } from 'typeorm';
+import type { Logger } from '@map-colonies/js-logger';
 import type { LayerObject } from '../entities';
 import { LayerObjectEntity } from '../entities';
 import { getDataSource } from '../connection';
@@ -12,7 +13,17 @@ function getRepository(): Repository<LayerObjectEntity> {
   return getDataSource().getRepository(LayerObjectEntity);
 }
 
-export async function insertObjects(layerName: string, objects: LayerObject[]): Promise<void> {
+async function insertRow(layerName: string, object: LayerObject): Promise<void> {
+  await getRepository()
+    .createQueryBuilder()
+    .insert()
+    .into(LayerObjectEntity)
+    .values({ layerName, id: object.id, geom: object.geom, properties: object.properties } as unknown as ObjectLiteral)
+    .orIgnore()
+    .execute();
+}
+
+export async function insertObjects(logger: Logger, layerName: string, objects: LayerObject[]): Promise<void> {
   if (objects.length === 0) return;
 
   const rows = objects.map((o) => ({
@@ -24,13 +35,31 @@ export async function insertObjects(layerName: string, objects: LayerObject[]):
 
   await asyncCallWithSpan(
     async () => {
-      await getRepository()
-        .createQueryBuilder()
-        .insert()
-        .into(LayerObjectEntity)
-        .values(rows as unknown as ObjectLiteral[])
-        .orIgnore()
-        .execute();
+      try {
+        await getRepository()
+          .createQueryBuilder()
+          .insert()
+          .into(LayerObjectEntity)
+          .values(rows as unknown as ObjectLiteral[])
+          .orIgnore()
+          .execute();
+      } catch (batchErr) {
+        logger.warn({ msg: 'Batch insert failed, falling back to per-object inserts', layerName, count: objects.length, err: batchErr });
+        for (const object of objects) {
+          try {
+            await insertRow(layerName, object);
+          } catch (err) {
+            logger.error({
+              msg: 'Insert failed for object, skipping',
+              layerName,
+              id: object.id,
+              geom: object.geom,
+              properties: object.properties,
+              err,
+            });
+          }
+        }
+      }
     },
     tracer,
     'layerDataRepository.insertObjects'

src/handler/layerSyncHandler.ts

@@ -25,7 +25,7 @@ export async function fetchAndSyncLayerPage(logger: Logger, entry: ScheduleEntry
 
         if (response.objects.length > 0) {
           logger.info(`Inserting ${response.objects.length} new objects into layer "${entry.layerName}"`);
-          await layerDataRepository.insertObjects(entry.layerName, response.objects);
+          await layerDataRepository.insertObjects(logger, entry.layerName, response.objects);
         }
 
         if (response.deletedIds.length > 0) {

tests/unit/handler/layerSyncHandler.spec.ts

@@ -99,7 +99,7 @@ describe('layerSyncHandler', () => {
       await fetchAndSyncLayerPage(makeLogger(), entry);
 
       expect(layerClient.fetchPage).toHaveBeenCalledWith(expect.anything(), 'obstacles', '5');
-      expect(layerDataRepository.insertObjects).toHaveBeenCalledWith('obstacles', objects);
+      expect(layerDataRepository.insertObjects).toHaveBeenCalledWith(expect.anything(), 'obstacles', objects);
       expect(layerDataRepository.deleteDeprecatedObjects).toHaveBeenCalledWith('obstacles', ['old-1']);
       expect(syncStateRepository.updateSequence).toHaveBeenCalledWith('obstacles', '10');
     });