@pikku/inspector 0.12.22 → 0.12.24

package/src/utils/resolve-ref-contract.ts

@@ -0,0 +1,71 @@
+import * as ts from 'typescript'
+
+export interface RefContractResolution<T> {
+  contract: T
+  /**
+   * Optional basePath override supplied by the consumer via the second
+   * argument, e.g. refHTTP('ns:routes', { basePath: '/ext' }). When undefined
+   * the addon contract's own basePath is preserved.
+   */
+  basePath?: string
+}
+
+const getStringProperty = (
+  obj: ts.ObjectLiteralExpression,
+  name: string
+): string | undefined => {
+  for (const prop of obj.properties) {
+    if (
+      ts.isPropertyAssignment(prop) &&
+      (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) &&
+      prop.name.text === name &&
+      ts.isStringLiteral(prop.initializer)
+    ) {
+      return prop.initializer.text
+    }
+  }
+  return undefined
+}
+
+/**
+ * Resolve a refHTTP / refChannel / refCLI call expression against the addon
+ * contracts already loaded (and namespaced) by loadAddonFunctionsMeta.
+ *
+ * The first string argument has the form 'namespace:contractName', mirroring
+ * how ref('namespace:fn') references an addon function. Detection is purely
+ * syntactic — no import resolution is required because the namespace and
+ * contract name are carried in the string literal. An optional second object
+ * argument may override mount details such as basePath.
+ */
+export const resolveRefContract = <T>(
+  node: ts.Node,
+  helperName: 'refHTTP' | 'refChannel' | 'refCLI',
+  addonContracts: Record<string, Record<string, T>>
+): RefContractResolution<T> | null => {
+  if (!ts.isCallExpression(node)) return null
+  if (
+    !ts.isIdentifier(node.expression) ||
+    node.expression.text !== helperName
+  ) {
+    return null
+  }
+
+  const [arg, optionsArg] = node.arguments
+  if (!arg || !ts.isStringLiteral(arg)) return null
+
+  const separator = arg.text.indexOf(':')
+  if (separator === -1) return null
+
+  const namespace = arg.text.slice(0, separator)
+  const contractName = arg.text.slice(separator + 1)
+
+  const contract = addonContracts[namespace]?.[contractName]
+  if (contract === undefined) return null
+
+  let basePath: string | undefined
+  if (optionsArg && ts.isObjectLiteralExpression(optionsArg)) {
+    basePath = getStringProperty(optionsArg, 'basePath')
+  }
+
+  return { contract, basePath }
+}

package/src/utils/serialize-inspector-state.ts

@@ -263,6 +263,7 @@ export interface SerializableInspectorState {
   openAPISpec: Record<string, any> | null
   diagnostics: InspectorDiagnostic[]
   addonFunctions: InspectorState['addonFunctions']
+  exportedContracts: InspectorState['exportedContracts']
 }
 
 /**
@@ -443,6 +444,7 @@ export function serializeInspectorState(
     openAPISpec: state.openAPISpec,
     diagnostics: state.diagnostics,
     addonFunctions: state.addonFunctions,
+    exportedContracts: state.exportedContracts,
   }
 }
 
@@ -630,6 +632,14 @@ export function deserializeInspectorState(
     openAPISpec: data.openAPISpec || null,
     diagnostics: data.diagnostics || [],
     addonFunctions: data.addonFunctions || {},
+    exportedContracts: data.exportedContracts || {
+      http: {},
+      cli: {},
+      channel: {},
+      addonHttp: {},
+      addonCli: {},
+      addonChannel: {},
+    },
     program: null,
   }
 }

package/src/visit.ts

@@ -3,6 +3,7 @@ import { addFileWithFactory } from './add/add-file-with-factory.js'
 import { addFileExtendsCoreType } from './add/add-file-extends-core-type.js'
 import { addHTTPRoute } from './add/add-http-route.js'
 import { addHTTPRoutes } from './add/add-http-routes.js'
+import { checkAddonBans } from './add/add-addon-bans.js'
 import { addSchedule } from './add/add-schedule.js'
 import { addTrigger } from './add/add-trigger.js'
 import { addQueueWorker } from './add/add-queue-worker.js'
@@ -106,27 +107,33 @@ export const visitRoutes = (
   state: InspectorState,
   options: InspectorOptions
 ) => {
-  addFunctions(logger, node, checker, state, options)
-  addAuth(logger, node, checker, state, options)
-  addSecret(logger, node, checker, state, options)
-  addCredential(logger, node, checker, state, options)
-  addVariable(logger, node, checker, state, options)
+  const nextOptions = ts.isSourceFile(node)
+    ? { ...options, sourceFile: node }
+    : options
 
-  addHTTPRoute(logger, node, checker, state, options)
-  addHTTPRoutes(logger, node, checker, state, options)
-  addSchedule(logger, node, checker, state, options)
-  addTrigger(logger, node, checker, state, options)
-  addQueueWorker(logger, node, checker, state, options)
-  addChannel(logger, node, checker, state, options)
-  addGateway(logger, node, checker, state, options)
-  addCLI(logger, node, checker, state, options)
-  addCLIRenderers(logger, node, checker, state, options)
-  addMCPResource(logger, node, checker, state, options)
-  addMCPPrompt(logger, node, checker, state, options)
-  addWorkflowGraph(logger, node, checker, state, options)
-  addAIAgent(logger, node, checker, state, options)
+  checkAddonBans(logger, node, checker, state, nextOptions)
+
+  addFunctions(logger, node, checker, state, nextOptions)
+  addAuth(logger, node, checker, state, nextOptions)
+  addSecret(logger, node, checker, state, nextOptions)
+  addCredential(logger, node, checker, state, nextOptions)
+  addVariable(logger, node, checker, state, nextOptions)
+
+  addHTTPRoute(logger, node, checker, state, nextOptions)
+  addHTTPRoutes(logger, node, checker, state, nextOptions)
+  addSchedule(logger, node, checker, state, nextOptions)
+  addTrigger(logger, node, checker, state, nextOptions)
+  addQueueWorker(logger, node, checker, state, nextOptions)
+  addChannel(logger, node, checker, state, nextOptions)
+  addGateway(logger, node, checker, state, nextOptions)
+  addCLI(logger, node, checker, state, nextOptions)
+  addCLIRenderers(logger, node, checker, state, nextOptions)
+  addMCPResource(logger, node, checker, state, nextOptions)
+  addMCPPrompt(logger, node, checker, state, nextOptions)
+  addWorkflowGraph(logger, node, checker, state, nextOptions)
+  addAIAgent(logger, node, checker, state, nextOptions)
 
   ts.forEachChild(node, (child) =>
-    visitRoutes(logger, checker, child, state, options)
+    visitRoutes(logger, checker, child, state, nextOptions)
   )
 }