@pikku/cli 0.6.20 → 0.7.1

package/src/{schema/schema-generator.ts → schema-generator.ts}

@@ -1,5 +1,5 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator'
-import { logInfo, writeFileInDir } from '../utils.js'
+import { logInfo, writeFileInDir } from './utils.js'
 import { mkdir, writeFile } from 'fs/promises'
 import { JSONValue } from '@pikku/core'
 import { HTTPRoutesMeta } from '@pikku/core/http'
@@ -7,17 +7,39 @@ import { TypesMap } from '@pikku/inspector'
 
 export async function generateSchemas(
   tsconfig: string,
-  typesMap: TypesMap,
-  routesMeta: HTTPRoutesMeta
+  typesMaps: TypesMap[],
+  httpRoutesMeta: HTTPRoutesMeta
 ): Promise<Record<string, JSONValue>> {
-  const schemasSet = new Set(typesMap.customTypes.keys())
-  for (const { input, output, inputTypes } of routesMeta) {
+  const schemasSet = new Set(
+    typesMaps.flatMap((tm) => [...tm.customTypes.keys()])
+  )
+  for (const { input, inputTypes } of httpRoutesMeta) {
     if (input) {
-      schemasSet.add(typesMap.getTypeMeta(input).uniqueName)
-    }
-    if (output) {
-      schemasSet.add(typesMap.getTypeMeta(output).uniqueName)
+      let found = false
+      for (const typesMap of typesMaps) {
+        try {
+          const uniqueName = typesMap.getUniqueName(input)
+          if (uniqueName) {
+            found = true
+            schemasSet.add(uniqueName)
+            break
+          }
+        } catch (e) {}
+      }
+      if (!found) {
+        console.error('Input type not found in any types map:', input)
+      }
     }
+    // if (output) {
+    //   for (const typesMap of typesMaps) {
+    //     const uniqueName = typesMap.getUniqueName(output)
+    //     if (uniqueName) {
+    //       console.log('Adding output schema:', uniqueName)
+    //       schemasSet.add(uniqueName)
+    //       break
+    //     }
+    //   }
+    // }
     if (inputTypes?.body) {
       schemasSet.add(inputTypes.body)
     }

package/src/{core/serialize-import-map.ts → serialize-import-map.ts}

@@ -1,5 +1,5 @@
 import { TypesMap } from '@pikku/inspector'
-import { getFileImportRelativePath } from '../utils.js'
+import { getFileImportRelativePath } from './utils.js'
 
 export const serializeImportMap = (
   relativeToPath: string,
@@ -12,6 +12,7 @@ export const serializeImportMap = (
     const { originalName, uniqueName, path } =
       typesMap.getTypeMeta(requiredType)
     if (!path) {
+      // This is a custom type that exists in file, so we don't need to import it
       return
     }
     const variables = paths.get(path) || []

package/src/serialize-pikku-types.ts

@@ -0,0 +1,143 @@
+/**
+ *
+ */
+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 { CoreAPIPermission, PikkuMiddleware } from '@pikku/core'
+import { CoreAPIFunction, CoreAPIFunctionSessionless } from '@pikku/core/function'
+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'
+
+${userSessionTypeImport}
+${singletonServicesTypeImport}
+${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, 
+  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}>
+
+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>(
+  func:
+    | APIFunction<In, Out>
+    | {
+        func: APIFunction<In, Out>
+        auth?: true
+        name?: string
+      }
+    | {
+        func: APIFunctionSessionless<In, Out>
+        auth: false
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuSessionlessFunc = <In, Out = unknown>(
+  func:
+    | APIFunctionSessionless<In, Out>
+    | {
+        func: APIFunctionSessionless<In, Out>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelConnectionFunc = <Out = unknown, ChannelData = unknown>(
+  func:
+    | APIFunctionSessionless<void, Out, ChannelData>
+    | {
+        func: APIFunctionSessionless<void, Out, ChannelData>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelDisconnectionFunc = <ChannelData = unknown>(
+  func:
+    | APIFunctionSessionless<void, void, ChannelData>
+    | {
+        func: APIFunction<void, void, ChannelData>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unknown>(
+  func:
+    | APIFunctionSessionless<In, Out, ChannelData>
+    | {
+        func: APIFunctionSessionless<In, Out, ChannelData>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuVoidFunc = (
+  func:
+    | APIFunctionSessionless<void, void>
+    | {
+        func: APIFunctionSessionless<void, void>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+   
+export const addChannel = <ChannelData, Channel extends string>(
+  channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
+) => {
+  addCoreChannel(channel as any) // TODO
+}
+
+export const addHTTPRoute = <In, Out, Route extends string>(
+  route: APIRoute<In, Out, Route> & AssertRouteParams<In, 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/{channels/serialize-typed-channel-map.ts → serialize-typed-channel-map.ts}

@@ -1,7 +1,7 @@
 import { ChannelsMeta } from '@pikku/core/channel'
-import { serializeImportMap } from '../core/serialize-import-map.js'
+import { serializeImportMap } from './serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
-import { generateCustomTypes } from '../http/serialize-typed-route-map.js'
+import { generateCustomTypes } from './serialize-typed-http-map.js'
 
 export const serializeTypedChannelsMap = (
   relativeToPath: string,
@@ -71,7 +71,7 @@ function generateChannels(channelsMeta: ChannelsMeta) {
     }
   > = {}
 
-  for (const meta of channelsMeta) {
+  for (const meta of Object.values(channelsMeta)) {
     const { name, messageRoutes, message } = meta
 
     if (!channelsObject[name]) {
@@ -107,9 +107,9 @@ function generateChannels(channelsMeta: ChannelsMeta) {
     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
-        )}, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`
+        routesStr += `        readonly ${method}: ChannelHandler<${
+          formatTypeArray(handler.inputTypes) || 'void'
+        }, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`
       }
       routesStr += '      },\n'
     }
@@ -120,6 +120,8 @@ function generateChannels(channelsMeta: ChannelsMeta) {
       routesStr += `    readonly defaultMessage: ChannelHandler<${formatTypeArray(
         message.inputs
       )}, ${formatTypeArray(message.outputs)}>,\n`
+    } else {
+      routesStr += `    readonly defaultMessage: never,\n`
     }
 
     routesStr += '  },\n'

package/src/{http/serialize-typed-route-map.ts → serialize-typed-function-map.ts}

@@ -1,5 +1,5 @@
 import { HTTPRoutesMeta } from '@pikku/core/http'
-import { serializeImportMap } from '../core/serialize-import-map.js'
+import { serializeImportMap } from './serialize-import-map.js'
 import { MetaInputTypes, TypesMap } from '@pikku/inspector'
 
 export const serializeTypedRoutesMap = (
@@ -12,13 +12,14 @@ export const serializeTypedRoutesMap = (
   const requiredTypes = new Set<string>()
   const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
   const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap)
+  const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes)
+
   const serializedImportMap = serializeImportMap(
     relativeToPath,
     packageMappings,
     typesMap,
     requiredTypes
   )
-  const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes)
 
   return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types

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

@@ -0,0 +1,151 @@
+import { HTTPRoutesMeta } from '@pikku/core/http'
+import { serializeImportMap } from './serialize-import-map.js'
+import { MetaInputTypes, TypesMap } from '@pikku/inspector'
+
+export const serializeTypedRoutesMap = (
+  relativeToPath: string,
+  packageMappings: Record<string, string>,
+  typesMap: TypesMap,
+  routesMeta: HTTPRoutesMeta,
+  metaTypes: MetaInputTypes
+) => {
+  const requiredTypes = new Set<string>()
+  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
+  const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap)
+  const serializedRoutes = generateRoutes(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(
+  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, input, output } = meta
+
+    // 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/utils.ts

@@ -28,17 +28,17 @@ export const getFileImportRelativePath = (
   if (!/^\.+\//.test(filePath)) {
     filePath = `./${filePath}`
   }
-  let usesPackageName = false
+  // let usesPackageName = false
   for (const [path, packageName] of Object.entries(packageMappings)) {
     if (filePath.includes(path)) {
-      usesPackageName = true
+      // usesPackageName = true
       filePath = filePath.replace(new RegExp(`.*${path}`), packageName)
       break
     }
   }
-  if (usesPackageName) {
-    return filePath.replace('.ts', '')
-  }
+  // if (usesPackageName) {
+  //   return filePath.replace('.ts', '')
+  // }
   return filePath.replace('.ts', '.js')
 }
 
@@ -258,3 +258,27 @@ export const DO_NOT_MODIFY_COMMENT = `/**
  * This file was generated by the @pikku/cli
  */
 `
+
+export const serializeFileImports = (
+  importType: string,
+  outputPath: string,
+  files: Set<string>,
+  packageMappings: Record<string, string> = {}
+) => {
+  const serializedOutput: string[] = [
+    `/* The files with an ${importType} function call */`,
+  ]
+
+  Array.from(files)
+    .sort()
+    .forEach((path) => {
+      const filePath = getFileImportRelativePath(
+        outputPath,
+        path,
+        packageMappings
+      )
+      serializedOutput.push(`import '${filePath}'`)
+    })
+
+  return serializedOutput.join('\n')
+}

package/dist/src/channels/serialize-channels.d.ts

@@ -1,3 +0,0 @@
-import { ChannelsMeta } from '@pikku/core/channel';
-export declare const serializeChannels: (outputPath: string, filesWithChannels: Set<string>, packageMappings?: Record<string, string>) => string;
-export declare const serializeChannelMeta: (channelsMeta: ChannelsMeta) => string;

package/dist/src/channels/serialize-channels.js

@@ -1,19 +0,0 @@
-import { getFileImportRelativePath } from '../utils.js';
-export const serializeChannels = (outputPath, filesWithChannels, packageMappings = {}) => {
-    const serializedOutput = [
-        '/* The files with an addChannel function call */',
-    ];
-    Array.from(filesWithChannels)
-        .sort()
-        .forEach((path) => {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        serializedOutput.push(`import '${filePath}'`);
-    });
-    return serializedOutput.join('\n');
-};
-export const serializeChannelMeta = (channelsMeta) => {
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push(`pikkuState('channel', 'meta', ${JSON.stringify(channelsMeta, null, 2)})`);
-    return serializedOutput.join('\n');
-};

package/dist/src/core/serialize-pikku-types.js

@@ -1,48 +0,0 @@
-/**
- *
- */
-export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, servicesTypeName) => {
-    return `/**
-* This is used to provide the application types in the typescript project
-*/
-  
-import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, PikkuMiddleware, MakeRequired } from '@pikku/core'
-import { CoreHTTPFunctionRoute, AssertRouteParams, addRoute as addCoreHTTP } from '@pikku/core/http'
-import { CoreScheduledTask, addScheduledTask as addCoreScheduledTask } from '@pikku/core/scheduler'
-import { CoreAPIChannel, PikkuChannel, addChannel as addCoreChannel } from '@pikku/core/channel'
-
-${userSessionTypeImport}
-${singletonServicesTypeImport}
-${sessionServicesTypeImport}
-
-export type APIPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
-export type APIMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = PikkuMiddleware<RequiredServices, ${userSessionTypeName}>
-
-export type APIFunctionSessionless<In = unknown, Out = never, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = CoreAPIFunctionSessionless<In, Out, RequiredServices, ${userSessionTypeName}>
-export type APIFunction<In = unknown, Out = never, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = CoreAPIFunction<In, Out, RequiredServices, ${userSessionTypeName}>
-type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>, APIMiddleware>
-
-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>
-export type ChannelMessage<In, Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<RequiredServices, 'userSession'>, channel: PikkuChannel<ChannelData, Out>, data: In) => Promise<Out | void>
-type APIChannel<ChannelData, Channel extends string> = CoreAPIChannel<ChannelData, Channel, ChannelConnection, ChannelDisconnection, ChannelMessage<any, any, ChannelData>, ChannelMessage<any, any, ChannelData>, APIPermission>
-
-type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>, ${userSessionTypeName}>
-
-export const addChannel = <ChannelData, Channel extends string>(
-  channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
-) => {
-  addCoreChannel(channel as any) // TODO
-}
-
-export const addRoute = <In, Out, Route extends string>(
-  route: APIRoute<In, Out, Route> & AssertRouteParams<In, Route>
-) => {
-  addCoreHTTP(route)
-}
-
-export const addScheduledTask = (task: ScheduledTask) => {
-  addCoreScheduledTask(task as any) // TODO
-}
-`;
-};

package/dist/src/http/serialize-route-imports.d.ts

@@ -1 +0,0 @@
-export declare const serializeRoutes: (outputPath: string, filesWithRoutes: Set<string>, packageMappings?: Record<string, string>) => string;

package/dist/src/http/serialize-route-imports.js

@@ -1,13 +0,0 @@
-import { getFileImportRelativePath } from '../utils.js';
-export const serializeRoutes = (outputPath, filesWithRoutes, packageMappings = {}) => {
-    const serializedOutput = [
-        '/* The files with an addRoute function call */',
-    ];
-    Array.from(filesWithRoutes)
-        .sort()
-        .forEach((path) => {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        serializedOutput.push(`import '${filePath}'`);
-    });
-    return serializedOutput.join('\n');
-};

package/dist/src/http/serialize-route-meta.d.ts

@@ -1,2 +0,0 @@
-import type { HTTPRoutesMeta } from '@pikku/core/http';
-export declare const serializeHTTPRoutesMeta: (routesMeta: HTTPRoutesMeta) => string;

package/dist/src/http/serialize-route-meta.js

@@ -1,6 +0,0 @@
-export const serializeHTTPRoutesMeta = (routesMeta) => {
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push(`pikkuState('http', 'meta', ${JSON.stringify(routesMeta, null, 2)})`);
-    return serializedOutput.join('\n');
-};

package/dist/src/scheduler/serialize-schedulers.js

@@ -1,22 +0,0 @@
-import { getFileImportRelativePath } from '../utils.js';
-export const serializeSchedulers = (outputPath, filesWithScheduledTasks, packageMappings = {}) => {
-    const serializedOutput = [
-        '/* The files with an addSerializedTasks function call */',
-    ];
-    Array.from(filesWithScheduledTasks)
-        .sort()
-        .forEach((path) => {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        serializedOutput.push(`import '${filePath}'`);
-    });
-    return serializedOutput.join('\n');
-};
-export const serializeSchedulerMeta = (scheduledTasksMeta) => {
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push(`pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`);
-    if (scheduledTasksMeta.length > 0) {
-        serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMeta.map((s) => s.name).join("' | '")}'`);
-    }
-    return serializedOutput.join('\n');
-};

package/src/channels/serialize-channels.ts

@@ -1,34 +0,0 @@
-import { ChannelsMeta } from '@pikku/core/channel'
-import { getFileImportRelativePath } from '../utils.js'
-
-export const serializeChannels = (
-  outputPath: string,
-  filesWithChannels: Set<string>,
-  packageMappings: Record<string, string> = {}
-) => {
-  const serializedOutput: string[] = [
-    '/* The files with an addChannel function call */',
-  ]
-
-  Array.from(filesWithChannels)
-    .sort()
-    .forEach((path) => {
-      const filePath = getFileImportRelativePath(
-        outputPath,
-        path,
-        packageMappings
-      )
-      serializedOutput.push(`import '${filePath}'`)
-    })
-
-  return serializedOutput.join('\n')
-}
-
-export const serializeChannelMeta = (channelsMeta: ChannelsMeta) => {
-  const serializedOutput: string[] = []
-  serializedOutput.push("import { pikkuState } from '@pikku/core'")
-  serializedOutput.push(
-    `pikkuState('channel', 'meta', ${JSON.stringify(channelsMeta, null, 2)})`
-  )
-  return serializedOutput.join('\n')
-}