@pikku/inspector 0.12.75 → 0.12.81

package/src/utils/nested-project-filter.ts

@@ -1,28 +0,0 @@
-import { existsSync } from 'fs'
-import { dirname, join } from 'path'
-
-export const createNestedProjectFilter = (rootDir: string) => {
-  const cache = new Map<string, boolean>()
-  return (fileName: string): boolean => {
-    const pending: string[] = []
-    let dir = dirname(fileName)
-    let nested = false
-    while (dir.startsWith(rootDir) && dir !== rootDir) {
-      const cached = cache.get(dir)
-      if (cached !== undefined) {
-        nested = cached
-        break
-      }
-      pending.push(dir)
-      if (existsSync(join(dir, 'pikku.config.json'))) {
-        nested = true
-        break
-      }
-      const parent = dirname(dir)
-      if (parent === dir) break
-      dir = parent
-    }
-    for (const d of pending) cache.set(d, nested)
-    return nested
-  }
-}

package/src/utils/permissions-shorthand.test.ts

@@ -1,79 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-import * as ts from 'typescript'
-import { extractPermissionPikkuNames } from './permissions.js'
-
-/**
- * A checker stub. With no symbols to resolve, every reference falls back to a
- * deterministic `__temp_` id — which is fine, because the question here is
- * whether a declared permission is *seen*, not what it resolves to. A dropped
- * property yields nothing at all, and that is the bug being pinned.
- */
-const checker = {
-  getSymbolAtLocation: () => undefined,
-  getAliasedSymbol: () => undefined,
-  getShorthandAssignmentValueSymbol: () => undefined,
-} as unknown as ts.TypeChecker
-
-/** Parses `permissions: <expr>` and counts the references the inspector records. */
-const countFor = (permissionsExpression: string): number => {
-  const file = ts.createSourceFile(
-    'fn.ts',
-    `const config = { permissions: ${permissionsExpression} }`,
-    ts.ScriptTarget.Latest,
-    true
-  )
-  let node: ts.Expression | undefined
-  const visit = (n: ts.Node) => {
-    if (
-      ts.isPropertyAssignment(n) &&
-      ts.isIdentifier(n.name) &&
-      n.name.text === 'permissions'
-    ) {
-      node = n.initializer
-    }
-    ts.forEachChild(n, visit)
-  }
-  visit(file)
-  assert.ok(node, 'failed to find the permissions node')
-  return extractPermissionPikkuNames(node, checker, '/root').length
-}
-
-describe('extractPermissionPikkuNames', () => {
-  test('records a permission declared with object shorthand', () => {
-    // `permissions: { canAdminOrg }` is enforced identically to the longhand
-    // form at runtime — verifyPermissions has a non-array branch — but was
-    // dropped here, so meta reported a guarded function as carrying no
-    // permissions at all. An audit reading meta saw an open door where one
-    // was shut.
-    assert.equal(countFor('{ canAdminOrg }'), 1)
-  })
-
-  test('records the longhand form', () => {
-    assert.equal(countFor('{ org: canAdminOrg }'), 1)
-  })
-
-  test('records shorthand and longhand together', () => {
-    assert.equal(countFor('{ canAdminOrg, billing: canBill }'), 2)
-  })
-
-  test('records several shorthands', () => {
-    assert.equal(countFor('{ canAdminOrg, canBill }'), 2)
-  })
-
-  test('records the array form', () => {
-    assert.equal(countFor('[canAdminOrg, canBill]'), 2)
-  })
-
-  test('records a group whose value is an array', () => {
-    assert.equal(countFor('{ org: [canAdminOrg, canBill] }'), 2)
-  })
-
-  test('records a call expression, shorthand-adjacent', () => {
-    assert.equal(countFor('{ quota: hasEmailQuota(100) }'), 1)
-  })
-
-  test('records nothing for an empty object', () => {
-    assert.equal(countFor('{}'), 0)
-  })
-})

package/src/utils/permissions.test.ts

