adding the option to add upstream ids to event tabels in xlsx templat…

…e (as relatedEntity with some role)

.changeset/nine-otters-wait.md

@@ -0,0 +1,5 @@
+---
+"@intavia/data-import": patch
+---
+
+adding the option to add upstream ids to event tabels in xlsx template (as relatedEntity with some role)

package.json

@@ -28,6 +28,7 @@
     },
     "dependencies": {
         "@intavia/api-client": "^0.1.25",
+        "buffer": "^6.0.3",
         "lodash.isequal": "^4.5.0",
         "xlsx": "^0.18.5"
     },

src/config.ts

@@ -32,7 +32,6 @@ export const eventTargetProps: Array<string> = [
     "source",
     "startDate",
     "endDate",
-    "relations",
 ];
 
 export const biographyTargetProps: Array<string> = ["id", "text", "citation"];

src/create-event.ts

@@ -9,10 +9,12 @@ import type {
 import { eventTargetProps } from "./config";
 import { eventPropertyMappers } from "./data-mappers";
 import type { UnmappedProps, VocabularyIdAndEntry } from "./types";
+import { Buffer } from "buffer";
 
 interface CreateEventReturn {
     event: Event;
     vocabularyEntries?: Array<VocabularyIdAndEntry>;
+    upstreamEntities?: Array<Entity["id"]>;
     unmappedProperties?: UnmappedProps;
 }
 
@@ -28,6 +30,7 @@ export function createEvent(entry: Record<string, unknown>): CreateEventReturn {
 
     const event: any = {};
     const vocabularyEntries: Array<VocabularyIdAndEntry> = [];
+    const upstreamEntities: Array<Entity["id"]> = [];
 
     for (const targetProp of targetProps) {
         if (!(targetProp in eventPropertyMappers)) {
@@ -65,6 +68,19 @@ export function createEvent(entry: Record<string, unknown>): CreateEventReturn {
         }
     }
 
+    // eventEntityRelation
+    const {
+        eventEntityRelation,
+        vocabularyEntries: _vocabularyEntries,
+        upstreamEntities: _upstreamEntities,
+    } = createEventEntityRelation(entry);
+    if (!("relations" in event)) {
+        event.relations = [];
+    }
+    eventEntityRelation !== undefined && event.relations.push(eventEntityRelation);
+    _vocabularyEntries !== undefined && vocabularyEntries.push(..._vocabularyEntries);
+    _upstreamEntities !== undefined && upstreamEntities.push(..._upstreamEntities);
+
     // has Place ? add additional EventEntityRelation
     if (entry.place != null && String(entry.place).trim().length > 0) {
         for (const place of String(entry.place).split(";")) {
@@ -97,13 +113,15 @@ export function createEvent(entry: Record<string, unknown>): CreateEventReturn {
     return {
         event,
         vocabularyEntries,
+        upstreamEntities,
         unmappedProperties,
     };
 }
 
 interface CreateEventEntityRelationReturn {
     eventEntityRelation?: EventEntityRelation;
     vocabularyEntries?: Array<VocabularyIdAndEntry>;
+    upstreamEntities?: Array<Entity["id"]>;
     error?: string;
 }
 
@@ -121,14 +139,22 @@ export function createEventEntityRelation(
         return { error: "some error" };
     }
 
-    if (mapper.vocabulary !== undefined) {
-        return {
-            eventEntityRelation: mapper.mapper(entry)[0],
-            vocabularyEntries: [mapper.vocabulary(entry)],
-        };
+    const eventEntityRelation = mapper.mapper(entry)[0];
+    const base64candidate = eventEntityRelation.entity.split("-")[1];
+    const base64regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+    const isUpstream =
+        base64regex.test(base64candidate) &&
+        Buffer.from(base64candidate, "base64").toString("utf-8").startsWith("http");
+
+    const result: CreateEventEntityRelationReturn = {};
+
+    if (isUpstream) {
+        eventEntityRelation.entity = base64candidate;
+        result.upstreamEntities = [eventEntityRelation.entity];
     }
 
-    return {
-        eventEntityRelation: mapper.mapper(entry)[0],
-    };
+    eventEntityRelation && (result.eventEntityRelation = eventEntityRelation);
+    mapper.vocabulary !== undefined && (result.vocabularyEntries = [mapper.vocabulary(entry)]);
+
+    return result;
 }

src/import-data.ts

@@ -19,6 +19,7 @@ export interface ImportData {
     unmappedEntries?: Array<unknown>;
     collections?: Record<string, CollectionCandidate>;
     tags?: Array<TagCandidate>;
+    upstreamEntityIds?: Array<Entity["id"]>;
 }
 
 interface ImportDataParams {

src/transform-data.ts

@@ -27,6 +27,7 @@ export function transformData(params: TransformDataParams): ImportData {
     const entityGroups: Record<string, Array<Entity["id"]>> = {};
     const collections: ImportData["collections"] = {};
     const tags: ImportData["tags"] = [];
+    const upstreamEntityIds: ImportData["upstreamEntityIds"] = [];
 
     const registerVocabularyEntries = (
         vocabularyEntries: Array<VocabularyIdAndEntry> | undefined
@@ -44,6 +45,18 @@ export function transformData(params: TransformDataParams): ImportData {
         }
     };
 
+    const registerUpstreamEntities = (
+        _upstreamEntities: ImportData["upstreamEntityIds"] | undefined
+    ) => {
+        if (_upstreamEntities !== undefined) {
+            for (const upstreamEntity of _upstreamEntities) {
+                if (!upstreamEntityIds.includes(upstreamEntity)) {
+                    upstreamEntityIds.push(upstreamEntity);
+                }
+            }
+        }
+    };
+
     // check if any of the entries has tagging
     // has Tag for all? otherwise use prefix for all entities and events
     let tagsForAll = input.filter((entry) => {
@@ -129,22 +142,25 @@ export function transformData(params: TransformDataParams): ImportData {
                 // Add relation to existing event (rows in the xlsx that have the same id an only add relations; other props are ignored)
                 events = events.map((event) => {
                     if (event.id === entry.id) {
-                        const { eventEntityRelation, vocabularyEntries } =
+                        const { eventEntityRelation, vocabularyEntries, upstreamEntities } =
                             createEventEntityRelation(entry);
 
                         eventEntityRelation !== undefined &&
                             event.relations.push(eventEntityRelation);
                         registerVocabularyEntries(vocabularyEntries);
+                        registerUpstreamEntities(upstreamEntities);
 
                         // TODO unmapped entries
                     }
                     return event;
                 });
             } else {
                 // Create new event
-                const { event, vocabularyEntries, unmappedProperties } = createEvent(entry);
+                const { event, vocabularyEntries, upstreamEntities, unmappedProperties } =
+                    createEvent(entry);
                 events.push(event);
                 registerVocabularyEntries(vocabularyEntries);
+                registerUpstreamEntities(upstreamEntities);
 
                 const entryGroup = entry.sheetName as string;
                 if (!(entryGroup in eventGroups)) {
@@ -272,6 +288,7 @@ export function transformData(params: TransformDataParams): ImportData {
     unmappedEntries && (result.unmappedEntries = unmappedEntries);
     collections && (result.collections = collections);
     tags && (result.tags = _tags);
+    upstreamEntityIds && (result.upstreamEntityIds = upstreamEntityIds);
 
     return result;
 }