@pikku/cli 0.7.0 → 0.7.2

package/{dist/src/core/serialize-pikku-types.js → src/serialize-pikku-types.ts}

@@ -1,14 +1,21 @@
 /**
  *
  */
-export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, servicesTypeName) => {
-    return `/**
+export const serializePikkuTypes = (
+  userSessionTypeImport: string,
+  userSessionTypeName: string,
+  singletonServicesTypeImport: string,
+  singletonServicesTypeName: string,
+  sessionServicesTypeImport: string,
+  servicesTypeName: string
+) => {
+  return `/**
 * This is used to provide the application types in the typescript project
 */
   
-import { CorePermissionGroup, CoreAPIPermission, PikkuMiddleware, MakeRequired } from '@pikku/core'
+import { CoreAPIPermission, PikkuMiddleware } from '@pikku/core'
 import { CoreAPIFunction, CoreAPIFunctionSessionless } from '@pikku/core/function'
-import { CoreHTTPFunctionRoute, AssertRouteParams, addRoute as addCoreHTTP } from '@pikku/core/http'
+import { CoreHTTPFunctionRoute, AssertRouteParams, addHTTPRoute as addCoreHTTPRoute } from '@pikku/core/http'
 import { CoreScheduledTask, addScheduledTask as addCoreScheduledTask } from '@pikku/core/scheduler'
 import { CoreAPIChannel, PikkuChannel, addChannel as addCoreChannel } from '@pikku/core/channel'
 
@@ -19,14 +26,30 @@ ${sessionServicesTypeImport}
 export type APIPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
 export type APIMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = PikkuMiddleware<RequiredServices, ${userSessionTypeName}>
 
-type APIFunctionSessionless<In = unknown, Out = never, Channel extends boolean = false, RequiredServices extends Services = Services & (Channel extends true ? { channel: PikkuChannel<unknown, Out> } : { channel?: PikkuChannel<unknown, Out> })> = CoreAPIFunctionSessionless<In, Out, Channel, RequiredServices, ${userSessionTypeName}>
-type APIFunction<In = unknown, Out = never, Channel extends boolean = false, RequiredServices extends Services = Services & (Channel extends true ? { channel: PikkuChannel<unknown, Out> } : { channel?: PikkuChannel<unknown, Out> })> = CoreAPIFunction<In, Out, Channel, RequiredServices, ${userSessionTypeName}>
-type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, CorePermissionGroup<APIPermission>, APIMiddleware>
+type APIFunctionSessionless<
+  In = unknown, 
+  Out = never, 
+  ChannelData = null,  // null means optional channel
+  RequiredServices extends Services = Services & (
+    [ChannelData] extends [null] 
+      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
+      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  )
+> = CoreAPIFunctionSessionless<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
 
-export type ChannelConnection<Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<RequiredServices, 'userSession'>, channel: PikkuChannel<ChannelData, Out>) => Promise<void>
-export type ChannelDisconnection<ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<RequiredServices, 'userSession'>, channel: PikkuChannel<ChannelData, never>) => Promise<void>
-type APIChannel<ChannelData, Channel extends string> = CoreAPIChannel<ChannelData, Channel, APIFunction<any, any, false> | APIFunction<any, any, true>, APIPermission>
+type APIFunction<
+  In = unknown, 
+  Out = never, 
+  ChannelData = null,  // null means optional channel
+  RequiredServices extends Services = Services & (
+    [ChannelData] extends [null] 
+      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
+      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  )
+> = CoreAPIFunction<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
 