@@ -1,125 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert'
-import { resolvePermissions } from './permissions.js'
-import type { InspectorState } from '../types.js'
-
-describe('resolvePermissions', () => {
-  test('should return undefined when the object declares no permissions', () => {
-    const state: InspectorState = createMockState()
-    const mockObj = createMockObjectLiteral()
-
-    const result = resolvePermissions(state, mockObj, undefined, {} as any)
-
-    assert.strictEqual(result, undefined)
-  })
-
-  test('tags no longer resolve to permissions', () => {
-    // Permissions are function-scoped only; tags are organizational and never
-    // contribute permission metadata.
-    const state: InspectorState = createMockState()
-    const mockObj = createMockObjectLiteral()
-
-    const result = resolvePermissions(
-      state,
-      mockObj,
-      ['mcp', 'admin'],
-      {} as any
-    )
-
-    assert.strictEqual(result, undefined)
-  })
-})
-
-// Helper to create a mock TypeScript object literal expression
-function createMockObjectLiteral(): any {
-  return {
-    properties: [],
-    kind: 206, // ObjectLiteralExpression
-  }
-}
-
-// Helper function to create a mock InspectorState
-function createMockState(): InspectorState {
-  return {
-    singletonServicesTypeImportMap: new Map(),
-    wireServicesTypeImportMap: new Map(),
-    userSessionTypeImportMap: new Map(),
-    configTypeImportMap: new Map(),
-    singletonServicesFactories: new Map(),
-    wireServicesFactories: new Map(),
-    wireServicesMeta: new Map(),
-    configFactories: new Map(),
-    filesAndMethods: {},
-    filesAndMethodsErrors: new Map(),
-    typesLookup: new Map(),
-    http: {
-      metaInputTypes: new Map(),
-      meta: {
-        get: {},
-        post: {},
-        put: {},
-        delete: {},
-        head: {},
-        patch: {},
-        options: {},
-      },
-      files: new Set(),
-      routeMiddleware: new Map(),
-    },
-    functions: {
-      typesMap: {} as any,
-      meta: {},
-      files: new Map(),
-    },
-    channels: {
-      meta: {},
-      files: new Set(),
-    },
-    scheduledTasks: {
-      meta: {},
-      files: new Set(),
-    },
-    queueWorkers: {
-      meta: {},
-      files: new Set(),
-    },
-    workflows: {
-      meta: {},
-      files: new Map(),
-      graphMeta: {},
-      graphFiles: new Map(),
-      invokedWorkflows: new Set(),
-    },
-    rpc: {
-      internalMeta: {},
-      internalFiles: new Map(),
-      exposedMeta: {},
-      exposedFiles: new Map(),
-      invokedFunctions: new Set(),
-    },
-    mcpEndpoints: {
-      resourcesMeta: {},
-      toolsMeta: {},
-      promptsMeta: {},
-      files: new Set(),
-    },
-    cli: {
-      meta: {},
-      files: new Set(),
-    },
-    middleware: {
-      definitions: {},
-      instances: {},
-      tagMiddleware: new Map(),
-    },
-    channelMiddleware: {
-      definitions: {},
-      instances: {},
-      tagMiddleware: new Map(),
-    },
-    permissions: {
-      definitions: {},
-      instances: {},
-    },
-  }
-}

package/src/utils/permissions.ts

