@things-factory/kpi 10.1.38 → 10.1.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/kpi",
-  "version": "10.1.38",
+  "version": "10.1.40",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "@operato/app": "^10.0.0",
-    "@operato/data-grist": "^10.0.0",
+    "@operato/data-grist": "^10.19.0",
     "@operato/dataset": "^10.0.0",
     "@operato/ghost-print": "^10.0.0",
     "@operato/graphql": "^10.0.0",
@@ -41,9 +41,9 @@
     "@operato/shell": "^10.0.0",
     "@operato/styles": "^10.0.0",
     "@operato/utils": "^10.0.0",
-    "@things-factory/auth-base": "^10.1.38",
-    "@things-factory/dataset": "^10.1.38",
-    "@things-factory/shell": "^10.1.38"
+    "@things-factory/auth-base": "^10.1.40",
+    "@things-factory/dataset": "^10.1.40",
+    "@things-factory/shell": "^10.1.40"
   },
-  "gitHead": "b947349fe1c27d11038b592ceadaba336f14785b"
+  "gitHead": "51c5d804c14ad8fcc6d4707e6ef80c9deede2766"
 }

package/tests/entities-sqlite.test.ts

@@ -0,0 +1,92 @@
+/**
+ * kpi's tables build on sqlite - the development default.
+ *
+ * KpiMetric.collectType was declared type 'enum', a name only postgres and mysql know. The sqlite driver
+ * refused it when the DataSource opened (DataTypeNotSupportedError), so no app with kpi could start on
+ * sqlite, and list-search-db could only run on postgres. It is 'simple-enum' now: postgres and mysql turn
+ * it into the same native enum as before (an existing postgres table sees no schema change), sqlite a
+ * varchar with a CHECK.
+ *
+ * Needs kpi's dist-server, for the same reason list-search-db does:
+ *
+ *   yarn workspace @things-factory/kpi build:server
+ *   yarn _test packages/kpi/tests
+ */
+
+import type { DataSource } from 'typeorm'
+import { existsSync } from 'fs'
+import { join } from 'path'
+
+/* Entities pick their column types from ormconfig.type when they load, so the driver is named first. */
+require('@things-factory/env').config.set('ormconfig', { type: 'sqlite' })
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+/* The same closed entity graph list-search-db builds: KpiMetric -> DataSet -> Scenario, worklist. */
+const integration = require('@things-factory/integration-base')
+const worklist = require('@things-factory/worklist')
+const dataset = require('@things-factory/dataset')
+const attachment = require('@things-factory/attachment-base')
+
+const DIST = join(__dirname, '..', 'dist-server')
+if (!existsSync(join(DIST, 'service', 'index.js'))) {
+  throw new Error(`kpi's dist-server is missing - run "yarn workspace @things-factory/kpi build:server" first`)
+}
+const kpi = require(join(DIST, 'service', 'index.js'))
+
+let dataSource: DataSource
+let domain: any
+
+describe('kpi entities on sqlite', () => {
+  beforeAll(async () => {
+    dataSource = new TypeOrmDataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      synchronize: true,
+      dropSchema: true,
+      namingStrategy: new shell.NamingStrategy(),
+      entities: [
+        ...shell.entities,
+        ...authBase.entities,
+        ...attachment.entities,
+        ...integration.entities,
+        ...worklist.entities,
+        ...dataset.entities,
+        ...kpi.entities
+      ],
+      logging: false
+    })
+    await dataSource.initialize()
+    domain = await dataSource.getRepository(shell.Domain).save({ name: 'Plant A', subdomain: 'plant-a' })
+  })
+
+  afterAll(async () => {
+    if (dataSource?.isInitialized) await dataSource.destroy()
+  })
+
+  it('builds every kpi table', async () => {
+    const tables = (await dataSource.query(`SELECT name FROM sqlite_master WHERE type = 'table'`)).map(
+      (row: any) => row.name
+    )
+    for (const entity of kpi.entities) {
+      expect(tables).toContain(dataSource.getMetadata(entity).tableName)
+    }
+  })
+
+  it('a metric takes AUTO when no collect type is given, and keeps the one it is given', async () => {
+    const repo = dataSource.getRepository(kpi.KpiMetric)
+    const auto = await repo.save({ domain, name: 'Downtime minutes' })
+    const manual = await repo.save({ domain, name: 'Good units', collectType: kpi.KpiMetricCollectType.MANUAL })
+    expect((await repo.findOneBy({ id: auto.id })).collectType).toBe('AUTO')
+    expect((await repo.findOneBy({ id: manual.id })).collectType).toBe('MANUAL')
+  })
+
+  it('refuses a collect type outside the enum - the column still holds only its values', async () => {
+    const table = dataSource.getMetadata(kpi.KpiMetric).tableName
+    await dataSource.getRepository(kpi.KpiMetric).save({ domain, name: 'Scrap count' })
+    await expect(
+      dataSource.query(`UPDATE "${table}" SET "collect_type" = 'SOMETHING_ELSE'`)
+    ).rejects.toThrow(/CHECK constraint failed/)
+  })
+})

package/tests/list-search-db.test.ts

