@things-factory/menu-base 10.1.79 → 10.1.105

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/menu-base",
-  "version": "10.1.79",
+  "version": "10.1.105",
   "main": "dist-server/index.js",
   "browser": "client/index.ts",
   "things-factory": true,
@@ -26,5 +26,5 @@
   "dependencies": {
     "@things-factory/auth-base": "^10.1.79"
   },
-  "gitHead": "94cde9ba17dfdddb0a16139b71e5a7e370977e4a"
+  "gitHead": "c8ad9b40d57709beefd5e3d6167fd9cab6efea3a"
 }

package/tests/domain-reference.test.ts

@@ -0,0 +1,140 @@
+/**
+ * A menu's parent and children, and the menu a save edits, are looked up inside the caller's domain.
+ *
+ * `updateMenu` and the grid save (`updateMultipleMenu`, cuFlag 'M') took the parent and children by id
+ * alone, so a menu of one domain could be put under another domain's menu, or pull another domain's menus
+ * under itself. A target the domain does not have fell through to a save by its id, which edited the row of
+ * the other domain. This runs the real mutations on sqlite and reads the rows back.
+ */
+import 'reflect-metadata'
+
+const { existsSync } = require('fs')
+const { join } = require('path')
+const { DataSource } = require('typeorm')
+
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+
+function loadCompiled(modulePath: string): any {
+  const resolved = join(__dirname, '..', 'dist-server', `${modulePath}.js`)
+  if (!existsSync(resolved)) {
+    throw new Error(`menu-base build output is missing: ${resolved}\nBuild it first: npx tsc`)
+  }
+  return require(resolved)
+}
+
+let dataSource: any
+let Menu: any
+let MenuMutation: any
+
+let domain: any
+let other: any
+let user: any
+let ourTop: any
+let ourMenu: any
+let theirTop: any
+let theirMenu: any
+
+beforeAll(async () => {
+  const menuBase = loadCompiled('service/index')
+  Menu = menuBase.Menu
+  MenuMutation = loadCompiled('service/menu/menu-mutation').MenuMutation
+
+  dataSource = new DataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ...menuBase.entities],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+beforeEach(async () => {
+  await dataSource.synchronize(true)
+  const domains = dataSource.getRepository(shell.Domain)
+  domain = await domains.save({ name: 'ours', subdomain: 'ours' })
+  other = await domains.save({ name: 'theirs', subdomain: 'theirs' })
+  user = await dataSource.getRepository(authBase.User).save({ name: 'tester', email: 'tester@menu-base.test' })
+
+  const menus = dataSource.getRepository(Menu)
+  ourTop = await menus.save({ domain, name: 'our top' })
+  ourMenu = await menus.save({ domain, name: 'our menu', description: 'ours' })
+  theirTop = await menus.save({ domain: other, name: 'their top' })
+  theirMenu = await menus.save({ domain: other, name: 'their menu', description: 'theirs', parent: theirTop })
+})
+
+afterAll(async () => {
+  if (!dataSource) return
+  shell.removeDataSource('default')
+  shell.removeDataSource('tx')
+  await dataSource.destroy()
+})
+
+const context = () => ({ state: { domain, user, tx: dataSource.manager } })
+
+async function row(id: string) {
+  return await dataSource.getRepository(Menu).findOne({ where: { id }, relations: ['parent'] })
+}
+
+describe("a menu's parent and children come from the caller's domain", () => {
+  it('a parent of this domain is accepted', async () => {
+    await new MenuMutation().updateMenu(ourMenu.id, { parent: { id: ourTop.id } }, context())
+    expect((await row(ourMenu.id)).parent?.id).toBe(ourTop.id)
+  })
+
+  it('createMenu refuses a parent of another domain', async () => {
+    await expect(
+      new MenuMutation().createMenu({ name: 'new', parent: { id: theirTop.id } }, context())
+    ).rejects.toThrow(/parent menu not found in this domain/)
+    expect(await dataSource.getRepository(Menu).countBy({ name: 'new' })).toBe(0)
+  })
+
+  it('updateMenu refuses a parent of another domain', async () => {
+    await expect(new MenuMutation().updateMenu(ourMenu.id, { parent: { id: theirTop.id } }, context())).rejects.toThrow(
+      /parent menu not found in this domain/
+    )
+    expect((await row(ourMenu.id)).parent).toBeNull()
+  })
+
+  it('updateMenu refuses a child of another domain', async () => {
+    await expect(
+      new MenuMutation().updateMenu(ourTop.id, { children: [{ id: theirMenu.id }] }, context())
+    ).rejects.toThrow(/child menu not found in this domain/)
+    expect((await row(theirMenu.id)).parent?.id).toBe(theirTop.id)
+  })
+
+  it('updateMultipleMenu refuses them on a new row and on an edited one', async () => {
+    const mutation = new MenuMutation()
+    await expect(
+      mutation.updateMultipleMenu([{ cuFlag: '+', name: 'new', parent: { id: theirTop.id } }], context())
+    ).rejects.toThrow(/parent menu not found in this domain/)
+    await expect(
+      mutation.updateMultipleMenu([{ cuFlag: 'M', id: ourMenu.id, parent: { id: theirTop.id } }], context())
+    ).rejects.toThrow(/parent menu not found in this domain/)
+    await expect(
+      mutation.updateMultipleMenu([{ cuFlag: 'M', id: ourTop.id, children: [{ id: theirMenu.id }] }], context())
+    ).rejects.toThrow(/child menu not found in this domain/)
+    expect((await row(theirMenu.id)).parent?.id).toBe(theirTop.id)
+  })
+})
+
+describe("a save does not edit another domain's menu by its id", () => {
+  it('updateMenu', async () => {
+    await expect(
+      new MenuMutation().updateMenu(theirMenu.id, { description: 'overwritten' }, context())
+    ).rejects.toThrow(/menu not found in this domain/)
+    expect((await row(theirMenu.id)).description).toBe('theirs')
+  })
+
+  it('updateMultipleMenu', async () => {
+    await expect(
+      new MenuMutation().updateMultipleMenu([{ cuFlag: 'M', id: theirMenu.id, description: 'overwritten' }], context())
+    ).rejects.toThrow(/menu not found in this domain/)
+    expect((await row(theirMenu.id)).description).toBe('theirs')
+  })
+})

package/tests/open-doors.test.ts

@@ -0,0 +1,46 @@
+/*
+ * Every mutation of menu-base declares a privilege, and the domain owner may call it.
+ *
+ * Until 2026-10-01 no mutation of menu-base declared anything: any member of a domain could call them. Menus and their columns, buttons and details ask for `menu:mutation`
+ * (the category lite-menu already uses); which menus a role sees is role administration and asks for
+ * `user:mutation`, as the role mutations of auth-base do.
+ * The queries are not gated yet and are not measured here.
+ */
+import { gatesOf, openFields } from '../../../test/helpers/open-doors'
+
+/** The category each mutation asks for; anything not named here asks for `menu`. */
+const CATEGORY: Record<string, string> = {
+  updateRoleMenu: 'user',
+  updateRoleMenus: 'user'
+}
+
+/** Open on purpose or not decided yet, each with its reason. */
+const OPEN: Record<string, string> = {}
+
+let gates: Awaited<ReturnType<typeof gatesOf>>
+
+beforeAll(async () => {
+  gates = await gatesOf('menu-base')
+})
+
+it('every open mutation has a written reason', () => {
+  expect(openFields(gates.Mutation)).toEqual(Object.keys(OPEN).sort())
+})
+
+it('every declared mutation asks for its category and admits the domain owner', () => {
+  for (const [field, gate] of Object.entries(gates.Mutation)) {
+    if (field in OPEN) continue
+    expect({ field, ...gate }).toEqual({
+      field,
+      category: CATEGORY[field] ?? 'menu',
+      privilege: 'mutation',
+      owner: true,
+      super: false
+    })
+  }
+})
+
+it('the walk reaches every mutation', () => {
+  /* If the resolver list shrank, the checks above would pass by having nothing to look at. */
+  expect(Object.keys(gates.Mutation)).toHaveLength(33)
+})