@pikku/cli 0.6.6

package/bin/pikku-function-types.ts

@@ -0,0 +1,76 @@
+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 { pikkuRoutes } from './pikku-routes.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 } =
+        await getPikkuFilesAndMethods(
+          visitState,
+          packageMappings,
+          typesFile,
+          options,
+          { userSessionType: true, sessionServiceType: true }
+        )
+      const content = serializePikkuTypes(
+        `import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`,
+        userSessionType.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',
+  ])
+
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.routeDirectories
+  )
+  await pikkuRoutes(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-nextjs.test.ts

@@ -0,0 +1,279 @@
+// 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

@@ -0,0 +1,113 @@
+import { Command } from 'commander'
+import { serializeNextJsWrapper } from '../src/nextjs/serialize-nextjs-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 (
+  {
+    nextJSfile,
+    routesFile,
+    routesMapDeclarationFile,
+    schemaDirectory,
+    packageMappings,
+  }: PikkuCLIConfig,
+  visitState: InspectorState,
+  options: PikkuCLIOptions
+) => {
+  return await logCommandInfoAndTime(
+    'Generating nextjs wrapper',
+    'Generated nextjs wrapper',
+    [nextJSfile === undefined, 'nextjs outfile is not defined'],
+    async () => {
+      if (!nextJSfile) {
+        throw new Error('nextJSfile is required in pikku config')
+      }
+
+      const {
+        pikkuConfigFactory,
+        singletonServicesFactory,
+        sessionServicesFactory,
+      } = await getPikkuFilesAndMethods(
+        visitState,
+        packageMappings,
+        nextJSfile,
+        options,
+        {
+          config: true,
+          singletonServicesFactory: true,
+          sessionServicesFactory: true,
+        }
+      )
+
+      const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextJSfile, pikkuConfigFactory.file, packageMappings)}'`
+      const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextJSfile, singletonServicesFactory.file, packageMappings)}'`
+      const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextJSfile, sessionServicesFactory.file, packageMappings)}'`
+
+      const routesPath = getFileImportRelativePath(
+        nextJSfile,
+        routesFile,
+        packageMappings
+      )
+      const routesMapDeclarationPath = getFileImportRelativePath(
+        nextJSfile,
+        routesMapDeclarationFile,
+        packageMappings
+      )
+      const schemasPath = getFileImportRelativePath(
+        nextJSfile,
+        `${schemaDirectory}/register.gen.ts`,
+        packageMappings
+      )
+
+      const content = serializeNextJsWrapper(
+        routesPath,
+        routesMapDeclarationPath,
+        schemasPath,
+        pikkuConfigImport,
+        singletonServicesImport,
+        sessionServicesImport
+      )
+      await writeFileInDir(nextJSfile, content)
+    }
+  )
+}
+
+export const action = async (options: PikkuCLIOptions): Promise<void> => {
+  logPikkuLogo()
+  const cliConfig = await getPikkuCLIConfig(
+    options.config,
+    ['rootDir', 'schemaDirectory', 'configDir', 'nextJSfile'],
+    true
+  )
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.routeDirectories
+  )
+  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

@@ -0,0 +1,71 @@
+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 }: PikkuCLIOptions): Promise<void> {
+  logPikkuLogo()
+  const cliConfig = await getPikkuCLIConfig(config, [
+    'rootDir',
+    'routesFile',
+    'openAPI',
+    'schemaDirectory',
+    'tsconfig',
+  ])
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.routeDirectories
+  )
+  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

@@ -0,0 +1,54 @@
+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',
+  ])
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.routeDirectories
+  )
+  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-routes.ts

@@ -0,0 +1,55 @@
+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 pikkuRoutes = async (
+  cliConfig: PikkuCLIConfig,
+  visitState: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    'Finding routes',
+    'Found 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',
+  ])
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.routeDirectories
+  )
+  await pikkuRoutes(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)
+}