@@ -1,129 +0,0 @@
-import * as ts from 'typescript'
-import type { PermissionMetadata } from '@pikku/core/function'
-import { extractFunctionName } from './extract-function-name.js'
-import type { InspectorState } from '../types.js'
-
-/**
- * Extract permission pikkuFuncIds from an expression (array or object literal)
- * Resolves each identifier to its pikkuFuncId using extractFunctionName
- * Also handles call expressions (like rolePermission({...}))
- *
- * Supports both formats:
- * - Array: [permission1, permission2]
- * - Record: { groupName: permission1, anotherGroup: [permission2, permission3] }
- */
-export function extractPermissionPikkuNames(
-  node: ts.Expression,
-  checker: ts.TypeChecker,
-  rootDir: string
-): string[] {
-  const names: string[] = []
-
-  // Helper to extract from a single element
-  const extractFromElement = (element: ts.Expression) => {
-    if (ts.isIdentifier(element)) {
-      const { pikkuFuncId } = extractFunctionName(element, checker, rootDir)
-      names.push(pikkuFuncId)
-    } else if (ts.isCallExpression(element)) {
-      // Handle call expressions like hasEmailQuota(100) or rolePermission({...})
-      // Extract the function being called (e.g., 'hasEmailQuota' from 'hasEmailQuota(100)')
-      const { pikkuFuncId } = extractFunctionName(
-        element.expression,
-        checker,
-        rootDir
-      )
-      names.push(pikkuFuncId)
-    } else if (ts.isArrayLiteralExpression(element)) {
-      // Nested array (for Record values that are arrays)
-      for (const nestedElement of element.elements) {
-        extractFromElement(nestedElement)
-      }
-    }
-  }
-
-  if (ts.isArrayLiteralExpression(node)) {
-    // Array format: [permission1, permission2]
-    for (const element of node.elements) {
-      extractFromElement(element)
-    }
-  } else if (ts.isObjectLiteralExpression(node)) {
-    // Record format: { groupName: permission1, anotherGroup: [permission2] }
-    for (const prop of node.properties) {
-      if (ts.isPropertyAssignment(prop)) {
-        extractFromElement(prop.initializer)
-      } else if (ts.isShorthandPropertyAssignment(prop)) {
-        // `permissions: { canAdminOrg }`. The runtime resolves this exactly
-        // like the longhand form — `verifyPermissions` has a non-array branch —
-        // so dropping it here reported a guarded function as having no
-        // permissions at all, which is the most dangerous direction to be wrong
-        // in: an audit reading meta sees an open door where one is shut.
-        extractFromElement(prop.name)
-      }
-    }
-  }
-
-  return names
-}
-
-/**
- * Get permissions array from an object literal expression property
- * Returns the initializer node for the 'permissions' property if it exists
- */
-export function getPermissionsNode(
-  obj: ts.ObjectLiteralExpression
-): ts.Expression | undefined {
-  const permissionsProp = obj.properties.find(
-    (p) =>
-      ts.isPropertyAssignment(p) &&
-      ts.isIdentifier(p.name) &&
-      p.name.text === 'permissions'
-  ) as ts.PropertyAssignment | undefined
-
-  return permissionsProp?.initializer
-}
-
-/**
- * Resolve the explicit permission references declared on a function (or agent).
- * Permissions are function-scoped only: a `permissions: { group: [fn] }` object
- * is flattened to `{ type: 'wire', name }` references used at filter time.
- * Returns undefined if none are declared, otherwise an array with ≥1 item.
- */
-function resolveExplicitPermissions(
-  state: InspectorState,
-  explicitPermissionsNode: ts.Expression | undefined,
-  checker: ts.TypeChecker
-): PermissionMetadata[] | undefined {
-  if (!explicitPermissionsNode) {
-    return undefined
-  }
-
-  const resolved: PermissionMetadata[] = []
-  const permissionNames = extractPermissionPikkuNames(
-    explicitPermissionsNode,
-    checker,
-    state.rootDir
-  )
-  for (const name of permissionNames) {
-    const def = state.permissions.definitions[name]
-    resolved.push({
-      type: 'wire',
-      name,
-      inline: def?.exportedName === null,
-    })
-  }
-
-  return resolved.length > 0 ? resolved : undefined
-}
-
-/**
- * Convenience wrapper: Extract permissions node from object and resolve
- * Use this in add-* files for cleaner code
- */
-export function resolvePermissions(
-  state: InspectorState,
-  obj: ts.ObjectLiteralExpression,
-  _tags: string[] | undefined,
-  checker: ts.TypeChecker
-): PermissionMetadata[] | undefined {
-  return resolveExplicitPermissions(state, getPermissionsNode(obj), checker)
-}