@pikku/cli 0.9.16-next.0 → 0.10.0

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

@@ -58,8 +58,6 @@ export const pikkuMiddleware: any = pikkuSessionlessFunc<
     logCommandInfoAndTime({
       commandStart: 'Serializing Pikku middleware',
       commandEnd: 'Serialized Pikku middleware',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

package/src/functions/wirings/middleware/serialize-middleware-groups-meta.ts

@@ -7,13 +7,7 @@ import type { InspectorState } from '@pikku/inspector'
  * This includes services, middleware count, factory status, etc.
  */
 export const serializeMiddlewareGroupsMeta = (state: InspectorState) => {
-  const lines: string[] = [
-    `/**`,
-    ` * This file was generated by the @pikku/cli`,
-    ` */`,
-    `import { pikkuState } from '@pikku/core'`,
-    ``,
-  ]
+  const lines: string[] = [`import { pikkuState } from '@pikku/core'`, ``]
 
   // Serialize HTTP middleware groups metadata
   const httpGroups: Record<string, any> = {}

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

@@ -0,0 +1,49 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializePermissionsImports } from './serialize-permissions-imports.js'
+
+export const pikkuPermissions: any = pikkuSessionlessFunc<
+  void,
+  boolean | undefined
+>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const state = await getInspectorState()
+    const { permissions } = state
+    const { permissionsFile, packageMappings } = config
+
+    let filesGenerated = false
+
+    // Check if there are any permission group factories
+    const hasHTTPFactories = Array.from(
+      state.http.routePermissions.values()
+    ).some((meta) => meta.exportName && meta.isFactory)
+    const hasTagFactories = Array.from(
+      state.permissions.tagPermissions.values()
+    ).some((meta) => meta.exportName && meta.isFactory)
+    const hasFactories = hasHTTPFactories || hasTagFactories
+
+    // Generate permissions imports file if there are factories
+    if (hasFactories) {
+      await writeFileInDir(
+        logger,
+        permissionsFile,
+        serializePermissionsImports(
+          permissionsFile,
+          permissions,
+          state.http,
+          packageMappings
+        )
+      )
+      filesGenerated = true
+    }
+
+    return filesGenerated
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Serializing Pikku permissions',
+      commandEnd: 'Serialized Pikku permissions',
+    }),
+  ],
+})

package/src/functions/wirings/permissions/serialize-permissions-imports.test.ts

