@pikku/cli 0.11.3 → 0.12.1

package/src/functions/wirings/channels/pikku-command-channel-types.ts

@@ -1,25 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeChannelTypes } from './serialize-channel-types.js'
-
-export const pikkuChannelTypes: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config }) => {
-    const { channelsTypesFile, functionTypesFile, packageMappings } = config
-
-    const functionTypesImportPath = getFileImportRelativePath(
-      channelsTypesFile,
-      functionTypesFile,
-      packageMappings
-    )
-    const content = serializeChannelTypes(functionTypesImportPath)
-    await writeFileInDir(logger, channelsTypesFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating channel types',
-      commandEnd: 'Created channel types',
-    }),
-  ],
-})

package/src/functions/wirings/channels/pikku-command-channels-map.ts

@@ -1,26 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeTypedChannelsMap } from './serialize-typed-channel-map.js'
-
-export const pikkuChannelsMap: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const state = await getInspectorState()
-    const { channelsMapDeclarationFile, packageMappings } = config
-
-    const content = serializeTypedChannelsMap(
-      channelsMapDeclarationFile,
-      packageMappings,
-      state.functions.typesMap,
-      state.functions.meta,
-      state.channels.meta
-    )
-    await writeFileInDir(logger, channelsMapDeclarationFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating channels map',
-      commandEnd: 'Created channels map',
-    }),
-  ],
-})

package/src/functions/wirings/channels/pikku-command-channels.ts

@@ -1,83 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import {
-  stripVerboseFields,
-  hasVerboseFields,
-} from '../../../utils/strip-verbose-meta.js'
-
-export const pikkuChannels: any = pikkuSessionlessFunc<
-  void,
-  boolean | undefined
->({
-  func: async ({ logger, config, getInspectorState }) => {
-    const visitState = await getInspectorState()
-    const {
-      channelsWiringFile,
-      channelsWiringMetaFile,
-      channelsWiringMetaJsonFile,
-      packageMappings,
-      schema,
-    } = config
-    const { channels } = visitState
-
-    await writeFileInDir(
-      logger,
-      channelsWiringFile,
-      serializeFileImports(
-        'addChannel',
-        channelsWiringFile,
-        channels.files,
-        packageMappings
-      )
-    )
-
-    // Write minimal JSON (runtime-only fields)
-    const minimalMeta = stripVerboseFields(channels.meta)
-    await writeFileInDir(
-      logger,
-      channelsWiringMetaJsonFile,
-      JSON.stringify(minimalMeta, null, 2)
-    )
-
-    // Write verbose JSON only if it has additional fields
-    if (hasVerboseFields(channels.meta)) {
-      const verbosePath = channelsWiringMetaJsonFile.replace(
-        /\.gen\.json$/,
-        '-verbose.gen.json'
-      )
-      await writeFileInDir(
-        logger,
-        verbosePath,
-        JSON.stringify(channels.meta, null, 2)
-      )
-    }
-
-    // Generate TypeScript file that imports the minimal JSON
-    const jsonImportPath = getFileImportRelativePath(
-      channelsWiringMetaFile,
-      channelsWiringMetaJsonFile,
-      packageMappings
-    )
-    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
-    const importStatement = supportsImportAttributes
-      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-      : `import metaData from '${jsonImportPath}'`
-
-    await writeFileInDir(
-      logger,
-      channelsWiringMetaFile,
-      `import { pikkuState } from '@pikku/core'\nimport type { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)`
-    )
-
-    return true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Finding Channels',
-      commandEnd: 'Found channels',
-    }),
-  ],
-})

package/src/functions/wirings/channels/pikku-command-websocket-typed.ts

@@ -1,37 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeWebsocketWrapper } from './serialize-websocket-wrapper.js'
-
-export const pikkuWebSocketTyped: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config }) => {
-    const { websocketFile, channelsMapDeclarationFile, packageMappings } =
-      config
-
-    // If websocketFile is not set, clean up any existing file and return
-    if (!websocketFile) {
-      logger.info({
-        message:
-          "Skipping generating websocket wrapper since websocketFile isn't set in the pikku config.",
-        type: 'skip',
-      })
-      return
-    }
-
-    const channelsMapDeclarationPath = getFileImportRelativePath(
-      websocketFile,
-      channelsMapDeclarationFile,
-      packageMappings
-    )
-
-    const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)]
-    await writeFileInDir(logger, websocketFile, content.join('\n'))
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating websocket wrapper',
-      commandEnd: 'Generated websocket wrapper',
-    }),
-  ],
-})

