@pikku/cli 0.6.20 → 0.7.0

package/bin/pikku-nextjs.test.ts

@@ -1,279 +0,0 @@
-// import * as path from 'path'
-// import { assert } from 'chai'
-// import * as sinon from 'sinon'
-
-// import { action } from './pikku-nextjs.js'
-
-// // Mocking external dependencies
-// import * as fsPromises from 'fs/promises'
-// import * as extractPikkuInformation from '../src/extract-pikku-information.js'
-// import * as getFileImportRelativePath from '../src/utils.js'
-// import * as nextjsWrapperGenerator from '../src/nextjs-wrapper-generator.js'
-
-// import * as getPikkuConfig from '@pikku/core/pikku-config'
-
-// describe('action function - generateNextJsWrapper arguments', () => {
-//   let sandbox: sinon.SinonSandbox
-//   let getPikkuConfigStub: sinon.SinonStub
-//   let extractPikkuInformationStub: sinon.SinonStub
-//   let getFileImportRelativePathStub: sinon.SinonStub
-//   let generateNextJsWrapperStub: sinon.SinonStub
-//   let processExitStub: sinon.SinonStub
-//   let consoleErrorStub: sinon.SinonStub
-
-//   beforeEach(() => {
-//     sandbox = sinon.createSandbox()
-
-//     // Stub external dependencies
-//     getPikkuConfigStub = sandbox.stub(
-//       getPikkuConfig,
-//       'getPikkuConfig'
-//     )
-//     extractPikkuInformationStub = sandbox.stub(
-//       extractPikkuInformation,
-//       'extractPikkuInformation'
-//     )
-//     getFileImportRelativePathStub = sandbox.stub(
-//       getFileImportRelativePath,
-//       'getFileImportRelativePath'
-//     )
-//     generateNextJsWrapperStub = sandbox.stub(
-//       nextjsWrapperGenerator,
-//       'generateNextJsWrapper'
-//     )
-
-//     // Stub fs.promises methods to prevent actual file system operations
-//     sandbox.stub(fsPromises, 'mkdir').resolves()
-//     sandbox.stub(fsPromises, 'writeFile').resolves()
-
-//     // Stub process.exit and console.error to prevent test from exiting and to capture errors
-//     processExitStub = sandbox.stub(process, 'exit')
-//     sandbox.stub(console, 'log')
-//     consoleErrorStub = sandbox.stub(console, 'error')
-
-//     // Default stubs for external functions
-//     getPikkuConfigStub.resolves({
-//       pikkuNextFile: 'nextFile.ts',
-//       rootDir: 'rootDir',
-//       routesFile: 'routes.ts',
-//       configDir: 'configDir',
-//       packageMappings: {},
-//       schemaDirectory: 'schemas',
-//     })
-
-//     extractPikkuInformationStub.resolves({
-//       pikkuConfigs: { 'configFile.ts': ['pikkuConfigVariable'] },
-//       sessionServicesFactories: {
-//         'sessionFactoryFile.ts': ['sessionFactoryVariable'],
-//       },
-//       singletonServicesFactories: {
-//         'singletonFactoryFile.ts': ['singletonFactoryVariable'],
-//       },
-//     })
-
-//     // Mock getFileImportRelativePath to return predictable paths
-//     getFileImportRelativePathStub.callsFake(
-//       (from: string, to: string, packageMappings: any) => {
-//         return `./${to}`
-//       }
-//     )
-//   })
-
-//   afterEach(() => {
-//     sandbox.restore()
-//   })
-
-//   it('should pass correct imports to generateNextJsWrapper', async () => {
-//     await action({})
-
-//     // Capture the arguments passed to generateNextJsWrapper
-//     assert(
-//       generateNextJsWrapperStub.calledOnce,
-//       'generateNextJsWrapper should be called once'
-//     )
-
-//     const [
-//       ,
-//       ,
-//       pikkuConfigImport,
-//       singletonServicesImport,
-//       sessionServicesImport,
-//     ] = generateNextJsWrapperStub.firstCall.args
-
-//     const expectedPikkuConfigImport = `import { pikkuConfigVariable } from './configFile.ts'`
-//     const expectedSingletonServicesImport = `import { singletonFactoryVariable } from './singletonFactoryFile.ts'`
-//     const expectedSessionServicesImport = `import { sessionFactoryVariable } from './sessionFactoryFile.ts'`
-
-//     assert.strictEqual(
-//       pikkuConfigImport,
-//       expectedPikkuConfigImport,
-//       'pikkuConfigImport should match expected import'
-//     )
-//     assert.strictEqual(
-//       singletonServicesImport,
-//       expectedSingletonServicesImport,
-//       'singletonServicesImport should match expected import'
-//     )
-//     assert.strictEqual(
-//       sessionServicesImport,
-//       expectedSessionServicesImport,
-//       'sessionServicesImport should match expected import'
-//     )
-//   })
-
-//   it('should use provided pikkuConfigFile and pikkuConfigVariable', async () => {
-//     const options = {
-//       pikkuConfigFile: 'customConfigFile.ts',
-//       pikkuConfigVariable: 'customPikkuConfigVariable',
-//     }
-
-//     await action(options)
-
-//     assert(
-//       generateNextJsWrapperStub.calledOnce,
-//       'generateNextJsWrapper should be called once'
-//     )
-
-//     const [, , pikkuConfigImport] = generateNextJsWrapperStub.firstCall.args
-
-//     const expectedImport = `import { customPikkuConfigVariable } from './customConfigFile.ts'`
-//     assert.strictEqual(
-//       pikkuConfigImport,
-//       expectedImport,
-//       'pikkuConfigImport should use provided file and variable'
-//     )
-//   })
-
-//   it('should handle missing pikkuConfigs and exit', async () => {
-//     // Modify the stub to simulate missing pikkuConfigs
-//     extractPikkuInformationStub.resolves({
-//       pikkuConfigs: {},
-//       sessionServicesFactories: {
-//         'sessionFactoryFile.ts': ['sessionFactoryVariable'],
-//       },
-//       singletonServicesFactories: {
-//         'singletonFactoryFile.ts': ['singletonFactoryVariable'],
-//       },
-//     })
-
-//     await action({})
-
-//     assert(consoleErrorStub.calledWithMatch('Found errors:'))
-//     assert(consoleErrorStub.calledWithMatch('No PikkuConfig object found'))
-//     assert(
-//       processExitStub.calledWith(1),
-//       'process.exit should be called with 1'
-//     )
-//     assert.isFalse(
-//       generateNextJsWrapperStub.called,
-//       'generateNextJsWrapper should not be called when there is an error'
-//     )
-//   })
-
-//   it('should generate correct import paths with packageMappings', async () => {
-//     // Provide packageMappings in the pikkuConfig
-//     getPikkuConfigStub.resolves({
-//       pikkuNextFile: 'nextFile.ts',
-//       rootDir: 'rootDir',
-//       routesFile: 'routes.ts',
-//       configDir: 'configDir',
-//       packageMappings: {
-//         'configFile.ts': '@configs/configFile',
-//         'singletonFactoryFile.ts': '@factories/singletonFactory',
-//         'sessionFactoryFile.ts': '@factories/sessionFactory',
-//       },
-//       schemaDirectory: 'schemas',
-//     })
-
-//     // Modify getFileImportRelativePath to consider packageMappings
-//     getFileImportRelativePathStub.callsFake(
-//       (from: string, to: string, packageMappings: any) => {
-//         const mappedPackage = packageMappings[to]
-//         return mappedPackage || `./${path.relative(path.dirname(from), to)}`
-//       }
-//     )
-
-//     await action({})
-
-//     assert(
-//       generateNextJsWrapperStub.calledOnce,
-//       'generateNextJsWrapper should be called once'
-//     )
-
-//     const [
-//       ,
-//       ,
-//       pikkuConfigImport,
-//       singletonServicesImport,
-//       sessionServicesImport,
-//     ] = generateNextJsWrapperStub.firstCall.args
-
-//     const expectedPikkuConfigImport = `import { pikkuConfigVariable } from '@configs/configFile'`
-//     const expectedSingletonServicesImport = `import { singletonFactoryVariable } from '@factories/singletonFactory'`
-//     const expectedSessionServicesImport = `import { sessionFactoryVariable } from '@factories/sessionFactory'`
-
-//     assert.strictEqual(
-//       pikkuConfigImport,
-//       expectedPikkuConfigImport,
-//       'pikkuConfigImport should use package mapping'
-//     )
-//     assert.strictEqual(
-//       singletonServicesImport,
-//       expectedSingletonServicesImport,
-//       'singletonServicesImport should use package mapping'
-//     )
-//     assert.strictEqual(
-//       sessionServicesImport,
-//       expectedSessionServicesImport,
-//       'sessionServicesImport should use package mapping'
-//     )
-//   })
-
-//   it('should use provided singletonServicesFactoryFile and singletonServicesFactoryVariable', async () => {
-//     const options = {
-//       singletonServicesFactoryFile: 'customSingletonFactoryFile.ts',
-//       singletonServicesFactoryVariable: 'customSingletonFactoryVariable',
-//     }
-
-//     await action(options)
-
-//     assert(
-//       generateNextJsWrapperStub.calledOnce,
-//       'generateNextJsWrapper should be called once'
-//     )
-
-//     const [, , , singletonServicesImport] =
-//       generateNextJsWrapperStub.firstCall.args
-
-//     const expectedImport = `import { customSingletonFactoryVariable } from './customSingletonFactoryFile.ts'`
-//     assert.strictEqual(
-//       singletonServicesImport,
-//       expectedImport,
-//       'singletonServicesImport should use provided file and variable'
-//     )
-//   })
-
-//   it('should use provided sessionServicesFactoryFile and sessionServicesFactoryVariable', async () => {
-//     const options = {
-//       sessionServicesFactoryFile: 'customSessionFactoryFile.ts',
-//       sessionServicesFactoryVariable: 'customSessionFactoryVariable',
-//     }
-
-//     await action(options)
-
-//     assert(
-//       generateNextJsWrapperStub.calledOnce,
-//       'generateNextJsWrapper should be called once'
-//     )
-
-//     const [, , , , sessionServicesImport] =
-//       generateNextJsWrapperStub.firstCall.args
-
-//     const expectedImport = `import { customSessionFactoryVariable } from './customSessionFactoryFile.ts'`
-//     assert.strictEqual(
-//       sessionServicesImport,
-//       expectedImport,
-//       'sessionServicesImport should use provided file and variable'
-//     )
-//   })
-// })

