@pikku/inspector 0.12.41 → 0.12.43

package/src/add/add-permission.ts

@@ -1,53 +1,21 @@
 import * as ts from 'typescript'
 import type { FunctionWiresMeta } from '@pikku/core'
-import type { AddWiring, InspectorState } from '../types.js'
-import {
-  extractFunctionName,
-  isNamedExport,
-  makeContextBasedId,
-} from '../utils/extract-function-name.js'
+import type { AddWiring } from '../types.js'
+import { extractFunctionName } from '../utils/extract-function-name.js'
 import {
   extractServicesFromFunction,
   extractUsedWires,
 } from '../utils/extract-services.js'
-import { extractPermissionPikkuNames } from '../utils/permissions.js'
 import { getPropertyValue } from '../utils/get-property-value.js'
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 
-function renameTempDefinitions(
-  state: InspectorState,
-  definitionIds: string[],
-  groupType: string,
-  groupKey: string
-): void {
-  const tempIndices = definitionIds
-    .map((name, i) => (name.startsWith('__temp_') ? i : -1))
-    .filter((i) => i >= 0)
-
-  for (const idx of tempIndices) {
-    const oldId = definitionIds[idx]
-    const newId =
-      tempIndices.length === 1
-        ? makeContextBasedId(groupType, groupKey)
-        : makeContextBasedId(groupType, groupKey, String(idx))
-    const existing = state.permissions.definitions[oldId]
-    if (existing) {
-      delete state.permissions.definitions[oldId]
-      state.permissions.definitions[newId] = existing
-    }
-    definitionIds[idx] = newId
-  }
-}
-
 function isInsidePermissionContainer(node: ts.Node): boolean {
   let current = node.parent
   while (current) {
     if (
       ts.isCallExpression(current) &&
       ts.isIdentifier(current.expression) &&
-      (current.expression.text === 'pikkuPermissionFactory' ||
-        current.expression.text === 'addTagPermission' ||
-        current.expression.text === 'addHTTPPermission')
+      current.expression.text === 'pikkuPermissionFactory'
     ) {
       return true
     }
@@ -57,7 +25,7 @@ function isInsidePermissionContainer(node: ts.Node): boolean {
 }
 
 /**
- * Inspect pikkuPermission calls, addPermission calls, and addHTTPPermission calls
+ * Inspect pikkuPermission, pikkuAuth, and pikkuPermissionFactory definitions.
  */
 export const addPermission: AddWiring = (logger, node, checker, state) => {
   if (!ts.isCallExpression(node)) return
@@ -340,210 +308,4 @@ export const addPermission: AddWiring = (logger, node, checker, state) => {
     )
     return
   }
-
-  // Handle addPermission('tag', [permission1, permission2])
-  // Supports two patterns:
-  // 1. export const x = () => addTagPermission('tag', [...])  (factory - tree-shakeable)
-  // 2. export const x = addTagPermission('tag', [...])  (direct - no tree-shaking)
-  if (expression.text === 'addTagPermission') {
-    const tagArg = args[0]
-    const permissionsArrayArg = args[1]
-
-    if (!tagArg || !permissionsArrayArg) return
-
-    // Extract tag name
-    let tag: string | undefined
-    if (ts.isStringLiteral(tagArg)) {
-      tag = tagArg.text
-    }
-
-    if (!tag) {
-      logger.warn(`• addTagPermission call without valid tag string`)
-      return
-    }
-
-    // Check if permissions is a literal array or object
-    if (
-      !ts.isArrayLiteralExpression(permissionsArrayArg) &&
-      !ts.isObjectLiteralExpression(permissionsArrayArg)
-    ) {
-      logger.error(
-        `• addTagPermission('${tag}', ...) must have a literal array or object as second argument`
-      )
-      return
-    }
-
-    // Extract permission pikkuFuncIds from array
-    const permissionNames = extractPermissionPikkuNames(
-      permissionsArrayArg,
-      checker,
-      state.rootDir
-    )
-
-    if (permissionNames.length > 0) {
-      renameTempDefinitions(state, permissionNames, 'tag', tag)
-    }
-
-    const allServices = new Set<string>()
-    for (const permissionName of permissionNames) {
-      const permissionMeta = state.permissions.definitions[permissionName]
-      if (permissionMeta && permissionMeta.services) {
-        for (const service of permissionMeta.services.services) {
-          allServices.add(service)
-        }
-      }
-    }
-
-    let isFactory = false
-    let exportedName: string | null = null
-    let parent = node.parent
-
-    if (parent && ts.isArrowFunction(parent)) {
-      if (parent.parameters.length === 0) {
-        isFactory = true
-
-        const arrowParent = parent.parent
-        if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
-          if (ts.isIdentifier(arrowParent.name)) {
-            if (isNamedExport(arrowParent)) {
-              exportedName = arrowParent.name.text
-            }
-          }
-        }
-      }
-    }
-
-    if (!isFactory) {
-      const extracted = extractFunctionName(node, checker, state.rootDir)
-      exportedName = extracted.exportedName
-    }
-
-    if (!isFactory && exportedName) {
-      logger.warn(
-        `• Permission group '${exportedName}' for tag '${tag}' is not wrapped in a factory function. ` +
-          `For tree-shaking, use: export const ${exportedName} = () => addTagPermission('${tag}', [...])`
-      )
-    }
-
-    state.permissions.tagPermissions.set(tag, {
-      exportName: exportedName,
-      sourceFile: node.getSourceFile().fileName,
-      position: node.getStart(),
-      services: {
-        optimized: false,
-        services: Array.from(allServices),
-      },
-      count: permissionNames.length,
-      instanceIds: permissionNames,
-      isFactory,
-    })
-
-    logger.debug(
-      `• Found tag permission group: ${tag} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`
-    )
-    return
-  }
-
-  // Handle addHTTPPermission(pattern, [permission1, permission2])
-  // Supports two patterns:
-  // 1. export const x = () => addHTTPPermission('*', [...])  (factory - tree-shakeable)
-  // 2. export const x = addHTTPPermission('*', [...])  (direct - no tree-shaking)
-  if (expression.text === 'addHTTPPermission') {
-    const patternArg = args[0]
-    const permissionsArrayArg = args[1]
-
-    if (!patternArg || !permissionsArrayArg) return
-
-    // Extract route pattern
-    let pattern: string | undefined
-    if (ts.isStringLiteral(patternArg)) {
-      pattern = patternArg.text
-    }
-
-    if (!pattern) {
-      logger.warn(`• addHTTPPermission call without valid pattern string`)
-      return
-    }
-
-    // Check if permissions is a literal array or object
-    if (
-      !ts.isArrayLiteralExpression(permissionsArrayArg) &&
-      !ts.isObjectLiteralExpression(permissionsArrayArg)
-    ) {
-      logger.error(
-        `• addHTTPPermission('${pattern}', ...) must have a literal array or object as second argument`
-      )
-      return
-    }
-
-    // Extract permission pikkuFuncIds from array
-    const permissionNames = extractPermissionPikkuNames(
-      permissionsArrayArg,
-      checker,
-      state.rootDir
-    )
-
-    if (permissionNames.length > 0) {
-      renameTempDefinitions(state, permissionNames, 'http', pattern)
-    }
-
-    const allServices = new Set<string>()
-    for (const permissionName of permissionNames) {
-      const permissionMeta = state.permissions.definitions[permissionName]
-      if (permissionMeta && permissionMeta.services) {
-        for (const service of permissionMeta.services.services) {
-          allServices.add(service)
-        }
-      }
-    }
-
-    let isFactory = false
-    let exportedName: string | null = null
-    let parent = node.parent
-
-    if (parent && ts.isArrowFunction(parent)) {
-      if (parent.parameters.length === 0) {
-        isFactory = true
-
-        const arrowParent = parent.parent
-        if (arrowParent && ts.isVariableDeclaration(arrowParent)) {
-          if (ts.isIdentifier(arrowParent.name)) {
-            if (isNamedExport(arrowParent)) {
-              exportedName = arrowParent.name.text
-            }
-          }
-        }
-      }
-    }
-
-    if (!isFactory) {
-      const extracted = extractFunctionName(node, checker, state.rootDir)
-      exportedName = extracted.exportedName
-    }
-
-    if (!isFactory && exportedName) {
-      logger.warn(
-        `• HTTP permission group '${exportedName}' for pattern '${pattern}' is not wrapped in a factory function. ` +
-          `For tree-shaking, use: export const ${exportedName} = () => addHTTPPermission('${pattern}', [...])`
-      )
-    }
-
-    state.http.routePermissions.set(pattern, {
-      exportName: exportedName,
-      sourceFile: node.getSourceFile().fileName,
-      position: node.getStart(),
-      services: {
-        optimized: false,
-        services: Array.from(allServices),
-      },
-      count: permissionNames.length,
-      instanceIds: permissionNames,
-      isFactory,
-    })
-
-    logger.debug(
-      `• Found HTTP route permission group: ${pattern} -> [${permissionNames.join(', ')}] (${isFactory ? 'factory' : 'direct'})`
-    )
-    return
-  }
 }