package/src/functions/wirings/channels/serialize-channel-types.ts

@@ -1,151 +0,0 @@
-/**
- * Generates type definitions for WebSocket channel wirings
- */
-export const serializeChannelTypes = (functionTypesImportPath: string) => {
-  return `/**
-
- * Channel-specific type definitions for tree-shaking optimization
- */
-
-import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
-import { AssertHTTPWiringParams } from '@pikku/core/http'
-import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
-import type { ZodLike, CorePermissionGroup } from '@pikku/core'
-
-/**
- * Helper type to infer the output type from a Zod schema
- */
-type InferZodOutput<T> = T extends ZodLike<infer U> ? U : never
-
-/**
- * Type definition for WebSocket channels with typed data exchange.
- * Supports connection, disconnection, and message handling.
- * Accepts both session-based (PikkuFunction) and sessionless (PikkuFunctionSessionless) functions.
- *
- * @template ChannelData - Type of data exchanged through the channel
- * @template Channel - String literal type for the channel name
- */
-type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<
-  ChannelData,
-  Channel,
-  PikkuFunctionConfig<void, any, 'channel' | 'session' | 'rpc'>,
-  PikkuFunctionConfig<void, void, 'channel' | 'session' | 'rpc'>,
-  PikkuFunctionConfig<any, any, 'channel' | 'session' | 'rpc'>,
-  PikkuPermission,
-  PikkuMiddleware
->
-
-/**
- * Creates a function that handles WebSocket channel connections.
- * Called when a client connects to a channel.
- *
- * @template Out - Output type for connection response
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- */
-export const pikkuChannelConnectionFunc = <Out = unknown>(
-  func:
-    | PikkuFunctionSessionless<void, Out, 'channel' | 'session' | 'rpc'>
-    | PikkuFunctionConfig<void, Out, 'channel' | 'session' | 'rpc'>
-) => {
-  return typeof func === 'function' ? { func } : func
-}
-
-/**
- * Creates a function that handles WebSocket channel disconnections.
- * Called when a client disconnects from a channel.
- *
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- */
-export const pikkuChannelDisconnectionFunc = (
-  func:
-    | PikkuFunctionSessionless<void, void, 'channel'>
-    | PikkuFunctionConfig<void, void, 'channel' | 'session' | 'rpc'>
-) => {
-  return typeof func === 'function' ? { func } : func
-}
-
-/**
- * Configuration object for channel functions with Zod schema validation.
- */
-type PikkuChannelFuncConfigWithSchema<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined
-> = {
-  name?: string
-  tags?: string[]
-  expose?: boolean
-  internal?: boolean
-  func: PikkuFunctionSessionless<
-    InferZodOutput<InputSchema>,
-    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
-    'channel' | 'session' | 'rpc'
-  >
-  auth?: boolean
-  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
-  middleware?: PikkuMiddleware[]
-  input: InputSchema
-  output?: OutputSchema
-}
-
-/**
- * Creates a function that handles WebSocket channel messages.
- * Called when a message is received on a channel.
- *
- * Supports two patterns:
- * 1. Generic types: \`pikkuChannelFunc<Input, Output>({ func: ... })\`
- * 2. Zod schemas: \`pikkuChannelFunc({ input: z.object(...), func: ... })\`
- *
- * @template In - Input type for channel messages (inferred from schema if provided)
- * @template Out - Output type for channel responses (inferred from schema if provided)
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- *
- * @example
- * \`\`\`typescript
- * // Pattern 1: Using generic types
- * const handleMessage = pikkuChannelFunc<{text: string}, {received: boolean}>({
- *   func: async (_services, { text }) => ({ received: true })
- * })
- *
- * // Pattern 2: Using Zod schemas
- * const messageInput = z.object({ text: z.string() })
- * const messageOutput = z.object({ received: z.boolean() })
- *
- * const handleMessage = pikkuChannelFunc({
- *   input: messageInput,
- *   output: messageOutput,
- *   func: async (_services, { text }) => ({ received: true })
- * })
- * \`\`\`
- */
-export function pikkuChannelFunc<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined
->(
-  config: PikkuChannelFuncConfigWithSchema<InputSchema, OutputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'channel' | 'session' | 'rpc'>
-export function pikkuChannelFunc<In, Out = unknown>(
-  func:
-    | PikkuFunctionSessionless<In, Out, 'channel' | 'session' | 'rpc'>
-    | PikkuFunctionConfig<In, Out, 'channel' | 'session' | 'rpc'>
-): PikkuFunctionConfig<In, Out, 'channel' | 'session' | 'rpc'>
-export function pikkuChannelFunc(func: any) {
-  return typeof func === 'function' ? { func } : func
-}
-
-/**
- * Registers a WebSocket channel with the Pikku framework.
- *
- * @template ChannelData - Type of data associated with the channel
- * @template Channel - String literal type for the channel name
- * @param channel - Channel definition with connection, disconnection, and message handlers
- */
-export const wireChannel = <ChannelData, Channel extends string>(
-  channel: ChannelWiring<ChannelData, Channel> & AssertHTTPWiringParams<ChannelData, Channel>
-) => {
-  wireChannelCore(channel as any) // TODO
-}
-`
-}

