@pikku/cli 0.9.15 → 0.10.0

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

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

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

@@ -0,0 +1,25 @@
+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',
+    }),
+  ],
+})

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

@@ -0,0 +1,41 @@
+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 { serializeQueueMeta } from './serialize-queue-meta.js'
+
+export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean | undefined>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const visitState = await getInspectorState()
+    const {
+      queueWorkersWiringFile,
+      queueWorkersWiringMetaFile,
+      packageMappings,
+    } = config
+    const { queueWorkers } = visitState
+
+    await writeFileInDir(
+      logger,
+      queueWorkersWiringMetaFile,
+      serializeQueueMeta(queueWorkers.meta)
+    )
+    await writeFileInDir(
+      logger,
+      queueWorkersWiringFile,
+      serializeFileImports(
+        'addQueueWorkers',
+        queueWorkersWiringFile,
+        queueWorkers.files,
+        packageMappings
+      )
+    )
+
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding Queues',
+      commandEnd: 'Found Queues',
+    }),
+  ],
+})

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

@@ -0,0 +1,26 @@
+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-queue.ts

@@ -0,0 +1,41 @@
+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 { serializeQueueMeta } from './serialize-queue-meta.js'
+
+export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const visitState = await getInspectorState()
+    const {
+      queueWorkersWiringFile,
+      queueWorkersWiringMetaFile,
+      packageMappings,
+    } = config
+    const { queueWorkers } = visitState
+
+    await writeFileInDir(
+      logger,
+      queueWorkersWiringMetaFile,
+      serializeQueueMeta(queueWorkers.meta)
+    )
+    await writeFileInDir(
+      logger,
+      queueWorkersWiringFile,
+      serializeFileImports(
+        'addQueueWorkers',
+        queueWorkersWiringFile,
+        queueWorkers.files,
+        packageMappings
+      )
+    )
+
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding queues',
+      commandEnd: 'Found queue',
+    }),
+  ],
+})

package/src/{wirings → functions/wirings}/queue/serialize-queue-map.ts

@@ -1,8 +1,8 @@
 import type { queueWorkersMeta } from '@pikku/core/queue'
-import { serializeImportMap } from '../../serialize-import-map.js'
+import { serializeImportMap } from '../../../utils/serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
 import { FunctionsMeta } from '@pikku/core'
-import { generateCustomTypes } from '../../utils.js'
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js'
 
 export const serializeQueueMap = (
   relativeToPath: string,

package/src/{wirings → 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

@@ -0,0 +1,30 @@
+/**
+ * Generates type definitions for queue wirings
+ */
+export const serializeQueueTypes = (functionTypesImportPath: string) => {
+  return `/**
+ * Queue-specific type definitions for tree-shaking optimization
+ */
+
+import { CoreQueueWorker, wireQueueWorker as wireQueueWorkerCore } from '@pikku/core/queue'
+import type { PikkuFunctionConfig } from '${functionTypesImportPath}'
+
+/**
+ * Type definition for queue workers that process background jobs.
+ *
+ * @template In - Input type for the queue job
+ * @template Out - Output type for the queue job
+ */
+type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out>>
+
+/**
+ * Registers a queue worker with the Pikku framework.
+ * Workers process background jobs from queues.
+ *
+ * @param queueWorker - Queue worker definition with job handler
+ */
+export const wireQueueWorker = (queueWorker: QueueWiring<any, any>) => {
+  wireQueueWorkerCore(queueWorker as any) // TODO
+}
+`
+}

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

@@ -0,0 +1,35 @@
+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 { serializeRPCWrapper } from './serialize-rpc-wrapper.js'
+
+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
+    }
+
+    const rpcMapDeclarationPath = getFileImportRelativePath(
+      rpcWiringsFile,
+      rpcMapDeclarationFile,
+      packageMappings
+    )
+    const content = [serializeRPCWrapper(rpcMapDeclarationPath)]
+    await writeFileInDir(logger, rpcWiringsFile, content.join('\n'))
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating RPC wrappers',
+      commandEnd: 'Generated RPC wrappers',
+    }),
+  ],
+})