@pikku/cli 0.6.20 → 0.7.0

package/bin/pikku-all.ts

@@ -1,180 +0,0 @@
-import { Command } from 'commander'
-import {
-  getFileImportRelativePath,
-  logInfo,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuHTTP } from './pikku-http.js'
-import { pikkuFunctionTypes } from './pikku-function-types.js'
-import { pikkuHTTPMap } from './pikku-routes-map.js'
-import { existsSync } from 'fs'
-import { pikkuFetch } from './pikku-fetch.js'
-import { pikkuChannelsMap } from './pikku-channels-map.js'
-import { pikkuChannels } from './pikku-channels.js'
-import { pikkuNext } from './pikku-nextjs.js'
-import { pikkuOpenAPI } from './pikku-openapi.js'
-import { pikkuScheduler } from './pikku-scheduler.js'
-import { pikkuSchemas } from './pikku-schemas.js'
-import { pikkuWebSocket } from './pikku-websocket.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-import chokidar from 'chokidar'
-
-const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
-  const imports: string[] = []
-  const addImport = (from: string) => {
-    imports.push(
-      `import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`
-    )
-  }
-
-  let typesDeclarationFileExists = true
-  let visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.routeDirectories,
-    cliConfig.filters
-  )
-
-  if (!existsSync(cliConfig.typesDeclarationFile)) {
-    typesDeclarationFileExists = false
-  }
-  await pikkuFunctionTypes(cliConfig, options, visitState)
-
-  // This is needed since the addRoutes function will add the routes to the visitState
-  if (!typesDeclarationFileExists) {
-    logInfo(`• Type file first created, inspecting again...\x1b[0m`)
-    visitState = await inspectorGlob(
-      cliConfig.rootDir,
-      cliConfig.routeDirectories,
-      cliConfig.filters
-    )
-  }
-
-  const routes = await pikkuHTTP(cliConfig, visitState)
-  if (routes) {
-    await pikkuHTTPMap(cliConfig, visitState)
-    await pikkuFetch(cliConfig)
-    addImport(cliConfig.routesFile)
-  }
-
-  const scheduled = await pikkuScheduler(cliConfig, visitState)
-  if (scheduled) {
-    addImport(cliConfig.schedulersFile)
-  }
-
-  const channels = await pikkuChannels(cliConfig, visitState)
-  if (channels) {
-    await pikkuChannelsMap(cliConfig, visitState)
-    await pikkuWebSocket(cliConfig)
-    addImport(cliConfig.channelsFile)
-  }
-
-  const schemas = await pikkuSchemas(cliConfig, visitState)
-  if (schemas) {
-    addImport(`${cliConfig.schemaDirectory}/register.gen.ts`)
-  }
-
-  if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
-    await pikkuNext(cliConfig, visitState, options)
-  }
-
-  if (cliConfig.openAPI) {
-    logInfo(`• OpenAPI requires a reinspection to pickup new generated types..`)
-    visitState = await inspectorGlob(
-      cliConfig.rootDir,
-      cliConfig.routeDirectories,
-      cliConfig.filters
-    )
-    await pikkuOpenAPI(cliConfig, visitState)
-  }
-
-  await writeFileInDir(cliConfig.bootstrapFile, imports.join('\n'))
-}
-
-const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
-  const configWatcher = chokidar.watch(cliConfig.routeDirectories, {
-    ignoreInitial: true,
-    ignored: /.*\.gen\.tsx?/,
-  })
-
-  let watcher = new chokidar.FSWatcher({})
-
-  const generatorWatcher = () => {
-    watcher.close()
-
-    logInfo(
-      `• Watching directories: \n  - ${cliConfig.routeDirectories.join('\n  - ')}`
-    )
-    watcher = chokidar.watch(cliConfig.routeDirectories, {
-      ignoreInitial: true,
-      ignored: /.*\.gen\.ts/,
-    })
-
-    watcher.on('ready', async () => {
-      const handle = async () => {
-        try {
-          await runAll(cliConfig, options)
-        } catch (err) {
-          console.error(err)
-          console.info()
-        }
-      }
-
-      await handle()
-
-      let timeout: ReturnType<typeof setTimeout> | undefined
-
-      const deduped = (_file: string) => {
-        if (timeout) {
-          clearTimeout(timeout)
-        }
-        timeout = setTimeout(handle, 10)
-      }
-
-      watcher.on('change', deduped)
-      watcher.on('add', deduped)
-      watcher.on('unlink', deduped)
-    })
-  }
-
-  configWatcher.on('ready', generatorWatcher)
-  configWatcher.on('change', generatorWatcher)
-}
-
-export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
-
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    [],
-    options.tags,
-    true
-  )
-
-  if (options.watch) {
-    watch(cliConfig, options)
-  } else {
-    await runAll(cliConfig, options)
-  }
-}
-
-export const all = (program: Command): void => {
-  program
-    .command('all', { isDefault: true })
-    .description('Generate all the files used by pikku')
-    .option('-ct | --pikku-config-type', 'The type of your pikku config object')
-    .option(
-      '-ss | --singleton-services-factory-type',
-      'The type of your singleton services factory'
-    )
-    .option(
-      '-se | --session-services-factory-type',
-      'The type of your session services factory'
-    )
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .option('-t | --tags <tags...>', 'Which tags to filter by')
-    .option('-w | --watch', 'Whether to watch file changes')
-    .action(action)
-}

package/bin/pikku-channels-map.ts

