@likec4/leanix-bridge 1.53.0

package/src/reconcile.ts

@@ -0,0 +1,227 @@
+/**
+ * Reconciliation of LeanIX inventory snapshot with LikeC4 manifest.
+ * Produces matched, unmatched (in LikeC4 only / in LeanIX only), and ambiguous pairs.
+ * No DSL generation; read-only comparison.
+ */
+
+import { type BridgeManifest, type CanonicalId, type ManifestEntity, LEANIX_PROVIDER } from './contracts'
+import type {
+  LeanixFactSheetSnapshotItem,
+  LeanixInventorySnapshot,
+} from './leanix-inventory-snapshot'
+import type { LeanixInventoryDryRun } from './to-leanix-inventory-dry-run'
+
+/** A manifest entity matched to a single LeanIX fact sheet. */
+export interface MatchedPair {
+  canonicalId: CanonicalId
+  factSheetId: string
+  name: string
+  type: string
+}
+
+/** Manifest entity with no matching LeanIX fact sheet. */
+export interface UnmatchedInLikec4 {
+  canonicalId: CanonicalId
+  name?: string | undefined
+  type?: string | undefined
+}
+
+/** LeanIX fact sheet with no matching manifest entity. */
+export interface UnmatchedInLeanix {
+  factSheetId: string
+  name: string
+  type: string
+  likec4Id?: string | undefined
+}
+
+/** Manifest entity that could match multiple LeanIX fact sheets (e.g. same name+type). */
+export interface AmbiguousMatch {
+  canonicalId: CanonicalId
+  name?: string | undefined
+  type?: string | undefined
+  /** Multiple LeanIX fact sheets could match (e.g. same name+type). */
+  candidateFactSheetIds: string[]
+}
+
+/** Result of reconciling a LeanIX snapshot with the bridge manifest (matched, unmatched, ambiguous). */
+export interface ReconciliationResult {
+  generatedAt: string
+  manifestProjectId: string
+  snapshotGeneratedAt: string
+  matched: MatchedPair[]
+  unmatchedInLikec4: UnmatchedInLikec4[]
+  unmatchedInLeanix: UnmatchedInLeanix[]
+  ambiguous: AmbiguousMatch[]
+  summary: {
+    matched: number
+    unmatchedInLikec4: number
+    unmatchedInLeanix: number
+    ambiguous: number
+  }
+}
+
+/** Separator for name+type composite key (G25: avoid magic character). */
+const NAME_TYPE_SEP = '\0'
+
+/** Tries to match by manifest entity's external.leanix.factSheetId; returns match or null. */
+function tryMatchByManifestFactSheetId(
+  entity: ManifestEntity,
+  canonicalId: CanonicalId,
+  snapshotById: Map<string, LeanixFactSheetSnapshotItem>,
+  usedFactSheetIds: Set<string>,
+): MatchedPair | null {
+  const leanixExternal = entity.external?.[LEANIX_PROVIDER]
+  const manifestFactSheetId = leanixExternal?.factSheetId ?? leanixExternal?.externalId
+  if (manifestFactSheetId == null) return null
+  const fs = snapshotById.get(manifestFactSheetId)
+  if (!fs) return null
+  if (usedFactSheetIds.has(fs.id)) return null
+  usedFactSheetIds.add(fs.id)
+  return { canonicalId, factSheetId: fs.id, name: fs.name, type: fs.type }
+}
+
+/** Tries to match by snapshot fact sheet's likec4Id === canonicalId; returns match or null. */
+function tryMatchByLikec4Id(
+  canonicalId: CanonicalId,
+  snapshotByLikec4Id: Map<string, LeanixFactSheetSnapshotItem>,
+  usedFactSheetIds: Set<string>,
+): MatchedPair | null {
+  const byLikec4 = snapshotByLikec4Id.get(canonicalId)
+  if (!byLikec4 || usedFactSheetIds.has(byLikec4.id)) return null
+  usedFactSheetIds.add(byLikec4.id)
+  return { canonicalId, factSheetId: byLikec4.id, name: byLikec4.name, type: byLikec4.type }
+}
+
+/** Resolves match by name+type (or pushes to unmatchedInLikec4 / ambiguous). */
+function resolveByNameAndType(
+  canonicalId: CanonicalId,
+  entityName: string | undefined,
+  entityType: string | undefined,
+  snapshotByNameAndType: Map<string, LeanixFactSheetSnapshotItem[]>,
+  usedFactSheetIds: Set<string>,
+  matched: MatchedPair[],
+  unmatchedInLikec4: UnmatchedInLikec4[],
+  ambiguous: AmbiguousMatch[],
+): void {
+  const nameTypeKey = `${entityName ?? canonicalId}${NAME_TYPE_SEP}${entityType ?? ''}`
+  const candidates = snapshotByNameAndType.get(nameTypeKey)?.filter(f => !usedFactSheetIds.has(f.id)) ?? []
+  if (candidates.length === 0) {
+    unmatchedInLikec4.push({
+      canonicalId,
+      ...(entityName !== undefined ? { name: entityName } : {}),
+      ...(entityType !== undefined ? { type: entityType } : {}),
+    })
+  } else if (candidates.length === 1) {
+    const candidate = candidates[0]!
+    matched.push({
+      canonicalId,
+      factSheetId: candidate.id,
+      name: candidate.name,
+      type: candidate.type,
+    })
+    usedFactSheetIds.add(candidate.id)
+  } else {
+    ambiguous.push({
+      canonicalId,
+      ...(entityName !== undefined ? { name: entityName } : {}),
+      ...(entityType !== undefined ? { type: entityType } : {}),
+      candidateFactSheetIds: candidates.map(c => c.id),
+    })
+  }
+}
+
+/** Options for reconcileInventoryWithManifest (generatedAt, optional dry-run for name/type resolution). */
+export interface ReconcileOptions {
+  generatedAt?: string
+  /** When provided, name+type matching and ambiguous detection use dry-run fact sheet names/types. */
+  dryRun?: LeanixInventoryDryRun
+}
+
+/**
+ * Reconciles a LeanIX inventory snapshot with the bridge manifest.
+ * Matching order: 1) manifest entity has external.leanix.factSheetId; 2) snapshot fact sheet has likec4Id === canonicalId; 3) if dryRun provided, name+type (can be ambiguous).
+ * Does not modify any data; no DSL generation.
+ */
+export function reconcileInventoryWithManifest(
+  snapshot: LeanixInventorySnapshot,
+  manifest: BridgeManifest,
+  options: ReconcileOptions = {},
+): ReconciliationResult {
+  const generatedAt = options.generatedAt ?? new Date().toISOString()
+  const dryRun = options.dryRun
+  const matched: MatchedPair[] = []
+  const unmatchedInLikec4: UnmatchedInLikec4[] = []
+  const ambiguous: AmbiguousMatch[] = []
+
+  const snapshotById = new Map(snapshot.factSheets.map(f => [f.id, f]))
+  const snapshotByLikec4Id = new Map<string, LeanixFactSheetSnapshotItem>()
+  const snapshotByNameAndType = new Map<string, LeanixFactSheetSnapshotItem[]>()
+  for (const fs of snapshot.factSheets) {
+    if (fs.likec4Id) snapshotByLikec4Id.set(fs.likec4Id, fs)
+    const key = `${fs.name}${NAME_TYPE_SEP}${fs.type}`
+    if (!snapshotByNameAndType.has(key)) snapshotByNameAndType.set(key, [])
+    snapshotByNameAndType.get(key)!.push(fs)
+  }
+
+  const dryRunByCanonicalId = dryRun
+    ? new Map(dryRun.factSheets.map(f => [f.likec4Id, f]))
+    : null
+
+  const usedFactSheetIds = new Set<string>()
+
+  for (const [canonicalId, entity] of Object.entries(manifest.entities)) {
+    const byManifest = tryMatchByManifestFactSheetId(
+      entity,
+      canonicalId,
+      snapshotById,
+      usedFactSheetIds,
+    )
+    if (byManifest) {
+      matched.push(byManifest)
+      continue
+    }
+    const byLikec4 = tryMatchByLikec4Id(canonicalId, snapshotByLikec4Id, usedFactSheetIds)
+    if (byLikec4) {
+      matched.push(byLikec4)
+      continue
+    }
+    const dryRunFs = dryRunByCanonicalId?.get(canonicalId)
+    const entityName = dryRunFs?.name ?? undefined
+    const entityType = dryRunFs?.type ?? undefined
+    resolveByNameAndType(
+      canonicalId,
+      entityName,
+      entityType,
+      snapshotByNameAndType,
+      usedFactSheetIds,
+      matched,
+      unmatchedInLikec4,
+      ambiguous,
+    )
+  }
+
+  const unmatchedInLeanix: UnmatchedInLeanix[] = snapshot.factSheets
+    .filter(f => !usedFactSheetIds.has(f.id))
+    .map(f => ({
+      factSheetId: f.id,
+      name: f.name,
+      type: f.type,
+      ...(f.likec4Id ? { likec4Id: f.likec4Id } : {}),
+    }))
+
+  return {
+    generatedAt,
+    manifestProjectId: manifest.projectId,
+    snapshotGeneratedAt: snapshot.generatedAt,
+    matched,
+    unmatchedInLikec4,
+    unmatchedInLeanix,
+    ambiguous,
+    summary: {
+      matched: matched.length,
+      unmatchedInLikec4: unmatchedInLikec4.length,
+      unmatchedInLeanix: unmatchedInLeanix.length,
+      ambiguous: ambiguous.length,
+    },
+  }
+}

