@pikku/cli 0.9.14 → 0.9.16-next.0

package/src/schemas.ts

@@ -1,35 +0,0 @@
-import { saveSchemas, generateSchemas } from './schema-generator.js'
-import { logCommandInfoAndTime } from './utils.js'
-import { PikkuCommand } from './types.js'
-
-export const pikkuSchemas: PikkuCommand = async (
-  logger,
-  { tsconfig, schemaDirectory, supportsImportAttributes, schemasFromTypes },
-  { functions, http }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating schemas',
-    'Created schemas',
-    [false],
-    async () => {
-      const schemas = await generateSchemas(
-        logger,
-        tsconfig,
-        functions.typesMap,
-        functions.meta,
-        http.meta,
-        schemasFromTypes
-      )
-      await saveSchemas(
-        logger,
-        schemaDirectory,
-        schemas,
-        functions.typesMap,
-        functions.meta,
-        supportsImportAttributes,
-        schemasFromTypes
-      )
-    }
-  )
-}

package/src/types.ts

@@ -1,16 +0,0 @@
-import { InspectorState } from '@pikku/inspector'
-import { PikkuCLIConfig } from './pikku-cli-config.js'
-import { CLILogger, PikkuCLIOptions } from './utils.js'
-
-export type PikkuCommand = (
-  logger: CLILogger,
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState,
-  options?: PikkuCLIOptions
-) => Promise<boolean>
-
-export type PikkuCommandWithoutState = (
-  logger: CLILogger,
-  cliConfig: PikkuCLIConfig,
-  options?: PikkuCLIOptions
-) => Promise<boolean>

package/src/utils.ts