@@ -0,0 +1,274 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { serializePermissionsImports } from './serialize-permissions-imports.js'
+import type {
+  InspectorPermissionState,
+  InspectorHTTPState,
+  PermissionGroupMeta,
+} from '@pikku/inspector'
+
+describe('serializePermissionsImports', () => {
+  test('should return empty string when no permission factories exist', () => {
+    const permissionsState: InspectorPermissionState = {
+      meta: {},
+      tagPermissions: new Map(),
+    }
+    const httpState: InspectorHTTPState = {
+      metaInputTypes: new Map(),
+      meta: {
+        get: {},
+        post: {},
+        put: {},
+        delete: {},
+        head: {},
+        patch: {},
+        options: {},
+      },
+      files: new Set(),
+      routeMiddleware: new Map(),
+      routePermissions: new Map(),
+    }
+
+    const result = serializePermissionsImports(
+      '/test/output.ts',
+      permissionsState,
+      httpState
+    )
+
+    assert.strictEqual(result, '')
+  })
+
+  test('should generate imports and calls for HTTP permission factories', () => {
+    const permissionsState: InspectorPermissionState = {
+      meta: {},
+      tagPermissions: new Map(),
+    }
+
+    const httpPermissionMeta: PermissionGroupMeta = {
+      exportName: 'globalHttpPermissions',
+      sourceFile: '/src/permissions/http.ts',
+      position: 100,
+      services: { services: [], singletons: [] },
+      permissionCount: 2,
+      isFactory: true,
+    }
+
+    const httpState: InspectorHTTPState = {
+      metaInputTypes: new Map(),
+      meta: {
+        get: {},
+        post: {},
+        put: {},
+        delete: {},
+        head: {},
+        patch: {},
+        options: {},
+      },
+      files: new Set(),
+      routeMiddleware: new Map(),
+      routePermissions: new Map([['*', httpPermissionMeta]]),
+    }
+
+    const result = serializePermissionsImports(
+      '/test/.pikku/permissions/output.ts',
+      permissionsState,
+      httpState,
+      {}
+    )
+
+    assert.ok(
+      result.includes(
+        '/* Call permission group factories to register at module evaluation */'
+      )
+    )
+    assert.ok(result.includes('import { globalHttpPermissions } from'))
+    assert.ok(result.includes('globalHttpPermissions()'))
+  })
+
+  test('should generate imports and calls for tag permission factories', () => {
+    const tagPermissionMeta: PermissionGroupMeta = {
+      exportName: 'adminPermissions',
+      sourceFile: '/src/permissions/admin.ts',
+      position: 200,
+      services: { services: [], singletons: [] },
+      permissionCount: 3,
+      isFactory: true,
+    }
+
+    const permissionsState: InspectorPermissionState = {
+      meta: {},
+      tagPermissions: new Map([['admin', tagPermissionMeta]]),
+    }
+
+    const httpState: InspectorHTTPState = {
+      metaInputTypes: new Map(),
+      meta: {
+        get: {},
+        post: {},
+        put: {},
+        delete: {},
+        head: {},
+        patch: {},
+        options: {},
+      },
+      files: new Set(),
+      routeMiddleware: new Map(),
+      routePermissions: new Map(),
+    }
+
+    const result = serializePermissionsImports(
+      '/test/.pikku/permissions/output.ts',
+      permissionsState,
+      httpState,
+      {}
+    )
+
+    assert.ok(result.includes('import { adminPermissions } from'))
+    assert.ok(result.includes('adminPermissions()'))
+  })
+
+  test('should deduplicate permission factories used in both HTTP and tag groups', () => {
+    const sharedPermissionMeta: PermissionGroupMeta = {
+      exportName: 'sharedPermissions',
+      sourceFile: '/src/permissions/shared.ts',
+      position: 300,
+      services: { services: [], singletons: [] },
+      permissionCount: 1,
+      isFactory: true,
+    }
+
+    const permissionsState: InspectorPermissionState = {
+      meta: {},
+      tagPermissions: new Map([['shared', sharedPermissionMeta]]),
+    }
+
+    const httpState: InspectorHTTPState = {
+      metaInputTypes: new Map(),
+      meta: {
+        get: {},
+        post: {},
+        put: {},
+        delete: {},
+        head: {},
+        patch: {},
+        options: {},
+      },
+      files: new Set(),
+      routeMiddleware: new Map(),
+      routePermissions: new Map([
+        ['/api/*', { ...sharedPermissionMeta, position: 400 }],
+      ]),
+    }
+
+    const result = serializePermissionsImports(
+      '/test/.pikku/permissions/output.ts',
+      permissionsState,
+      httpState,
+      {}
+    )
+
+    // Should only have one import and one call despite being in both maps
+    const importMatches = result.match(/import { sharedPermissions }/g)
+    const callMatches = result.match(/sharedPermissions\(\)/g)
+
+    assert.strictEqual(
+      importMatches?.length,
+      1,
+      'Should have exactly one import'
+    )
+    assert.strictEqual(
+      callMatches?.length,
+      1,
+      'Should have exactly one function call'
+    )
+  })
+
+  test('should skip non-factory permission groups', () => {
+    const nonFactoryMeta: PermissionGroupMeta = {
+      exportName: 'directPermissions',
+      sourceFile: '/src/permissions/direct.ts',
+      position: 500,
+      services: { services: [], singletons: [] },
+      permissionCount: 2,
+      isFactory: false, // Not a factory
+    }
+
+    const permissionsState: InspectorPermissionState = {
+      meta: {},
+      tagPermissions: new Map([['direct', nonFactoryMeta]]),
+    }
+
+    const httpState: InspectorHTTPState = {
+      metaInputTypes: new Map(),
+      meta: {
+        get: {},
+        post: {},
+        put: {},
+        delete: {},
+        head: {},
+        patch: {},
+        options: {},
+      },
+      files: new Set(),
+      routeMiddleware: new Map(),
+      routePermissions: new Map(),
+    }
+
+    const result = serializePermissionsImports(
+      '/test/.pikku/permissions/output.ts',
+      permissionsState,
+      httpState,
+      {}
+    )
+
+    assert.strictEqual(
+      result,
+      '',
+      'Should not generate anything for non-factory permissions'
+    )
+  })
+
+  test('should handle package mappings correctly', () => {
+    const permissionMeta: PermissionGroupMeta = {
+      exportName: 'apiPermissions',
+      sourceFile: '/Users/test/project/packages/api/src/permissions.ts',
+      position: 600,
+      services: { services: [], singletons: [] },
+      permissionCount: 1,
+      isFactory: true,
+    }
+
+    const permissionsState: InspectorPermissionState = {
+      meta: {},
+      tagPermissions: new Map([['api', permissionMeta]]),
+    }
+
+    const httpState: InspectorHTTPState = {
+      metaInputTypes: new Map(),
+      meta: {
+        get: {},
+        post: {},
+        put: {},
+        delete: {},
+        head: {},
+        patch: {},
+        options: {},
+      },
+      files: new Set(),
+      routeMiddleware: new Map(),
+      routePermissions: new Map(),
+    }
+
+    const result = serializePermissionsImports(
+      '/Users/test/project/.pikku/permissions/output.ts',
+      permissionsState,
+      httpState,
+      { '/Users/test/project/packages/api/src': '@myapp/api' }
+    )
+
+    // Should use package mapping (or relative path if mapping doesn't match)
+    // The actual behavior depends on getFileImportRelativePath implementation
+    assert.ok(result.includes('import { apiPermissions } from'))
+    assert.ok(result.includes('apiPermissions()'))
+  })
+})

