@pikku/cli 0.11.2 → 0.12.0

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

@@ -1,85 +0,0 @@
-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 { serializeMiddlewareImports } from './serialize-middleware-imports.js'
-import { serializeMiddlewareGroupsMeta } from './serialize-middleware-groups-meta.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-export const pikkuMiddleware: any = pikkuSessionlessFunc<
-  void,
-  boolean | undefined
->({
-  func: async ({ logger, config, getInspectorState }) => {
-    const state = await getInspectorState()
-    const { middleware } = state
-    const { middlewareFile, packageMappings, schema } = config
-
-    let filesGenerated = false
-
-    // Check if there are any middleware groups
-    const hasHTTPGroups = state.http.routeMiddleware.size > 0
-    const hasTagGroups = state.middleware.tagMiddleware.size > 0
-
-    if (hasHTTPGroups || hasTagGroups) {
-      const metaData = serializeMiddlewareGroupsMeta(state)
-
-      // Write JSON file
-      await writeFileInDir(
-        logger,
-        config.middlewareGroupsMetaJsonFile,
-        JSON.stringify(metaData, null, 2)
-      )
-
-      // Calculate relative path from TS file to JSON file
-      const jsonImportPath = getFileImportRelativePath(
-        config.middlewareGroupsMetaFile,
-        config.middlewareGroupsMetaJsonFile,
-        packageMappings
-      )
-
-      // Write TypeScript file that imports JSON
-      const supportsImportAttributes = schema?.supportsImportAttributes ?? false
-      const importStatement = supportsImportAttributes
-        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-        : `import metaData from '${jsonImportPath}'`
-
-      const tsContent = `import { pikkuState } from '@pikku/core'
-${importStatement}
-
-// HTTP middleware groups metadata
-if (metaData.httpGroups && Object.keys(metaData.httpGroups).length > 0) {
-  pikkuState('middleware', 'httpGroupMeta', metaData.httpGroups)
-}
-
-// Tag middleware groups metadata
-if (metaData.tagGroups && Object.keys(metaData.tagGroups).length > 0) {
-  pikkuState('middleware', 'tagGroupMeta', metaData.tagGroups)
-}
-`
-
-      await writeFileInDir(logger, config.middlewareGroupsMetaFile, tsContent)
-
-      // Always generate middleware imports file when groups exist (even if empty)
-      await writeFileInDir(
-        logger,
-        middlewareFile,
-        serializeMiddlewareImports(
-          middlewareFile,
-          middleware,
-          state.http,
-          packageMappings
-        )
-      )
-
-      filesGenerated = true
-    }
-
-    return filesGenerated
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Serializing Pikku middleware',
-      commandEnd: 'Serialized Pikku middleware',
-    }),
-  ],
-})

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

@@ -1,40 +0,0 @@
-import type { InspectorState } from '@pikku/inspector'
-
-/**
- * Generates the middleware groups metadata that stores metadata about
- * tag-based and HTTP middleware groups for visualization and inspection.
- *
- * This includes services, middleware count, factory status, etc.
- */
-export const serializeMiddlewareGroupsMeta = (state: InspectorState) => {
-  // Serialize HTTP middleware groups metadata
-  const httpGroups: Record<string, any> = {}
-  for (const [pattern, meta] of state.http.routeMiddleware.entries()) {
-    httpGroups[pattern] = {
-      exportName: meta.exportName,
-      sourceFile: meta.sourceFile,
-      position: meta.position,
-      services: meta.services,
-      middlewareCount: meta.middlewareCount,
-      isFactory: meta.isFactory,
-    }
-  }
-
-  // Serialize tag middleware groups metadata
-  const tagGroups: Record<string, any> = {}
-  for (const [tag, meta] of state.middleware.tagMiddleware.entries()) {
-    tagGroups[tag] = {
-      exportName: meta.exportName,
-      sourceFile: meta.sourceFile,
-      position: meta.position,
-      services: meta.services,
-      middlewareCount: meta.middlewareCount,
-      isFactory: meta.isFactory,
-    }
-  }
-
-  return {
-    httpGroups,
-    tagGroups,
-  }
-}

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

@@ -1,78 +0,0 @@
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import type {
-  InspectorMiddlewareState,
-  InspectorHTTPState,
-  InspectorState,
-} from '@pikku/inspector'
-
-export const serializeMiddlewareImports = (
-  outputPath: string,
-  middlewareState: InspectorMiddlewareState,
-  httpState: InspectorHTTPState,
-  packageMappings: Record<string, string> = {},
-  fullState?: InspectorState
-) => {
-  const serializedImports: string[] = []
-  const serializedFactoryCalls: string[] = []
-
-  // Collect factory imports and calls for HTTP middleware groups
-  const httpFactories = new Map<
-    string,
-    { exportName: string; filePath: string }
-  >()
-  for (const [, groupMeta] of httpState.routeMiddleware.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 middleware groups
-  const tagFactories = new Map<
-    string,
-    { exportName: string; filePath: string }
-  >()
-  for (const [, groupMeta] of middlewareState.tagMiddleware.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 middleware 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/permissions/pikku-command-permissions.ts

@@ -1,49 +0,0 @@
-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: any) => meta.exportName && meta.isFactory)
-    const hasTagFactories = Array.from(
-      state.permissions.tagPermissions.values()
-    ).some((meta: any) => 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

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

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

@@ -1,26 +0,0 @@
-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 { serializeQueueMap } from './serialize-queue-map.js'
-
-export const pikkuQueueMap: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const { queueWorkers, functions } = await getInspectorState()
-    const { queueMapDeclarationFile, packageMappings } = config
-
-    const content = serializeQueueMap(
-      queueMapDeclarationFile,
-      packageMappings,
-      functions.typesMap,
-      functions.meta,
-      queueWorkers.meta
-    )
-    await writeFileInDir(logger, queueMapDeclarationFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating Queue map',
-      commandEnd: 'Created Queue map',
-    }),
-  ],
-})

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

@@ -1,37 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeQueueWrapper } from './serialize-queue-wrapper.js'
-
-export const pikkuQueueService: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config }) => {
-    const { queueWiringsFile, queueMapDeclarationFile, packageMappings } =
-      config
-
-    // If queueWiringsFile is not set, clean up any existing file and return
-    if (!queueWiringsFile) {
-      logger.info({
-        message:
-          "Skipping generating queue service wrapper since queueWiringsFile isn't set in the pikku config.",
-        type: 'skip',
-      })
-      return
-    }
-
-    const queueMapDeclarationPath = getFileImportRelativePath(
-      queueWiringsFile,
-      queueMapDeclarationFile,
-      packageMappings
-    )
-
-    const content = [serializeQueueWrapper(queueMapDeclarationPath)]
-    await writeFileInDir(logger, queueWiringsFile, content.join('\n'))
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating queue service wrapper',
-      commandEnd: 'Generated queue service wrapper',
-    }),
-  ],
-})

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

@@ -1,25 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { writeFileInDir } from '../../../utils/file-writer.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-import { serializeQueueTypes } from './serialize-queue-types.js'
-
-export const pikkuQueueTypes: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config }) => {
-    const { queueTypesFile, functionTypesFile, packageMappings } = config
-
-    const functionTypesImportPath = getFileImportRelativePath(
-      queueTypesFile,
-      functionTypesFile,
-      packageMappings
-    )
-    const content = serializeQueueTypes(functionTypesImportPath)
-    await writeFileInDir(logger, queueTypesFile, content)
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Creating queue types',
-      commandEnd: 'Created queue types',
-    }),
-  ],
-})