package/src/functions/wirings/channels/serialize-typed-channel-map.ts

@@ -1,173 +0,0 @@
-import { ChannelsMeta } from '@pikku/core/channel'
-import { serializeImportMap } from '../../../utils/serialize-import-map.js'
-import { TypesMap } from '@pikku/inspector'
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js'
-import { FunctionsMeta } from '@pikku/core'
-
-export const serializeTypedChannelsMap = (
-  relativeToPath: string,
-  packageMappings: Record<string, string>,
-  typesMap: TypesMap,
-  functionsMeta: FunctionsMeta,
-  channelsMeta: ChannelsMeta
-): string => {
-  const { channels, requiredTypes } = generateChannels(
-    functionsMeta,
-    channelsMeta
-  )
-  typesMap.customTypes.forEach(({ references }) => {
-    for (const reference of references) {
-      if (reference !== '__object' && !reference.startsWith('__object_')) {
-        requiredTypes.add(reference)
-      }
-    }
-  })
-
-  const imports = serializeImportMap(
-    relativeToPath,
-    packageMappings,
-    typesMap,
-    requiredTypes
-  )
-  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
-
-  return `/**
- * This provides the structure needed for TypeScript to be aware of channels
- */
-
-${imports}
-${serializedCustomTypes}
-
-interface ChannelHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${channels}
-
-export type ChannelDefaultHandlerOf<Channel extends keyof ChannelsMap> =
-    ChannelsMap[Channel]['defaultMessage'] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;
-
-export type ChannelWiringHandlerOf<
-    Channel extends keyof ChannelsMap, 
-    Route extends keyof ChannelsMap[Channel]['routes'], 
-    Method extends keyof ChannelsMap[Channel]['routes'][Route],
-> =
-    ChannelsMap[Channel]['routes'][Route][Method] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;
-`
-}
-
-function generateChannels(
-  functionsMeta: FunctionsMeta,
-  channelsMeta: ChannelsMeta
-) {
-  const requiredTypes = new Set<string>()
-  const channelsObject: Record<
-    string,
-    {
-      message: { inputs: string[] | null; outputs: string[] | null } | null
-      routes: Record<
-        string,
-        Record<
-          string,
-          {
-            inputTypes: string[] | null
-            outputTypes: string[] | null
-          }
-        >
-      >
-    }
-  > = {}
-
-  for (const meta of Object.values(channelsMeta)) {
-    const { name, messageWirings, message } = meta
-
-    if (!channelsObject[name]) {
-      channelsObject[name] = { message: null, routes: {} }
-    }
-
-    if (message) {
-      const func = functionsMeta[message.pikkuFuncName]
-      if (!func) {
-        throw new Error(
-          `Function ${message.pikkuFuncName} not found in functionsMeta for channel ${name}`
-        )
-      }
-      const inputTypes = func.inputs || null
-      const outputTypes = func.outputs || null
-      channelsObject[name].message = {
-        inputs: inputTypes,
-        outputs: outputTypes,
-      }
-      inputTypes?.forEach((type) => requiredTypes.add(type))
-      outputTypes?.forEach((type) => requiredTypes.add(type))
-    }
-
-    for (const [key, route] of Object.entries(messageWirings)) {
-      if (!channelsObject[name].routes[key]) {
-        channelsObject[name].routes[key] = {}
-      }
-      for (const [method, { pikkuFuncName }] of Object.entries(route)) {
-        const func = functionsMeta[pikkuFuncName]
-        if (!func) {
-          throw new Error(
-            `Function ${pikkuFuncName} not found in functionsMeta for channel ${name}, route ${key}, method ${method}`
-          )
-        }
-        const inputTypes = func.inputs || null
-        const outputTypes = func.outputs || null
-        channelsObject[name].routes[key][method] = {
-          inputTypes,
-          outputTypes,
-        }
-        inputTypes?.forEach((type) => requiredTypes.add(type))
-        outputTypes?.forEach((type) => requiredTypes.add(type))
-      }
-    }
-  }
-
-  let routesStr = 'export type ChannelsMap = {\n'
-
-  for (const [channelPath, { routes, message }] of Object.entries(
-    channelsObject
-  )) {
-    routesStr += `  readonly '${channelPath}': {\n`
-
-    // Add `routes` object
-    routesStr += `    readonly routes: {\n`
-    for (const [key, methods] of Object.entries(routes)) {
-      routesStr += `      readonly ${key}: {\n`
-      for (const [method, handler] of Object.entries(methods)) {
-        routesStr += `        readonly ${method}: ChannelHandler<${
-          formatTypeArray(handler.inputTypes) || 'void'
-        }, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`
-      }
-      routesStr += '      },\n'
-    }
-    routesStr += '    },\n'
-
-    // Add `defaultMessage` outside `routes`
-    if (message) {
-      routesStr += `    readonly defaultMessage: ChannelHandler<${formatTypeArray(
-        message.inputs
-      )}, ${formatTypeArray(message.outputs)}>,\n`
-    } else {
-      routesStr += `    readonly defaultMessage: never,\n`
-    }
-
-    routesStr += '  },\n'
-  }
-
-  routesStr += '};'
-
-  return { channels: routesStr, requiredTypes }
-}
-
-// Utility to format type arrays
-function formatTypeArray(types: string[] | null): string {
-  return types ? types.join(' | ') : 'null'
-}