package/src/functions/wirings/permissions/serialize-permissions-imports.ts

@@ -0,0 +1,78 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import type {
+  InspectorPermissionState,
+  InspectorHTTPState,
+  InspectorState,
+} from '@pikku/inspector'
+
+export const serializePermissionsImports = (
+  outputPath: string,
+  permissionsState: InspectorPermissionState,
+  httpState: InspectorHTTPState,
+  packageMappings: Record<string, string> = {},
+  fullState?: InspectorState
+) => {
+  const serializedImports: string[] = []
+  const serializedFactoryCalls: string[] = []
+
+  // Collect factory imports and calls for HTTP permission groups
+  const httpFactories = new Map<
+    string,
+    { exportName: string; filePath: string }
+  >()
+  for (const [, groupMeta] of httpState.routePermissions.entries()) {
+    if (groupMeta.exportName && groupMeta.isFactory) {
+      const filePath = getFileImportRelativePath(
+        outputPath,
+        groupMeta.sourceFile,
+        packageMappings
+      )
+      httpFactories.set(groupMeta.exportName, {
+        exportName: groupMeta.exportName,
+        filePath,
+      })
+    }
+  }
+
+  // Collect factory imports and calls for tag permission groups
+  const tagFactories = new Map<
+    string,
+    { exportName: string; filePath: string }
+  >()
+  for (const [, groupMeta] of permissionsState.tagPermissions.entries()) {
+    if (groupMeta.exportName && groupMeta.isFactory) {
+      const filePath = getFileImportRelativePath(
+        outputPath,
+        groupMeta.sourceFile,
+        packageMappings
+      )
+      tagFactories.set(groupMeta.exportName, {
+        exportName: groupMeta.exportName,
+        filePath,
+      })
+    }
+  }
+
+  // Combine all factories and deduplicate by exportName (same factory might be used in multiple groups)
+  const allFactories = new Map([...httpFactories, ...tagFactories])
+
+  // Add factory imports and calls
+  if (allFactories.size > 0) {
+    serializedImports.push(
+      '/* Call permission group factories to register at module evaluation */'
+    )
+
+    // Import factories
+    for (const [exportName, { filePath }] of allFactories) {
+      serializedImports.push(`import { ${exportName} } from '${filePath}'`)
+    }
+
+    // Call factories
+    for (const [exportName] of allFactories) {
+      serializedFactoryCalls.push(`${exportName}()`)
+    }
+  }
+
+  // Return combined output
+  return [...serializedImports, ...serializedFactoryCalls].join('\n')
+}

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