@@ -1,55 +0,0 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import {
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils.js'
-import { serializeTypedChannelsMap } from '../src/channels/serialize-typed-channel-map.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuChannelsMap = async (
-  { channelsMapDeclarationFile, packageMappings }: PikkuCLIConfig,
-  state: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    'Creating channels map',
-    'Created channels map',
-    [state.channels.files.size === 0],
-    async () => {
-      const content = serializeTypedChannelsMap(
-        channelsMapDeclarationFile,
-        packageMappings,
-        state.channels.typesMap,
-        state.channels.meta
-      )
-      await writeFileInDir(channelsMapDeclarationFile, content)
-    }
-  )
-}
-
-async function action(cliOptions: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-  const cliConfig = await getPikkuCLIConfig(
-    cliOptions.config,
-    ['rootDir', 'routeDirectories', 'routesFile'],
-    cliOptions.tags,
-    false
-  )
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.routeDirectories,
-    cliConfig.filters
-  )
-  await pikkuChannelsMap(cliConfig, visitState)
-}
-
-export const channelsMap = (program: Command): void => {
-  program
-    .command('channels-map')
-    .description('Generate a map of all channels to aid in type checking')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-channels.ts

@@ -1,58 +0,0 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import {
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils.js'
-import {
-  serializeChannels,
-  serializeChannelMeta,
-} from '../src/channels/serialize-channels.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuChannels = async (
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    'Finding Channels',
-    'Found channels',
-    [visitState.channels.files.size === 0],
-    async () => {
-      const { channelsFile, packageMappings } = cliConfig
-      const { channels } = visitState
-      const content = [
-        serializeChannels(channelsFile, channels.files, packageMappings),
-        serializeChannelMeta(channels.meta),
-      ]
-      await writeFileInDir(channelsFile, content.join('\n\n'))
-    }
-  )
-}
-
-async function action(cliOptions: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-
-  const cliConfig = await getPikkuCLIConfig(
-    cliOptions.config,
-    ['rootDir', 'routeDirectories', 'routesFile'],
-    cliOptions.tags
-  )
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.routeDirectories,
-    cliConfig.filters
-  )
-  await pikkuChannels(cliConfig, visitState)
-}
-
-export const channels = (program: Command): void => {
-  program
-    .command('channels')
-    .description('Find all channels to import')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-fetch.ts

@@ -1,55 +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 { serializeFetchWrapper } from '../src/http/serialize-fetch-wrapper.js'
-
-export const pikkuFetch = async ({
-  fetchFile,
-  routesMapDeclarationFile,
-  packageMappings,
-}: PikkuCLIConfig) => {
-  await logCommandInfoAndTime(
-    '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,
-        routesMapDeclarationFile,
-        packageMappings
-      )
-
-      const content = [serializeFetchWrapper(routesMapDeclarationPath)]
-      await writeFileInDir(fetchFile, 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 pikkuFetch(cliConfig)
-}
-
-export const fetch = (program: Command): void => {
-  program
-    .command('fetch')
-    .description('generate fetch wrapper')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-function-types.ts

@@ -1,84 +0,0 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import {
-  getFileImportRelativePath,
-  getPikkuFilesAndMethods,
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils.js'
-import { pikkuHTTP } from './pikku-http.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-import { serializePikkuTypes } from '../src/core/serialize-pikku-types.js'
-
-export const pikkuFunctionTypes = async (
-  { typesDeclarationFile: typesFile, packageMappings }: PikkuCLIConfig,
-  options: PikkuCLIOptions,
-  visitState: InspectorState
-) => {
-  await logCommandInfoAndTime(
-    'Creating api types',
-    'Created api types',
-    [false],
-    async () => {
-      const { userSessionType, sessionServicesType, singletonServicesType } =
-        await getPikkuFilesAndMethods(
-          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
-      )
-      await writeFileInDir(typesFile, content)
-    }
-  )
-}
-
-async function action(cliOptions: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-
-  const cliConfig = await getPikkuCLIConfig(
-    cliOptions.config,
-    ['rootDir', 'routeDirectories', 'typesDeclarationFile'],
-    cliOptions.tags
-  )
-
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.routeDirectories,
-    cliConfig.filters
-  )
-  await pikkuHTTP(cliConfig, visitState)
-}
-
-export const functionTypes = (program: Command): void => {
-  program
-    .command('types')
-    .description('Generate the core API')
-    .option('-ct | --pikku-config-type', 'The type of your pikku config object')
-    .option(
-      '-ss | --singleton-services-factory-type',
-      'The type of your singleton services factory'
-    )
-    .option(
-      '-se | --session-services-factory-type',
-      'The type of your session services factory'
-    )
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-http.ts

@@ -1,56 +0,0 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { serializeHTTPRoutesMeta } from '../src/http/serialize-route-meta.js'
-import { InspectorState } from '@pikku/inspector'
-import {
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils.js'
-import { serializeRoutes } from '../src/http/serialize-route-imports.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuHTTP = async (
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    'Finding HTTP routes',
-    'Found HTTP routes',
-    [visitState.http.files.size === 0],
-    async () => {
-      const { routesFile, packageMappings } = cliConfig
-      const { http } = visitState
-      const content = [
-        serializeRoutes(routesFile, http.files, packageMappings),
-        serializeHTTPRoutesMeta(http.meta),
-      ]
-      await writeFileInDir(routesFile, content.join('\n\n'))
-    }
-  )
-}
-
-async function action(cliOptions: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-
-  const cliConfig = await getPikkuCLIConfig(
-    cliOptions.config,
-    ['rootDir', 'routeDirectories', 'routesFile'],
-    cliOptions.tags
-  )
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.routeDirectories,
-    cliConfig.filters
-  )
-  await pikkuHTTP(cliConfig, visitState)
-}
-
-export const routes = (program: Command): void => {
-  program
-    .command('routes')
-    .description('Find all routes to import')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}