@pikku/core 0.12.84 → 0.12.86

package/src/middleware/index.ts

@@ -11,3 +11,19 @@ export {
   runMiddleware,
 } from '../middleware-runner.js'
 export { addGlobalPermission } from '../permissions.js'
+export type {
+  CorePikkuMiddleware,
+  CorePikkuMiddlewareConfig,
+  CorePikkuMiddlewareFactory,
+  CorePikkuMiddlewareGroup,
+  MiddlewareMetadata,
+  MiddlewarePriority,
+} from './middleware.types.js'
+export {
+  pikkuAgentMiddleware,
+  pikkuChannelMiddleware,
+  pikkuChannelMiddlewareFactory,
+  pikkuMiddleware,
+  pikkuMiddlewareFactory,
+} from './middleware-factories.js'
+export type { PikkuAgentMiddlewareHooks } from '../wirings/agent/agent.types.js'

package/src/middleware/middleware-factories.ts

@@ -0,0 +1,62 @@
+import type {
+  CoreSingletonServices,
+  CoreUserSession,
+} from '../types/core.types.js'
+import type {
+  CorePikkuChannelMiddleware,
+  CorePikkuChannelMiddlewareFactory,
+} from '../wirings/channel/channel.types.js'
+import type { PikkuAgentMiddlewareHooks } from '../wirings/agent/agent.types.js'
+import type {
+  CorePikkuMiddleware,
+  CorePikkuMiddlewareConfig,
+  CorePikkuMiddlewareFactory,
+  MiddlewarePriority,
+} from './middleware.types.js'
+
+export const pikkuMiddleware = <
+  SingletonServices extends CoreSingletonServices = CoreSingletonServices,
+  UserSession extends CoreUserSession = CoreUserSession,
+>(
+  middleware:
+    | CorePikkuMiddleware<SingletonServices, UserSession>
+    | CorePikkuMiddlewareConfig<SingletonServices, UserSession>
+): CorePikkuMiddleware<SingletonServices, UserSession> => {
+  if (typeof middleware === 'function') return middleware
+  const func = middleware.func as CorePikkuMiddleware<
+    SingletonServices,
+    UserSession
+  > & { __priority?: MiddlewarePriority }
+  if (middleware.priority) {
+    func.__priority = middleware.priority
+  }
+  return func
+}
+
+export const pikkuMiddlewareFactory = <In = any>(
+  factory: CorePikkuMiddlewareFactory<In>
+): CorePikkuMiddlewareFactory<In> => {
+  return factory
+}
+
+export const pikkuChannelMiddleware = <
+  SingletonServices extends CoreSingletonServices = CoreSingletonServices,
+  Event = unknown,
+>(
+  middleware: CorePikkuChannelMiddleware<SingletonServices, Event>
+): CorePikkuChannelMiddleware<SingletonServices, Event> => {
+  return middleware
+}
+
+export const pikkuChannelMiddlewareFactory = <In = any>(
+  factory: CorePikkuChannelMiddlewareFactory<In>
+): CorePikkuChannelMiddlewareFactory<In> => {
+  return factory
+}
+
+export const pikkuAgentMiddleware = <
+  State extends Record<string, unknown> = Record<string, unknown>,
+  SingletonServices extends CoreSingletonServices = CoreSingletonServices,
+>(
+  hooks: PikkuAgentMiddlewareHooks<State, SingletonServices>
+): PikkuAgentMiddlewareHooks<State, SingletonServices> => hooks

package/src/middleware/middleware.types.ts

