@dooer/dooer-test-env 1.18.1 → 1.19.0

package/lib/copy.js

@@ -94,17 +94,29 @@ async function copyOrganization({ organizationId, sourceEnv, targetEnv, reason,
   )
   console.log(`  new organization id: ${chalk.bold(detail.organizationId)}`)
 
+  // Parent rows carried alongside the organization: global rows (workflow definitions, system messages)
+  // that its rows point at and the target may not have, because a target's base DB is a point-in-time
+  // snapshot while the source keeps moving. Only what was MISSING is inserted.
+  const refs = detail.references
+  if (refs && refs.rowsInArtifact) {
+    console.log(
+      `  referenced rows carried: ${refs.rowsInArtifact} from ${refs.tables.length} table(s)` +
+        `, ${refs.rowsInserted} inserted (the rest the target already had)`
+    )
+  }
+
   // Rows whose foreign key points at a parent that did not come with them. The load runs with FK
   // enforcement off (no ordering of 336 tables satisfies every constraint), and Postgres never re-checks,
   // so these commit silently — they have to be told, or the copy looks clean when it is not.
   if (detail.danglingRows) {
-    console.log(chalk.yellow(`\n  ${detail.danglingRows} row(s) reference a parent that was not copied:`))
+    console.log(chalk.yellow(`\n  ${detail.danglingRows} row(s) still reference a parent that is not there:`))
     for (const d of detail.dangling || []) {
       console.log(`    ${String(d.rows).padStart(6)}  ${d.from} → ${d.to}  (${d.cause})`)
     }
     console.log(
-      '  The copy is complete and usable; these references dangle. `parent table not in schema map`\n' +
-        '  means the map does not carry that parent — it will recur on every copy until the map changes.'
+      '  The copy is complete and usable; these references dangle. Reference closure carries the parents\n' +
+        '  a copied row points at, so anything left here is a table it deliberately does not carry\n' +
+        '  (service_accounts.users / companies) or one it could not follow — see the warnings above.'
     )
   }
   console.log(`  audit: export ${exported.id} (${source.name}), import ${imported.id} (${target.name})\n`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dooer/dooer-test-env",
-  "version": "1.18.1",
+  "version": "1.19.0",
   "description": "Run the whole Dooer backend locally (staging DB minus customers), copy/purge customers between environments, and shred — one CLI.",
   "license": "UNLICENSED",
   "repository": "Dooer/cli-dooer-test-env",

package/readme.md

@@ -262,19 +262,35 @@ npx @dooer/dooer-test-env@latest customer purge --org <orgId> --local --execute
 documents in the bucket; the command says so in its own output. Removing them needs bucket credentials the
 service does not hold today.
 
-**Dangling references.** The load runs with foreign-key enforcement off — no ordering of 336 tables
-satisfies every constraint on the way in — and Postgres never re-checks afterwards, so a copied row whose
-parent is missing would otherwise commit silently. The import checks the rows it wrote and reports any
-that dangle:
+**Referenced rows come with the org.** A copied row can point at a row in a table the schema map does not
+copy: `service_workflow.run` is org-scoped and copied, but the workflow `definition` it points at is
+global and is not. The target usually has those already — every environment's base DB descends from the
+same production dump — but a base DB is a point-in-time snapshot while the source keeps moving. Production
+has 819 workflow definitions; a base DB built in April 2023 has 689, so a 2026 org's runs pointed at
+versions that were not there.
+
+So the export carries the exact parent rows the org's rows reach, transitively (a carried `definition`
+points at a `workflow` in turn), and the import inserts only what is missing:
 
 ```
-  44 row(s) reference a parent that was not copied:
-      42  service_workflow.run.definitionId → service_workflow.definition  (parent table not in schema map)
-       2  service_accounts.systemMessageRecipient.systemMessageId → service_accounts.systemMessage
+  referenced rows carried: 9 from 2 table(s), 8 inserted (the rest the target already had)
 ```
 
-`parent table not in schema map` means the map does not carry that parent at all, so it recurs on every
-copy until the map changes. The copy is complete and usable; those references dangle.
+Their ids are **not** remapped — the copied rows reference them verbatim.
+
+Two tables are never carried: **`service_accounts.users`** (it would move real names and personnummer from
+the source environment into the target — exactly what a live→staging copy must not do) and
+**`service_accounts.companies`** (the organization itself). The closure is capped at 50,000 rows, and both
+the cap and any composite-key foreign key it declines to follow are reported as warnings.
+
+Anything that still dangles is reported after the load, because the bulk load runs with foreign-key
+enforcement off and Postgres never re-checks afterwards — so a dangling row would otherwise commit
+silently:
+
+```
+  44 row(s) still reference a parent that is not there:
+      42  service_workflow.run.definitionId → service_workflow.definition
+```
 
 Naming: with **neither `--name` nor `--target`** the copy creates a new org that **keeps the source org's
 own name** (its `short_name` still gets a unique suffix). Pass `--name` to rename it, or `--target <uuid>`