@@ -21,11 +21,6 @@ export const pikkuQueueMap: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating Queue map',
       commandEnd: 'Created Queue map',
-      skipCondition: async ({ getInspectorState }) => {
-        const { queueWorkers } = await getInspectorState()
-        return queueWorkers.files.size === 0
-      },
-      skipMessage: 'none found',
     }),
   ],
 })

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

@@ -9,8 +9,14 @@ export const pikkuQueueService: any = pikkuSessionlessFunc<void, void>({
     const { queueWiringsFile, queueMapDeclarationFile, packageMappings } =
       config
 
+    // If queueWiringsFile is not set, clean up any existing file and return
     if (!queueWiringsFile) {
-      throw new Error("queueWiringsFile is isn't set in the pikku config")
+      logger.info({
+        message:
+          "Skipping generating queue service wrapper since queueWiringsFile isn't set in the pikku config.",
+        type: 'skip',
+      })
+      return
     }
 
     const queueMapDeclarationPath = getFileImportRelativePath(
@@ -26,8 +32,6 @@ export const pikkuQueueService: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Generating queue service wrapper',
       commandEnd: 'Generated queue service wrapper',
-      skipCondition: ({ config }) => config.queueWiringsFile === undefined,
-      skipMessage: "queueWiringsFile isn't set in the pikku config",
     }),
   ],
 })

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

@@ -20,8 +20,6 @@ export const pikkuQueueTypes: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating queue types',
       commandEnd: 'Created queue types',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

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

@@ -36,11 +36,6 @@ export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean | undefined>({
     logCommandInfoAndTime({
       commandStart: 'Finding Queues',
       commandEnd: 'Found Queues',
-      skipCondition: async ({ getInspectorState }) => {
-        const visitState = await getInspectorState()
-        return visitState.queueWorkers.files.size === 0
-      },
-      skipMessage: 'none found',
     }),
   ],
 })

package/src/functions/wirings/queue/pikku-queue-map.ts

@@ -21,11 +21,6 @@ export const pikkuQueueMap: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating Queue map',
       commandEnd: 'Created Queue map',
-      skipCondition: async ({ getInspectorState }) => {
-        const { queueWorkers } = await getInspectorState()
-        return queueWorkers.files.size === 0
-      },
-      skipMessage: 'none found',
     }),
   ],
 })

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

@@ -4,7 +4,7 @@ import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
 import { serializeQueueMeta } from './serialize-queue-meta.js'
 
