@pikku/cli 0.6.20 → 0.7.0

package/bin/pikku-websocket.ts

@@ -1,58 +0,0 @@
-import { Command } from 'commander'
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { serializeWebsocketWrapper } from '../src/channels/serialize-websocket-wrapper.js'
-
-export const pikkuWebSocket = async ({
-  websocketFile,
-  channelsMapDeclarationFile,
-  packageMappings,
-}: PikkuCLIConfig) => {
-  await logCommandInfoAndTime(
-    'Generating websocket wrapper',
-    'Generated websocket wrapper',
-    [
-      websocketFile === undefined,
-      "websocketFile isn't set in the pikku config",
-    ],
-    async () => {
-      if (!websocketFile) {
-        throw new Error("fetchFile is isn't set in the pikku config")
-      }
-
-      const channelsMapDeclarationPath = getFileImportRelativePath(
-        websocketFile,
-        channelsMapDeclarationFile,
-        packageMappings
-      )
-
-      const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)]
-      await writeFileInDir(websocketFile, content.join('\n'))
-    }
-  )
-}
-
-export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
-    options.tags,
-    true
-  )
-  await pikkuWebSocket(cliConfig)
-}
-
-export const websocket = (program: Command): void => {
-  program
-    .command('websocket')
-    .description('generate websocket wrapper')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku.ts

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander'
-import { schemas } from './pikku-schemas.js'
-import { routes } from './pikku-http.js'
-import { nextjs } from './pikku-nextjs.js'
-import { all } from './pikku-all.js'
-import { functionTypes } from './pikku-function-types.js'
-import { routesMap } from './pikku-routes-map.js'
-import { fetch } from './pikku-fetch.js'
-import { channels } from './pikku-channels.js'
-import { schedules } from './pikku-scheduler.js'
-
-const program = new Command('pikku')
-program.usage('[command]')
-
-all(program)
-routes(program)
-routesMap(program)
-functionTypes(program)
-schemas(program)
-nextjs(program)
-fetch(program)
-channels(program)
-schedules(program)
-
-program.parse(process.argv)

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../bin/pikku-all.ts","../bin/pikku-channels-map.ts","../bin/pikku-channels.ts","../bin/pikku-fetch.ts","../bin/pikku-function-types.ts","../bin/pikku-http.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-routes-map.ts","../bin/pikku-scheduler.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/utils.ts","../src/channels/serialize-channels.ts","../src/channels/serialize-typed-channel-map.ts","../src/channels/serialize-websocket-wrapper.ts","../src/core/serialize-import-map.ts","../src/core/serialize-pikku-types.ts","../src/http/serialize-fetch-wrapper.ts","../src/http/serialize-route-imports.ts","../src/http/serialize-route-meta.ts","../src/http/serialize-typed-route-map.ts","../src/nextjs/serialize-nextjs-backend-wrapper.ts","../src/nextjs/serialize-nextjs-http-wrapper.ts","../src/openapi/openapi-spec-generator.ts","../src/scheduler/serialize-schedulers.ts","../src/schema/schema-generator.ts"],"version":"5.7.3"}

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')
-}

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

@@ -1,136 +0,0 @@
-import { ChannelsMeta } from '@pikku/core/channel'
-import { serializeImportMap } from '../core/serialize-import-map.js'
-import { TypesMap } from '@pikku/inspector'
-import { generateCustomTypes } from '../http/serialize-typed-route-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 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
-        )}, ${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`
-    }
-
-    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/core/serialize-import-map.ts

@@ -1,33 +0,0 @@
-import { TypesMap } from '@pikku/inspector'
-import { getFileImportRelativePath } from '../utils.js'
-
-export const serializeImportMap = (
-  relativeToPath: string,
-  packageMappings: Record<string, string>,
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) => {
-  const paths = new Map<string, string[]>()
-  Array.from(requiredTypes).forEach((requiredType) => {
-    const { originalName, uniqueName, path } =
-      typesMap.getTypeMeta(requiredType)
-    if (!path) {
-      return
-    }
-    const variables = paths.get(path) || []
-    if (originalName === uniqueName) {
-      variables.push(originalName)
-    } else {
-      variables.push(`${originalName} as ${uniqueName}`)
-    }
-    paths.set(path, variables)
-  })
-
-  const imports: string[] = []
-  for (const [path, variables] of paths.entries()) {
-    imports.push(
-      `import type { ${variables.join(', ')} } from '${getFileImportRelativePath(relativeToPath, path, packageMappings)}'`
-    )
-  }
-  return imports.join('\n')
-}

package/src/core/serialize-pikku-types.ts

@@ -1,55 +0,0 @@
-/**
- *
- */
-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 { 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/src/http/serialize-route-imports.ts

@@ -1,24 +0,0 @@
-import { getFileImportRelativePath } from '../utils.js'
-
-export const serializeRoutes = (
-  outputPath: string,
-  filesWithRoutes: Set<string>,
-  packageMappings: Record<string, string> = {}
-) => {
-  const serializedOutput: string[] = [
-    '/* 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/src/http/serialize-route-meta.ts

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

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

@@ -1,150 +0,0 @@
-import { HTTPRoutesMeta } from '@pikku/core/http'
-import { serializeImportMap } from '../core/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 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
- */
-    
-${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/inspector-glob.ts

@@ -1,28 +0,0 @@
-import * as path from 'path'
-import { glob } from 'tinyglobby'
-import { InspectorFilters, InspectorState, inspect } from '@pikku/inspector'
-import { logCommandInfoAndTime } from './utils.js'
-
-export const inspectorGlob = async (
-  rootDir: string,
-  routeDirectories: string[],
-  filters: InspectorFilters
-) => {
-  let result: InspectorState
-  await logCommandInfoAndTime(
-    'Inspecting codebase',
-    'Inspected codebase',
-    [false],
-    async () => {
-      const routeFiles = (
-        await Promise.all(
-          routeDirectories.map((dir) =>
-            glob(`${path.join(rootDir, dir)}/**/*.ts`)
-          )
-        )
-      ).flat()
-      result = await inspect(routeFiles, filters)
-    }
-  )
-  return result!
-}