@pikku/cli 0.9.15 → 0.10.0

package/dist/src/wirings/rpc/pikku-command-rpc-client.d.ts

@@ -1,2 +0,0 @@
-import { PikkuCommandWithoutState } from '../../types.js';
-export declare const pikkuRPCClient: PikkuCommandWithoutState;

package/dist/src/wirings/rpc/pikku-command-rpc-client.js

@@ -1,15 +0,0 @@
-import { serializeRPCWrapper } from './serialize-rpc-wrapper.js';
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const pikkuRPCClient = async (logger, { rpcWiringsFile, rpcMapDeclarationFile, packageMappings }) => {
-    return await logCommandInfoAndTime(logger, 'Generating RPC wrappers', 'Generated RPC wrappers', [
-        rpcWiringsFile === undefined || rpcWiringsFile === null,
-        "rpcWiringsFile isn't set in the pikku config",
-    ], async () => {
-        if (!rpcWiringsFile) {
-            throw new Error("rpcWiringsFile isn't set in the pikku config");
-        }
-        const rpcMapDeclarationPath = getFileImportRelativePath(rpcWiringsFile, rpcMapDeclarationFile, packageMappings);
-        const content = [serializeRPCWrapper(rpcMapDeclarationPath)];
-        await writeFileInDir(logger, rpcWiringsFile, content.join('\n'));
-    });
-};

package/dist/src/wirings/rpc/pikku-command-rpc-map.d.ts

@@ -1,3 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const pikkuRPCInternalMap: PikkuCommand;
-export declare const pikkuRPCExposedMap: PikkuCommand;

package/dist/src/wirings/rpc/pikku-command-rpc-map.js

@@ -1,14 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js';
-export const pikkuRPCInternalMap = async (logger, { rpcInternalMapDeclarationFile, packageMappings }, { functions, rpc }) => {
-    return await logCommandInfoAndTime(logger, 'Creating RPC internal map', 'Created RPC internal map', [false], async () => {
-        const content = serializeTypedRPCMap(rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.internalMeta);
-        await writeFileInDir(logger, rpcInternalMapDeclarationFile, content);
-    });
-};
-export const pikkuRPCExposedMap = async (logger, { rpcMapDeclarationFile, packageMappings }, { functions, rpc }) => {
-    return await logCommandInfoAndTime(logger, 'Creating RPC external map', 'Created RPC external map', [false], async () => {
-        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.exposedMeta);
-        await writeFileInDir(logger, rpcMapDeclarationFile, content);
-    });
-};

package/dist/src/wirings/rpc/pikku-command-rpc.d.ts

@@ -1,2 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const pikkuRPC: PikkuCommand;

package/dist/src/wirings/rpc/pikku-command-rpc.js