-export const pikkuQueue: any = pikkuSessionlessFunc<void, void>({
+export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean>({
   func: async ({ logger, config, getInspectorState }) => {
     const visitState = await getInspectorState()
     const {
@@ -29,16 +29,13 @@ export const pikkuQueue: any = pikkuSessionlessFunc<void, void>({
         packageMappings
       )
     )
+
+    return true
   },
   middleware: [
     logCommandInfoAndTime({
       commandStart: 'Finding queues',
       commandEnd: 'Found queue',
-      skipCondition: async ({ getInspectorState }) => {
-        const { queueWorkers } = await getInspectorState()
-        return queueWorkers.files.size === 0
-      },
-      skipMessage: 'none found',
     }),
   ],
 })

package/src/functions/wirings/queue/serialize-queue-meta.ts

@@ -1,4 +1,4 @@
-import { queueWorkersMeta } from '@pikku/core'
+import { queueWorkersMeta } from '@pikku/core/queue'
 
 export const serializeQueueMeta = (queueWorkersMeta: queueWorkersMeta) => {
   const serializedOutput: string[] = []

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

@@ -3,7 +3,6 @@
  */
 export const serializeQueueTypes = (functionTypesImportPath: string) => {
   return `/**
- * This file was generated by the @pikku/cli
  * Queue-specific type definitions for tree-shaking optimization
  */
 

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

@@ -8,9 +8,14 @@ export const pikkuRPCClient: any = pikkuSessionlessFunc<void, void>({
   func: async ({ logger, config }) => {
     const { rpcWiringsFile, rpcMapDeclarationFile, packageMappings } = config
 
+    // If rpcWiringsFile is not set, clean up any existing file and return
     if (!rpcWiringsFile) {
+      logger.info({
+        message:
+          "Skipping generating RPC wrappers since rpcWiringsFile isn't set in the pikku config.",
+        type: 'skip',
+      })
       return
-      // TODO:  throw new Error("rpcWiringsFile isn't set in the pikku config")
     }
 
     const rpcMapDeclarationPath = getFileImportRelativePath(
@@ -25,8 +30,6 @@ export const pikkuRPCClient: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Generating RPC wrappers',
       commandEnd: 'Generated RPC wrappers',
-      skipCondition: ({ config }) => config.rpcWiringsFile === undefined,
-      skipMessage: "rpcWiringsFile isn't set in the pikku config",
     }),
   ],
 })

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

@@ -21,8 +21,6 @@ export const pikkuRPCInternalMap: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating RPC internal map',
       commandEnd: 'Created RPC internal map',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })
@@ -45,8 +43,6 @@ export const pikkuRPCExposedMap: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating RPC external map',
       commandEnd: 'Created RPC external map',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

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

@@ -21,8 +21,6 @@ export const pikkuRPC: any = pikkuSessionlessFunc<void, boolean>({
     logCommandInfoAndTime({
       commandStart: 'Finding RPCs tasks',
       commandEnd: 'Found RPCs',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

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

@@ -20,8 +20,6 @@ export const pikkuSchedulerTypes: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating cheduler types',
       commandEnd: 'Created scheduler types',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

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

@@ -36,11 +36,6 @@ export const pikkuScheduler: any = pikkuSessionlessFunc<
     logCommandInfoAndTime({
       commandStart: 'Finding Scheduled tasks',
       commandEnd: 'Found Scheduled tasks',
-      skipCondition: async ({ getInspectorState }) => {
-        const visitState = await getInspectorState()
-        return visitState.scheduledTasks.files.size === 0
-      },
-      skipMessage: 'none found',
     }),
   ],
 })

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

@@ -3,7 +3,6 @@
  */
 export const serializeSchedulerTypes = (functionTypesImportPath: string) => {
   return `/**
- * This file was generated by the @pikku/cli
  * Scheduler-specific type definitions for tree-shaking optimization
  */
 

package/src/middleware/log-command-info-and-time.ts

@@ -1,7 +1,4 @@
-import type {
-  SingletonServices,
-  Services,
-} from '../../types/application-types.js'
+import type { Services } from '../../types/application-types.js'
 import type { PikkuInteraction } from '@pikku/core'
 
 // Middleware type for CLI
@@ -14,40 +11,17 @@ type PikkuMiddleware = (
 export interface LogCommandInfoOptions {
   commandStart: string
   commandEnd: string
-  skipCondition?:
-    | boolean
-    | ((services: SingletonServices) => boolean | Promise<boolean>)
-  skipMessage?: string
 }
 
 /**
  * Middleware to log command execution timing and status
  * Replaces the logCommandInfoAndTime wrapper function
- *
- * The skipCondition can be:
- * - A boolean valuewe
- * - A function that receives services and returns a boolean (can access getInspectorState)
  */
 export const logCommandInfoAndTime = ({
   commandStart,
   commandEnd,
-  skipCondition = false,
-  skipMessage = 'none found',
 }: LogCommandInfoOptions): PikkuMiddleware => {
-  return async ({ logger, ...services }, _interaction, next) => {
-    // Evaluate skip condition (can be boolean or function)
-    const shouldSkip =
-      typeof skipCondition === 'function'
-        ? await skipCondition({ logger, ...services } as any)
-        : skipCondition
-
-    if (shouldSkip === true) {
-      logger.info(
-        `• Skipping ${commandStart.charAt(0).toLocaleLowerCase()}${commandStart.slice(1)} since ${skipMessage}.`
-      )
-      return
-    }
-
+  return async ({ logger }, _interaction, next) => {
     // Log start
     const start = Date.now()
     logger.info(`• ${commandStart}...`)