@@ -1,420 +0,0 @@
-import { relative, dirname, resolve } from 'path'
-import { PathToNameAndType, InspectorState, TypesMap } from '@pikku/inspector'
-import { mkdir, readFile, writeFile } from 'fs/promises'
-import chalk from 'chalk'
-import { fileURLToPath } from 'url'
-import { readFileSync } from 'fs'
-
-const __filename = fileURLToPath(import.meta.url)
-
-const logo = `
- ______ _ _     _           
-(_____ (_) |   | |          
- _____) )| |  _| |  _ _   _ 
-|  ____/ | |_/ ) |_/ ) | | |
-| |    | |  _ (|  _ (| |_| |
-|_|    |_|_| _)_| _)____/ 
-`
-
-export class CLILogger {
-  private silent: boolean
-
-  constructor({
-    logLogo,
-    silent = false,
-  }: {
-    logLogo: boolean
-    silent?: boolean
-  }) {
-    this.silent = silent
-    if (logLogo && !silent) {
-      this.logPikkuLogo()
-    }
-  }
-
-  primary(message: string) {
-    if (!this.silent) {
-      console.log(chalk.green(message))
-    }
-  }
-  success(message: string) {
-    if (!this.silent) {
-      console.log(chalk.green(message))
-    }
-  }
-  info(message: string) {
-    if (!this.silent) {
-      console.log(chalk.blue(message))
-    }
-  }
-  error(message: string) {
-    console.error(chalk.red(message))
-  }
-  warn(message: string) {
-    console.error(chalk.yellow(message))
-  }
-  debug(message: string) {
-    if (process.env.DEBUG && !this.silent) {
-      console.log(chalk.gray(message))
-    }
-  }
-
-  timing(message: string) {
-    console.log(chalk.gray(message))
-  }
-
-  private logPikkuLogo() {
-    this.primary(logo)
-    const packageJson = JSON.parse(
-      readFileSync(`${dirname(__filename)}/../../package.json`, 'utf-8')
-    )
-    this.primary(`⚙️ Welcome to the Pikku CLI (v${packageJson.version})\n`)
-  }
-}
-
-export const getFileImportRelativePath = (
-  from: string,
-  to: string,
-  packageMappings: Record<string, string>
-): string => {
-  let filePath = relative(dirname(from), to)
-  if (!/^\.+\//.test(filePath)) {
-    filePath = `./${filePath}`
-  }
-
-  // If the path includes node_modules, strip everything before and including node_modules/
-  if (filePath.includes('node_modules')) {
-    const nodeModulesIndex = filePath.indexOf('node_modules/')
-    if (nodeModulesIndex !== -1) {
-      filePath = filePath.substring(nodeModulesIndex + 'node_modules/'.length)
-    }
-    return filePath.replace('.ts', '.js')
-  }
-
-  const absolutePath = resolve(dirname(from), to)
-  const fromAbsolutePath = resolve(dirname(from))
-
-  // Check if both files are in the same package directory
-  // If so, skip packageMappings to use relative paths
-  let inSamePackage = false
-  for (const [path] of Object.entries(packageMappings)) {
-    if (absolutePath.includes(path) && fromAbsolutePath.includes(path)) {
-      inSamePackage = true
-      break
-    }
-  }
-
-  // Only apply packageMappings if files are not in the same package
-  if (!inSamePackage) {
-    // let usesPackageName = false
-    for (const [path, packageName] of Object.entries(packageMappings)) {
-      if (absolutePath.includes(path)) {
-        // usesPackageName = true
-        filePath = absolutePath.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
-  singletonServicesType: Meta
-  pikkuConfigFactory: Meta
-  singletonServicesFactory: Meta
-  sessionServicesFactory: Meta
-}
-
-export interface PikkuCLIOptions {
-  watch?: boolean
-  config?: string
-  configFileType?: string
-  userSessionType?: string
-  singletonServicesFactoryType?: string
-  sessionServicesFactoryType?: string
-  tags?: string[]
-  types?: string[]
-  directories?: string[]
-  silent?: boolean
-}
-
-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 (
-  logger: CLILogger,
-  {
-    singletonServicesTypeImportMap,
-    sessionServicesTypeImportMap,
-    userSessionTypeImportMap,
-    sessionServicesFactories,
-    singletonServicesFactories,
-    configFactories,
-  }: InspectorState,
-  packageMappings: Record<string, string>,
-  outputFile: string,
-  {
-    configFileType,
-    singletonServicesFactoryType,
-    sessionServicesFactoryType,
-  }: PikkuCLIOptions,
-  requires: Partial<{
-    config: boolean
-    sessionServiceType: boolean
-    singletonServicesType: boolean
-    userSessionType: boolean
-    singletonServicesFactory: boolean
-    sessionServicesFactory: boolean
-  }> = {
-    config: false,
-    singletonServicesType: 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
-    ),
-    singletonServicesType: getMetaTypes(
-      'CoreSingletonServices',
-      requires.singletonServicesType ? errors : new Map(),
-      singletonServicesTypeImportMap
-    ),
-    sessionServicesType: getMetaTypes(
-      'CoreServices',
-      requires.sessionServiceType ? errors : new Map(),
-      sessionServicesTypeImportMap
-    ),
-    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(', ')}`
-        )
-      }
-    })
-
-    logger.error(result.join('\n'))
-    process.exit(1)
-  }
-
-  return result as FilesAndMethods
-}
-
-export const writeFileInDir = async (
-  logger: CLILogger,
-  path: string,
-  content: string,
-  {
-    ignoreModifyComment = false,
-    logWrite = true,
-  }: { ignoreModifyComment?: boolean; logWrite?: boolean } = {}
-) => {
-  if (path.includes('.json')) {
-    ignoreModifyComment = true
-  }
-
-  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}`
-  }
-
-  // Try to read existing file content
-  let existingContent: string | undefined
-  try {
-    existingContent = await readFile(path, 'utf-8')
-  } catch (error) {
-    // File doesn't exist, so we need to write it
-  }
-
-  // Only write if content has changed or file doesn't exist
-  if (existingContent !== content) {
-    await mkdir(dirname(path), { recursive: true })
-    await writeFile(path, content, 'utf-8')
-
-    if (logWrite) {
-      logger.success(`✓ File written to ${path}`)
-    }
-  }
-}
-
-export const logCommandInfoAndTime = async (
-  logger: CLILogger,
-  commandStart: string,
-  commandEnd: string,
-  [skipCondition, skipMessage = 'none found']: [boolean] | [boolean, string],
-  callback: (...args: any[]) => Promise<unknown>
-): Promise<boolean> => {
-  if (skipCondition === true) {
-    logger.info(
-      `• Skipping ${commandStart.charAt(0).toLocaleLowerCase()}${commandStart.slice(1)} since ${skipMessage}.`
-    )
-    return false
-  }
-
-  const start = Date.now()
-  chalk.blue(`• ${commandStart}...`)
-  await callback()
-
-  logger.success(`✓ ${commandEnd} in ${Date.now() - start}ms.`)
-  return true
-}
-
-// TODO: add version back in once the ESM dust settles
-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')
-}
-
-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) => {
-      requiredTypes.add(name)
-    })
-
-    // Extract type names from the type string that might not be in references
-    const typeString = type
-    // Use regex to extract potential type names (PascalCase identifiers)
-    const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g
-    const potentialTypes = typeString.match(typeNameRegex) || []
-
-    potentialTypes.forEach((typeName) => {
-      // Skip string literals and common keywords
-      if (
-        typeString.includes(`"${typeName}"`) ||
-        ['Pick', 'Omit', 'Partial', 'Required', 'Record', 'Readonly'].includes(
-          typeName
-        )
-      ) {
-        return
-      }
-
-      // Try to find this type in the typesMap and add it if found
-      try {
-        const typeMeta = typesMap.getTypeMeta(typeName)
-        if (typeMeta.path) {
-          requiredTypes.add(typeName)
-        }
-      } catch (e) {
-        // Type not found in map, but add it anyway for fallback resolution
-        requiredTypes.add(typeName)
-      }
-    })
-
-    return `export type ${name} = ${type}`
-  })
-  .join('\n')}`
-}

package/src/wirings/channels/pikku-channels.ts

@@ -1,41 +0,0 @@
-import { PikkuCLIConfig } from '../../pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import {
-  logCommandInfoAndTime,
-  serializeFileImports,
-  writeFileInDir,
-} from '../../utils.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuChannels: PikkuCommand = async (
-  logger,
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Finding Channels',
-    'Found channels',
-    [visitState.channels.files.size === 0],
-    async () => {
-      const { channelsWiringFile, channelsWiringMetaFile, packageMappings } =
-        cliConfig
-      const { channels } = visitState
-      await writeFileInDir(
-        logger,
-        channelsWiringFile,
-        serializeFileImports(
-          'addChannel',
-          channelsWiringFile,
-          channels.files,
-          packageMappings
-        )
-      )
-      await writeFileInDir(
-        logger,
-        channelsWiringMetaFile,
-        `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
-      )
-    }
-  )
-}