+type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>, APIMiddleware>
+type APIChannel<ChannelData, Channel extends string> = CoreAPIChannel<ChannelData, Channel, APIFunction<void, unknown> | APIFunction<void, unknown, ChannelData>, APIFunction<void, void> | APIFunction<void, void, ChannelData>, APIFunction<any, any> | APIFunction<any, any, ChannelData>, APIPermission>
 type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>, ${userSessionTypeName}>
 
 export const pikkuFunc = <In, Out = unknown>(
@@ -57,45 +80,33 @@ export const pikkuSessionlessFunc = <In, Out = unknown>(
   return typeof func === 'function' ? func : func.func
 }
 
-export const pikkuChannelConnection = <In, Out = unknown>(
+export const pikkuChannelConnectionFunc = <Out = unknown, ChannelData = unknown>(
   func:
-    | ChannelConnection<In, Out>
-    | {
-        func: ChannelConnection<In, Out>
-        auth?: true
-        name?: string
-      }
+    | APIFunctionSessionless<void, Out, ChannelData>
     | {
-        func: ChannelConnection<In, Out>
-        auth: false
+        func: APIFunctionSessionless<void, Out, ChannelData>
         name?: string
       }
 ) => {
   return typeof func === 'function' ? func : func.func
 }
 
-export const pikkuChannelDisconnection = <In>(
+export const pikkuChannelDisconnectionFunc = <ChannelData = unknown>(
   func:
-    | ChannelDisconnection<In>
+    | APIFunctionSessionless<void, void, ChannelData>
     | {
-        func: ChannelDisconnection<In>
-        auth?: true
-        name?: string
-      }
-    | {
-        func: ChannelDisconnection<In>
-        auth: false
+        func: APIFunction<void, void, ChannelData>
         name?: string
       }
 ) => {
   return typeof func === 'function' ? func : func.func
 }
 
-export const pikkuChannelFunc = <In, Out = unknown>(
+export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unknown>(
   func:
-    | APIFunctionSessionless<In, Out, true>
+    | APIFunctionSessionless<In, Out, ChannelData>
     | {
-        func: APIFunctionSessionless<In, Out, true>
+        func: APIFunctionSessionless<In, Out, ChannelData>
         name?: string
       }
 ) => {
@@ -119,14 +130,14 @@ export const addChannel = <ChannelData, Channel extends string>(
   addCoreChannel(channel as any) // TODO
 }
 
-export const addRoute = <In, Out, Route extends string>(
+export const addHTTPRoute = <In, Out, Route extends string>(
   route: APIRoute<In, Out, Route> & AssertRouteParams<In, Route>
 ) => {
-  addCoreHTTP(route)
+  addCoreHTTPRoute(route)
 }
 
 export const addScheduledTask = (task: ScheduledTask) => {
   addCoreScheduledTask(task as any) // TODO
 }
-`;
-};
+`
+}

package/src/serialize-scheduler-meta.ts

@@ -0,0 +1,18 @@
+import { ScheduledTasksMeta } from '@pikku/core/scheduler'
+
+export const serializeSchedulerMeta = (
+  scheduledTasksMeta: ScheduledTasksMeta
+) => {
+  const serializedOutput: string[] = []
+  serializedOutput.push("import { pikkuState } from '@pikku/core'")
+  serializedOutput.push(
+    `pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`
+  )
+  const scheduledTasksMetaValues = Object.values(scheduledTasksMeta)
+  if (scheduledTasksMetaValues.length > 0) {
+    serializedOutput.push(
+      `export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`
+    )
+  }
+  return serializedOutput.join('\n')
+}

package/src/serialize-typed-channel-map.ts

@@ -0,0 +1,138 @@
+import { ChannelsMeta } from '@pikku/core/channel'
+import { serializeImportMap } from './serialize-import-map.js'
+import { TypesMap } from '@pikku/inspector'
+import { generateCustomTypes } from './serialize-typed-http-map.js'
+
+export const serializeTypedChannelsMap = (
+  relativeToPath: string,
+  packageMappings: Record<string, string>,
+  typesMap: TypesMap,
+  channelsMeta: ChannelsMeta
+): string => {
+  const { channels, requiredTypes } = generateChannels(channelsMeta)
+  typesMap.customTypes.forEach(({ references }) => {
+    for (const reference of references) {
+      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 ChannelRouteHandlerOf<
+    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(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, messageRoutes, message } = meta
+
+    if (!channelsObject[name]) {
+      channelsObject[name] = { message, routes: {} }
+    }
+
+    for (const [key, route] of Object.entries(messageRoutes)) {
+      if (!channelsObject[name].routes[key]) {
+        channelsObject[name].routes[key] = {}
+      }
+      for (const [method, { inputs, outputs }] of Object.entries(route)) {
+        const inputTypes = inputs || null
+        const outputTypes = 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/serialize-typed-function-map.ts

@@ -0,0 +1,161 @@
+import { HTTPRoutesMeta } from '@pikku/core/http'
+import { serializeImportMap } from './serialize-import-map.js'
+import { MetaInputTypes, TypesMap } from '@pikku/inspector'
+import { FunctionsMeta } from '@pikku/core'
+
+export const serializeTypedRoutesMap = (
+  relativeToPath: string,
+  packageMappings: Record<string, string>,
+  typesMap: TypesMap,
+  functionsMeta: FunctionsMeta,
+  routesMeta: HTTPRoutesMeta,
+  metaTypes: MetaInputTypes
+) => {
+  const requiredTypes = new Set<string>()
+  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
+  const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap)
+  const serializedRoutes = generateRoutes(
+    functionsMeta,
+    routesMeta,
+    typesMap,
+    requiredTypes
+  )
+
+  const serializedImportMap = serializeImportMap(
+    relativeToPath,
+    packageMappings,
+    typesMap,
+    requiredTypes
+  )
+
+  return `/**
+ * This provides the structure needed for typescript to be aware of routes and their return types
+ */
+    
+${serializedImportMap}
+${serializedCustomTypes}
+${serializedMetaTypes}
+
+interface RouteHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${serializedRoutes}
+
+export type RouteHandlerOf<Route extends keyof RoutesMap, Method extends keyof RoutesMap[Route]> =
+    RoutesMap[Route][Method] extends { input: infer I; output: infer O }
+        ? RouteHandler<I, O>
+        : never;
+
+export type RoutesWithMethod<Method extends string> = {
+  [Route in keyof RoutesMap]: Method extends keyof RoutesMap[Route] ? Route : never;
+}[keyof RoutesMap];
+  `
+}
+
+export function generateCustomTypes(
+  typesMap: TypesMap,
+  requiredTypes: Set<string>
+) {
+  return `
+// Custom types are those that are defined directly within generics
+// or are broken into simpler types
+${Array.from(typesMap.customTypes.entries())
+  .map(([name, { type, references }]) => {
+    references.forEach((name) => {
+      const originalName = typesMap.getTypeMeta(name).originalName
+      requiredTypes.add(originalName)
+    })
+    return `export type ${name} = ${type}`
+  })
+  .join('\n')}`
+}
+
+function generateRoutes(
+  functionsMeta: FunctionsMeta,
+  routesMeta: HTTPRoutesMeta,
+  typesMap: TypesMap,
+  requiredTypes: Set<string>
+) {
+  // Initialize an object to collect routes
+  const routesObj: Record<
+    string,
+    Record<string, { inputType: string; outputType: string }>
+  > = {}
+
+  for (const meta of routesMeta) {
+    const { route, method, pikkuFuncName } = meta
+    const input = functionsMeta[pikkuFuncName]?.inputs?.[0]
+    const output = functionsMeta[pikkuFuncName]?.outputs?.[0]
+
+    // Initialize the route entry if it doesn't exist
+    if (!routesObj[route]) {
+      routesObj[route] = {}
+    }
+
+    // Store the input and output types separately for RouteHandler
+    const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null'
+    const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null'
+
+    requiredTypes.add(inputType)
+    requiredTypes.add(outputType)
+
+    // Add method entry
+    routesObj[route][method] = {
+      inputType,
+      outputType,
+    }
+  }
+
+  // Build the routes object as a string
+  let routesStr = 'export type RoutesMap = {\n'
+
+  for (const [routePath, methods] of Object.entries(routesObj)) {
+    routesStr += `  readonly '${routePath}': {\n`
+    for (const [method, handler] of Object.entries(methods)) {
+      routesStr += `    readonly ${method.toUpperCase()}: RouteHandler<${handler.inputType}, ${handler.outputType}>,\n`
+    }
+    routesStr += '  },\n'
+  }
+
+  routesStr += '};'
+
+  return routesStr
+}
+
+const generateMetaTypes = (metaTypes: MetaInputTypes, typesMap: TypesMap) => {
+  const nameToTypeMap = Array.from(metaTypes.entries()).reduce<
+    Map<string, string>
+  >((result, [_name, { query, body, params }]) => {
+    const { uniqueName } = typesMap.getTypeMeta(_name)
+    const queryType =
+      query && query.length > 0
+        ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
+        : undefined
+    if (queryType) {
+      result.set(`${uniqueName}Query`, queryType)
+    }
+    const paramsType =
+      params && params.length > 0
+        ? `Pick<${uniqueName}, '${params.join("' | '")}'>`
+        : undefined
+    if (paramsType) {
+      result.set(`${uniqueName}Params`, paramsType)
+    }
+    const bodyType =
+      (body && body.length > 0) || (params && params.length > 0)
+        ? `Omit<${uniqueName}, '${[...new Set([...(query || []), ...(params || [])])].join("' | '")}'>`
+        : uniqueName!
+    if (bodyType) {
+      result.set(`${uniqueName}Body`, bodyType)
+    }
+    return result
+  }, new Map())
+
+  return `
+// The '& {}' is a workaround for not directly refering to a type since it confuses typescript
+${Array.from(nameToTypeMap.entries())
+  .map(([name, type]) => `export type ${name} = ${type} & {}`)
+  .join('\n')}`
+}

package/src/serialize-typed-http-map.ts

@@ -0,0 +1,167 @@
+import { HTTPRoutesMeta } from '@pikku/core/http'
+import { serializeImportMap } from './serialize-import-map.js'
+import { MetaInputTypes, TypesMap } from '@pikku/inspector'
+import { FunctionsMeta } from '@pikku/core'
+
+export const serializeTypedRoutesMap = (
+  relativeToPath: string,
+  packageMappings: Record<string, string>,
+  typesMap: TypesMap,
+  functionsMeta: FunctionsMeta,
+  routesMeta: HTTPRoutesMeta,
+  metaTypes: MetaInputTypes
+) => {
+  const requiredTypes = new Set<string>()
+  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
+  const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap)
+  const serializedRoutes = generateRoutes(
+    routesMeta,
+    functionsMeta,
+    typesMap,
+    requiredTypes
+  )
+
+  const serializedImportMap = serializeImportMap(
+    relativeToPath,
+    packageMappings,
+    typesMap,
+    requiredTypes
+  )
+
+  return `/**
+ * This provides the structure needed for typescript to be aware of routes and their return types
+ */
+    
+${serializedImportMap}
+${serializedCustomTypes}
+${serializedMetaTypes}
+
+interface RouteHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${serializedRoutes}
+
+export type RouteHandlerOf<Route extends keyof RoutesMap, Method extends keyof RoutesMap[Route]> =
+    RoutesMap[Route][Method] extends { input: infer I; output: infer O }
+        ? RouteHandler<I, O>
+        : never;
+
+export type RoutesWithMethod<Method extends string> = {
+  [Route in keyof RoutesMap]: Method extends keyof RoutesMap[Route] ? Route : never;
+}[keyof RoutesMap];
+  `
+}
+
+export function generateCustomTypes(
+  typesMap: TypesMap,
+  requiredTypes: Set<string>
+) {
+  return `
+// Custom types are those that are defined directly within generics
+// or are broken into simpler types
+${Array.from(typesMap.customTypes.entries())
+  .map(([name, { type, references }]) => {
+    references.forEach((name) => {
+      const originalName = typesMap.getTypeMeta(name).originalName
+      requiredTypes.add(originalName)
+    })
+    return `export type ${name} = ${type}`
+  })
+  .join('\n')}`
+}
+
+function generateRoutes(
+  routesMeta: HTTPRoutesMeta,
+  functionsMeta: FunctionsMeta,
+  typesMap: TypesMap,
+  requiredTypes: Set<string>
+) {
+  // Initialize an object to collect routes
+  const routesObj: Record<
+    string,
+    Record<string, { inputType: string; outputType: string }>
+  > = {}
+
+  for (const meta of routesMeta) {
+    const { route, method, pikkuFuncName } = meta
+    const functionMeta = functionsMeta[pikkuFuncName]
+    if (!functionMeta) {
+      throw new Error(
+        `Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`
+      )
+    }
+    const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined
+    const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
+
+    // Initialize the route entry if it doesn't exist
+    if (!routesObj[route]) {
+      routesObj[route] = {}
+    }
+
+    // Store the input and output types separately for RouteHandler
+    const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null'
+    const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null'
+
+    requiredTypes.add(inputType)
+    requiredTypes.add(outputType)
+
+    // Add method entry
+    routesObj[route][method] = {
+      inputType,
+      outputType,
+    }
+  }
+
+  // Build the routes object as a string
+  let routesStr = 'export type RoutesMap = {\n'
+
+  for (const [routePath, methods] of Object.entries(routesObj)) {
+    routesStr += `  readonly '${routePath}': {\n`
+    for (const [method, handler] of Object.entries(methods)) {
+      routesStr += `    readonly ${method.toUpperCase()}: RouteHandler<${handler.inputType}, ${handler.outputType}>,\n`
+    }
+    routesStr += '  },\n'
+  }
+
+  routesStr += '};'
+
+  return routesStr
+}
+
+const generateMetaTypes = (metaTypes: MetaInputTypes, typesMap: TypesMap) => {
+  const nameToTypeMap = Array.from(metaTypes.entries()).reduce<
+    Map<string, string>
+  >((result, [_name, { query, body, params }]) => {
+    const { uniqueName } = typesMap.getTypeMeta(_name)
+    const queryType =
+      query && query.length > 0
+        ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
+        : undefined
+    if (queryType) {
+      result.set(`${uniqueName}Query`, queryType)
+    }
+    const paramsType =
+      params && params.length > 0
+        ? `Pick<${uniqueName}, '${params.join("' | '")}'>`
+        : undefined
+    if (paramsType) {
+      result.set(`${uniqueName}Params`, paramsType)
+    }
+    const bodyType =
+      (body && body.length > 0) || (params && params.length > 0)
+        ? `Omit<${uniqueName}, '${[...new Set([...(query || []), ...(params || [])])].join("' | '")}'>`
+        : uniqueName!
+    if (bodyType) {
+      result.set(`${uniqueName}Body`, bodyType)
+    }
+    return result
+  }, new Map())
+
+  return `
+// The '& {}' is a workaround for not directly refering to a type since it confuses typescript
+${Array.from(nameToTypeMap.entries())
+  .map(([name, type]) => `export type ${name} = ${type} & {}`)
+  .join('\n')}`
+}

package/{dist/src/channels/serialize-websocket-wrapper.js → src/serialize-websocket-wrapper.ts}

@@ -1,5 +1,5 @@
-export const serializeWebsocketWrapper = (channelsMapPath) => {
-    return `import { CorePikkuWebsocket, CorePikkuRouteHandler } from '@pikku/websocket'
+export const serializeWebsocketWrapper = (channelsMapPath: string) => {
+  return `import { CorePikkuWebsocket, CorePikkuRouteHandler } from '@pikku/websocket'
 import { ChannelDefaultHandlerOf, ChannelRouteHandlerOf, ChannelsMap } from '${channelsMapPath}';
 
 class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof ChannelsMap[Channel]['routes']> extends CorePikkuRouteHandler {
@@ -57,5 +57,5 @@ export class PikkuWebSocket<Channel extends keyof ChannelsMap> extends CorePikku
         super.send(data)
     }
 }
-  `;
-};
+  `
+}