package/src/add/add-queue-worker.ts

@@ -9,6 +9,7 @@ import {
   makeContextBasedId,
 } from '../utils/extract-function-name.js'
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
+import { ensureInlineWiringFunction } from '../utils/ensure-function-metadata.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
 import { resolveAddonName } from '../utils/resolve-addon-package.js'
@@ -82,6 +83,16 @@ export const addQueueWorker: AddWiring = (logger, node, checker, state) => {
       return
     }
 
+    // Register metadata for a func inlined into the wiring (see helper).
+    ensureInlineWiringFunction(
+      state,
+      pikkuFuncId,
+      name,
+      funcInitializer,
+      checker,
+      extracted.isHelper
+    )
+
     // --- resolve middleware ---
     const middleware = resolveMiddleware(state, obj, tags, checker)
 

package/src/add/add-schedule.ts

@@ -9,6 +9,7 @@ import {
   makeContextBasedId,
 } from '../utils/extract-function-name.js'
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
+import { ensureInlineWiringFunction } from '../utils/ensure-function-metadata.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
 import { resolveAddonName } from '../utils/resolve-addon-package.js'
@@ -84,6 +85,16 @@ export const addSchedule: AddWiring = (
       return
     }
 
+    // Register metadata for a func inlined into the wiring (see helper).
+    ensureInlineWiringFunction(
+      state,
+      pikkuFuncId,
+      nameValue,
+      funcInitializer,
+      checker,
+      extracted.isHelper
+    )
+
     // --- resolve middleware ---
     const middleware = resolveMiddleware(state, obj, tags, checker)
 

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

