@pikku/cli 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @pikku/cli
 
+## 0.7.1
+
+### Patch Changes
+
+- 534fdef: feat: adding rpc (locally for now)
+- Updated dependencies [534fdef]
+  - @pikku/inspector@0.7.3
+  - @pikku/core@0.7.3
+
 ## 0.7.0
 
 - Now function first. No breaking changes for end user here, just internals

package/bin/pikku-all.ts

@@ -0,0 +1,203 @@
+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-routes.js'
+import { pikkuFunctionTypes } from './pikku-function-types.js'
+import { pikkuHTTPMap } from './pikku-http-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'
+import { pikkuFunctions } from './pikku-functions.js'
+import { pikkuRPC } from './pikku-rpc.js'
+
+const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
+  const metaImports: string[] = []
+  const imports: string[] = []
+  const addImport = (from: string, type: 'meta' | 'events' | 'other') => {
+    const statement = `import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`
+    if (type === 'meta') {
+      metaImports.push(statement)
+    } else {
+      imports.push(statement)
+    }
+  }
+
+  let typesDeclarationFileExists = true
+  let visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.srcDirectories,
+    cliConfig.filters
+  )
+
+  if (!existsSync(cliConfig.typesDeclarationFile)) {
+    typesDeclarationFileExists = false
+  }
+  await pikkuFunctionTypes(cliConfig, options, visitState)
+
+  // This is needed since the addHTTPRoute 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.srcDirectories,
+      cliConfig.filters
+    )
+  }
+
+  const functions = pikkuFunctions(cliConfig, visitState)
+  if (!functions) {
+    logInfo(`• No functions found, skipping remaining steps...\x1b[0m`)
+    process.exit(1)
+  }
+  addImport(cliConfig.functionsMetaFile, 'meta')
+  addImport(cliConfig.functionsFile, 'events')
+
+  await pikkuRPC(cliConfig, visitState)
+  addImport(cliConfig.rpcFile, 'meta')
+
+  const routes = await pikkuHTTP(cliConfig, visitState)
+  if (routes) {
+    await pikkuHTTPMap(cliConfig, visitState)
+    await pikkuFetch(cliConfig)
+    addImport(cliConfig.httpRoutesMetaFile, 'meta')
+    addImport(cliConfig.httpRoutesFile, 'events')
+  }
+
+  const scheduled = await pikkuScheduler(cliConfig, visitState)
+  if (scheduled) {
+    addImport(cliConfig.schedulersMetaFile, 'meta')
+    addImport(cliConfig.schedulersFile, 'events')
+  }
+
+  const channels = await pikkuChannels(cliConfig, visitState)
+  if (channels) {
+    await pikkuChannelsMap(cliConfig, visitState)
+    await pikkuWebSocket(cliConfig)
+    addImport(cliConfig.channelsMetaFile, 'meta')
+    addImport(cliConfig.channelsFile, 'events')
+  }
+
+  const schemas = await pikkuSchemas(cliConfig, visitState)
+  if (schemas) {
+    addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other')
+  }
+
+  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.srcDirectories,
+      cliConfig.filters
+    )
+    await pikkuOpenAPI(cliConfig, visitState)
+  }
+
+  await writeFileInDir(
+    cliConfig.bootstrapFile,
+    [...metaImports, ...imports].join('\n')
+  )
+}
+
+const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
+  const configWatcher = chokidar.watch(cliConfig.srcDirectories, {
+    ignoreInitial: true,
+    ignored: /.*\.gen\.tsx?/,
+  })
+
+  let watcher = new chokidar.FSWatcher({})
+
+  const generatorWatcher = () => {
+    watcher.close()
+
+    logInfo(
+      `• Watching directories: \n  - ${cliConfig.srcDirectories.join('\n  - ')}`
+    )
+    watcher = chokidar.watch(cliConfig.srcDirectories, {
+      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

@@ -0,0 +1,55 @@
+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/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.functions.typesMap,
+        state.channels.meta
+      )
+      await writeFileInDir(channelsMapDeclarationFile, content)
+    }
+  )
+}
+
+async function action(cliOptions: PikkuCLIOptions): Promise<void> {
+  logPikkuLogo()
+  const cliConfig = await getPikkuCLIConfig(
+    cliOptions.config,
+    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
+    cliOptions.tags,
+    false
+  )
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.srcDirectories,
+    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

@@ -0,0 +1,63 @@
+import { Command } from 'commander'
+import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import {
+  logCommandInfoAndTime,
+  logPikkuLogo,
+  PikkuCLIOptions,
+  serializeFileImports,
+  writeFileInDir,
+} from '../src/utils.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, channelsMetaFile, packageMappings } = cliConfig
+      const { channels } = visitState
+      await writeFileInDir(
+        channelsFile,
+        serializeFileImports(
+          'addChannel',
+          channelsFile,
+          channels.files,
+          packageMappings
+        )
+      )
+      await writeFileInDir(
+        channelsMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
+      )
+    }
+  )
+}
+
+async function action(cliOptions: PikkuCLIOptions): Promise<void> {
+  logPikkuLogo()
+
+  const cliConfig = await getPikkuCLIConfig(
+    cliOptions.config,
+    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
+    cliOptions.tags
+  )
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.srcDirectories,
+    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

@@ -0,0 +1,55 @@
+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/serialize-fetch-wrapper.js'
+
+export const pikkuFetch = async ({
+  fetchFile,
+  httpRoutesMapDeclarationFile,
+  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,
+        httpRoutesMapDeclarationFile,
+        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

@@ -0,0 +1,84 @@
+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-routes.js'
+import { inspectorGlob } from '../src/inspector-glob.js'
+import { serializePikkuTypes } from '../src/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', 'srcDirectories', 'typesDeclarationFile'],
+    cliOptions.tags
+  )
+
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.srcDirectories,
+    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-functions.ts

@@ -0,0 +1,35 @@
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import {
+  logCommandInfoAndTime,
+  serializeFileImports,
+  writeFileInDir,
+} from '../src/utils.js'
+
+export const pikkuFunctions = async (
+  cliConfig: PikkuCLIConfig,
+  visitState: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    'Finding Pikku functions',
+    'Found Pikku functions',
+    [visitState.functions.files.size === 0],
+    async () => {
+      const { functionsFile, functionsMetaFile, packageMappings } = cliConfig
+      const { functions } = visitState
+      await writeFileInDir(
+        functionsFile,
+        serializeFileImports(
+          'addFunction',
+          functionsFile,
+          functions.files,
+          packageMappings
+        )
+      )
+      await writeFileInDir(
+        functionsMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`
+      )
+    }
+  )
+}

package/bin/pikku-http-map.ts

@@ -0,0 +1,55 @@
+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 { serializeTypedRoutesMap } from '../src/serialize-typed-http-map.js'
+import { inspectorGlob } from '../src/inspector-glob.js'
+
+export const pikkuHTTPMap = async (
+  { httpRoutesMapDeclarationFile, packageMappings }: PikkuCLIConfig,
+  { http, functions }: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    'Creating HTTP map',
+    'Created HTTP map',
+    [http.files.size === 0],
+    async () => {
+      const content = serializeTypedRoutesMap(
+        httpRoutesMapDeclarationFile,
+        packageMappings,
+        functions.typesMap,
+        http.meta,
+        http.metaInputTypes
+      )
+      await writeFileInDir(httpRoutesMapDeclarationFile, content)
+    }
+  )
+}
+
+async function action(cliOptions: PikkuCLIOptions): Promise<void> {
+  logPikkuLogo()
+  const cliConfig = await getPikkuCLIConfig(
+    cliOptions.config,
+    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
+    cliOptions.tags
+  )
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.srcDirectories,
+    cliConfig.filters
+  )
+  await pikkuHTTPMap(cliConfig, visitState)
+}
+
+export const routesMap = (program: Command): void => {
+  program
+    .command('map')
+    .description('Generate a map of all routes to aid in type checking')
+    .option('-c | --config <string>', 'The path to pikku cli config file')
+    .action(action)
+}

package/bin/pikku-http-routes.ts

@@ -0,0 +1,63 @@
+import { Command } from 'commander'
+import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import {
+  logCommandInfoAndTime,
+  logPikkuLogo,
+  PikkuCLIOptions,
+  serializeFileImports,
+  writeFileInDir,
+} from '../src/utils.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 { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig
+      const { http } = visitState
+      await writeFileInDir(
+        httpRoutesFile,
+        serializeFileImports(
+          'addHTTPRoute',
+          httpRoutesFile,
+          http.files,
+          packageMappings
+        )
+      )
+      await writeFileInDir(
+        httpRoutesMetaFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
+      )
+    }
+  )
+}
+
+async function action(cliOptions: PikkuCLIOptions): Promise<void> {
+  logPikkuLogo()
+
+  const cliConfig = await getPikkuCLIConfig(
+    cliOptions.config,
+    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
+    cliOptions.tags
+  )
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.srcDirectories,
+    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)
+}