@@ -0,0 +1,61 @@
+import type {
+  CoreSingletonServices,
+  CoreUserSession,
+  PikkuWire,
+} from '../types/core.types.js'
+
+export type CorePikkuMiddleware<
+  SingletonServices extends CoreSingletonServices = CoreSingletonServices,
+  UserSession extends CoreUserSession = CoreUserSession,
+> = (
+  services: SingletonServices,
+  wires: PikkuWire,
+  next: () => Promise<void>
+) => Promise<void>
+
+/**
+ * Execution order: `highest` runs first (outermost in the onion), `lowest`
+ * runs last, closest to the function.
+ */
+export type MiddlewarePriority =
+  'highest' | 'high' | 'medium' | 'low' | 'lowest'
+
+export type CorePikkuMiddlewareConfig<
+  SingletonServices extends CoreSingletonServices = CoreSingletonServices,
+  UserSession extends CoreUserSession = CoreUserSession,
+> = {
+  func: CorePikkuMiddleware<SingletonServices, UserSession>
+  name?: string
+  description?: string
+  /** Execution priority. Lower runs first (outermost). Defaults to 'medium'. */
+  priority?: MiddlewarePriority
+}
+
+export type CorePikkuMiddlewareFactory<
+  In = any,
+  SingletonServices extends CoreSingletonServices = CoreSingletonServices,
+  UserSession extends CoreUserSession = CoreUserSession,
+> = (input: In) => CorePikkuMiddleware<SingletonServices, UserSession>
+
+export type CorePikkuMiddlewareGroup<
+  SingletonServices extends CoreSingletonServices = CoreSingletonServices,
+  UserSession extends CoreUserSession = CoreUserSession,
+> = Array<
+  | CorePikkuMiddleware<SingletonServices, UserSession>
+  | CorePikkuMiddlewareFactory<any, SingletonServices, UserSession>
+>
+
+export type MiddlewareMetadata =
+  | {
+      type: 'http'
+      route: string // Route pattern (e.g., '*' for all, '/api/*' for specific)
+    }
+  | {
+      type: 'tag'
+      tag: string
+    }
+  | {
+      type: 'wire'
+      name: string
+      inline?: boolean
+    }

package/src/middleware/remote-auth.test.ts

@@ -4,7 +4,7 @@ import { pikkuRemoteAuthMiddleware } from './remote-auth.js'
 import { UnauthorizedError } from '../errors/errors.js'
 import { resetPikkuState } from '../pikku-state.js'
 import { encryptWithKeyMaterial, REMOTE_SESSION_INFO } from '../crypto-utils.js'
