@pikku/cli 0.7.0 → 0.7.1

package/src/pikku-cli-config.ts

@@ -0,0 +1,240 @@
+import { join, dirname, resolve, isAbsolute } from 'path'
+import { readdir, readFile } from 'fs/promises'
+import { OpenAPISpecInfo } from './openapi-spec-generator.js'
+import { InspectorFilters } from '@pikku/inspector'
+
+export interface PikkuCLICoreOutputFiles {
+  outDir?: string
+  functionsFile: string
+  functionsMetaFile: string
+  httpRoutesFile: string
+  httpRoutesMetaFile: string
+  channelsFile: string
+  channelsMetaFile: string
+  schedulersFile: string
+  schedulersMetaFile: string
+  rpcFile: string
+  schemaDirectory: string
+  typesDeclarationFile: string
+  httpRoutesMapDeclarationFile: string
+  channelsMapDeclarationFile: string
+  bootstrapFile: string
+}
+
+export type PikkuCLIConfig = {
+  $schema?: string
+
+  extends?: string
+
+  rootDir: string
+  srcDirectories: string[]
+  packageMappings: Record<string, string>
+  supportsImportAttributes: boolean
+
+  configDir: string
+  tsconfig: string
+
+  nextBackendFile?: string
+  nextHTTPFile?: string
+  fetchFile?: string
+  websocketFile?: string
+
+  openAPI?: {
+    outputFile: string
+    additionalInfo: OpenAPISpecInfo
+  }
+
+  filters: InspectorFilters
+} & PikkuCLICoreOutputFiles
+
+const CONFIG_DIR_FILES = [
+  'nextBackendFile',
+  'nextHTTPFile',
+  'fetchFile',
+  'websocketFile',
+]
+
+export const getPikkuCLIConfig = async (
+  configFile: string | undefined = undefined,
+  requiredFields: Array<keyof PikkuCLIConfig>,
+  tags: string[] = [],
+  exitProcess: boolean = false
+): Promise<PikkuCLIConfig> => {
+  const config = await _getPikkuCLIConfig(
+    configFile,
+    requiredFields,
+    tags,
+    exitProcess
+  )
+  return config
+}
+
+const _getPikkuCLIConfig = async (
+  configFile: string | undefined = undefined,
+  requiredFields: Array<keyof PikkuCLIConfig>,
+  tags: string[] = [],
+  exitProcess: boolean = false
+): Promise<PikkuCLIConfig> => {
+  if (!configFile) {
+    let execDirectory = process.cwd()
+    const files = await readdir(execDirectory)
+    const file = files.find((file) => /pikku\.config\.(ts|js|json)$/.test(file))
+    if (!file) {
+      const errorMessage =
+        '\nConfig file pikku.config.json not found\nExiting...'
+      if (exitProcess) {
+        console.error(errorMessage)
+        process.exit(1)
+      }
+      throw new Error(errorMessage)
+    }
+    configFile = join(execDirectory, file)
+  }
+
+  try {
+    let result: PikkuCLIConfig
+    const file = await readFile(configFile, 'utf-8')
+    const configDir = dirname(configFile)
+    const config: PikkuCLIConfig = JSON.parse(file)
+    if (config.extends) {
+      const extendedConfig = await getPikkuCLIConfig(
+        resolve(configDir, config.extends),
+        [],
+        tags,
+        exitProcess
+      )
+      result = {
+        ...extendedConfig,
+        ...config,
+        configDir,
+        packageMappings: {
+          ...extendedConfig.packageMappings,
+          ...config.packageMappings,
+        },
+      }
+    } else {
+      result = {
+        ...config,
+        configDir,
+        packageMappings: config.packageMappings || {},
+        rootDir: config.rootDir
+          ? resolve(configDir, config.rootDir)
+          : configDir,
+      }
+    }
+
+    if (result.outDir) {
+      if (!result.schemaDirectory) {
+        result.schemaDirectory = join(result.outDir, 'pikku-schemas')
+      }
+      if (!result.functionsFile) {
+        result.functionsFile = join(result.outDir, 'pikku-functions.gen.ts')
+      }
+      if (!result.functionsMetaFile) {
+        result.functionsMetaFile = join(
+          result.outDir,
+          'pikku-functions-meta.gen.ts'
+        )
+      }
+      if (!result.rpcFile) {
+        result.rpcFile = join(result.outDir, 'pikku-rpc.gen.ts')
+      }
+      if (!result.httpRoutesFile) {
+        result.httpRoutesFile = join(result.outDir, 'pikku-http-routes.gen.ts')
+      }
+      if (!result.httpRoutesMetaFile) {
+        result.httpRoutesMetaFile = join(
+          result.outDir,
+          'pikku-http-routes-meta.gen.ts'
+        )
+      }
+      if (!result.schedulersFile) {
+        result.schedulersFile = join(result.outDir, 'pikku-schedules.gen.ts')
+      }
+      if (!result.schedulersMetaFile) {
+        result.schedulersMetaFile = join(
+          result.outDir,
+          'pikku-schedules-meta.gen.ts'
+        )
+      }
+      if (!result.channelsFile) {
+        result.channelsFile = join(result.outDir, 'pikku-channels.gen.ts')
+      }
+      if (!result.channelsMetaFile) {
+        result.channelsMetaFile = join(
+          result.outDir,
+          'pikku-channels-meta.gen.ts'
+        )
+      }
+      if (!result.typesDeclarationFile) {
+        result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts')
+      }
+      if (!result.httpRoutesMapDeclarationFile) {
+        result.httpRoutesMapDeclarationFile = join(
+          result.outDir,
+          'pikku-routes-map.gen.d.ts'
+        )
+      }
+      if (!result.channelsMapDeclarationFile) {
+        result.channelsMapDeclarationFile = join(
+          result.outDir,
+          'pikku-channels-map.gen.d.ts'
+        )
+      }
+      if (!result.bootstrapFile) {
+        result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts')
+      }
+    }
+
+    if (requiredFields.length > 0) {
+      validateCLIConfig(result, requiredFields)
+    }
+
+    for (const objectKey of Object.keys(result)) {
+      if (objectKey.endsWith('File') || objectKey.endsWith('Directory')) {
+        const relativeTo = CONFIG_DIR_FILES.includes(objectKey)
+          ? result.configDir
+          : result.rootDir
+        if (result[objectKey]) {
+          if (!isAbsolute(result[objectKey])) {
+            result[objectKey] = join(relativeTo, result[objectKey])
+          }
+        }
+      }
+    }
+
+    result.filters = result.filters || {}
+    if (tags.length > 0) {
+      result.filters.tags = tags
+    }
+
+    if (!isAbsolute(result.tsconfig)) {
+      result.tsconfig = join(result.rootDir, result.tsconfig)
+    }
+
+    return result
+  } catch (e: any) {
+    console.error(e)
+    console.error(`Config file not found: ${configFile}`)
+    process.exit(1)
+  }
+}
+
+export const validateCLIConfig = (
+  cliConfig: PikkuCLIConfig,
+  required: Array<keyof PikkuCLIConfig>
+) => {
+  let errors: string[] = []
+  for (const key of required) {
+    if (!cliConfig[key]) {
+      errors.push(key)
+    }
+  }
+
+  if (errors.length > 0) {
+    console.error(
+      `${errors.join(', ')} ${errors.length === 1 ? 'is' : 'are'} required in pikku.config.json`
+    )
+    process.exit(1)
+  }
+}