package/src/report.ts

@@ -0,0 +1,73 @@
+import type { BridgeManifest } from './contracts'
+import type { LeanixInventoryDryRun } from './to-leanix-inventory-dry-run'
+
+/** Summary report for the bridge run (no live sync) */
+export interface BridgeReport {
+  generatedAt: string
+  projectId: string
+  manifestVersion: string
+  bridgeVersion: string
+  mappingProfile: string
+  counts: {
+    entities: number
+    views: number
+    relations: number
+    factSheets: number
+    leanixRelations: number
+  }
+  artifacts: {
+    manifest: string
+    leanixDryRun: string
+  }
+}
+
+/** Builds error message listing which coherence fields mismatched (projectId, mappingProfile). */
+function buildCoherenceErrorMessage(
+  manifest: BridgeManifest,
+  leanixDryRun: LeanixInventoryDryRun,
+): string {
+  const mismatches: string[] = []
+  if (manifest.projectId !== leanixDryRun.projectId) {
+    mismatches.push(`projectId (manifest: ${manifest.projectId}, leanixDryRun: ${leanixDryRun.projectId})`)
+  }
+  if (manifest.mappingProfile !== leanixDryRun.mappingProfile) {
+    mismatches.push(
+      `mappingProfile (manifest: ${manifest.mappingProfile}, leanixDryRun: ${leanixDryRun.mappingProfile})`,
+    )
+  }
+  return `Manifest and LeanIX dry-run must belong to the same run. Mismatch: ${mismatches.join('; ')}`
+}
+
+/**
+ * Builds a summary report (counts, artifact names) from manifest and dry-run. Throws if projectId or mappingProfile differ.
+ */
+export function buildBridgeReport(
+  manifest: BridgeManifest,
+  leanixDryRun: LeanixInventoryDryRun,
+): BridgeReport {
+  if (
+    manifest.projectId !== leanixDryRun.projectId ||
+    manifest.mappingProfile !== leanixDryRun.mappingProfile
+  ) {
+    throw new Error(buildCoherenceErrorMessage(manifest, leanixDryRun))
+  }
+
+  return {
+    generatedAt: manifest.generatedAt,
+    projectId: manifest.projectId,
+    manifestVersion: manifest.manifestVersion,
+    bridgeVersion: manifest.bridgeVersion,
+    mappingProfile: manifest.mappingProfile,
+    counts: {
+      entities: Object.keys(manifest.entities).length,
+      views: Object.keys(manifest.views).length,
+      relations: manifest.relations.length,
+      factSheets: leanixDryRun.factSheets.length,
+      leanixRelations: leanixDryRun.relations.length,
+    },
+    artifacts: {
+      manifest: 'manifest.json',
+      leanixDryRun: 'leanix-dry-run.json',
+    },
+  }
+}