-import { createSecretValue } from '../secret-value.js'
+import { createSecretValue } from '../classification/secret-value.js'
 
 beforeEach(() => {
   resetPikkuState()

package/src/middleware/remote-auth.ts

@@ -1,5 +1,5 @@
 import { UnauthorizedError } from '../errors/errors.js'
-import { pikkuMiddleware } from '../types/core.types.js'
+import { pikkuMiddleware } from './middleware-factories.js'
 import {
   assertStrongKeyMaterial,
   decryptWithKeyMaterial,

package/src/middleware/telemetry.ts

@@ -1,5 +1,7 @@
-import { pikkuMiddleware, pikkuMiddlewareFactory } from '../types/core.types.js'
-
+import {
+  pikkuMiddleware,
+  pikkuMiddlewareFactory,
+} from './middleware-factories.js'
 /** Outermost telemetry: total duration, including every middleware. */
 export const telemetryOuter = pikkuMiddlewareFactory<{
   environmentId?: string

package/src/middleware-runner.test.ts

@@ -9,9 +9,8 @@ import { pikkuState, resetPikkuState } from './pikku-state.js'
 import type {
   CorePikkuMiddleware,
   MiddlewarePriority,
-} from './types/core.types.js'
-import { pikkuMiddleware } from './types/core.types.js'
-
+} from './middleware/middleware.types.js'
+import { pikkuMiddleware } from './middleware/middleware-factories.js'
 const withPriority = (
   name: string,
   priority: MiddlewarePriority,

package/src/middleware-runner.ts

@@ -1,10 +1,10 @@
+import type { PikkuWiringTypes } from './types/core.types.js'
 import type {
   CorePikkuMiddleware,
   CorePikkuMiddlewareGroup,
-  PikkuWiringTypes,
   MiddlewareMetadata,
   MiddlewarePriority,
-} from './types/core.types.js'
+} from './middleware/middleware.types.js'
 import { pikkuState } from './pikku-state.js'
 import { freezeDedupe, getTagGroups } from './utils.js'
 

package/src/no-root-barrel.test.ts

@@ -0,0 +1,114 @@
+import { test, describe } from 'node:test'
+import * as assert from 'assert'
+import ts from 'typescript'
+import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * The package root was one barrel of 206 names that no bundler could take
+ * apart, and the one specifier that revealed nothing about what a consumer
+ * actually used.
+ *
+ * It is gone. Every name lives on the subpath that owns it, and every import
+ * carries that subpath. What survives is a bootstrap shim, which the second
+ * test here holds to its exact contents.
+ */
+const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '../../..')
+
+const skipDirectory = new Set([
+  'node_modules',
+  'dist',
+  '.git',
+  'build',
+  'coverage',
+])
+
+const walk = (dir: string, out: string[] = []): string[] => {
+  for (const entry of readdirSync(dir)) {
+    if (skipDirectory.has(entry)) continue
+    const path = join(dir, entry)
+    if (statSync(path).isDirectory()) walk(path, out)
+    else if (path.endsWith('.ts') || path.endsWith('.tsx')) out.push(path)
+  }
+  return out
+}
+
+/**
+ * Generated output belongs to whichever CLI wrote it — including the pinned
+ * published one that bootstraps `packages/cli` and still emits the old
+ * specifiers. What this branch's serializers emit is covered by the CLI's own
+ * tests, against the template rather than its output.
+ */
+const isGenerated = (path: string) =>
+  path.includes('.gen.') || path.endsWith('.d.ts') || path.includes('/.pikku/')
+
+describe('no root barrel', () => {
+  /**
+   * Parsed rather than grepped: several tests hold a user's file as a template
+   * literal, and `import { pikkuSessionlessFunc } from '@pikku/core'` inside
+   * one is fixture text for the inspector, not an import this repo makes.
+   */
+  test('nothing imports the package root', () => {
+    const offenders: string[] = []
+
+    for (const file of walk(repoRoot)) {
+      if (isGenerated(file)) continue
+      const source = ts.createSourceFile(
+        file,
+        readFileSync(file, 'utf8'),
+        ts.ScriptTarget.Latest,
+        true
+      )
+      for (const statement of source.statements) {
+        if (
+          !ts.isImportDeclaration(statement) &&
+          !ts.isExportDeclaration(statement)
+        ) {
+          continue
+        }
+        const specifier = statement.moduleSpecifier
+        if (!specifier || !ts.isStringLiteral(specifier)) continue
+        if (specifier.text !== '@pikku/core') continue
+        const { line } = source.getLineAndCharacterOfPosition(
+          statement.getStart(source)
+        )
+        offenders.push(`${relative(repoRoot, file)}:${line + 1}`)
+      }
+    }
+
+    assert.deepStrictEqual(
+      offenders,
+      [],
+      `The '@pikku/core' root is a bootstrap shim, not an entry point. Every ` +
+        `import carries the subpath that owns the name — '@pikku/core/types' ` +
+        `for the shared types, '@pikku/core/services' for the services.\n\n` +
+        offenders.join('\n')
+    )
+  })
+
+  /**
+   * The shim exists because `packages/cli` is generated by the published CLI
+   * pinned in its `build.sh`, which still writes these specifiers. Holding it
+   * to an exact list is what keeps it a shim: a name can only be added here by
+   * someone who has read why it should not be.
+   */
+  test('the bootstrap shim carries only what the pinned CLI emits', () => {
+    const surface = (file: string) =>
+      readFileSync(join(dirname(fileURLToPath(import.meta.url)), file), 'utf8')
+        .replace(/\/\*\*[\s\S]*?\*\//g, '')
+        .match(/\b[A-Za-z][A-Za-z0-9]*\b(?=[,\n\s]*(?:,|\}))/g)
+        ?.sort() ?? []
+
+    assert.deepStrictEqual(surface('bootstrap-compat/root.ts'), [
+      'CorePermissionGroup',
+      'CorePikkuMiddleware',
+      'ListInput',
+      'ListOutput',
+      'PickRequired',
+      'PikkuWire',
+      'SecretService',
+      'SecretlessServices',
+    ])
+  })
+})

package/src/permissions.ts

@@ -75,8 +75,7 @@ export const addGlobalPermission = (
   packageName: string | null = null
 ): CorePermissionGroup | CorePikkuPermission[] => {
   const state = pikkuState(packageName, 'permissions', 'global') as unknown as (
-    | CorePermissionGroup
-    | CorePikkuPermission
+    CorePermissionGroup | CorePikkuPermission
   )[]
   if (Array.isArray(permissions)) {
     state.push(...(permissions as CorePikkuPermission[]))
@@ -91,8 +90,7 @@ const bucket = (
   packageName: string | null
 ): (CorePermissionGroup | CorePikkuPermission)[] =>
   (pikkuState(packageName, 'permissions', 'global') as unknown as (
-    | CorePermissionGroup
-    | CorePikkuPermission
+    CorePermissionGroup | CorePikkuPermission
   )[]) ?? []
 
 /**

package/src/pikku-state.ts

@@ -1,4 +1,4 @@
-import type { PikkuPackageState } from './index.js'
+import type { PikkuPackageState } from './types/state.types.js'
 import type {
   CoreSingletonServices,
   CreateWireServices,
@@ -202,3 +202,5 @@ export const addPackageServiceFactories = (
 ): void => {
   pikkuState(packageName, 'package', 'factories', factories)
 }
+
+export type { PikkuPackageState } from './types/state.types.js'