@things-factory/headless-twin 10.1.24 → 10.1.26

package/test/twin-model-parent-relation-db.test.ts

@@ -0,0 +1,125 @@
+/*
+ * A location's parent is another location or an area — the item panel splits them by lookup.
+ *
+ * Contract 0.9.24 (ops-contract `00a346f`) declares `locations.parentId` as `axis-or-external`: the parent is
+ * another location (line · cell · zone) or, when no location has that id, an area of the space. Before this, the
+ * declaration said "area" only, so a bin under a zone could not walk to its zone, and a zone could not see the
+ * bins under it.
+ *
+ * What is held here:
+ *  - a parent that is a location becomes a link to that location, and nothing of it is sent to the area resolver;
+ *  - a parent that is not a location is resolved as an area — only those ids reach the resolver;
+ *  - a parent id found nowhere comes back as the resolver answers it (missing), not as an empty relation;
+ *  - a zone sees the locations under it as incoming, counted from the document (rows carry no parent location).
+ */
+import { test, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { createRequire } from 'node:module'
+import type { DataSource } from 'typeorm'
+
+const req = createRequire(import.meta.url)
+const { NamingStrategy, addDataSource, entities: shellEntities, Domain } = req('@things-factory/shell')
+const { entities: authEntities } = req('@things-factory/auth-base')
+const { entities: twinEntities } = req('../dist-server/service/index.js')
+const { TwinEngine } = req('../dist-server/engine/index.js')
+const { TwinModelItemQuery } = req('../dist-server/service/twin-model/twin-model-item-query.js')
+const { registerExternalResolver, clearExternalResolvers } = req('../dist-server/service/twin-model/external-resolver.js')
+const { DataSource: TypeOrmDataSource } = req('typeorm')
+
+let ds: DataSource
+let domainId: string
+let q: any
+let ctx: any
+const asked: string[][] = []
+
+const INSTANCE = 'parent-probe'
+
+const master = (): any => ({
+  source: INSTANCE,
+  system: 'wms',
+  siteName: 'parent site',
+  space: { width: 80, depth: 40, unit: 'm' },
+  locations: [
+    { id: 'hall-a', type: 'storage', role: 'area', name: 'Hall A' },
+    { id: 'zone-1', type: 'storage', role: 'location', name: 'Zone 1', parentId: 'hall-a' },
+    { id: 'bin-1', type: 'storage', role: 'location', name: 'Bin 1', parentId: 'zone-1', capacity: 10 },
+    { id: 'bin-2', type: 'storage', role: 'location', name: 'Bin 2', parentId: 'zone-1', capacity: 10 },
+    { id: 'bin-x', type: 'storage', role: 'location', name: 'Bin X', parentId: 'nowhere', capacity: 10 }
+  ],
+  equipment: [{ id: 'fk-1', kind: 'forklift', homeLocationId: 'zone-1' }]
+})
+
+before(async () => {
+  ds = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new NamingStrategy(),
+    entities: [...shellEntities, ...authEntities, ...twinEntities],
+    logging: false
+  })
+  await ds.initialize()
+  addDataSource('default', ds)
+  const d = await ds.getRepository(Domain).save({ name: 'parent-test', subdomain: 'parent-test' } as any)
+  domainId = d.id
+  q = new TwinModelItemQuery()
+  ctx = { state: { domain: { id: domainId } } }
+
+  /* A stand-in for the host's area resolver: it records what it was asked and knows one area. */
+  registerExternalResolver({
+    entity: 'space.area',
+    resolve: async (_domainId: string, ids: string[]) => {
+      asked.push([...ids])
+      return ids.map(id => (id === 'hall-a' ? { id, name: 'Hall A' } : { id, missing: true }))
+    }
+  })
+
+  await TwinEngine.ingestMaster(domainId, master(), 'reset')
+})
+
+after(async () => {
+  clearExternalResolvers()
+  await TwinEngine.stop(domainId, INSTANCE).catch(() => {})
+  await ds?.destroy()
+})
+
+const parentLinks = (item: any) => item.links.out.filter((l: any) => l.field === 'parentId')
+
+test('a parent that is a location is a link to that location — none of it goes to the area resolver', async () => {
+  asked.length = 0
+  const bin = await q.twinModelItem(INSTANCE, 'locations', 'bin-1', ctx)
+  const links = parentLinks(bin)
+  assert.equal(links.length, 1, `expected one parent line, got ${JSON.stringify(links)}`)
+  assert.deepEqual(links[0].target, { kind: 'axis', axis: 'locations' })
+  assert.equal(links[0].declaredTarget.kind, 'axis-or-external')
+  assert.deepEqual(links[0].ids, ['zone-1'])
+  assert.deepEqual(asked, [], 'a location parent was sent to the area resolver')
+})
+
+test('a parent that is not a location is resolved as an area — only that id reaches the resolver', async () => {
+  asked.length = 0
+  const zone = await q.twinModelItem(INSTANCE, 'locations', 'zone-1', ctx)
+  const links = parentLinks(zone)
+  assert.equal(links.length, 1)
+  assert.deepEqual(links[0].target, { kind: 'external', entity: 'space.area' })
+  assert.deepEqual(links[0].refs, [{ id: 'hall-a', name: 'Hall A' }])
+  assert.deepEqual(asked, [['hall-a']])
+})
+
+test('a parent found nowhere is said to be missing — not an empty relation', async () => {
+  const bin = await q.twinModelItem(INSTANCE, 'locations', 'bin-x', ctx)
+  const links = parentLinks(bin)
+  assert.equal(links.length, 1)
+  assert.equal(links[0].target.kind, 'external')
+  assert.equal(links[0].total, 1)
+  assert.deepEqual(links[0].refs, [{ id: 'nowhere', missing: true }])
+})
+
+test('a zone sees the locations under it as incoming — counted from the document', async () => {
+  const zone = await q.twinModelItem(INSTANCE, 'locations', 'zone-1', ctx)
+  const under = zone.links.incoming.find((l: any) => l.from === 'locations' && l.field === 'parentId')
+  assert.ok(under, `no incoming parent relation on the zone: ${JSON.stringify(zone.links.incoming.map((l: any) => [l.from, l.field]))}`)
+  assert.deepEqual([...under.ids].sort(), ['bin-1', 'bin-2'])
+  assert.equal(under.total, 2)
+})