@pikku/cli 0.6.6

package/src/pikku-cli-config.ts

@@ -0,0 +1,189 @@
+import { join, dirname, resolve, isAbsolute } from 'path'
+import { readdir, readFile } from 'fs/promises'
+import { OpenAPISpecInfo } from './openapi/openapi-spec-generator.js'
+
+export interface PikkuCLICoreOutputFiles {
+  outDir?: string
+  routesFile: string
+  channelsFile: string
+  schedulersFile: string
+  schemaDirectory: string
+  typesDeclarationFile: string
+  routesMapDeclarationFile: string
+  channelsMapDeclarationFile: string
+  bootstrapFile: string
+}
+
+export type PikkuCLIConfig = {
+  $schema?: string
+
+  extends?: string
+
+  rootDir: string
+  routeDirectories: string[]
+  packageMappings: Record<string, string>
+  supportsImportAttributes: boolean
+
+  configDir: string
+  tsconfig: string
+
+  nextJSfile?: string
+  fetchFile?: string
+  websocketFile?: string
+
+  openAPI?: {
+    outputFile: string
+    additionalInfo: OpenAPISpecInfo
+  }
+} & PikkuCLICoreOutputFiles
+
+const CONFIG_DIR_FILES = ['nextJSfile', 'fetchFile', 'websocketFile']
+
+export const getPikkuCLIConfig = async (
+  configFile: string | undefined = undefined,
+  requiredFields: Array<keyof PikkuCLIConfig>,
+  exitProcess: boolean = false
+): Promise<PikkuCLIConfig> => {
+  const config = await _getPikkuCLIConfig(
+    configFile,
+    requiredFields,
+    exitProcess
+  )
+  return config
+}
+
+const _getPikkuCLIConfig = async (
+  configFile: string | undefined = undefined,
+  requiredFields: Array<keyof PikkuCLIConfig>,
+  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),
+        [],
+        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.routesFile) {
+        result.routesFile = join(result.outDir, 'pikku-routes.gen.ts')
+      }
+      if (!result.schedulersFile) {
+        result.schedulersFile = join(result.outDir, 'pikku-schedules.gen.ts')
+      }
+      if (!result.channelsFile) {
+        result.channelsFile = join(result.outDir, 'pikku-channels.gen.ts')
+      }
+      if (!result.typesDeclarationFile) {
+        result.typesDeclarationFile = join(
+          result.outDir,
+          'pikku-types.gen.d.ts'
+        )
+      }
+      if (!result.routesMapDeclarationFile) {
+        result.routesMapDeclarationFile = 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])
+          }
+        }
+      }
+    }
+
+    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/scheduler/serialize-schedulers.ts