@@ -0,0 +1,142 @@
+/**
+ * The two value lists answer the title bar search - against a real database.
+ *
+ * The screens send the term itself (`search-mode="term"`, ADR-0060 decision 10) and the door expands
+ * it over its own searchables. A pure test cannot see whether that list is one the entity can answer:
+ * a name the entity does not have throws, and a uuid column is an error on postgres (LOWER(uuid) has
+ * no function). kpiMetricValues had both - metricId and a group the entity never had - so the search
+ * would have answered with an error instead of rows.
+ *
+ * Postgres only, with TEST_POSTGRES_URL set - a throwaway container is enough, synchronize builds the
+ * tables:
+ *
+ *   docker run -d --rm --name kpi-pg -e POSTGRES_PASSWORD=x -p 55433:5432 postgres:14-alpine
+ *   TEST_POSTGRES_URL=postgres://postgres:x@localhost:55433/postgres yarn _test packages/kpi/tests
+ *
+ * Not sqlite: sqlite lowers a uuid without complaint, so it cannot show the defect. (It builds these
+ * tables since KpiMetric.collectType became 'simple-enum' - entities-sqlite.test.ts keeps that so.)
+ * Without the variable the suite is skipped, and says so.
+ */
+
+import type { DataSource } from 'typeorm'
+import { existsSync } from 'fs'
+import { join } from 'path'
+
+const POSTGRES = process.env.TEST_POSTGRES_URL
+
+/* Entities pick their column types from ormconfig.type when they load (attachment's contents is blob
+   or bytea), so the driver is named before any of them is required. */
+require('@things-factory/env').config.set('ormconfig', { type: 'postgres' })
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+/* KpiMetric points at dataset's DataSet, which points at integration's Scenario - the entity graph
+   has to close before the tables can be built (dataset's out-of-control reviews reach worklist). */
+const integration = require('@things-factory/integration-base')
+const worklist = require('@things-factory/worklist')
+const dataset = require('@things-factory/dataset')
+const attachment = require('@things-factory/attachment-base')
+
+const DIST = join(__dirname, '..', 'dist-server')
+if (!existsSync(join(DIST, 'service', 'index.js'))) {
+  throw new Error(`kpi's dist-server is missing - run "yarn workspace @things-factory/kpi build:server" first`)
+}
+/* The entities use type-graphql decorators that need tsc's metadata, which babel cannot give -
+   the same reason auth-base's DB tests load the compiled output (auth-base/tests/compiled.ts). */
+const kpi = require(join(DIST, 'service', 'index.js'))
+const { KpiValueQuery } = require(join(DIST, 'service', 'kpi-value', 'kpi-value-query.js'))
+const { KpiMetricValueQuery } = require(join(DIST, 'service', 'kpi-metric-value', 'kpi-metric-value-query.js'))
+
+let dataSource: DataSource
+let domain: any
+
+const onPostgres = POSTGRES ? describe : describe.skip
+
+const context = () => ({ state: { domain } }) as any
+const repo = (entity: any) => dataSource.getRepository(entity)
+
+onPostgres('the value lists answer the title bar search (postgres, TEST_POSTGRES_URL)', () => {
+  beforeAll(async () => {
+    dataSource = new TypeOrmDataSource({
+      type: 'postgres',
+      url: POSTGRES,
+      synchronize: true,
+      dropSchema: true,
+      namingStrategy: new shell.NamingStrategy(),
+      entities: [
+        ...shell.entities,
+        ...authBase.entities,
+        ...attachment.entities,
+        ...integration.entities,
+        ...worklist.entities,
+        ...dataset.entities,
+        ...kpi.entities
+      ],
+      logging: false
+    })
+    await dataSource.initialize()
+    shell.addDataSource('default', dataSource)
+  })
+
+  afterAll(async () => {
+    if (dataSource?.isInitialized) await dataSource.destroy()
+  })
+
+  beforeEach(async () => {
+    await dataSource.synchronize(true)
+    domain = await repo(shell.Domain).save({ name: 'Plant A', subdomain: 'plant-a' })
+  })
+
+  describe('kpiValues', () => {
+    async function seed() {
+      const scrap = await repo(kpi.Kpi).save({ domain, name: 'Scrap rate' })
+      const oee = await repo(kpi.Kpi).save({ domain, name: 'OEE' })
+      await repo(kpi.KpiValue).save([
+        { domain, kpi: scrap, version: 1, valueDate: '2026-09-01', value: 1.2, group: 'line-1' },
+        { domain, kpi: oee, version: 1, valueDate: '2026-09-02', value: 81, group: 'line-2' }
+      ])
+    }
+
+    it('finds a value by the name of its KPI', async () => {
+      await seed()
+      const { items, total } = await new KpiValueQuery().kpiValues({ search: 'scrap' }, context())
+      expect(total).toBe(1)
+      expect(items[0].valueDate).toBe('2026-09-01')
+    })
+
+    it('finds a value by its group and by its date', async () => {
+      await seed()
+      expect((await new KpiValueQuery().kpiValues({ search: 'line-2' }, context())).total).toBe(1)
+      expect((await new KpiValueQuery().kpiValues({ search: '09-01' }, context())).total).toBe(1)
+    })
+
+    it('answers the whole list without a term', async () => {
+      await seed()
+      expect((await new KpiValueQuery().kpiValues({}, context())).total).toBe(2)
+    })
+  })
+
+  describe('kpiMetricValues', () => {
+    async function seed() {
+      const downtime = await repo(kpi.KpiMetric).save({ domain, name: 'Downtime minutes' })
+      const output = await repo(kpi.KpiMetric).save({ domain, name: 'Good units' })
+      await repo(kpi.KpiMetricValue).save([
+        { domain, metric: downtime, valueDate: '2026-09-01', value: 42 },
+        { domain, metric: output, valueDate: '2026-09-02', value: 900 }
+      ])
+    }
+
+    it('finds a value by the name of its metric - an answer, not an error', async () => {
+      await seed()
+      const { items, total } = await new KpiMetricValueQuery().kpiMetricValues({ search: 'downtime' }, context())
+      expect(total).toBe(1)
+      expect(items[0].value).toBe(42)
+    })
+
+    it('finds a value by its date', async () => {
+      await seed()
+      expect((await new KpiMetricValueQuery().kpiMetricValues({ search: '09-02' }, context())).total).toBe(1)
+    })
+  })
+})