package/src/schema-generator.ts

@@ -0,0 +1,136 @@
+import { createGenerator, RootlessError } from 'ts-json-schema-generator'
+import { logInfo, writeFileInDir } from './utils.js'
+import { mkdir, writeFile } from 'fs/promises'
+import { JSONValue } from '@pikku/core'
+import { HTTPRoutesMeta } from '@pikku/core/http'
+import { TypesMap } from '@pikku/inspector'
+
+export async function generateSchemas(
+  tsconfig: string,
+  typesMaps: TypesMap[],
+  httpRoutesMeta: HTTPRoutesMeta
+): Promise<Record<string, JSONValue>> {
+  const schemasSet = new Set(
+    typesMaps.flatMap((tm) => [...tm.customTypes.keys()])
+  )
+  for (const { input, inputTypes } of httpRoutesMeta) {
+    if (input) {
+      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)
+    }
+    if (inputTypes?.query) {
+      schemasSet.add(inputTypes.query)
+    }
+    if (inputTypes?.params) {
+      schemasSet.add(inputTypes.params)
+    }
+  }
+
+  const generator = createGenerator({
+    tsconfig,
+    skipTypeCheck: true,
+    topRef: false,
+    discriminatorType: 'open-api',
+  })
+  const schemas: Record<string, JSONValue> = {}
+  schemasSet.forEach((schema) => {
+    try {
+      schemas[schema] = generator.createSchema(schema) as JSONValue
+    } catch (e) {
+      // Ignore rootless errors
+      if (e instanceof RootlessError) {
+        console.error('Error generating schema since it has no root:', schema)
+        return
+      }
+      throw e
+    }
+  })
+
+  return schemas
+}
+
+export async function saveSchemas(
+  schemaParentDir: string,
+  schemas: Record<string, JSONValue>,
+  typesMap: TypesMap,
+  routesMeta: HTTPRoutesMeta,
+  supportsImportAttributes: boolean
+) {
+  await writeFileInDir(
+    `${schemaParentDir}/register.gen.ts`,
+    'export const empty = null;'
+  )
+
+  const desiredSchemas = new Set([
+    ...routesMeta
+      .map(({ input, output }) => [
+        input ? typesMap.getUniqueName(input) : undefined,
+        output ? typesMap.getUniqueName(output) : undefined,
+      ])
+      .flat()
+      .filter(
+        (s) =>
+          !!s &&
+          !['boolean', 'string', 'number', 'null', 'undefined'].includes(s)
+      ),
+    ...typesMap.customTypes.keys(),
+  ])
+
+  if (desiredSchemas.size === 0) {
+    logInfo(`• Skipping schemas since none found.\x1b[0m`)
+    return
+  }
+
+  await mkdir(`${schemaParentDir}/schemas`, { recursive: true })
+  await Promise.all(
+    Object.entries(schemas).map(async ([schemaName, schema]) => {
+      if (desiredSchemas.has(schemaName)) {
+        await writeFile(
+          `${schemaParentDir}/schemas/${schemaName}.schema.json`,
+          JSON.stringify(schema),
+          'utf-8'
+        )
+      }
+    })
+  )
+
+  const schemaImports = Array.from(desiredSchemas)
+    .map(
+      (schema) => `
+import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
+addSchema('${schema}', ${schema})
+`
+    )
+    .join('\n')
+
+  await writeFileInDir(
+    `${schemaParentDir}/register.gen.ts`,
+    `import { addSchema } from '@pikku/core/schema'
+${schemaImports}`
+  )
+}