package/src/wirings/channels/pikku-command-channels-map.ts

@@ -1,26 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
-import { serializeTypedChannelsMap } from './serialize-typed-channel-map.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuChannelsMap: PikkuCommand = async (
-  logger,
-  { channelsMapDeclarationFile, packageMappings },
-  state
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating channels map',
-    'Created channels map',
-    [state.channels.files.size === 0],
-    async () => {
-      const content = serializeTypedChannelsMap(
-        channelsMapDeclarationFile,
-        packageMappings,
-        state.functions.typesMap,
-        state.functions.meta,
-        state.channels.meta
-      )
-      await writeFileInDir(logger, channelsMapDeclarationFile, content)
-    }
-  )
-}

package/src/wirings/channels/pikku-command-channels.ts

@@ -1,39 +0,0 @@
-import {
-  logCommandInfoAndTime,
-  serializeFileImports,
-  writeFileInDir,
-} from '../../utils.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuChannels: PikkuCommand = async (
-  logger,
-  cliConfig,
-  visitState
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Finding Channels',
-    'Found channels',
-    [visitState.channels.files.size === 0],
-    async () => {
-      const { channelsWiringFile, channelsWiringMetaFile, packageMappings } =
-        cliConfig
-      const { channels } = visitState
-      await writeFileInDir(
-        logger,
-        channelsWiringFile,
-        serializeFileImports(
-          'addChannel',
-          channelsWiringFile,
-          channels.files,
-          packageMappings
-        )
-      )
-      await writeFileInDir(
-        logger,
-        channelsWiringMetaFile,
-        `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
-      )
-    }
-  )
-}

package/src/wirings/channels/pikku-command-websocket-typed.ts

@@ -1,36 +0,0 @@
-import { PikkuCommandWithoutState } from '../../types.js'
-import {
-  logCommandInfoAndTime,
-  getFileImportRelativePath,
-  writeFileInDir,
-} from '../../utils.js'
-import { serializeWebsocketWrapper } from './serialize-websocket-wrapper.js'
-
-export const pikkuWebSocketTyped: PikkuCommandWithoutState = async (
-  logger,
-  { websocketFile, channelsMapDeclarationFile, packageMappings }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    '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(logger, websocketFile, content.join('\n'))
-    }
-  )
-}

package/src/wirings/fetch/index.ts

@@ -1,33 +0,0 @@
-import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js'
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  writeFileInDir,
-} from '../../utils.js'
-import { PikkuCommandWithoutState } from '../../types.js'
-
-export const pikkuFetch: PikkuCommandWithoutState = async (
-  logger,
-  { fetchFile, httpMapDeclarationFile, packageMappings }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Generating fetch wrapper',
-    'Generated fetch wrapper',
-    [fetchFile === undefined, "fetchFile isn't set in the pikku config"],
-    async () => {
-      if (!fetchFile) {
-        throw new Error("fetchFile is isn't set in the pikku config")
-      }
-
-      const routesMapDeclarationPath = getFileImportRelativePath(
-        fetchFile,
-        httpMapDeclarationFile,
-        packageMappings
-      )
-
-      const content = [serializeFetchWrapper(routesMapDeclarationPath)]
-      await writeFileInDir(logger, fetchFile, content.join('\n'))
-    }
-  )
-}

package/src/wirings/functions/pikku-command-function-types.ts

@@ -1,53 +0,0 @@
-import {
-  getFileImportRelativePath,
-  getPikkuFilesAndMethods,
-  logCommandInfoAndTime,
-  writeFileInDir,
-} from '../../utils.js'
-import { serializePikkuTypes } from '../../serialize-pikku-types.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuFunctionTypes: PikkuCommand = async (
-  logger,
-  {
-    typesDeclarationFile: typesFile,
-    packageMappings,
-    rpcInternalMapDeclarationFile,
-  },
-  visitState,
-  options = {}
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating api types',
-    'Created api types',
-    [false],
-    async () => {
-      const { userSessionType, sessionServicesType, singletonServicesType } =
-        await getPikkuFilesAndMethods(
-          logger,
-          visitState,
-          packageMappings,
-          typesFile,
-          options,
-          {
-            userSessionType: true,
-            sessionServiceType: true,
-            singletonServicesType: true,
-          }
-        )
-
-      const content = serializePikkuTypes(
-        `import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`,
-        userSessionType.type,
-        `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`,
-        singletonServicesType.type,
-        `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`,
-        sessionServicesType.type,
-        `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcInternalMapDeclarationFile, packageMappings)}'`
-      )
-
-      await writeFileInDir(logger, typesFile, content)
-    }
-  )
-}