@@ -0,0 +1,43 @@
+import { ScheduledTasksMeta } from '@pikku/core/scheduler'
+import { getFileImportRelativePath } from '../utils.js'
+
+export const serializeSchedulers = (
+  outputPath: string,
+  filesWithScheduledTasks: Set<string>,
+  packageMappings: Record<string, string> = {}
+) => {
+  const serializedOutput: string[] = [
+    '/* 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: ScheduledTasksMeta
+) => {
+  const serializedOutput: string[] = []
+  serializedOutput.push(
+    "import { setScheduledTasksMeta } from '@pikku/core/scheduler'"
+  )
+  serializedOutput.push(
+    `setScheduledTasksMeta(${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/schema/schema-generator.ts

@@ -0,0 +1,117 @@
+import { createGenerator, RootlessError } from 'ts-json-schema-generator'
+import { 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,
+  typesMap: TypesMap,
+  routesMeta: HTTPRoutesMeta
+): Promise<Record<string, JSONValue>> {
+  const schemasSet = new Set(typesMap.customTypes.keys())
+  for (const { input, output, inputTypes } of routesMeta) {
+    if (input) {
+      schemasSet.add(typesMap.getTypeMeta(input).uniqueName)
+    }
+    if (output) {
+      schemasSet.add(typesMap.getTypeMeta(output).uniqueName)
+    }
+    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.log('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) {
+    console.log(`\x1b[34m• 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})
+// addSchema('${schema}', require('./schemas/${schema}.schema.json'))
+`
+    )
+    .join('\n')
+
+  await writeFileInDir(
+    `${schemaParentDir}/register.gen.ts`,
+    `import { addSchema } from '@pikku/core/schema'
+// import { createRequire } from "module"
+// const require = createRequire(import.meta.url)
+${schemaImports}`
+  )
+}

package/src/utils.ts

@@ -0,0 +1,219 @@
+// import packageInfo from '../package.json'
+import { relative, dirname } from 'path'
+import { PathToNameAndType, InspectorState } from '@pikku/inspector'
+import { mkdir, writeFile } from 'fs/promises'
+
+export const getFileImportRelativePath = (
+  from: string,
+  to: string,
+  packageMappings: Record<string, string>
+): string => {
+  let filePath = relative(dirname(from), to)
+  if (!/^\.+\//.test(filePath)) {
+    filePath = `./${filePath}`
+  }
+  let usesPackageName = false
+  for (const [path, packageName] of Object.entries(packageMappings)) {
+    if (filePath.includes(path)) {
+      usesPackageName = true
+      filePath = filePath.replace(new RegExp(`.*${path}`), packageName)
+      break
+    }
+  }
+  if (usesPackageName) {
+    return filePath.replace('.ts', '')
+  }
+  return filePath.replace('.ts', '.js')
+}
+
+interface Meta {
+  file: string
+  variable: string
+  type: string
+  typePath: string
+}
+
+export type FilesAndMethods = {
+  userSessionType: Meta
+  sessionServicesType: Meta
+  pikkuConfigFactory: Meta
+  singletonServicesFactory: Meta
+  sessionServicesFactory: Meta
+}
+
+export interface PikkuCLIOptions {
+  config?: string
+  configFileType?: string
+  userSessionType?: string
+  singletonServicesFactoryType?: string
+  sessionServicesFactoryType?: string
+}
+
+const getMetaTypes = (
+  type: string,
+  errors: Map<string, PathToNameAndType>,
+  map: PathToNameAndType,
+  desiredType?: string
+) => {
+  if (desiredType) {
+    const entries = Object.entries(map)
+    for (const [file, meta] of entries) {
+      for (const { type, variable, typePath } of meta) {
+        if (type === desiredType) {
+          return { file, variable, type, typePath }
+        }
+      }
+    }
+    errors.set(`No ${desiredType} found that extends ${type}`, map)
+    return undefined
+  }
+
+  const totalValues = Object.values(map).flat()
+  if (totalValues.length === 0) {
+    errors.set(`No ${type} found`, map)
+  } else if (totalValues.length > 1) {
+    errors.set(`More than one ${type} found`, map)
+  } else {
+    const entry = Object.entries(map)[0]
+    if (entry) {
+      const [file, [{ type, variable, typePath }]] = entry
+      return { file, type, variable, typePath }
+    }
+  }
+
+  return undefined
+}
+
+export const getPikkuFilesAndMethods = async (
+  {
+    sessionServicesTypeImportMap: httpSessionServicesTypeImportMap,
+    userSessionTypeImportMap,
+    sessionServicesFactories,
+    singletonServicesFactories,
+    configFactories,
+  }: InspectorState,
+  packageMappings: Record<string, string>,
+  outputFile: string,
+  {
+    configFileType,
+    singletonServicesFactoryType,
+    sessionServicesFactoryType,
+  }: PikkuCLIOptions,
+  requires: Partial<{
+    config: boolean
+    sessionServiceType: boolean
+    userSessionType: boolean
+    singletonServicesFactory: boolean
+    sessionServicesFactory: boolean
+  }> = {
+    config: false,
+    sessionServiceType: false,
+    userSessionType: false,
+    singletonServicesFactory: false,
+    sessionServicesFactory: false,
+  }
+): Promise<FilesAndMethods> => {
+  let errors = new Map<string, PathToNameAndType>()
+
+  const result: Partial<FilesAndMethods> = {
+    userSessionType: getMetaTypes(
+      'CoreUserSession',
+      requires.userSessionType ? errors : new Map(),
+      userSessionTypeImportMap,
+      configFileType
+    ),
+    sessionServicesType: getMetaTypes(
+      'CoreServices',
+      requires.sessionServiceType ? errors : new Map(),
+      httpSessionServicesTypeImportMap
+    ),
+    pikkuConfigFactory: getMetaTypes(
+      'CoreConfig',
+      requires.config ? errors : new Map(),
+      configFactories,
+      configFileType
+    ),
+    singletonServicesFactory: getMetaTypes(
+      'CreateSingletonServices',
+      requires.singletonServicesFactory ? errors : new Map(),
+      singletonServicesFactories,
+      singletonServicesFactoryType
+    ),
+    sessionServicesFactory: getMetaTypes(
+      'CreateSessionServices',
+      requires.sessionServicesFactory ? errors : new Map(),
+      sessionServicesFactories,
+      sessionServicesFactoryType
+    ),
+  }
+
+  if (errors.size > 0) {
+    const result: string[] = ['Found errors:']
+    errors.forEach((filesAndMethods, message) => {
+      result.push(`- ${message}`)
+      for (const [file, methods] of Object.entries(filesAndMethods)) {
+        result.push(
+          `\t* file: ${getFileImportRelativePath(outputFile, file, packageMappings)}`
+        )
+        result.push(
+          `\t* methods: ${methods.map(({ variable, type }) => `${variable}: ${type}`).join(', ')}`
+        )
+      }
+    })
+
+    console.error(result.join('\n'))
+    process.exit(1)
+  }
+
+  return result as FilesAndMethods
+}
+
+export const writeFileInDir = async (
+  path: string,
+  content: string,
+  ignoreModifyComment: boolean = false
+) => {
+  if (content.includes('server-only')) {
+    content = content.replace(
+      "'server-only'",
+      `'server-only'\n\n${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}`
+    )
+  } else {
+    content = `${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}${content}`
+  }
+
+  await mkdir(dirname(path), { recursive: true })
+  await writeFile(path, content, 'utf-8')
+  console.log(`\x1b[32m✓ File written to ${path}\x1b[0m`)
+}
+
+export const logCommandInfoAndTime = async (
+  commandStart: string,
+  commandEnd: string,
+  [skipCondition, skipMessage = 'none found']: [boolean] | [boolean, string],
+  callback: (...args: any[]) => Promise<unknown>
+): Promise<boolean> => {
+  if (skipCondition === true) {
+    console.log(
+      `\x1b[34m• Skipping ${commandStart} since ${skipMessage}.\x1b[0m`
+    )
+    return false
+  }
+
+  const start = Date.now()
+  console.log(`\x1b[34m• ${commandStart}...\x1b[0m`)
+  await callback()
+
+  console.log(`\x1b[32m✓ ${commandEnd} in ${Date.now() - start}ms.\x1b[0m`)
+  return true
+}
+
+export const logPikkuLogo = () => {
+  console.log(`\x1b[33m⚙️ PIKKU CLI ⚙️\n-------------------\x1b[0m`)
+}
+
+// TODO: add version back in once the ESM dust settles
+export const DO_NOT_MODIFY_COMMENT = `/**
+ * This file was generated by the @pikku/cli
+ */
+`

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "module": "Node16",
+    "outDir": "dist",
+    "target": "esnext",
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["bin/**/*.ts", "src/**/*.ts"],
+  "exclude": ["**/*.test.ts", "node_modules", "bin/dist"],
+  "references": [
+    {
+      "path": "../core/tsconfig.json"
+    },
+    {
+      "path": "../inspector/tsconfig.json"
+    }
+  ]
+}