@pikku/cli 0.7.0 → 0.7.1

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,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/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/{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)
     }
 }
-  `;
-};
+  `
+}