@@ -1,8 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-export const pikkuRPC = async (logger, { rpcInternalWiringMetaFile }, { rpc }) => {
-    return await logCommandInfoAndTime(logger, 'Finding RPCs tasks', 'Found RPCs', [false], async () => {
-        if (rpc.internalFiles.size > 0) {
-            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`);
-        }
-    });
-};

package/dist/src/wirings/scheduler/pikku-command-scheduler.d.ts

@@ -1,2 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const pikkuScheduler: PikkuCommand;

package/dist/src/wirings/scheduler/pikku-command-scheduler.js

@@ -1,10 +0,0 @@
-import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
-import { serializeSchedulerMeta } from './serialize-scheduler-meta.js';
-export const pikkuScheduler = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Finding scheduled tasks', 'Found scheduled tasks', [visitState.scheduledTasks.files.size === 0], async () => {
-        const { schedulersWiringFile, schedulersWiringMetaFile, packageMappings, } = cliConfig;
-        const { scheduledTasks } = visitState;
-        await writeFileInDir(logger, schedulersWiringMetaFile, serializeSchedulerMeta(scheduledTasks.meta));
-        await writeFileInDir(logger, schedulersWiringFile, serializeFileImports('addScheduledTasks', schedulersWiringFile, scheduledTasks.files, packageMappings));
-    });
-};

package/src/inspector-glob.ts

@@ -1,30 +0,0 @@
-import * as path from 'path'
-import { glob } from 'tinyglobby'
-import { InspectorFilters, InspectorState, inspect } from '@pikku/inspector'
-import { logCommandInfoAndTime } from './utils.js'
-
-export const inspectorGlob = async (
-  logger,
-  rootDir: string,
-  srcDirectories: string[],
-  filters: InspectorFilters
-) => {
-  let result: InspectorState
-  await logCommandInfoAndTime(
-    logger,
-    'Inspecting codebase',
-    'Inspected codebase',
-    [false],
-    async () => {
-      const wiringFiles = (
-        await Promise.all(
-          srcDirectories.map((dir) =>
-            glob(`${path.join(rootDir, dir)}/**/*.ts`)
-          )
-        )
-      ).flat()
-      result = await inspect(logger, wiringFiles, filters)
-    }
-  )
-  return result!
-}

package/src/pikku-cli-config.ts

@@ -1,387 +0,0 @@
-import { join, dirname, resolve, isAbsolute } from 'path'
-import { readdir, readFile } from 'fs/promises'
-import { OpenAPISpecInfo } from './wirings/http/openapi-spec-generator.js'
-import { InspectorFilters } from '@pikku/inspector'
-import { PikkuWiringTypes } from '@pikku/core'
-
-export interface PikkuCLICoreOutputFiles {
-  // Base directory
-  outDir?: string
-
-  // Schema and types
-  schemaDirectory: string
-  typesDeclarationFile: string
-
-  // Function definitions
-  functionsFile: string
-  functionsMetaFile: string
-  functionsMetaMinFile: string
-
-  // HTTP
-  httpWiringsFile: string
-  httpWiringMetaFile: string
-  httpMapDeclarationFile: string
-
-  // Channels
-  channelsWiringFile: string
-  channelsWiringMetaFile: string
-  channelsMapDeclarationFile: string
-
-  // RPC Internal
-  rpcInternalWiringMetaFile: string
-  rpcInternalMapDeclarationFile: string
-
-  // RPC Exposed
-  rpcMapDeclarationFile: string
-
-  // Schedulers
-  schedulersWiringFile: string
-  schedulersWiringMetaFile: string
-
-  // Queue processors
-  queueWorkersWiringFile: string
-  queueWorkersWiringMetaFile: string
-  queueMapDeclarationFile: string
-
-  // MCP
-  mcpWiringsFile: string
-  mcpWiringsMetaFile: string
-
-  // Services
-  servicesFile: string
-
-  // Application bootstrap
-  bootstrapFile: string
-  bootstrapFiles: Record<PikkuWiringTypes, string>
-}
-
-export type PikkuCLIConfig = {
-  $schema?: string
-
-  extends?: string
-
-  rootDir: string
-  srcDirectories: string[]
-  packageMappings: Record<string, string>
-  supportsImportAttributes: boolean
-
-  configDir: string
-  tsconfig: string
-
-  nextBackendFile?: string
-  nextHTTPFile?: string
-  fetchFile?: string
-  websocketFile?: string
-  rpcWiringsFile?: string
-  queueWiringsFile?: string
-  mcpJsonFile?: string
-
-  openAPI?: {
-    outputFile: string
-    additionalInfo: OpenAPISpecInfo
-  }
-
-  middlewareServices?: string[]
-
-  schemasFromTypes?: string[]
-
-  filters: InspectorFilters
-} & PikkuCLICoreOutputFiles
-
-const CONFIG_DIR_FILES = [
-  'nextBackendFile',
-  'nextHTTPFile',
-  'fetchFile',
-  'websocketFile',
-  'rpcWiringsFile',
-  'queueWiringsFile',
-  'mcpJsonFile',
-]
-
-export const getPikkuCLIConfig = async (
-  configFile: string | undefined = undefined,
-  requiredFields: Array<keyof PikkuCLIConfig>,
-  filters: InspectorFilters = {},
-  exitProcess: boolean = false
-): Promise<PikkuCLIConfig> => {
-  const config = await _getPikkuCLIConfig(
-    configFile,
-    requiredFields,
-    filters,
-    exitProcess
-  )
-  return config
-}
-
-const _getPikkuCLIConfig = async (
-  configFile: string | undefined = undefined,
-  requiredFields: Array<keyof PikkuCLIConfig>,
-  filters: InspectorFilters = {},
-  exitProcess: boolean = false
-): Promise<PikkuCLIConfig> => {
-  if (!configFile) {
-    let execDirectory = process.cwd()
-    const files = await readdir(execDirectory)
-    const file = files.find((file) => /pikku\.config\.(ts|js|json)$/.test(file))
-    if (!file) {
-      const errorMessage =
-        '\nConfig file pikku.config.json not found\nExiting...'
-      if (exitProcess) {
-        console.error(errorMessage)
-        process.exit(1)
-      }
-      throw new Error(errorMessage)
-    }
-    configFile = join(execDirectory, file)
-  }
-
-  try {
-    let result: PikkuCLIConfig
-    const file = await readFile(configFile, 'utf-8')
-    const configDir = dirname(configFile)
-    const config: PikkuCLIConfig = JSON.parse(file)
-    if (config.extends) {
-      const extendedConfig = await getPikkuCLIConfig(
-        resolve(configDir, config.extends),
-        [],
-        filters,
-        exitProcess
-      )
-      result = {
-        ...extendedConfig,
-        ...config,
-        configDir,
-        packageMappings: {
-          ...extendedConfig.packageMappings,
-          ...config.packageMappings,
-        },
-      }
-    } else {
-      result = {
-        ...config,
-        configDir,
-        packageMappings: config.packageMappings || {},
-        rootDir: config.rootDir
-          ? resolve(configDir, config.rootDir)
-          : configDir,
-      }
-    }
-
-    if (result.outDir) {
-      // Create transport/event directories
-      const functionDir = join(result.outDir, 'function')
-      const httpDir = join(result.outDir, 'http')
-      const channelDir = join(result.outDir, 'channel')
-      const rpcDir = join(result.outDir, 'rpc')
-      const schedulerDir = join(result.outDir, 'scheduler')
-      const queueDir = join(result.outDir, 'queue')
-      const mcpDir = join(result.outDir, 'mcp')
-
-      // Create directories if they don't exist (will be done lazily when files are written)
-
-      if (!result.schemaDirectory) {
-        result.schemaDirectory = join(result.outDir, 'schemas')
-      }
-
-      // Functions
-      if (!result.functionsFile) {
-        result.functionsFile = join(functionDir, 'pikku-functions.gen.ts')
-      }
-      if (!result.functionsMetaFile) {
-        result.functionsMetaFile = join(
-          functionDir,
-          'pikku-functions-meta.gen.ts'
-        )
-      }
-      if (!result.functionsMetaMinFile) {
-        result.functionsMetaMinFile = join(
-          functionDir,
-          'pikku-functions-meta.min.gen.ts'
-        )
-      }
-      if (!result.typesDeclarationFile) {
-        result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts')
-      }
-
-      // HTTP
-      if (!result.httpWiringsFile) {
-        result.httpWiringsFile = join(httpDir, 'pikku-http-wirings.gen.ts')
-      }
-      if (!result.httpWiringMetaFile) {
-        result.httpWiringMetaFile = join(
-          httpDir,
-          'pikku-http-wirings-meta.gen.ts'
-        )
-      }
-      if (!result.httpMapDeclarationFile) {
-        result.httpMapDeclarationFile = join(
-          httpDir,
-          'pikku-http-wirings-map.gen.d.ts'
-        )
-      }
-
-      // Channels/WebSocket
-      if (!result.channelsWiringFile) {
-        result.channelsWiringFile = join(channelDir, 'pikku-channels.gen.ts')
-      }
-      if (!result.channelsWiringMetaFile) {
-        result.channelsWiringMetaFile = join(
-          channelDir,
-          'pikku-channels-meta.gen.ts'
-        )
-      }
-      if (!result.channelsMapDeclarationFile) {
-        result.channelsMapDeclarationFile = join(
-          channelDir,
-          'pikku-channels-map.gen.d.ts'
-        )
-      }
-
-      // RPC (internal and exposed)
-      if (!result.rpcInternalWiringMetaFile) {
-        result.rpcInternalWiringMetaFile = join(
-          rpcDir,
-          'pikku-rpc-wirings-meta.internal.gen.ts'
-        )
-      }
-
-      if (!result.rpcInternalMapDeclarationFile) {
-        result.rpcInternalMapDeclarationFile = join(
-          rpcDir,
-          'pikku-rpc-wirings-map.internal.gen.d.ts'
-        )
-      }
-
-      if (!result.rpcMapDeclarationFile) {
-        result.rpcMapDeclarationFile = join(
-          rpcDir,
-          'pikku-rpc-wirings-map.gen.d.ts'
-        )
-      }
-
-      // Scheduler
-      if (!result.schedulersWiringFile) {
-        result.schedulersWiringFile = join(
-          schedulerDir,
-          'pikku-schedulers-wirings.gen.ts'
-        )
-      }
-      if (!result.schedulersWiringMetaFile) {
-        result.schedulersWiringMetaFile = join(
-          schedulerDir,
-          'pikku-schedulers-wirings-meta.gen.ts'
-        )
-      }
-
-      // Queue
-      if (!result.queueWorkersWiringFile) {
-        result.queueWorkersWiringFile = join(
-          queueDir,
-          'pikku-queue-workers-wirings.gen.ts'
-        )
-      }
-      if (!result.queueWorkersWiringMetaFile) {
-        result.queueWorkersWiringMetaFile = join(
-          queueDir,
-          'pikku-queue-workers-wirings-meta.gen.ts'
-        )
-      }
-      if (!result.queueMapDeclarationFile) {
-        result.queueMapDeclarationFile = join(
-          queueDir,
-          'pikku-queue-workers-wirings-map.gen.d.ts'
-        )
-      }
-
-      // Services
-      if (!result.servicesFile) {
-        result.servicesFile = join(result.outDir, 'pikku-services.gen.ts')
-      }
-
-      // Bootstrap files
-      if (!result.bootstrapFile) {
-        result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts')
-      }
-
-      // MCP
-      if (!result.mcpWiringsMetaFile) {
-        result.mcpWiringsMetaFile = join(
-          mcpDir,
-          'pikku-mcp-wirings-meta.gen.ts'
-        )
-      }
-      if (!result.mcpWiringsFile) {
-        result.mcpWiringsFile = join(mcpDir, 'pikku-mcp-wirings.gen.ts')
-      }
-      if (!result.mcpJsonFile) {
-        result.mcpJsonFile = join(mcpDir, 'pikku-mcp.gen.json')
-      }
-
-      result.bootstrapFiles = result.bootstrapFiles || {}
-      for (const key of Object.keys(PikkuWiringTypes)) {
-        const eventDir = join(result.outDir, key.toLowerCase())
-        result.bootstrapFiles[key] = join(
-          eventDir,
-          `pikku-bootstrap-${key}.gen.ts`
-        )
-      }
-    }
-
-    if (requiredFields.length > 0) {
-      validateCLIConfig(result, requiredFields)
-    }
-
-    for (const objectKey of Object.keys(result)) {
-      if (objectKey.endsWith('File') || objectKey.endsWith('Directory')) {
-        const relativeTo = CONFIG_DIR_FILES.includes(objectKey)
-          ? result.configDir
-          : result.rootDir
-        if (result[objectKey]) {
-          if (!isAbsolute(result[objectKey])) {
-            result[objectKey] = join(relativeTo, result[objectKey])
-          }
-        }
-      }
-    }
-
-    result.filters = result.filters || {}
-    if (filters.tags && filters.tags.length > 0) {
-      result.filters.tags = filters.tags
-    }
-    if (filters.types && filters.types.length > 0) {
-      result.filters.types = filters.types
-    }
-    if (filters.directories && filters.directories.length > 0) {
-      result.filters.directories = filters.directories
-    }
-
-    if (!isAbsolute(result.tsconfig)) {
-      result.tsconfig = join(result.rootDir, result.tsconfig)
-    }
-
-    return result
-  } catch (e: any) {
-    console.error(e)
-    console.error(`Config file not found: ${configFile}`)
-    process.exit(1)
-  }
-}
-
-export const validateCLIConfig = (
-  cliConfig: PikkuCLIConfig,
-  required: Array<keyof PikkuCLIConfig>
-) => {
-  let errors: string[] = []
-  for (const key of required) {
-    if (!cliConfig[key]) {
-      errors.push(key)
-    }
-  }
-
-  if (errors.length > 0) {
-    console.error(
-      `${errors.join(', ')} ${errors.length === 1 ? 'is' : 'are'} required in pikku.config.json`
-    )
-    process.exit(1)
-  }
-}

package/src/pikku-command-schemas.ts

@@ -1,35 +0,0 @@
-import { generateSchemas, saveSchemas } from './schema-generator.js'
-import { logCommandInfoAndTime } from './utils.js'
-import { PikkuCommand } from './types.js'
-
-export const pikkuSchemas: PikkuCommand = async (
-  logger,
-  { tsconfig, schemaDirectory, supportsImportAttributes, schemasFromTypes },
-  { functions, http }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating schemas',
-    'Created schemas',
-    [false],
-    async () => {
-      const schemas = await generateSchemas(
-        logger,
-        tsconfig,
-        functions.typesMap,
-        functions.meta,
-        http.meta,
-        schemasFromTypes
-      )
-      await saveSchemas(
-        logger,
-        schemaDirectory,
-        schemas,
-        functions.typesMap,
-        functions.meta,
-        supportsImportAttributes,
-        schemasFromTypes
-      )
-    }
-  )
-}

package/src/runtimes/nextjs/pikku-command-nextjs.ts

@@ -1,110 +0,0 @@
-import {
-  logCommandInfoAndTime,
-  getPikkuFilesAndMethods,
-  getFileImportRelativePath,
-  writeFileInDir,
-} from '../../utils.js'
-import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from './serialize-nextjs-backend-wrapper.js'
-import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from './serialize-nextjs-http-wrapper.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuNext: PikkuCommand = async (
-  logger,
-  {
-    nextBackendFile,
-    nextHTTPFile,
-    httpMapDeclarationFile,
-    packageMappings,
-    fetchFile,
-    bootstrapFiles,
-  },
-  visitState,
-  options = {}
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    '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(
-          logger,
-          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 httpBootstrapPath = getFileImportRelativePath(
-          nextBackendFile,
-          bootstrapFiles.http,
-          packageMappings
-        )
-
-        const routesMapDeclarationPath = getFileImportRelativePath(
-          nextBackendFile,
-          httpMapDeclarationFile,
-          packageMappings
-        )
-
-        const content = serializeNextBackendWrapper(
-          httpBootstrapPath,
-          routesMapDeclarationPath,
-          pikkuConfigImport,
-          singletonServicesImport,
-          sessionServicesImport
-        )
-        await writeFileInDir(logger, nextBackendFile, content)
-      }
-
-      if (nextHTTPFile && fetchFile) {
-        const routesMapDeclarationPath = getFileImportRelativePath(
-          nextHTTPFile,
-          httpMapDeclarationFile,
-          packageMappings
-        )
-
-        const fetchPath = getFileImportRelativePath(
-          nextHTTPFile,
-          fetchFile,
-          packageMappings
-        )
-
-        const content = serializeNextHTTPWrapper(
-          routesMapDeclarationPath,
-          fetchPath
-        )
-        await writeFileInDir(logger, nextHTTPFile, content)
-      }
-    }
-  )
-}

package/src/schemas.ts

@@ -1,35 +0,0 @@
-import { saveSchemas, generateSchemas } from './schema-generator.js'
-import { logCommandInfoAndTime } from './utils.js'
-import { PikkuCommand } from './types.js'
-
-export const pikkuSchemas: PikkuCommand = async (
-  logger,
-  { tsconfig, schemaDirectory, supportsImportAttributes, schemasFromTypes },
-  { functions, http }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating schemas',
-    'Created schemas',
-    [false],
-    async () => {
-      const schemas = await generateSchemas(
-        logger,
-        tsconfig,
-        functions.typesMap,
-        functions.meta,
-        http.meta,
-        schemasFromTypes
-      )
-      await saveSchemas(
-        logger,
-        schemaDirectory,
-        schemas,
-        functions.typesMap,
-        functions.meta,
-        supportsImportAttributes,
-        schemasFromTypes
-      )
-    }
-  )
-}