@pikku/cli 0.11.1 → 0.11.2

package/src/functions/wirings/channels/serialize-channel-types.ts

@@ -8,9 +8,8 @@ export const serializeChannelTypes = (functionTypesImportPath: string) => {
  */
 
 import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
-import { CorePikkuFunctionConfig } from '@pikku/core'
 import { AssertHTTPWiringParams } from '@pikku/core/http'
-import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
 
 /**
  * Type definition for WebSocket channels with typed data exchange.
@@ -23,9 +22,9 @@ import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMid
 type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<
   ChannelData,
   Channel,
-  CorePikkuFunctionConfig<PikkuFunctionSessionless<void, any, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
-  CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
-  CorePikkuFunctionConfig<PikkuFunctionSessionless<any, any, ChannelData> | PikkuFunction<any, any, ChannelData>, PikkuPermission<any>, PikkuMiddleware>,
+  PikkuFunctionConfig<void, any, 'channel' | 'session' | 'rpc'>,
+  PikkuFunctionConfig<void, void, 'channel' | 'session' | 'rpc'>,
+  PikkuFunctionConfig<any, any, 'channel' | 'session' | 'rpc'>,
   PikkuPermission,
   PikkuMiddleware
 >
@@ -40,8 +39,8 @@ type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<
  */
 export const pikkuChannelConnectionFunc = <Out = unknown>(
   func:
-    | PikkuFunctionSessionless<void, Out, unknown>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, Out, unknown>, PikkuPermission<void>, PikkuMiddleware>
+    | PikkuFunctionSessionless<void, Out, 'channel' | 'session' | 'rpc'>
+    | PikkuFunctionConfig<void, Out, 'channel' | 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -55,8 +54,8 @@ export const pikkuChannelConnectionFunc = <Out = unknown>(
  */
 export const pikkuChannelDisconnectionFunc = (
   func:
-    | PikkuFunctionSessionless<void, void, unknown>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, unknown>, PikkuPermission<void>, PikkuMiddleware>
+    | PikkuFunctionSessionless<void, void, 'channel'>
+    | PikkuFunctionConfig<void, void, 'channel' | 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -73,8 +72,8 @@ export const pikkuChannelDisconnectionFunc = (
  */
 export const pikkuChannelFunc = <In, Out = unknown>(
   func:
-    | PikkuFunctionSessionless<In, Out, unknown>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out, unknown>, PikkuPermission<In>, PikkuMiddleware>
+    | PikkuFunctionSessionless<In, Out, 'channel' | 'session' | 'rpc'>
+    | PikkuFunctionConfig<In, Out, 'channel' | 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }

package/src/functions/wirings/cli/pikku-command-cli-entry.ts

@@ -173,19 +173,19 @@ export const pikkuCLIEntry: any = pikkuSessionlessFunc<void, void>({
         checkRequiredTypes(visitState.filesAndMethodsErrors, {
           config: true,
           singletonServicesFactory: true,
-          sessionServicesFactory: true,
+          wireServicesFactory: true,
         })
 
         const {
           pikkuConfigFactory,
           singletonServicesFactory,
-          sessionServicesFactory,
+          wireServicesFactory,
         } = visitState.filesAndMethods
 
         if (
           !pikkuConfigFactory ||
           !singletonServicesFactory ||
-          !sessionServicesFactory
+          !wireServicesFactory
         ) {
           throw new Error('Required types not found')
         }
@@ -197,7 +197,7 @@ export const pikkuCLIEntry: any = pikkuSessionlessFunc<void, void>({
           config,
           pikkuConfigFactory,
           singletonServicesFactory,
-          sessionServicesFactory
+          wireServicesFactory
         )
 
         await writeFileInDir(logger, bootstrapFile, bootstrapCode)

package/src/functions/wirings/cli/pikku-command-cli-types.ts

@@ -19,7 +19,7 @@ export const pikkuCLITypes: any = pikkuSessionlessFunc<void, void>({
     // Check for required types
     checkRequiredTypes(visitState.filesAndMethodsErrors, {
       userSessionType: true,
-      sessionServiceType: true,
+      wireServiceType: true,
       singletonServicesType: true,
     })
 

package/src/functions/wirings/cli/pikku-command-cli.ts

@@ -2,11 +2,18 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
 import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuCLI: any = pikkuSessionlessFunc<void, boolean | undefined>({
   func: async ({ logger, config, getInspectorState }) => {
     const visitState = await getInspectorState()
-    const { cliWiringsFile, cliWiringMetaFile, packageMappings } = config
+    const {
+      cliWiringsFile,
+      cliWiringMetaFile,
+      cliWiringMetaJsonFile,
+      packageMappings,
+      schema,
+    } = config
     const { cli } = visitState
 
     // Generate CLI wirings file
@@ -21,11 +28,27 @@ export const pikkuCLI: any = pikkuSessionlessFunc<void, boolean | undefined>({
       )
     )
 
-    // Generate CLI metadata file
+    await writeFileInDir(
+      logger,
+      cliWiringMetaJsonFile,
+      JSON.stringify(cli.meta, null, 2)
+    )
+
+    const jsonImportPath = getFileImportRelativePath(
+      cliWiringMetaFile,
+      cliWiringMetaJsonFile,
+      packageMappings
+    )
+
+    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+    const importStatement = supportsImportAttributes
+      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+      : `import metaData from '${jsonImportPath}'`
+
     await writeFileInDir(
       logger,
       cliWiringMetaFile,
-      `import { pikkuState } from '@pikku/core'\npikkuState('cli', 'meta', ${JSON.stringify(cli.meta, null, 2)})`
+      `import { pikkuState } from '@pikku/core'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState('cli', 'meta', metaData as CLIMeta)`
     )
 
     return true

package/src/functions/wirings/cli/serialize-channel-cli.ts

@@ -89,7 +89,7 @@ import { pikkuMiddleware } from '${functionTypesPath}'
 ${imports}
 
 // Middleware to close the channel after CLI command completes
-const cliCloseOnComplete = pikkuMiddleware(async (services, { channel }, next) => {
+const cliCloseOnComplete = pikkuMiddleware(async (_services, { channel }, next) => {
   const closeChannel = () => {
     setTimeout(async () => {
       try {

package/src/functions/wirings/cli/serialize-cli-types.ts

@@ -56,7 +56,7 @@ export const pikkuCLIRender = <Data, RequiredServices extends SingletonServices
  * CLI command configuration with project-specific types.
  * Uses CoreCLICommandConfig from @pikku/core with local middleware and render types.
  */
-type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
+type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out, 'cli' | 'rpc' | 'session'>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
 
 /**
  * Type definition for CLI applications with commands and global options.
@@ -90,7 +90,7 @@ export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any
  * @returns CLI command configuration with inferred types
  */
 export const pikkuCLICommand = <
-  FuncConfig extends PikkuFunctionConfig<any, any>,
+  FuncConfig extends PikkuFunctionConfig<any, any, 'cli' | 'rpc' | 'session'>,
   Params extends string
 >(
   config: CLICommandConfig<FuncConfig, any, any, Params>

package/src/functions/wirings/cli/serialize-local-cli-bootstrap.ts

@@ -11,7 +11,7 @@ export function serializeLocalCLIBootstrap(
   config: Config,
   pikkuConfigFactory: { file: string; variable: string },
   singletonServicesFactory: { file: string; variable: string },
-  sessionServicesFactory: { file: string; variable: string }
+  wireServicesFactory: { file: string; variable: string }
 ): string {
   const capitalizedName =
     programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '')
@@ -27,9 +27,9 @@ export function serializeLocalCLIBootstrap(
     singletonServicesFactory.file,
     config.packageMappings
   )
-  const sessionServicesPath = getFileImportRelativePath(
+  const wireServicesPath = getFileImportRelativePath(
     bootstrapFile,
-    sessionServicesFactory.file,
+    wireServicesFactory.file,
     config.packageMappings
   )
   const cliBootstrapPath = getFileImportRelativePath(
@@ -42,7 +42,7 @@ export function serializeLocalCLIBootstrap(
 import { executeCLI, CLIError } from '@pikku/core/cli'
 import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'
 import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
-import { ${sessionServicesFactory.variable} as createSessionServices } from '${sessionServicesPath}'
+import { ${wireServicesFactory.variable} as createWireServices } from '${wireServicesPath}'
 import '${cliBootstrapPath}'
 
 /**
@@ -56,7 +56,7 @@ export async function ${capitalizedName}CLI(args: string[]): Promise<void> {
       args: args || process.argv.slice(2),
       createConfig,
       createSingletonServices,
-      createSessionServices,
+      createWireServices,
     })
   } catch (error) {
     if (error instanceof CLIError) {

package/src/functions/wirings/functions/pikku-command-function-types-split.ts

@@ -18,18 +18,18 @@ export const pikkuFunctionTypesSplit: any = pikkuSessionlessFunc<void, void>({
     // Check for required types
     checkRequiredTypes(visitState.filesAndMethodsErrors, {
       userSessionType: true,
-      sessionServiceType: true,
+      wireServiceType: true,
       singletonServicesType: true,
     })
 
     const {
       userSessionType,
-      sessionServicesType,
+      wireServicesType,
       singletonServicesType,
       pikkuConfigType,
     } = visitState.filesAndMethods
 
-    if (!userSessionType || !sessionServicesType || !singletonServicesType) {
+    if (!userSessionType || !wireServicesType || !singletonServicesType) {
       throw new Error('Required types not found')
     }
 
@@ -42,10 +42,10 @@ export const pikkuFunctionTypesSplit: any = pikkuSessionlessFunc<void, void>({
       userSessionType.type,
       `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`,
       singletonServicesType.type,
-      `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, sessionServicesType.typePath, packageMappings)}'`,
-      sessionServicesType.type,
+      `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`,
+      wireServicesType.type,
       `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`,
-      `import type { RequiredSingletonServices, RequiredSessionServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`,
+      `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`,
       configTypeImport
     )
 

package/src/functions/wirings/functions/pikku-command-functions.ts

@@ -5,6 +5,7 @@ import {
   generateRuntimeMeta,
   serializeFunctionImports,
 } from './serialize-function-imports.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuFunctions: any = pikkuSessionlessFunc<
   void,
@@ -14,24 +15,58 @@ export const pikkuFunctions: any = pikkuSessionlessFunc<
     const { functions, rpc } = await getInspectorState()
     const {
       functionsMetaFile,
+      functionsMetaJsonFile,
       functionsMetaMinFile,
+      functionsMetaMinJsonFile,
       functionsFile,
       packageMappings,
+      schema,
     } = config
 
-    // Generate full metadata
+    await writeFileInDir(
+      logger,
+      functionsMetaJsonFile,
+      JSON.stringify(functions.meta, null, 2)
+    )
+
+    const fullJsonImportPath = getFileImportRelativePath(
+      functionsMetaFile,
+      functionsMetaJsonFile,
+      packageMappings
+    )
+
+    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+    const fullImportStatement = supportsImportAttributes
+      ? `import metaData from '${fullJsonImportPath}' with { type: 'json' }`
+      : `import metaData from '${fullJsonImportPath}'`
+
     await writeFileInDir(
       logger,
       functionsMetaFile,
-      `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`
+      `import { pikkuState, FunctionsMeta } from '@pikku/core'\n${fullImportStatement}\npikkuState('function', 'meta', metaData as FunctionsMeta)`
     )
 
-    // Generate minimal metadata (runtime)
     const runtimeMeta = generateRuntimeMeta(functions.meta)
+    await writeFileInDir(
+      logger,
+      functionsMetaMinJsonFile,
+      JSON.stringify(runtimeMeta, null, 2)
+    )
+
+    const minJsonImportPath = getFileImportRelativePath(
+      functionsMetaMinFile,
+      functionsMetaMinJsonFile,
+      packageMappings
+    )
+
+    const minImportStatement = supportsImportAttributes
+      ? `import metaData from '${minJsonImportPath}' with { type: 'json' }`
+      : `import metaData from '${minJsonImportPath}'`
+
     await writeFileInDir(
       logger,
       functionsMetaMinFile,
-      `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(runtimeMeta, null, 2)})`
+      `import { pikkuState, FunctionsRuntimeMeta } from '@pikku/core'\n${minImportStatement}\npikkuState('function', 'meta', metaData as FunctionsRuntimeMeta)`
     )
 
     const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0

package/src/functions/wirings/functions/pikku-command-services.ts

@@ -6,11 +6,11 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 
 export const serializeServicesMap = (
   allSingletonServices: string[],
-  allSessionServices: string[],
+  allWireServices: string[],
   requiredServices: Set<string>,
   forceRequiredServices: string[] = [],
   servicesImport: string,
-  sessionServicesImport: string
+  wireServicesImport: string
 ): string => {
   // Use pre-aggregated services from inspector state
   // This includes services from:
@@ -20,7 +20,7 @@ export const serializeServicesMap = (
   // - Session factories
   const usedServices = new Set(requiredServices)
 
-  // Internal services that are created internally by the framework (PikkuInteraction)
+  // Internal services that are created internally by the framework (PikkuWire)
   // These should not appear in the services maps
   const internalServices = new Set([
     'rpc',
@@ -50,12 +50,12 @@ export const serializeServicesMap = (
     singletonServicesMap[service] = usedServices.has(service)
   })
 
-  // Create session services map: all session services with true/false based on usage
-  // Exclude internal framework services (PikkuInteraction)
-  const sessionServicesMap: Record<string, boolean> = {}
-  allSessionServices.forEach((service) => {
+  // Create wire services map: all wire services with true/false based on usage
+  // Exclude internal framework services (PikkuWire)
+  const wireServicesMap: Record<string, boolean> = {}
+  allWireServices.forEach((service) => {
     if (!internalServices.has(service)) {
-      sessionServicesMap[service] = usedServices.has(service)
+      wireServicesMap[service] = usedServices.has(service)
     }
   })
 
@@ -63,13 +63,13 @@ export const serializeServicesMap = (
   const requiredSingletonServiceNames = Object.keys(singletonServicesMap)
     .filter((key) => singletonServicesMap[key])
     .sort()
-  const requiredSessionServiceNames = Object.keys(sessionServicesMap)
-    .filter((key) => sessionServicesMap[key])
+  const requiredWireServiceNames = Object.keys(wireServicesMap)
+    .filter((key) => wireServicesMap[key])
     .sort()
 
   const code = [
     servicesImport,
-    sessionServicesImport,
+    wireServicesImport,
     '',
     '// Singleton services map: true if required, false if available but unused',
     'export const requiredSingletonServices = {',
@@ -78,11 +78,11 @@ export const serializeServicesMap = (
       .map((service) => `  '${service}': ${singletonServicesMap[service]},`),
     '} as const',
     '',
-    '// Session services map: true if required, false if available but unused',
-    'export const requiredSessionServices = {',
-    ...Object.keys(sessionServicesMap)
+    '// Wire services map: true if required, false if available but unused',
+    'export const requiredWireServices = {',
+    ...Object.keys(wireServicesMap)
       .sort()
-      .map((service) => `  '${service}': ${sessionServicesMap[service]},`),
+      .map((service) => `  '${service}': ${wireServicesMap[service]},`),
     '} as const',
     '',
     '// Type exports',
@@ -90,9 +90,9 @@ export const serializeServicesMap = (
       ? `export type RequiredSingletonServices = Pick<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
       : 'export type RequiredSingletonServices = Partial<SingletonServices>',
     '',
-    requiredSessionServiceNames.length > 0
-      ? `export type RequiredSessionServices = Pick<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredSessionServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
-      : 'export type RequiredSessionServices = Partial<Services>',
+    requiredWireServiceNames.length > 0
+      ? `export type RequiredWireServices = Pick<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
+      : 'export type RequiredWireServices = Partial<Services>',
     '',
   ].join('\n')
 
@@ -105,29 +105,29 @@ export const pikkuServices: any = pikkuSessionlessFunc<void, void>({
 
     // Check for required types
     checkRequiredTypes(visitState.filesAndMethodsErrors, {
-      sessionServiceType: true,
+      wireServiceType: true,
       singletonServicesType: true,
     })
 
-    const { sessionServicesType, singletonServicesType } =
+    const { wireServicesType, singletonServicesType } =
       visitState.filesAndMethods
 
-    if (!sessionServicesType || !singletonServicesType) {
+    if (!wireServicesType || !singletonServicesType) {
       throw new Error(
-        'Required types not found: sessionServicesType or singletonServicesType'
+        'Required types not found: wireServicesType or singletonServicesType'
       )
     }
 
     const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, singletonServicesType.typePath, config.packageMappings)}'`
-    const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`
+    const wireServicesImport = `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, wireServicesType.typePath, config.packageMappings)}'`
 
     const servicesCode = serializeServicesMap(
       visitState.serviceAggregation.allSingletonServices,
-      visitState.serviceAggregation.allSessionServices,
+      visitState.serviceAggregation.allWireServices,
       visitState.serviceAggregation.requiredServices,
       config.forceRequiredServices,
       servicesImport,
-      sessionServicesImport
+      wireServicesImport
     )
     await writeFileInDir(logger, config.servicesFile, servicesCode)
   },

package/src/functions/wirings/functions/schemas.ts

@@ -31,8 +31,8 @@ export const pikkuSchemas: any = pikkuSessionlessFunc<
       schemas,
       visitState.functions.typesMap,
       visitState.functions.meta,
-      config.schemasFromTypes,
-      config.schema?.supportsImportAttributes
+      config.schema?.supportsImportAttributes || true,
+      config.schemasFromTypes
     )
 
     return true