@@ -0,0 +1,346 @@
+import { strict as assert } from 'assert'
+import { describe, test } from 'node:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { inspect } from '../inspector.js'
+import { ErrorCode } from '../error-codes.js'
+import type { InspectorLogger } from '../types.js'
+
+const makeLogger = (criticals: Array<{ code: ErrorCode; message: string }>) =>
+  ({
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    diagnostic: ({ code, message }) => {
+      criticals.push({ code, message })
+    },
+    critical: (code: ErrorCode, message: string) => {
+      criticals.push({ code, message })
+    },
+    hasCriticalErrors: () => criticals.length > 0,
+  }) satisfies InspectorLogger
+
+const inspectSource = async (source: string) => {
+  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-add-scope-'))
+  const file = join(rootDir, 'scopes.ts')
+  await writeFile(file, source)
+  const criticals: Array<{ code: ErrorCode; message: string }> = []
+  try {
+    const state = await inspect(makeLogger(criticals), [file], { rootDir })
+    return { state, criticals, file }
+  } finally {
+    await rm(rootDir, { recursive: true, force: true })
+  }
+}
+
+describe('addScope inspector', () => {
+  test('extracts a flat scope', async () => {
+    const { state, criticals } = await inspectSource(
+      [
+        "import { wireScope } from '@pikku/core/scope'",
+        'wireScope({',
+        '  admin: {',
+        "    displayName: 'Administration',",
+        "    description: 'Administrative access',",
+        '  },',
+        '})',
+      ].join('\n')
+    )
+
+    assert.equal(criticals.length, 0)
+    assert.equal(state.scopes.definitions.length, 1)
+    assert.equal(state.scopes.definitions[0]!.name, 'admin')
+    assert.equal(state.scopes.definitions[0]!.displayName, 'Administration')
+    assert.equal(
+      state.scopes.definitions[0]!.description,
+      'Administrative access'
+    )
+  })
+
+  test('extracts a displayName at every depth', async () => {
+    const { state, criticals } = await inspectSource(
+      [
+        "import { wireScope } from '@pikku/core/scope'",
+        'wireScope({',
+        '  admin: {',
+        "    displayName: 'Administration',",
+        '    scopes: {',
+        '      invoices: {',
+        "        displayName: 'Invoice Management',",
+        '        scopes: {',
+        "          create: { displayName: 'Create Invoices' },",
+        '        },',
+        '      },',
+        '    },',
+        '  },',
+        '})',
+      ].join('\n')
+    )
+
+    assert.equal(criticals.length, 0)
+    const admin = state.scopes.definitions[0]!
+    assert.equal(admin.displayName, 'Administration')
+    const invoices = admin.scopes!.invoices!
+    assert.equal(invoices.displayName, 'Invoice Management')
+    assert.equal(invoices.scopes!.create!.displayName, 'Create Invoices')
+  })
+
+  test('extracts a nested scope tree', async () => {
+    const { state, criticals } = await inspectSource(
+      [
+        "import { wireScope } from '@pikku/core/scope'",
+        'wireScope({',
+        '  admin: {',
+        '    scopes: {',
+        '      invoices: {',
+        "        description: 'Invoice management',",
+        '        scopes: {',
+        "          create: { description: 'Create invoices' },",
+        '        },',
+        '      },',
+        '    },',
+        '  },',
+        '})',
+      ].join('\n')
+    )
+
+    assert.equal(criticals.length, 0)
+    assert.deepEqual(state.scopes.definitions[0]!.scopes, {
+      invoices: {
+        description: 'Invoice management',
+        scopes: {
+          create: { description: 'Create invoices' },
+        },
+      },
+    })
+  })
+
+  test('records the source file', async () => {
+    const { state, file } = await inspectSource(
+      [
+        "import { wireScope } from '@pikku/core/scope'",
+        'wireScope({ admin: {} })',
+      ].join('\n')
+    )
+
+    assert.equal(state.scopes.definitions[0]!.sourceFile, file)
+    assert.ok(state.scopes.files.has(file))
+  })
+
+  // The point of the keyed form: one call declares as many roots as you like,
+  // and a root reads exactly like the nodes beneath it.
+  test('extracts several roots from one declaration', async () => {
+    const { state, criticals } = await inspectSource(
+      [
+        "import { wireScope } from '@pikku/core/scope'",
+        'wireScope({ admin: {}, billing: { scopes: { read: {} } } })',
+      ].join('\n')
+    )
+
+    assert.equal(criticals.length, 0)
+    assert.deepEqual(
+      state.scopes.definitions.map((d) => d.name),
+      ['admin', 'billing']
+    )
+    assert.deepEqual(state.scopes.definitions[1]!.scopes, { read: {} })
+  })
+
+  test('extracts several declarations', async () => {
+    const { state } = await inspectSource(
+      [
+        "import { wireScope } from '@pikku/core/scope'",
+        'wireScope({ admin: {} })',
+        'wireScope({ billing: {} })',
+      ].join('\n')
+    )
+
+    assert.deepEqual(
+      state.scopes.definitions.map((d) => d.name),
+      ['admin', 'billing']
+    )
+  })
+
+  test('is critical when a root embeds the separator', async () => {
+    const { criticals } = await inspectSource(
+      [
+        "import { wireScope } from '@pikku/core/scope'",
+        "wireScope({ 'admin:users': {} })",
+      ].join('\n')
+    )
+
+    assert.ok(
+      criticals.some((c) => c.code === ErrorCode.INVALID_VALUE),
+      `expected an INVALID_VALUE critical, got ${JSON.stringify(criticals)}`
+    )
+  })
+
+  test('is critical when a root is the wildcard', async () => {
+    const { criticals } = await inspectSource(
+      [
+        "import { wireScope } from '@pikku/core/scope'",
+        "wireScope({ '*': {} })",
+      ].join('\n')
+    )
+
+    assert.ok(
+      criticals.some((c) => c.code === ErrorCode.INVALID_VALUE),
+      `expected an INVALID_VALUE critical, got ${JSON.stringify(criticals)}`
+    )
+  })
+
+  test('is critical when a root key is not a literal', async () => {
+    const { criticals } = await inspectSource(
+      [
+        "import { wireScope } from '@pikku/core/scope'",
+        'const k = String(1)',
+        'wireScope({ [k]: {} } as any)',
+      ].join('\n')
+    )
+
+    assert.ok(
+      criticals.some((c) => c.code === ErrorCode.NON_LITERAL_WIRE_NAME),
+      `expected a NON_LITERAL_WIRE_NAME critical, got ${JSON.stringify(criticals)}`
+    )
+  })
+
+  test('is critical when a root is not an object literal', async () => {
+    const { criticals } = await inspectSource(
+      [
+        "import { wireScope } from '@pikku/core/scope'",
+        "wireScope({ admin: 'nope' } as any)",
+      ].join('\n')
+    )
+
+    assert.ok(
+      criticals.some((c) => c.code === ErrorCode.INVALID_VALUE),
+      `expected an INVALID_VALUE critical, got ${JSON.stringify(criticals)}`
+    )
+  })
+})
+
+describe('validateScopeReferences', () => {
+  const funcSource = (scopes: string, decls: string[] = []) =>
+    [
+      "import { wireScope } from '@pikku/core/scope'",
+      "import { pikkuSessionlessFunc } from '@pikku/core'",
+      ...decls,
+      'export const f = pikkuSessionlessFunc({',
+      `  scopes: ${scopes},`,
+      "  func: async () => 'ok',",
+      '})',
+    ].join('\n')
+
+  test('accepts a declared scope', async () => {
+    const { criticals } = await inspectSource(
+      funcSource("['admin:invoices:create']", [
+        'wireScope({',
+        '  admin: {',
+        '    scopes: { invoices: { scopes: { create: {} } } },',
+        '  },',
+        '})',
+      ])
+    )
+
+    assert.deepEqual(criticals, [])
+  })
+
+  test('accepts an intermediate node of a declared tree', async () => {
+    const { criticals } = await inspectSource(
+      funcSource("['admin:invoices']", [
+        'wireScope({',
+        '  admin: {',
+        '    scopes: { invoices: { scopes: { create: {} } } },',
+        '  },',
+        '})',
+      ])
+    )
+
+    assert.deepEqual(criticals, [])
+  })
+
+  test('rejects an undeclared scope', async () => {
+    const { criticals } = await inspectSource(
+      funcSource("['billing:read']", ['wireScope({ admin: {} })'])
+    )
+
+    assert.ok(
+      criticals.some(
+        (c) =>
+          c.code === ErrorCode.INVALID_VALUE &&
+          c.message.includes('billing:read')
+      ),
+      `expected an INVALID_VALUE critical for billing:read, got ${JSON.stringify(criticals)}`
+    )
+  })
+
+  test('lists the available scopes when one is undeclared', async () => {
+    const { criticals } = await inspectSource(
+      funcSource("['nope']", ['wireScope({ admin: {} })'])
+    )
+
+    assert.ok(
+      criticals.some((c) => c.message.includes('Available scopes: admin')),
+      `expected the message to list available scopes, got ${JSON.stringify(criticals)}`
+    )
+  })
+
+  test('rejects a typo in a nested scope', async () => {
+    const { criticals } = await inspectSource(
+      funcSource("['admin:invoice:create']", [
+        'wireScope({',
+        '  admin: {',
+        '    scopes: { invoices: { scopes: { create: {} } } },',
+        '  },',
+        '})',
+      ])
+    )
+
+    assert.ok(
+      criticals.some((c) => c.message.includes('admin:invoice:create')),
+      `expected a critical for the typo, got ${JSON.stringify(criticals)}`
+    )
+  })
+
+  test('accepts a wildcard requirement whose node is declared', async () => {
+    const { criticals } = await inspectSource(
+      funcSource("['admin:*']", ['wireScope({ admin: {} })'])
+    )
+
+    assert.deepEqual(criticals, [])
+  })
+
+  test('rejects a wildcard requirement whose node is undeclared', async () => {
+    const { criticals } = await inspectSource(
+      funcSource("['billing:*']", ['wireScope({ admin: {} })'])
+    )
+
+    assert.ok(
+      criticals.some((c) => c.message.includes('billing:*')),
+      `expected a critical for billing:*, got ${JSON.stringify(criticals)}`
+    )
+  })
+
+  test('rejects a bare wildcard requirement', async () => {
+    const { criticals } = await inspectSource(
+      funcSource("['*']", ['wireScope({ admin: {} })'])
+    )
+
+    assert.ok(
+      criticals.some((c) => c.message.includes('bare wildcard')),
+      `expected a critical for the bare wildcard, got ${JSON.stringify(criticals)}`
+    )
+  })
+
+  test('is silent for a function declaring no scopes', async () => {
+    const { criticals } = await inspectSource(
+      [
+        "import { pikkuSessionlessFunc } from '@pikku/core'",
+        "export const f = pikkuSessionlessFunc({ func: async () => 'ok' })",
+      ].join('\n')
+    )
+
+    assert.deepEqual(criticals, [])
+  })
+})