@pikku/inspector 0.12.74 → 0.12.81

package/src/add/add-gateway.ts

@@ -1,143 +0,0 @@
-import * as ts from 'typescript'
-import {
-  getPropertyValue,
-  getCommonWireMetaData,
-} from '../utils/get-property-value.js'
-import type { AddWiring } from '../types.js'
-import {
-  extractFunctionName,
-  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'
-import type { GatewayTransportType } from '@pikku/core/gateway'
-
-import { ErrorCode } from '../error-codes.js'
-
-export const addGateway: AddWiring = (
-  logger,
-  node,
-  checker,
-  state,
-  _options
-) => {
-  if (!ts.isCallExpression(node)) {
-    return
-  }
-
-  const args = node.arguments
-  const firstArg = args[0]
-  const expression = node.expression
-
-  if (!ts.isIdentifier(expression) || expression.text !== 'wireGateway') {
-    return
-  }
-
-  if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) {
-    return
-  }
-
-  const obj = firstArg
-
-  const nameValue = getPropertyValue(obj, 'name') as string | null
-  const typeValue = getPropertyValue(obj, 'type') as GatewayTransportType | null
-  const routeValue = getPropertyValue(obj, 'route') as string | null
-  const platformValue = getPropertyValue(obj, 'platform') as string | null
-  const authValue = getPropertyValue(obj, 'auth')
-  const { disabled, tags, summary, description, errors } =
-    getCommonWireMetaData(obj, 'Gateway', nameValue, logger, checker)
-
-  if (disabled) return
-
-  const funcInitializer = getPropertyAssignmentInitializer(
-    obj,
-    'func',
-    true,
-    checker
-  )
-  if (!funcInitializer) {
-    logger.critical(
-      ErrorCode.MISSING_FUNC,
-      `No valid 'func' property for gateway '${nameValue}'.`
-    )
-    return
-  }
-
-  const extracted = extractFunctionName(funcInitializer, checker, state.rootDir)
-  let pikkuFuncId = extracted.pikkuFuncId
-  if (pikkuFuncId.startsWith('__temp_') && nameValue) {
-    pikkuFuncId = makeContextBasedId('gateway', nameValue)
-  }
-
-  const packageName = ts.isIdentifier(funcInitializer)
-    ? resolveAddonName(
-        funcInitializer,
-        checker,
-        state.rpc.wireAddonDeclarations
-      )
-    : null
-
-  if (!nameValue || !typeValue) {
-    return
-  }
-
-  // Register metadata for a func inlined into the wiring (see helper).
-  ensureInlineWiringFunction(
-    state,
-    pikkuFuncId,
-    nameValue,
-    funcInitializer,
-    checker,
-    extracted.isHelper
-  )
-
-  const middleware = resolveMiddleware(state, obj, tags, checker)
-
-  state.serviceAggregation.usedFunctions.add(pikkuFuncId)
-  extractWireNames(middleware).forEach((name) =>
-    state.serviceAggregation.usedMiddleware.add(name)
-  )
-
-  // Project webhook POST/GET wrappers into compiled http + function meta.
-  if (typeValue === 'webhook' && routeValue) {
-    const wrappers = [
-      { method: 'post', funcId: `gateway__${nameValue}__post` },
-      { method: 'get', funcId: `gateway__${nameValue}__verify` },
-    ] as const
-    for (const { method, funcId } of wrappers) {
-      // no middleware here — the gateway POST wrapper runs it itself
-      state.http.meta[method][routeValue] = {
-        pikkuFuncId: funcId,
-        route: routeValue,
-        method,
-      }
-      state.functions.meta[funcId] = {
-        pikkuFuncId: funcId,
-        inputSchemaName: null,
-        outputSchemaName: null,
-        sessionless: true,
-      }
-    }
-    state.http.files.add(node.getSourceFile().fileName)
-  }
-
-  state.gateways.files.add(node.getSourceFile().fileName)
-  state.gateways.meta[nameValue] = {
-    pikkuFuncId,
-    ...(packageName && { packageName }),
-    name: nameValue,
-    type: typeValue,
-    ...(routeValue && { route: routeValue }),
-    ...(platformValue && { platform: platformValue }),
-    ...(typeof authValue === 'boolean' && { auth: authValue }),
-    gateway: true,
-    summary,
-    description,
-    errors,
-    tags,
-    middleware,
-  }
-}

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

@@ -1,149 +0,0 @@
-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))
-  })
-})