package/bin/pikku-nextjs.ts

@@ -1,152 +0,0 @@
-import { Command } from 'commander'
-import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../src/nextjs/serialize-nextjs-backend-wrapper.js'
-import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/nextjs/serialize-nextjs-http-wrapper.js'
-import {
-  getFileImportRelativePath,
-  getPikkuFilesAndMethods,
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuNext = async (
-  {
-    nextBackendFile,
-    nextHTTPFile,
-    routesFile,
-    routesMapDeclarationFile,
-    schemaDirectory,
-    packageMappings,
-    fetchFile,
-  }: PikkuCLIConfig,
-  visitState: InspectorState,
-  options: PikkuCLIOptions
-) => {
-  return await logCommandInfoAndTime(
-    'Generating nextjs wrapper',
-    'Generated nextjs wrapper',
-    [
-      nextBackendFile === undefined && nextHTTPFile === undefined,
-      'nextjs outfile is not defined',
-    ],
-    async () => {
-      if (!nextBackendFile && !nextHTTPFile) {
-        throw new Error(
-          'nextBackendFile or nextHTTPFile is required in pikku config for nextJS'
-        )
-      }
-
-      if (nextHTTPFile && !fetchFile) {
-        throw new Error(
-          'fetchFile is required in pikku config in order for nextJS http wrapper to work'
-        )
-      }
-
-      if (nextBackendFile) {
-        const {
-          pikkuConfigFactory,
-          singletonServicesFactory,
-          sessionServicesFactory,
-        } = await getPikkuFilesAndMethods(
-          visitState,
-          packageMappings,
-          nextBackendFile,
-          options,
-          {
-            config: true,
-            singletonServicesFactory: true,
-            sessionServicesFactory: true,
-          }
-        )
-
-        const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`
-        const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`
-        const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`
-
-        const routesPath = getFileImportRelativePath(
-          nextBackendFile,
-          routesFile,
-          packageMappings
-        )
-
-        const routesMapDeclarationPath = getFileImportRelativePath(
-          nextBackendFile,
-          routesMapDeclarationFile,
-          packageMappings
-        )
-        const schemasPath = getFileImportRelativePath(
-          nextBackendFile,
-          `${schemaDirectory}/register.gen.ts`,
-          packageMappings
-        )
-
-        const content = serializeNextBackendWrapper(
-          routesPath,
-          routesMapDeclarationPath,
-          schemasPath,
-          pikkuConfigImport,
-          singletonServicesImport,
-          sessionServicesImport
-        )
-        await writeFileInDir(nextBackendFile, content)
-      }
-
-      if (nextHTTPFile) {
-        const routesPath = getFileImportRelativePath(
-          nextHTTPFile,
-          routesFile,
-          packageMappings
-        )
-
-        const routesMapDeclarationPath = getFileImportRelativePath(
-          nextHTTPFile,
-          routesMapDeclarationFile,
-          packageMappings
-        )
-
-        const content = serializeNextHTTPWrapper(
-          routesPath,
-          routesMapDeclarationPath
-        )
-        await writeFileInDir(nextHTTPFile, content)
-      }
-    }
-  )
-}
-
-export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    ['rootDir', 'schemaDirectory', 'configDir'],
-    options.tags,
-    true
-  )
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.routeDirectories,
-    cliConfig.filters
-  )
-  await pikkuNext(cliConfig, visitState, options)
-}
-
-export const nextjs = (program: Command): void => {
-  program
-    .command('nextjs')
-    .description('generate nextjs wrapper')
-    .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-openapi.ts

@@ -1,70 +0,0 @@
-import { Command } from 'commander'
-import {
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils.js'
-import { generateSchemas } from '../src/schema/schema-generator.js'
-import { generateOpenAPISpec } from '../src/openapi/openapi-spec-generator.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import { stringify } from 'yaml'
-import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuOpenAPI = async (
-  { tsconfig, openAPI }: PikkuCLIConfig,
-  { http }: InspectorState
-) => {
-  await logCommandInfoAndTime(
-    'Creating OpenAPI spec',
-    'Created OpenAPI spec',
-    [openAPI?.outputFile === undefined, 'openAPI outfile is not defined'],
-    async () => {
-      if (!openAPI?.outputFile) {
-        throw new Error('openAPI is required')
-      }
-      const schemas = await generateSchemas(tsconfig, http.typesMap, http.meta)
-      const openAPISpec = await generateOpenAPISpec(
-        http.meta,
-        schemas,
-        openAPI.additionalInfo
-      )
-      if (openAPI.outputFile.endsWith('.json')) {
-        await writeFileInDir(
-          openAPI.outputFile,
-          JSON.stringify(openAPISpec, null, 2),
-          true
-        )
-      } else if (
-        openAPI.outputFile.endsWith('.yaml') ||
-        openAPI.outputFile.endsWith('.yml')
-      ) {
-        await writeFileInDir(openAPI.outputFile, stringify(openAPISpec), true)
-      }
-    }
-  )
-}
-
-async function action({ config, tags }: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-  const cliConfig = await getPikkuCLIConfig(
-    config,
-    ['rootDir', 'routesFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
-    tags
-  )
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.routeDirectories,
-    cliConfig.filters
-  )
-  await pikkuOpenAPI(cliConfig, visitState)
-}
-
-export const openapi = (program: Command): void => {
-  program
-    .command('openapi')
-    .description('Generate an openapi spec')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-routes-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 { serializeTypedRoutesMap } from '../src/http/serialize-typed-route-map.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuHTTPMap = async (
-  { routesMapDeclarationFile, packageMappings }: PikkuCLIConfig,
-  { http }: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    'Creating routes map',
-    'Created routes map',
-    [http.files.size === 0],
-    async () => {
-      const content = serializeTypedRoutesMap(
-        routesMapDeclarationFile,
-        packageMappings,
-        http.typesMap,
-        http.meta,
-        http.metaInputTypes
-      )
-      await writeFileInDir(routesMapDeclarationFile, content)
-    }
-  )
-}
-
-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 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-scheduler.ts

@@ -1,62 +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 {
-  serializeSchedulerMeta,
-  serializeSchedulers,
-} from '../src/scheduler/serialize-schedulers.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuScheduler = async (
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    'Finding scheduled tasks',
-    'Found scheduled tasks',
-    [visitState.scheduledTasks.files.size === 0],
-    async () => {
-      const { schedulersFile, packageMappings } = cliConfig
-      const { scheduledTasks } = visitState
-      const content = [
-        serializeSchedulers(
-          schedulersFile,
-          scheduledTasks.files,
-          packageMappings
-        ),
-        serializeSchedulerMeta(scheduledTasks.meta),
-      ]
-      await writeFileInDir(schedulersFile, content.join('\n\n'))
-    }
-  )
-}
-
-async function action(options: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    ['rootDir', 'routeDirectories', 'routesFile'],
-    options.tags
-  )
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.routeDirectories,
-    cliConfig.filters
-  )
-  await pikkuScheduler(cliConfig, visitState)
-}
-
-export const schedules = (program: Command): void => {
-  program
-    .command('scheduler')
-    .description('Find all scheduled tasks to import')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-schemas.ts

@@ -1,52 +0,0 @@
-import { Command } from 'commander'
-import { saveSchemas, generateSchemas } from '../src/schema/schema-generator.js'
-
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import { logCommandInfoAndTime, logPikkuLogo } from '../src/utils.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-
-export const pikkuSchemas = async (
-  { tsconfig, schemaDirectory, supportsImportAttributes }: PikkuCLIConfig,
-  { http }: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    'Creating schemas',
-    'Created schemas',
-    [false],
-    async () => {
-      const schemas = await generateSchemas(tsconfig, http.typesMap, http.meta)
-      await saveSchemas(
-        schemaDirectory,
-        schemas,
-        http.typesMap,
-        http.meta,
-        supportsImportAttributes
-      )
-    }
-  )
-}
-
-async function action({ config }: { config?: string }): Promise<void> {
-  logPikkuLogo()
-
-  const cliConfig = await getPikkuCLIConfig(config, [
-    'routeDirectories',
-    'schemaDirectory',
-    'tsconfig',
-  ])
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.routeDirectories,
-    cliConfig.filters
-  )
-  await pikkuSchemas(cliConfig, visitState)
-}
-
-export const schemas = (program: Command): void => {
-  program
-    .command('schemas')
-    .description('Generate schemas for all the expected function input types')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}