@pikku/cli 0.7.0 → 0.7.1

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,152 @@
+import { Command } from 'commander'
+import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../src/serialize-nextjs-backend-wrapper.js'
+import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/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,
+    httpRoutesFile,
+    httpRoutesMapDeclarationFile,
+    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,
+          httpRoutesFile,
+          packageMappings
+        )
+
+        const routesMapDeclarationPath = getFileImportRelativePath(
+          nextBackendFile,
+          httpRoutesMapDeclarationFile,
+          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,
+          httpRoutesFile,
+          packageMappings
+        )
+
+        const routesMapDeclarationPath = getFileImportRelativePath(
+          nextHTTPFile,
+          httpRoutesMapDeclarationFile,
+          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.srcDirectories,
+    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

@@ -0,0 +1,74 @@
+import { Command } from 'commander'
+import {
+  logCommandInfoAndTime,
+  logPikkuLogo,
+  PikkuCLIOptions,
+  writeFileInDir,
+} from '../src/utils.js'
+import { generateSchemas } from '../src/schema-generator.js'
+import { generateOpenAPISpec } from '../src/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, functions }: 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, functions.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', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
+    tags
+  )
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.srcDirectories,
+    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-rpc.ts

@@ -0,0 +1,22 @@
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils.js'
+
+export const pikkuRPC = async (
+  cliConfig: PikkuCLIConfig,
+  visitState: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    'Finding RPCs tasks',
+    'Found rpcs',
+    [visitState.functions.files.size === 0],
+    async () => {
+      const { rpcFile } = cliConfig
+      const { rpc } = visitState
+      await writeFileInDir(
+        rpcFile,
+        `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`
+      )
+    }
+  )
+}

package/bin/pikku-scheduler.ts

@@ -0,0 +1,64 @@
+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 { serializeSchedulerMeta } from '../src/serialize-scheduler-meta.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, schedulersMetaFile, packageMappings } = cliConfig
+      const { scheduledTasks } = visitState
+      await writeFileInDir(
+        schedulersMetaFile,
+        serializeSchedulerMeta(scheduledTasks.meta)
+      )
+      await writeFileInDir(
+        schedulersFile,
+        serializeFileImports(
+          'addSerializedTasks',
+          schedulersFile,
+          scheduledTasks.files,
+          packageMappings
+        )
+      )
+    }
+  )
+}
+
+async function action(options: PikkuCLIOptions): Promise<void> {
+  logPikkuLogo()
+
+  const cliConfig = await getPikkuCLIConfig(
+    options.config,
+    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
+    options.tags
+  )
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.srcDirectories,
+    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

@@ -0,0 +1,56 @@
+import { Command } from 'commander'
+import { saveSchemas, generateSchemas } from '../src/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,
+  { functions, http, channels }: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    'Creating schemas',
+    'Created schemas',
+    [false],
+    async () => {
+      const schemas = await generateSchemas(
+        tsconfig,
+        [functions.typesMap, http.typesMap, channels.typesMap],
+        http.meta
+      )
+      await saveSchemas(
+        schemaDirectory,
+        schemas,
+        functions.typesMap,
+        http.meta,
+        supportsImportAttributes
+      )
+    }
+  )
+}
+
+async function action({ config }: { config?: string }): Promise<void> {
+  logPikkuLogo()
+
+  const cliConfig = await getPikkuCLIConfig(config, [
+    'srcDirectories',
+    'schemaDirectory',
+    'tsconfig',
+  ])
+  const visitState = await inspectorGlob(
+    cliConfig.rootDir,
+    cliConfig.srcDirectories,
+    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)
+}