@pikku/inspector 0.12.59 → 0.12.61

package/src/add/add-functions.ts

@@ -8,9 +8,10 @@ import {
 } from '../utils/extract-function-name.js'
 import { extractFunctionNode } from '../utils/extract-function-node.js'
 import { extractUsedWires } from '../utils/extract-services.js'
-import type { AuditDurability, FunctionServicesMeta } from '@pikku/core'
-import type { ScenarioStepKind, ScenarioSurface } from '@pikku/core/scenario'
-import { formatVersionedId, parseVersionedId } from '@pikku/core'
+import type { AuditDurability } from '@pikku/core/services'
+import type { FunctionServicesMeta } from '@pikku/core/function'
+import type { ScenarioSurface, ScenarioStepKind } from '@pikku/core/scenario'
+import { formatVersionedId, parseVersionedId } from '@pikku/core/utils'
 
 /** Binding keys a `pikkuScenarioStep` may declare, in report order. */
 const SCENARIO_SURFACE_KEYS: readonly ScenarioSurface[] = [
@@ -592,6 +593,7 @@ export const addFunctions: AddWiring = (
   let workflowRetries: number | undefined
   let workflowTimeout: string | undefined
   let scenarioStepSurfaces: ScenarioSurface[] | undefined
+  let scenarioStepRequiresActor: boolean | undefined
   let scenarioStepAddon: string | undefined
   let scenarioStepTemplate: string | undefined
   let scopes: string[] | undefined
@@ -683,8 +685,7 @@ export const addFunctions: AddWiring = (
     mcp = getPropertyValue(firstArg, 'mcp') as boolean | undefined
     auth = getPropertyValue(firstArg, 'auth') as boolean | undefined
     permissionsInBody = getPropertyValue(firstArg, 'permissionsInBody') as
-      | boolean
-      | undefined
+      boolean | undefined
     if (permissionsInBody && !options.allow?.permissionsInBody) {
       logger.critical(
         ErrorCode.PERMISSIONS_IN_BODY_NOT_ALLOWED,
@@ -721,22 +722,15 @@ export const addFunctions: AddWiring = (
     }
     readonly_ = getPropertyValue(firstArg, 'readonly') as boolean | undefined
     deploy = getPropertyValue(firstArg, 'deploy') as
-      | 'serverless'
-      | 'server'
-      | 'auto'
-      | undefined
+      'serverless' | 'server' | 'auto' | undefined
     approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
-      | boolean
-      | undefined
+      boolean | undefined
     workflowQueued = getPropertyValue(firstArg, 'workflowQueued') as
-      | boolean
-      | undefined
+      boolean | undefined
     workflowRetries = getPropertyValue(firstArg, 'workflowRetries') as
-      | number
-      | undefined
+      number | undefined
     workflowTimeout = getPropertyValue(firstArg, 'workflowTimeout') as
-      | string
-      | undefined
+      string | undefined
     // A step declares one implementation per surface it supports; the binding
     // keys that are present ARE the declaration, so there is nothing to read a
     // value from — only names to collect.
@@ -767,8 +761,7 @@ export const addFunctions: AddWiring = (
       scenarioStepSurfaces = ['default']
       if (scenarioStepKind === 'addon') {
         scenarioStepAddon = getPropertyValue(firstArg, 'addon') as
-          | string
-          | undefined
+          string | undefined
         if (!scenarioStepAddon) {
           logger.error(
             `• pikkuAddonScenarioStep('${name}') needs a string literal \`addon\` naming the addon whose system acts — the same name its wireAddon declares.`
@@ -780,10 +773,16 @@ export const addFunctions: AddWiring = (
       scenarioStepSurfaces = declaredSurfaces.length
         ? declaredSurfaces
         : undefined
+      // A browser binding cannot be provisioned without a window to open, so it
+      // requires an actor whether or not the step said so.
+      scenarioStepRequiresActor =
+        getPropertyValue(firstArg, 'actor') === true ||
+        declaredSurfaces.includes('browser')
+          ? true
+          : undefined
     }
     scenarioStepTemplate = getPropertyValue(firstArg, 'template') as
-      | string
-      | undefined
+      string | undefined
     scopes = getArrayPropertyValue(firstArg, 'scopes') ?? undefined
 
     // Extract approvalDescription identifier reference
@@ -827,13 +826,11 @@ export const addFunctions: AddWiring = (
       ) {
         const nodeObj = prop.initializer
         nodeDisplayName = getPropertyValue(nodeObj, 'displayName') as
-          | string
-          | null
+          string | null
         nodeCategory = getPropertyValue(nodeObj, 'category') as string | null
         nodeType = getPropertyValue(nodeObj, 'type') as NodeType | null
         nodeErrorOutput = getPropertyValue(nodeObj, 'errorOutput') as
-          | boolean
-          | null
+          boolean | null
 
         if (!nodeDisplayName) {
           logger.critical(
@@ -1376,6 +1373,7 @@ export const addFunctions: AddWiring = (
     workflowRetries: workflowRetries ?? undefined,
     workflowTimeout: workflowTimeout ?? undefined,
     scenarioStepSurfaces,
+    scenarioStepRequiresActor,
     // `persona` is the default reading of an unmarked step, so it is left off
     // rather than written into every step meta a project already has.
     scenarioStepKind:

package/src/add/add-http-route-ref.test.ts

@@ -0,0 +1,149 @@
+import { strict as assert } from 'assert'
+import { describe, test, before, after } from 'node:test'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { inspect } from '../inspector.js'
+import { filterInspectorState } from '../utils/filter-inspector-state.js'
+import type { InspectorLogger, InspectorState } from '../types.js'
+
+const ADDON_PACKAGE = '@addon/greeter'
+const NAMESPACE = 'ext'
+const TARGET = `${NAMESPACE}:greet`
+
+const logger: InspectorLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  diagnostic: () => {},
+  critical: () => {},
+  hasCriticalErrors: () => false,
+} as unknown as InspectorLogger
+
+const writeAddonFixture = (rootDir: string) => {
+  writeFileSync(
+    join(rootDir, 'package.json'),
+    JSON.stringify({ name: 'consumer' })
+  )
+  const addonDir = join(rootDir, 'node_modules', ADDON_PACKAGE)
+  const pikku = join(addonDir, '.pikku')
+  mkdirSync(join(pikku, 'function'), { recursive: true })
+  mkdirSync(join(pikku, 'schemas', 'schemas'), { recursive: true })
+  writeFileSync(
+    join(addonDir, 'package.json'),
+    JSON.stringify({ name: ADDON_PACKAGE })
+  )
+  writeFileSync(
+    join(pikku, 'function', 'pikku-functions-meta.gen.json'),
+    JSON.stringify({
+      greet: {
+        pikkuFuncId: 'greet',
+        name: 'greet',
+        sessionless: true,
+        inputSchemaName: 'GreetInput',
+        outputSchemaName: 'GreetOutput',
+        inputs: ['GreetInput'],
+        outputs: ['GreetOutput'],
+        services: { optimized: true, services: ['logger'] },
+      },
+    })
+  )
+  writeFileSync(
+    join(pikku, 'schemas', 'schemas', 'GreetInput.schema.json'),
+    JSON.stringify({
+      type: 'object',
+      properties: {
+        id: { type: 'string' },
+        loud: { type: 'boolean' },
+        name: { type: 'string' },
+      },
+    })
+  )
+}
+
+const writeWiring = (rootDir: string): string => {
+  const file = join(rootDir, 'greet.wiring.ts')
+  writeFileSync(
+    file,
+    [
+      `import { ref, wireAddon } from '@pikku/core'`,
+      `import { wireHTTP } from '@pikku/core/http'`,
+      ``,
+      `wireAddon({ name: '${NAMESPACE}', package: '${ADDON_PACKAGE}' })`,
+      ``,
+      `wireHTTP({`,
+      `  auth: false,`,
+      `  method: 'get',`,
+      `  route: '/greet/:id',`,
+      `  func: ref('${TARGET}'),`,
+      `})`,
+      ``,
+      `wireHTTP({`,
+      `  auth: false,`,
+      `  method: 'post',`,
+      `  route: '/greet',`,
+      `  query: ['loud'],`,
+      `  func: ref('${TARGET}'),`,
+      `})`,
+    ].join('\n')
+  )
+  return file
+}
+
+describe('an HTTP route wired with ref() to an addon function', () => {
+  let rootDir: string
+  let state: InspectorState
+
+  before(async () => {
+    rootDir = mkdtempSync(join(tmpdir(), 'pikku-http-ref-'))
+    writeAddonFixture(rootDir)
+    const file = writeWiring(rootDir)
+    state = await inspect(logger, [file], { rootDir })
+  })
+
+  after(() => {
+    rmSync(rootDir, { recursive: true, force: true })
+  })
+
+  test('records the ref target as the route function id', () => {
+    assert.equal(state.http.meta.get['/greet/:id']?.pikkuFuncId, TARGET)
+    assert.equal(state.http.meta.post['/greet']?.pikkuFuncId, TARGET)
+  })
+
+  // packageName names the package a wire runs in — its middleware, its
+  // services, its scoped credentials. The route belongs to the consuming app
+  // however its function is reached, so tagging it with the addon's package
+  // would silently swap the app's global middleware for the addon's.
+  test("leaves the route in the consuming app's package", () => {
+    assert.equal(state.http.meta.get['/greet/:id']?.packageName, undefined)
+    assert.equal(state.http.meta.post['/greet']?.packageName, undefined)
+  })
+
+  test('mints no wrapper function metadata for the route', () => {
+    const wrapperIds = Object.keys(state.functions.meta).filter((id) =>
+      id.startsWith('http:')
+    )
+    assert.deepEqual(wrapperIds, [])
+    assert.equal(state.functions.meta[TARGET], undefined)
+  })
+
+  test('keeps each route its own params and query', () => {
+    assert.deepEqual(state.http.meta.get['/greet/:id']?.params, ['id'])
+    assert.equal(state.http.meta.get['/greet/:id']?.query, undefined)
+    assert.equal(state.http.meta.post['/greet']?.params, undefined)
+    assert.deepEqual(state.http.meta.post['/greet']?.query, ['loud'])
+  })
+
+  test('marks the addon target as used so tree-shaking keeps it', () => {
+    assert.ok(state.serviceAggregation.usedFunctions.has(TARGET))
+  })
+
+  test('survives a filtered bundle together with its addon declaration', () => {
+    const filtered = filterInspectorState(state, { names: [TARGET] }, logger)
+    assert.equal(filtered.http.meta.get['/greet/:id']?.pikkuFuncId, TARGET)
+    assert.equal(filtered.http.meta.post['/greet']?.pikkuFuncId, TARGET)
+    assert.ok(filtered.rpc.wireAddonDeclarations.has(NAMESPACE))
+    assert.ok(filtered.serviceAggregation.usedFunctions.has(TARGET))
+  })
+})

package/src/add/add-http-route.ts

@@ -243,6 +243,17 @@ export function registerHTTPRoute({
       )
     : null
 
+  // A ref()-wired route points straight at the addon function, the same way the
+  // CLI and channel adders record one. The addon's own metadata is the contract
+  // — and it is authoritative where the checker is not: `ref('ns:fn')` only
+  // types precisely once the consumer's own rpc map already lists the addon's
+  // functions, so a cold run inferred the whole `FlattenedRPCMap` and a warm one
+  // inferred the real input. The addon's metadata says which it is either way.
+  //
+  // The route stays the consuming app's all the same, so it records no
+  // packageName: that names the package a wire *runs in*, and running this one
+  // inside the addon would hand it the addon's middleware and services instead
+  // of the app's. `ref` reaches the addon over RPC, which enters it properly.
   if (refAddonTarget) {
     const targetMeta = resolveFunctionMeta(state, refAddonTarget)
     if (!targetMeta) {
@@ -251,25 +262,16 @@ export function registerHTTPRoute({
       )
       return
     }
-  }
-
-  ensureFunctionMetadata(
-    state,
-    funcName,
-    fullRoute,
-    funcInitializer,
-    checker,
-    extracted.isHelper
-  )
-
-  // Propagate sessionless from the addon target so the runtime can correctly
-  // determine whether a session is required for ref()-based routes.
-  if (refAddonTarget) {
-    const targetMeta = resolveFunctionMeta(state, refAddonTarget)
-    const inlineMeta = state.functions.meta[funcName]
-    if (targetMeta && inlineMeta && targetMeta.sessionless !== undefined) {
-      inlineMeta.sessionless = targetMeta.sessionless
-    }
+    funcName = refAddonTarget
+  } else {
+    ensureFunctionMetadata(
+      state,
+      funcName,
+      fullRoute,
+      funcInitializer,
+      checker,
+      extracted.isHelper
+    )
   }
 
   // The route's own `auth`, falling back to the group's. Recorded on the meta
@@ -322,13 +324,12 @@ export function registerHTTPRoute({
   const input = fnMeta.inputs?.[0] || null
 
   const getRouteInputKeys = (): string[] | null => {
-    const targetFuncName = refAddonTarget ?? funcName
-    const inputTypes = state.typesLookup.get(targetFuncName)
+    const inputTypes = state.typesLookup.get(funcName)
     if (inputTypes && inputTypes.length > 0) {
       return extractTypeKeys(inputTypes[0])
     }
 
-    const targetMeta = resolveFunctionMeta(state, targetFuncName)
+    const targetMeta = resolveFunctionMeta(state, funcName)
     if (targetMeta?.inputSchemaName) {
       const schema = state.schemas[targetMeta.inputSchemaName] as any
       const properties = schema?.properties
@@ -354,7 +355,7 @@ export function registerHTTPRoute({
           logger.critical(
             ErrorCode.ROUTE_PARAM_MISMATCH,
             `Route '${fullRoute}' has path parameter(s) [${missingParams.join(', ')}] ` +
-              `not found in function '${refAddonTarget ?? funcName}' input type. ` +
+              `not found in function '${funcName}' input type. ` +
               `Input type has: [${inputKeys.join(', ')}]`
           )
           return
@@ -368,7 +369,7 @@ export function registerHTTPRoute({
           logger.critical(
             ErrorCode.ROUTE_QUERY_MISMATCH,
             `Route '${fullRoute}' has query parameter(s) [${missingQuery.join(', ')}] ` +
-              `not found in function '${refAddonTarget ?? funcName}' input type. ` +
+              `not found in function '${funcName}' input type. ` +
               `Input type has: [${inputKeys.join(', ')}]`
           )
           return
@@ -393,9 +394,6 @@ export function registerHTTPRoute({
   const permissions = resolvePermissions(state, obj, tags, checker)
 
   state.serviceAggregation.usedFunctions.add(funcName)
-  if (refAddonTarget) {
-    state.serviceAggregation.usedFunctions.add(refAddonTarget)
-  }
   extractWireNames(middleware).forEach((name) =>
     state.serviceAggregation.usedMiddleware.add(name)
   )
@@ -420,7 +418,6 @@ export function registerHTTPRoute({
   state.http.files.add(sourceFile.fileName)
   state.http.meta[method][fullRoute] = {
     pikkuFuncId: funcName,
-    ...(refAddonTarget && { refTarget: refAddonTarget }),
     ...(packageName && { packageName }),
     route: fullRoute,
     sourceFile: sourceFile.fileName,

package/src/add/add-keyed-wiring.ts

@@ -7,13 +7,15 @@ import {
 import type { AddWiring, InspectorState } from '../types.js'
 import { ErrorCode } from '../error-codes.js'
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js'
-import { parseDurationString } from '@pikku/core'
+import { parseDurationString } from '@pikku/core/utils'
 
 export interface KeyedWiringConfig {
   functionName: string
   idField: string
   label: string
   schemaPrefix: string
+  /** Boolean property carrying this wiring kind's deploy-gate opt-in/opt-out. */
+  flagField: string
   getState: (state: InspectorState) => {
     definitions: any[]
     files: Set<string>
@@ -49,17 +51,15 @@ export const createAddKeyedWiring = (config: KeyedWiringConfig): AddWiring => {
 
       const nameValue = getPropertyValue(obj, 'name') as string | null
       const displayNameValue = getPropertyValue(obj, 'displayName') as
-        | string
-        | null
+        string | null
       const descriptionValue = getPropertyValue(obj, 'description') as
-        | string
-        | null
+        string | null
       const rotationPeriodValue = getPropertyValue(obj, 'rotationPeriod') as
-        | string
-        | null
+        string | null
       const docsUrlValue = getPropertyValue(obj, 'docsUrl') as string | null
       const allowedHostsValue = getArrayPropertyValue(obj, 'allowedHosts')
       const idValue = getPropertyValue(obj, config.idField) as string | null
+      const flagValue = getPropertyValue(obj, config.flagField) === true
 
       let schemaVariableName: string | null = null
       let schemaSourceFile: string | null = null
@@ -171,6 +171,7 @@ export const createAddKeyedWiring = (config: KeyedWiringConfig): AddWiring => {
         docsUrl: docsUrlValue || undefined,
         allowedHosts: allowedHostsValue || undefined,
         [config.idField]: idValue,
+        [config.flagField]: flagValue || undefined,
         schema: schemaLookupName,
         sourceFile,
       })

package/src/add/add-middleware.ts

@@ -698,12 +698,14 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
     return
   }
 
-  if (expression.text === 'pikkuAIMiddleware') {
+  if (expression.text === 'pikkuAgentMiddleware') {
     const arg = args[0]
     if (!arg) return
 
     if (!ts.isObjectLiteralExpression(arg)) {
-      logger.error(`• pikkuAIMiddleware() requires an object literal argument.`)
+      logger.error(
+        `• pikkuAgentMiddleware() requires an object literal argument.`
+      )
       return
     }
 
@@ -744,13 +746,13 @@ export const addMiddleware: AddWiring = (logger, node, checker, state) => {
         pikkuFuncId = node.parent.name.text
       } else {
         logger.error(
-          `• pikkuAIMiddleware() must be assigned to a variable or object property. ` +
-            `Extract it to a const: const myMiddleware = pikkuAIMiddleware(...)`
+          `• pikkuAgentMiddleware() must be assigned to a variable or object property. ` +
+            `Extract it to a const: const myMiddleware = pikkuAgentMiddleware(...)`
         )
         return
       }
     }
-    state.aiMiddleware.definitions[pikkuFuncId] = {
+    state.agentMiddleware.definitions[pikkuFuncId] = {
       services,
       sourceFile: node.getSourceFile().fileName,
       position: node.getStart(),

package/src/add/add-permission.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript'
-import type { FunctionWiresMeta } from '@pikku/core'
+import type { FunctionWiresMeta } from '@pikku/core/function'
 import type { AddWiring } from '../types.js'
 import { extractFunctionName } from '../utils/extract-function-name.js'
 import {

package/src/add/add-personas.test.ts

@@ -108,6 +108,30 @@ describe('addPersonas inspector', () => {
     assert.equal(susan.runnable, true)
   })
 
+  test('the app a person signs into survives into the meta', async () => {
+    const { state, criticals } = await inspectSource(
+      withRoles(
+        'definePersonas({',
+        '  susan: {',
+        "    name: 'Susan',",
+        "    app: 'storefront',",
+        '  },',
+        '})'
+      )
+    )
+
+    assert.deepEqual(criticals, [])
+    assert.equal(state.personas.definitions[0]!.app, 'storefront')
+  })
+
+  test('a person who names no app has none, rather than a guessed one', async () => {
+    const { state } = await inspectSource(
+      withRoles('definePersonas({', "  susan: { name: 'Susan' },", '})')
+    )
+
+    assert.equal(state.personas.definitions[0]!.app, undefined)
+  })
+
   test('extracts a declared avatar', async () => {
     const { state } = await inspectSource(
       withRoles(

package/src/add/add-personas.ts

@@ -1,7 +1,7 @@
 import * as ts from 'typescript'
 import { DISPOSITIONS } from '@pikku/core/virtual-user'
 import { isRunnablePersona } from '@pikku/core/persona'
-import type { PersonaAccountMeta, PersonaMeta } from '@pikku/core/persona'
+import type { PersonaMeta, PersonaAccountMeta } from '@pikku/core/persona'
 import { ErrorCode } from '../error-codes.js'
 import { claimSingleDeclaration } from '../utils/single-declaration.js'
 import type { AddWiring, InspectorLogger } from '../types.js'
@@ -265,6 +265,8 @@ export const addPersonas: AddWiring = (logger, node, _checker, state) => {
     if (avatarUrl !== undefined) persona.avatarUrl = avatarUrl
     const personality = stringProperty(config, 'personality')
     if (personality !== undefined) persona.personality = personality
+    const app = stringProperty(config, 'app')
+    if (app !== undefined) persona.app = app
     if (disposition !== undefined) {
       persona.disposition = disposition as PersonaMeta['disposition']
     }

package/src/add/add-scenario-step.test.ts

@@ -39,6 +39,12 @@ const STEPS = [
   "  description: 'sees a receipt',",
   '  default: async ({ logger }) => ({ ok: true }),',
   '})',
+  'export const asksForTheReceipt = pikkuScenarioStep({',
+  "  name: 'asksForTheReceipt',",
+  "  description: 'asks for the receipt',",
+  '  actor: true,',
+  '  default: async ({ logger }) => ({ ok: true }),',
+  '})',
 ].join('\n')
 
 const scenarioSource = (body: string[], preamble: string[] = []) =>
@@ -210,6 +216,35 @@ describe('pikkuScenarioStep', () => {
     }
   })
 
+  test('a step declaring `actor: true` called without one is a PKU677 critical', async () => {
+    const { criticals, cleanup } = await run([
+      "await scenario.then('asks for the receipt', 'asksForTheReceipt', {})",
+    ])
+    try {
+      assert.ok(
+        criticals.find((c) => c.code === 'PKU677'),
+        `a step that says it runs as somebody must be given somebody, browser binding or not, got: ${JSON.stringify(criticals)}`
+      )
+    } finally {
+      await cleanup()
+    }
+  })
+
+  test('a step that declares no actor is not flagged for running without one', async () => {
+    const { criticals, cleanup } = await run([
+      "await scenario.then('sees a receipt', 'seesAReceipt', {})",
+    ])
+    try {
+      assert.equal(
+        criticals.filter((c) => c.code === 'PKU677').length,
+        0,
+        `an assertion over an earlier step's value has nobody to be, got: ${JSON.stringify(criticals)}`
+      )
+    } finally {
+      await cleanup()
+    }
+  })
+
   test('a scenario that never asserts is a PKU680 critical', async () => {
     const { criticals, cleanup } = await run([
       "await scenario.given('buys an apple', 'buysAnApple', { qty: 1 }, { actor: actors.shopper })",

package/src/add/add-scope.test.ts

@@ -202,10 +202,10 @@ describe('addScope inspector', () => {
       [],
       `expected no duplicate critical, got ${JSON.stringify(criticals)}`
     )
-    assert.deepEqual(
-      state.scopes.definitions.map((d) => d.name).sort(),
-      ['admin', 'billing']
-    )
+    assert.deepEqual(state.scopes.definitions.map((d) => d.name).sort(), [
+      'admin',
+      'billing',
+    ])
   })
 
   // The CLI scaffolds a scope tree of its own — `user-admin.gen.ts` declares the

package/src/add/add-scope.ts

@@ -88,14 +88,12 @@ const extractScopeNodes = (
 
     const node: ScopeNodeMeta = {}
     const displayName = getPropertyValue(prop.initializer, 'displayName') as
-      | string
-      | null
+      string | null
     if (displayName) {
       node.displayName = displayName
     }
     const description = getPropertyValue(prop.initializer, 'description') as
-      | string
-      | null
+      string | null
     if (description) {
       node.description = description
     }
@@ -192,11 +190,9 @@ export const addScope: AddWiring = (logger, node, checker, state, _options) => {
 
     const root = prop.initializer
     const displayNameValue = getPropertyValue(root, 'displayName') as
-      | string
-      | null
+      string | null
     const descriptionValue = getPropertyValue(root, 'description') as
-      | string
-      | null
+      string | null
 
     let scopes: Record<string, ScopeNodeMeta> | undefined
     const scopesProp = root.properties.find(

package/src/add/add-secret.ts

@@ -5,5 +5,6 @@ export const addSecret = createAddKeyedWiring({
   idField: 'secretId',
   label: 'Secret',
   schemaPrefix: 'SecretSchema',
+  flagField: 'optional',
   getState: (state) => state.secrets,
 })

package/src/add/add-system-role.test.ts

@@ -118,10 +118,10 @@ describe('addSystemRole inspector', () => {
       )
     )
 
-    assert.deepEqual(
-      state.systemRoles.definitions.map((r) => r.name).sort(),
-      ['admin', 'buyer']
-    )
+    assert.deepEqual(state.systemRoles.definitions.map((r) => r.name).sort(), [
+      'admin',
+      'buyer',
+    ])
   })
 
   // Roles follow scopes: a project scaffolding user-admin has a generated
@@ -142,10 +142,10 @@ describe('addSystemRole inspector', () => {
       [],
       `expected no duplicate critical, got ${JSON.stringify(criticals)}`
     )
-    assert.deepEqual(
-      state.systemRoles.definitions.map((r) => r.name).sort(),
-      ['admin', 'buyer']
-    )
+    assert.deepEqual(state.systemRoles.definitions.map((r) => r.name).sort(), [
+      'admin',
+      'buyer',
+    ])
   })
 
   // A generated file is not the one place a person adds a role to, so it neither

package/src/add/add-system-role.ts

@@ -146,11 +146,9 @@ export const addSystemRole: AddWiring = (
     }
 
     const displayName = getPropertyValue(prop.initializer, 'displayName') as
-      | string
-      | null
+      string | null
     const description = getPropertyValue(prop.initializer, 'description') as
-      | string
-      | null
+      string | null
 
     state.systemRoles.files.add(sourceFile)
     state.systemRoles.definitions.push({

package/src/add/add-variable.ts

@@ -5,5 +5,6 @@ export const addVariable = createAddKeyedWiring({
   idField: 'variableId',
   label: 'Variable',
   schemaPrefix: 'VariableSchema',
+  flagField: 'required',
   getState: (state) => state.variables,
 })