package/{dist/src/events/http/serialize-fetch-wrapper.js → src/serialize-fetch-wrapper.ts}

@@ -1,5 +1,5 @@
-export const serializeFetchWrapper = (routesMapPath) => {
-    return `
+export const serializeFetchWrapper = (routesMapPath: string) => {
+  return `
 import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
 import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
 
@@ -63,5 +63,5 @@ export class PikkuFetch extends CorePikkuFetch {
 }
 
 export const pikkuFetch = new PikkuFetch();
-`;
-};
+`
+}

package/src/serialize-import-map.ts

@@ -0,0 +1,34 @@
+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) {
+      // This is a custom type that exists in file, so we don't need to import it
+      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/{dist/src/nextjs/serialize-nextjs-backend-wrapper.js → src/serialize-nextjs-backend-wrapper.ts}

@@ -1,5 +1,12 @@
-export const serializeNextJsBackendWrapper = (routesPath, routesMapPath, schemasPath, configImport, singleServicesFactoryImport, sessionServicesImport) => {
-    return `'server-only'
+export const serializeNextJsBackendWrapper = (
+  routesPath: string,
+  routesMapPath: string,
+  schemasPath: string,
+  configImport: string,
+  singleServicesFactoryImport: string,
+  sessionServicesImport: string
+) => {
+  return `'server-only'
   
 /**
  * This file provides a wrapper around the PikkuNextJS class to allow for methods to be type checked against your routes.
@@ -176,5 +183,5 @@ export const pikku = (_options?: any) => {
     staticPost
   }
 }
-`;
-};
+`
+}

package/{dist/src/nextjs/serialize-nextjs-http-wrapper.js → src/serialize-nextjs-http-wrapper.ts}

@@ -1,5 +1,8 @@
-export const serializeNextJsHTTPWrapper = (routesMapPath, pikkuFetchImport) => {
-    return `'server-only'
+export const serializeNextJsHTTPWrapper = (
+  routesMapPath: string,
+  pikkuFetchImport: string
+) => {
+  return `'server-only'
   
 /**
  * This file provides a wrapper around the PikkuNextJS class to allow for methods to be type checked against your routes.
@@ -156,5 +159,5 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
     staticPost
   }
 }
-`;
-};
+`
+}

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