package/src/sync-to-leanix.ts

@@ -0,0 +1,352 @@
+/**
+ * Sync bridge manifest + LeanIX dry-run inventory to the LeanIX API.
+ * Creates or updates fact sheets and relations; returns manifest with external LeanIX IDs.
+ * Supports a read-only "plan" step that queries LeanIX to produce a sync plan artifact (Phase 2).
+ */
+
+import { type BridgeManifest, type CanonicalId, LEANIX_PROVIDER } from './contracts'
+import { LeanixApiClient } from './leanix-api-client'
+import {
+  createFactSheet,
+  createRelation,
+  findFactSheetByLikec4IdAttribute,
+  findFactSheetByNameAndType,
+  patchFactSheetAttribute,
+} from './leanix-graphql-operations'
+import type { LeanixFactSheetDryRun, LeanixInventoryDryRun } from './to-leanix-inventory-dry-run'
+
+/** Options for live sync (idempotent lookup, optional likec4Id custom attribute). */
+export interface SyncToLeanixOptions {
+  /** If true, only create fact sheets that do not exist (by name+type). Default: true. */
+  idempotent?: boolean
+  /** Custom attribute key in LeanIX to store likec4Id for lookup. If not set, lookup by name+type. */
+  likec4IdAttribute?: string
+}
+
+/** Result of syncToLeanix (updated manifest, counts, errors). */
+export interface SyncToLeanixResult {
+  /** Updated manifest with external.leanix.factSheetId and relation IDs filled. */
+  manifest: BridgeManifest
+  /** Count of fact sheets created. */
+  factSheetsCreated: number
+  /** Count of fact sheets reused (when idempotent and found; no mutation). */
+  factSheetsReused: number
+  /** Count of relations created. */
+  relationsCreated: number
+  /** Errors encountered (e.g. rate limit, validation). Partial sync may still have updated manifest. */
+  errors: string[]
+}
+
+/** Single fact sheet entry in a sync plan: what would happen when syncing. */
+export interface SyncPlanFactSheetEntry {
+  likec4Id: string
+  name: string
+  type: string
+  /** 'create' = not found in LeanIX; 'update' = found by name+type (idempotent). */
+  action: 'create' | 'update'
+  /** Set when action is 'update': existing LeanIX fact sheet id. */
+  existingFactSheetId?: string
+}
+
+/** Single relation entry in a sync plan (relations are always created when source/target exist). */
+export interface SyncPlanRelationEntry {
+  likec4RelationId: string
+  sourceLikec4Id: string
+  targetLikec4Id: string
+  type: string
+  action: 'create'
+}
+
+/** Summary counts for a sync plan. */
+export interface SyncPlanSummary {
+  factSheetsToCreate: number
+  factSheetsToUpdate: number
+  relationsToCreate: number
+}
+
+/** Sync plan artifact: what would be created/updated in LeanIX (no writes; uses API only to read existing). */
+export interface SyncPlan {
+  generatedAt: string
+  projectId: string
+  mappingProfile: string
+  summary: SyncPlanSummary
+  factSheetPlans: SyncPlanFactSheetEntry[]
+  relationPlans: SyncPlanRelationEntry[]
+  /** Errors from read-only queries (e.g. auth, rate limit). Plan may be partial. */
+  errors: string[]
+}
+
+function buildFactSheetPlanEntry(
+  fs: LeanixFactSheetDryRun,
+  existingFactSheetId: string | null,
+): SyncPlanFactSheetEntry {
+  const action = existingFactSheetId ? 'update' : 'create'
+  return {
+    likec4Id: fs.likec4Id,
+    name: fs.name,
+    type: fs.type,
+    action,
+    ...(existingFactSheetId ? { existingFactSheetId } : {}),
+  }
+}
+
+function buildPlanSummary(
+  factSheetPlans: SyncPlanFactSheetEntry[],
+  relationPlans: SyncPlanRelationEntry[],
+): SyncPlanSummary {
+  return {
+    factSheetsToCreate: factSheetPlans.filter(p => p.action === 'create').length,
+    factSheetsToUpdate: factSheetPlans.filter(p => p.action === 'update').length,
+    relationsToCreate: relationPlans.length,
+  }
+}
+
+/** Options for planSyncToLeanix (idempotent, likec4Id attribute, generatedAt). */
+export interface PlanSyncToLeanixOptions {
+  /** If true, plan assumes idempotent sync (look up by likec4IdAttribute or name+type to decide create vs update). Default: true. */
+  idempotent?: boolean
+  /** Custom attribute key for likec4Id lookup; when set, plan uses it for idempotent resolution. */
+  likec4IdAttribute?: string
+  /** ISO timestamp for the plan. Default: new Date().toISOString() */
+  generatedAt?: string
+}
+
+/** Normalise caught value to a string for error reporting (Clean Code: context in errors). */
+function toErrorMessage(err: unknown): string {
+  if (err instanceof Error) {
+    return err.stack ? `${err.message}\n${err.stack}` : err.message
+  }
+  if (typeof err === 'object' && err !== null) {
+    try {
+      return JSON.stringify(err, null, 2)
+    } catch {
+      return Object.prototype.toString.call(err)
+    }
+  }
+  return String(err)
+}
+
+/** Applies LeanIX fact sheet IDs to manifest entities; returns new entities object. */
+function applyLeanixIdsToEntities(
+  entities: BridgeManifest['entities'],
+  likec4IdToFactSheetId: Map<CanonicalId, string>,
+): BridgeManifest['entities'] {
+  const out = { ...entities }
+  for (const [canonicalId, entity] of Object.entries(entities)) {
+    const leanixId = likec4IdToFactSheetId.get(canonicalId)
+    if (leanixId) {
+      out[canonicalId] = {
+        ...entity,
+        external: { ...entity.external, [LEANIX_PROVIDER]: { factSheetId: leanixId, externalId: leanixId } },
+      }
+    }
+  }
+  return out
+}
+
+/** Resolves existing LeanIX fact sheet id by likec4Id attribute or name+type; optionally patches likec4Id. Returns null when not found. */
+async function resolveExistingFactSheetId(
+  client: LeanixApiClient,
+  fs: LeanixFactSheetDryRun,
+  idempotent: boolean,
+  likec4IdAttribute: string | undefined,
+): Promise<string | null> {
+  if (!idempotent) return null
+  if (likec4IdAttribute) {
+    const byAttr = await findFactSheetByLikec4IdAttribute(client, likec4IdAttribute, fs.likec4Id)
+    if (byAttr) return byAttr
+    const byNameType = await findFactSheetByNameAndType(client, fs.name, fs.type)
+    if (byNameType && fs.likec4Id) {
+      try {
+        await patchFactSheetAttribute(client, byNameType, likec4IdAttribute, fs.likec4Id)
+      } catch (err) {
+        console.warn(
+          `[leanix-bridge] Failed to backfill likec4Id on fact sheet ${byNameType} (${fs.name}/${fs.type}): ${
+            err instanceof Error ? err.message : String(err)
+          }. Reusing ID.`,
+        )
+      }
+    }
+    return byNameType ?? null
+  }
+  return findFactSheetByNameAndType(client, fs.name, fs.type)
+}
+
+/** Result of syncing fact sheets: map of likec4Id → factSheetId and counts/errors. */
+interface SyncFactSheetsResult {
+  likec4IdToFactSheetId: Map<CanonicalId, string>
+  factSheetsCreated: number
+  factSheetsReused: number
+  errors: string[]
+}
+
+/** Creates or finds fact sheets in LeanIX; returns map and counts. Single responsibility. */
+async function syncFactSheetsToLeanix(
+  client: LeanixApiClient,
+  factSheets: LeanixInventoryDryRun['factSheets'],
+  idempotent: boolean,
+  likec4IdAttribute: string | undefined,
+): Promise<SyncFactSheetsResult> {
+  const likec4IdToFactSheetId = new Map<CanonicalId, string>()
+  const errors: string[] = []
+  let factSheetsCreated = 0
+  let factSheetsReused = 0
+
+  for (const fs of factSheets) {
+    try {
+      let factSheetId = await resolveExistingFactSheetId(client, fs, idempotent, likec4IdAttribute)
+      if (factSheetId) factSheetsReused++
+      if (!factSheetId) {
+        factSheetId = await createFactSheet(client, fs, likec4IdAttribute)
+        factSheetsCreated++
+      }
+      if (factSheetId) likec4IdToFactSheetId.set(fs.likec4Id, factSheetId)
+    } catch (e) {
+      errors.push(`Fact sheet ${fs.likec4Id} (${String(fs.name)}): ${toErrorMessage(e)}`)
+    }
+  }
+
+  return { likec4IdToFactSheetId, factSheetsCreated, factSheetsReused, errors }
+}
+
+/** Result of syncing relations: updated relations array and count/errors. */
+interface SyncRelationsResult {
+  updatedRelations: BridgeManifest['relations']
+  relationsCreated: number
+  errors: string[]
+}
+
+/** Creates relations in LeanIX and returns manifest relations with external IDs. Single responsibility. */
+async function syncRelationsToLeanix(
+  client: LeanixApiClient,
+  manifestRelations: BridgeManifest['relations'],
+  leanixRelations: LeanixInventoryDryRun['relations'],
+  likec4IdToFactSheetId: Map<CanonicalId, string>,
+): Promise<SyncRelationsResult> {
+  const updatedRelations: BridgeManifest['relations'] = []
+  const errors: string[] = []
+  let relationsCreated = 0
+
+  for (const rel of manifestRelations) {
+    const sourceId = likec4IdToFactSheetId.get(rel.sourceFqn)
+    const targetId = likec4IdToFactSheetId.get(rel.targetFqn)
+    const existing = rel.external?.[LEANIX_PROVIDER]
+    if (sourceId && targetId && !existing?.relationId) {
+      const dryRel = leanixRelations.find(
+        r =>
+          r.sourceLikec4Id === rel.sourceFqn &&
+          r.targetLikec4Id === rel.targetFqn &&
+          r.likec4RelationId === rel.relationId,
+      )
+      if (dryRel) {
+        try {
+          const relationId = await createRelation(client, sourceId, targetId, dryRel.type, dryRel.title)
+          relationsCreated++
+          updatedRelations.push({
+            ...rel,
+            external: { ...rel.external, [LEANIX_PROVIDER]: { relationId, ...rel.external?.[LEANIX_PROVIDER] } },
+          })
+          continue
+        } catch (e) {
+          errors.push(`Relation ${rel.compositeKey}: ${toErrorMessage(e)}`)
+        }
+      }
+    }
+    updatedRelations.push(rel)
+  }
+
+  return { updatedRelations, relationsCreated, errors }
+}
+
+/**
+ * Produces a sync plan by querying LeanIX for existing fact sheets (read-only; no creates/updates).
+ * Use before syncToLeanix to review what would be created vs updated. Phase 2 dry-run sync planning.
+ */
+export async function planSyncToLeanix(
+  leanixDryRun: LeanixInventoryDryRun,
+  client: LeanixApiClient,
+  options: PlanSyncToLeanixOptions = {},
+): Promise<SyncPlan> {
+  const idempotent = options.idempotent ?? true
+  const likec4IdAttribute = options.likec4IdAttribute
+  const generatedAt = options.generatedAt ?? new Date().toISOString()
+  const errors: string[] = []
+  const factSheetPlans: SyncPlan['factSheetPlans'] = []
+
+  for (const fs of leanixDryRun.factSheets) {
+    try {
+      let existingId: string | null = null
+      if (idempotent) {
+        if (likec4IdAttribute) {
+          existingId = await findFactSheetByLikec4IdAttribute(client, likec4IdAttribute, fs.likec4Id)
+          if (!existingId) existingId = await findFactSheetByNameAndType(client, fs.name, fs.type)
+        } else {
+          existingId = await findFactSheetByNameAndType(client, fs.name, fs.type)
+        }
+      }
+      factSheetPlans.push(buildFactSheetPlanEntry(fs, existingId))
+    } catch (e) {
+      errors.push(`Fact sheet ${fs.likec4Id} (${String(fs.name)}): ${toErrorMessage(e)}`)
+      factSheetPlans.push(buildFactSheetPlanEntry(fs, null))
+    }
+  }
+
+  const relationPlans: SyncPlan['relationPlans'] = leanixDryRun.relations.map(rel => ({
+    likec4RelationId: rel.likec4RelationId,
+    sourceLikec4Id: rel.sourceLikec4Id,
+    targetLikec4Id: rel.targetLikec4Id,
+    type: rel.type,
+    action: 'create' as const,
+  }))
+
+  return {
+    generatedAt,
+    projectId: leanixDryRun.projectId,
+    mappingProfile: leanixDryRun.mappingProfile,
+    summary: buildPlanSummary(factSheetPlans, relationPlans),
+    factSheetPlans,
+    relationPlans,
+    errors,
+  }
+}
+
+/**
+ * Syncs the dry-run inventory to LeanIX: creates or finds fact sheets, creates relations,
+ * and returns an updated manifest with external LeanIX IDs.
+ */
+export async function syncToLeanix(
+  manifest: BridgeManifest,
+  leanixDryRun: LeanixInventoryDryRun,
+  client: LeanixApiClient,
+  options: SyncToLeanixOptions = {},
+): Promise<SyncToLeanixResult> {
+  const idempotent = options.idempotent ?? true
+  const likec4IdAttribute = options.likec4IdAttribute
+
+  const fsResult = await syncFactSheetsToLeanix(
+    client,
+    leanixDryRun.factSheets,
+    idempotent,
+    likec4IdAttribute,
+  )
+  const updatedEntities = applyLeanixIdsToEntities(manifest.entities, fsResult.likec4IdToFactSheetId)
+
+  const relResult = await syncRelationsToLeanix(
+    client,
+    manifest.relations,
+    leanixDryRun.relations,
+    fsResult.likec4IdToFactSheetId,
+  )
+
+  return {
+    manifest: {
+      ...manifest,
+      entities: updatedEntities,
+      relations: relResult.updatedRelations,
+    },
+    factSheetsCreated: fsResult.factSheetsCreated,
+    factSheetsReused: fsResult.factSheetsReused,
+    relationsCreated: relResult.relationsCreated,
+    errors: [...fsResult.errors, ...relResult.errors],
+  }
+}