package/src/functions/wirings/channels/serialize-websocket-wrapper.ts

@@ -1,89 +0,0 @@
-export const serializeWebsocketWrapper = (channelsMapPath: string) => {
-  return `import { CorePikkuWebsocket, CorePikkuRouteHandler } from '@pikku/websocket'
-import { ChannelDefaultHandlerOf, ChannelWiringHandlerOf, ChannelsMap } from '${channelsMapPath}';
-
-class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof ChannelsMap[Channel]['routes']> extends CorePikkuRouteHandler {
-    public subscribe<
-        Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelWiringHandlerOf<Channel, Route, Method>['output']
-    >(method: Method, callback: (data: Data) => void
-    ) {
-        super.subscribe(method.toString(), callback)
-    }
-
-    public unsubscribe<
-        Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelWiringHandlerOf<Channel, Route, Method>['output']
-    >(method: Method, callback?: (data: Data) => void) {
-        super.unsubscribe(method.toString(), callback)
-    }
-
-    public send<
-        Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelWiringHandlerOf<Channel, Route, Method>['input']
-    >(method: Method, data: Data) {
-        super.send(method.toString(), data)
-    }
-}
-
-/**
- * Type-safe WebSocket wrapper for Pikku channels.
- *
- * @example
- * // Browser usage
- * const ws = new WebSocket('ws://localhost:3000')
- * const pikkuWS = new PikkuWebSocket<'events'>(ws)
- *
- * @example
- * // Node.js usage
- * import WebSocket from 'ws'
- * const ws = new WebSocket('ws://localhost:3000')
- * const pikkuWS = new PikkuWebSocket<'events'>(ws)
- */
-export class PikkuWebSocket<Channel extends keyof ChannelsMap, EventHubTopics extends Record<string, any> = {}> extends CorePikkuWebsocket {
-    /**
-     * Send a message to a specific route and method.
-     * Validates the input data type.
-     */
-    public getRoute<Route extends keyof ChannelsMap[Channel]['routes']>(route: Route): PikkuWebSocketRoute<Channel, Route> {
-        return super.getRoute(route)
-    }
-
-    /**
-     * Subscribe to a specific route and method.
-     */
-    public subscribe<Data extends ChannelDefaultHandlerOf<Channel>['output']>(
-        callback: (data: Data) => void
-    ) {
-        super.subscribe(callback)
-    }
-
-    /**
-     * Subscribe to a specific route and method.
-     */
-    public unsubscribe<Data extends ChannelDefaultHandlerOf<Channel>['output']>(
-        callback?: (data: Data) => void
-    ) {
-        super.unsubscribe(callback)
-    }
-
-    public send(data: ChannelDefaultHandlerOf<Channel>['input']) {
-        super.send(data)
-    }
-
-    /**
-     * Subscribe to a topic from the EventHub system with strong typing.
-     */
-    public subscribeToEventHub<Topic extends keyof EventHubTopics>(
-        topic: Topic,
-        callback: (data: EventHubTopics[Topic]) => void
-    ) {
-        super.subscribe((data) => {
-            if (data.topic === topic) {
-                callback(data as EventHubTopics[Topic])
-            }
-        })
-    }
-}
-  `
-}