@pikku/cli 0.8.0 → 0.8.2

package/dist/src/utils.js

@@ -1,4 +1,4 @@
-import { relative, dirname } from 'path';
+import { relative, dirname, resolve } from 'path';
 import { mkdir, writeFile } from 'fs/promises';
 import chalk from 'chalk';
 import { fileURLToPath } from 'url';
@@ -33,6 +33,11 @@ export class CLILogger {
     warn(message) {
         console.error(chalk.yellow(message));
     }
+    debug(message) {
+        if (process.env.DEBUG) {
+            console.log(chalk.gray(message));
+        }
+    }
     logPikkuLogo() {
         this.primary(logo);
         const packageJson = JSON.parse(readFileSync(`${dirname(__filename)}/../../package.json`, 'utf-8'));
@@ -44,14 +49,28 @@ export const getFileImportRelativePath = (from, to, packageMappings) => {
     if (!/^\.+\//.test(filePath)) {
         filePath = `./${filePath}`;
     }
-    // let usesPackageName = false
-    for (const [path, packageName] of Object.entries(packageMappings)) {
-        if (filePath.includes(path)) {
-            // usesPackageName = true
-            filePath = filePath.replace(new RegExp(`.*${path}`), packageName);
+    const absolutePath = resolve(dirname(from), to);
+    const fromAbsolutePath = resolve(dirname(from));
+    // Check if both files are in the same package directory
+    // If so, skip packageMappings to use relative paths
+    let inSamePackage = false;
+    for (const [path] of Object.entries(packageMappings)) {
+        if (absolutePath.includes(path) && fromAbsolutePath.includes(path)) {
+            inSamePackage = true;
             break;
         }
     }
+    // Only apply packageMappings if files are not in the same package
+    if (!inSamePackage) {
+        // let usesPackageName = false
+        for (const [path, packageName] of Object.entries(packageMappings)) {
+            if (absolutePath.includes(path)) {
+                // usesPackageName = true
+                filePath = absolutePath.replace(new RegExp(`.*${path}`), packageName);
+                break;
+            }
+        }
+    }
     // if (usesPackageName) {
     //   return filePath.replace('.ts', '')
     // }

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../bin/pikku-all.ts","../bin/pikku-fetch.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-queue-service.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/pikku-command-schemas.ts","../src/schema-generator.ts","../src/schemas.ts","../src/serialize-import-map.ts","../src/serialize-pikku-types.ts","../src/types.ts","../src/utils.ts","../src/events/channels/pikku-channels.ts","../src/events/channels/pikku-command-channels-map.ts","../src/events/channels/pikku-command-channels.ts","../src/events/channels/pikku-command-websocket-typed.ts","../src/events/channels/serialize-typed-channel-map.ts","../src/events/channels/serialize-websocket-wrapper.ts","../src/events/fetch/index.ts","../src/events/functions/pikku-command-function-types.ts","../src/events/functions/pikku-command-functions.ts","../src/events/functions/pikku-function-types.ts","../src/events/functions/pikku-functions.ts","../src/events/http/openapi-spec-generator.ts","../src/events/http/pikku-command-http-map.ts","../src/events/http/pikku-command-http-routes.ts","../src/events/http/pikku-command-nextjs.ts","../src/events/http/pikku-command-openapi.ts","../src/events/http/pikku-http-routes.ts","../src/events/http/serialize-fetch-wrapper.ts","../src/events/http/serialize-typed-http-map.ts","../src/events/mcp/pikku-command-mcp-json.ts","../src/events/mcp/pikku-command-mcp.ts","../src/events/mcp/serialize-mcp-json.ts","../src/events/queue/pikku-command-queue-map.ts","../src/events/queue/pikku-command-queue-service.ts","../src/events/queue/pikku-command-queue.ts","../src/events/queue/pikku-queue-map.ts","../src/events/queue/pikku-queue.ts","../src/events/queue/serialize-queue-map.ts","../src/events/queue/serialize-queue-meta.ts","../src/events/queue/serialize-queue-wrapper.ts","../src/events/rpc/pikku-command-rpc-map.ts","../src/events/rpc/pikku-command-rpc.ts","../src/events/rpc/pikku-rpc.ts","../src/events/rpc/serialize-typed-rpc-map.ts","../src/events/scheduler/pikku-command-scheduler.ts","../src/events/scheduler/serialize-scheduler-meta.ts","../src/runtimes/nextjs/pikku-command-nextjs.ts","../src/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/runtimes/nextjs/serialize-nextjs-http-wrapper.ts"],"version":"5.8.3"}
+{"root":["../bin/pikku-all.ts","../bin/pikku-fetch.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-queue-service.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/pikku-command-schemas.ts","../src/schema-generator.ts","../src/schemas.ts","../src/serialize-import-map.ts","../src/serialize-pikku-types.ts","../src/types.ts","../src/utils.ts","../src/events/channels/pikku-channels.ts","../src/events/channels/pikku-command-channels-map.ts","../src/events/channels/pikku-command-channels.ts","../src/events/channels/pikku-command-websocket-typed.ts","../src/events/channels/serialize-typed-channel-map.ts","../src/events/channels/serialize-websocket-wrapper.ts","../src/events/fetch/index.ts","../src/events/functions/pikku-command-function-types.ts","../src/events/functions/pikku-command-functions.ts","../src/events/functions/pikku-command-services.ts","../src/events/functions/pikku-function-types.ts","../src/events/functions/pikku-functions.ts","../src/events/http/openapi-spec-generator.ts","../src/events/http/pikku-command-http-map.ts","../src/events/http/pikku-command-http-routes.ts","../src/events/http/pikku-command-openapi.ts","../src/events/http/pikku-http-routes.ts","../src/events/http/serialize-fetch-wrapper.ts","../src/events/http/serialize-typed-http-map.ts","../src/events/mcp/pikku-command-mcp-json.ts","../src/events/mcp/pikku-command-mcp.ts","../src/events/mcp/serialize-mcp-json.ts","../src/events/queue/pikku-command-queue-map.ts","../src/events/queue/pikku-command-queue-service.ts","../src/events/queue/pikku-command-queue.ts","../src/events/queue/pikku-queue-map.ts","../src/events/queue/pikku-queue.ts","../src/events/queue/serialize-queue-map.ts","../src/events/queue/serialize-queue-meta.ts","../src/events/queue/serialize-queue-wrapper.ts","../src/events/rpc/pikku-command-rpc-client.ts","../src/events/rpc/pikku-command-rpc-map.ts","../src/events/rpc/pikku-command-rpc.ts","../src/events/rpc/pikku-rpc.ts","../src/events/rpc/serialize-rpc-wrapper.ts","../src/events/rpc/serialize-typed-rpc-map.ts","../src/events/scheduler/pikku-command-scheduler.ts","../src/events/scheduler/serialize-scheduler-meta.ts","../src/runtimes/nextjs/pikku-command-nextjs.ts","../src/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/runtimes/nextjs/serialize-nextjs-http-wrapper.ts"],"version":"5.8.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
-    "@pikku/core": "^0.8.0",
-    "@pikku/inspector": "^0.8.0",
+    "@pikku/core": "^0.8.2",
+    "@pikku/inspector": "^0.8.1",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",

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

@@ -0,0 +1,125 @@
+import {
+  getFileImportRelativePath,
+  getPikkuFilesAndMethods,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../../utils.js'
+import { PikkuCommand } from '../../types.js'
+import { PikkuCLIConfig } from '../../pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+
+export const serializeServicesMap = (
+  functionsMetaData: Record<string, any>,
+  middlewareServices: string[] = [],
+  servicesImport: string,
+  sessionServicesImport: string
+): string => {
+  // Extract all unique services from all functions
+  const usedServices = new Set<string>()
+
+  // Internal services that are created internally and not via the create service script
+  const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession'])
+
+  for (const funcMeta of Object.values(functionsMetaData)) {
+    if (funcMeta.services && Array.isArray(funcMeta.services.services)) {
+      funcMeta.services.services.forEach((service: string) => {
+        // Only include services that are not internal
+        if (!internalServices.has(service)) {
+          usedServices.add(service)
+        }
+      })
+    }
+  }
+
+  // Add middleware services that might not be detected from function inspection
+  middlewareServices.forEach((service) => {
+    if (!internalServices.has(service)) {
+      usedServices.add(service)
+    }
+  })
+
+  // Create a map of services with true for all needed services
+  const servicesMap = Object.fromEntries(
+    Array.from(usedServices)
+      .sort()
+      .map((service) => [service, true])
+  )
+
+  // Generate the TypeScript code
+  const serviceKeys = Object.keys(servicesMap).sort()
+
+  // Services that are always required internally by the framework
+  const defaultServices = ['config', 'logger', 'variables', 'schema']
+
+  // Combine default services with detected services
+  const allRequiredServices = [
+    ...new Set([...defaultServices, ...serviceKeys]),
+  ].sort()
+
+  // For RequiredSingletonServices, we need to pick from the actual SingletonServices interface
+  // This will be resolved at compile time based on what's actually in the SingletonServices interface
+  // We don't need to hardcode which services are singletons beyond the core framework ones
+
+  const code = [
+    '/**',
+    ' * This file was generated by the @pikku/cli',
+    ' */',
+    '',
+    servicesImport,
+    sessionServicesImport,
+    "import type { PikkuInteraction } from '@pikku/core'",
+    '',
+    'export const singletonServices = {',
+    ...Object.keys(servicesMap).map((service) => `    '${service}': true,`),
+    '} as const',
+    '',
+    '// Singleton services (created once at startup)',
+    '// Only includes services that are both required and available in SingletonServices',
+    `export type RequiredSingletonServices = Pick<SingletonServices, Extract<keyof SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>> & Partial<Omit<SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>>`,
+    '',
+    '// Session services (created per request, can access singleton services)',
+    '// Omits singleton services and PikkuInteraction (mcp, rpc, http, channel)',
+    `export type RequiredSessionServices = Omit<Services, keyof SingletonServices | keyof PikkuInteraction>`,
+    '',
+  ].join('\n')
+
+  return code
+}
+
+export const pikkuServices: PikkuCommand = async (
+  logger,
+  cliConfig: PikkuCLIConfig,
+  visitState: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Generating Pikku services map',
+    'Generated Pikku services map',
+    [visitState.functions.files.size === 0],
+    async () => {
+      const { sessionServicesType, singletonServicesType } =
+        await getPikkuFilesAndMethods(
+          logger,
+          visitState,
+          cliConfig.packageMappings,
+          cliConfig.typesDeclarationFile,
+          {},
+          {
+            sessionServiceType: true,
+            singletonServicesType: true,
+          }
+        )
+
+      const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, singletonServicesType.typePath, cliConfig.packageMappings)}'`
+      const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, sessionServicesType.typePath, cliConfig.packageMappings)}'`
+
+      const servicesCode = serializeServicesMap(
+        visitState.functions.meta,
+        cliConfig.middlewareServices,
+        servicesImport,
+        sessionServicesImport
+      )
+      await writeFileInDir(logger, cliConfig.servicesFile, servicesCode)
+    }
+  )
+}

package/src/events/http/serialize-typed-http-map.ts

@@ -2,6 +2,7 @@ import { HTTPRoutesMeta } from '@pikku/core/http'
 import { serializeImportMap } from '../../serialize-import-map.js'
 import { MetaInputTypes, TypesMap } from '@pikku/inspector'
 import { FunctionsMeta } from '@pikku/core'
+import { generateCustomTypes } from '../../utils.js'
 
 export const serializeTypedRoutesMap = (
   relativeToPath: string,
@@ -54,24 +55,6 @@ export type RoutesWithMethod<Method extends string> = {
   `
 }
 
-export function generateCustomTypes(
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) {
-  return `
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
-${Array.from(typesMap.customTypes.entries())
-  .map(([name, { type, references }]) => {
-    references.forEach((name) => {
-      const originalName = typesMap.getTypeMeta(name).originalName
-      requiredTypes.add(originalName)
-    })
-    return `export type ${name} = ${type}`
-  })
-  .join('\n')}`
-}
-
 function generateRoutes(
   routesMeta: HTTPRoutesMeta,
   functionsMeta: FunctionsMeta,

package/src/events/rpc/pikku-command-rpc-client.ts

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

package/src/events/rpc/serialize-rpc-wrapper.ts

@@ -0,0 +1,29 @@
+export const serializeRPCWrapper = (rpcMapPath: string) => {
+  return `
+import { PikkuFetch } from "./pikku-fetch.gen.js"
+import type { RPCInvoke } from '${rpcMapPath}'
+
+export class PikkuRPC {
+    pikkuFetch = new PikkuFetch()
+
+    setPikkuFetch(pikkuFetch: PikkuFetch): void {
+        this.pikkuFetch = pikkuFetch
+    }
+
+    setServerUrl(serverUrl: string): void {
+        this.pikkuFetch.setServerUrl(serverUrl)
+    }
+
+    setAuthorizationJWT(jwt: string | null): void {
+        this.pikkuFetch.setAuthorizationJWT(jwt)
+    }
+
+    // Generic RPC invoke method
+    invoke: RPCInvoke = async (name, data) => {
+       return await this.pikkuFetch.post('/rpc', { name, data })
+    }
+}
+
+export const pikkuRPC = new PikkuRPC();
+`
+}

package/src/events/rpc/serialize-typed-rpc-map.ts

@@ -42,7 +42,7 @@ interface RPCHandler<I, O> {
 
 ${serializedRPCs}
 
-type RPCInvoke = <Name extends keyof RPCMap>(
+export type RPCInvoke = <Name extends keyof RPCMap>(
   name: Name,
   data: RPCMap[Name]['input'],
   options?: {

package/src/inspector-glob.ts

@@ -23,7 +23,7 @@ export const inspectorGlob = async (
           )
         )
       ).flat()
-      result = await inspect(routeFiles, filters)
+      result = await inspect(logger, routeFiles, filters)
     }
   )
   return result!

package/src/pikku-cli-config.ts

@@ -43,6 +43,9 @@ export interface PikkuCLICoreOutputFiles {
   mcpEndpointsFile: string
   mcpEndpointsMetaFile: string
 
+  // Services
+  servicesFile: string
+
   // Application bootstrap
   bootstrapFile: string
   bootstrapFiles: Record<PikkuEventTypes, string>
@@ -65,6 +68,7 @@ export type PikkuCLIConfig = {
   nextHTTPFile?: string
   fetchFile?: string
   websocketFile?: string
+  rpcFile?: string
   queueFile?: string
   mcpJsonFile?: string
 
@@ -73,6 +77,8 @@ export type PikkuCLIConfig = {
     additionalInfo: OpenAPISpecInfo
   }
 
+  middlewareServices?: string[]
+
   filters: InspectorFilters
 } & PikkuCLICoreOutputFiles
 
@@ -81,6 +87,7 @@ const CONFIG_DIR_FILES = [
   'nextHTTPFile',
   'fetchFile',
   'websocketFile',
+  'rpcFile',
   'queueFile',
   'mcpJsonFile',
 ]
@@ -88,13 +95,13 @@ const CONFIG_DIR_FILES = [
 export const getPikkuCLIConfig = async (
   configFile: string | undefined = undefined,
   requiredFields: Array<keyof PikkuCLIConfig>,
-  tags: string[] = [],
+  filters: InspectorFilters = {},
   exitProcess: boolean = false
 ): Promise<PikkuCLIConfig> => {
   const config = await _getPikkuCLIConfig(
     configFile,
     requiredFields,
-    tags,
+    filters,
     exitProcess
   )
   return config
@@ -103,7 +110,7 @@ export const getPikkuCLIConfig = async (
 const _getPikkuCLIConfig = async (
   configFile: string | undefined = undefined,
   requiredFields: Array<keyof PikkuCLIConfig>,
-  tags: string[] = [],
+  filters: InspectorFilters = {},
   exitProcess: boolean = false
 ): Promise<PikkuCLIConfig> => {
   if (!configFile) {
@@ -131,7 +138,7 @@ const _getPikkuCLIConfig = async (
       const extendedConfig = await getPikkuCLIConfig(
         resolve(configDir, config.extends),
         [],
-        tags,
+        filters,
         exitProcess
       )
       result = {
@@ -156,8 +163,9 @@ const _getPikkuCLIConfig = async (
 
     if (result.outDir) {
       // Create transport/event directories
+      const functionDir = join(result.outDir, 'function')
       const httpDir = join(result.outDir, 'http')
-      const channelsDir = join(result.outDir, 'channels')
+      const channelDir = join(result.outDir, 'channel')
       const rpcDir = join(result.outDir, 'rpc')
       const schedulerDir = join(result.outDir, 'scheduler')
       const queueDir = join(result.outDir, 'queue')
@@ -171,11 +179,11 @@ const _getPikkuCLIConfig = async (
 
       // Functions
       if (!result.functionsFile) {
-        result.functionsFile = join(result.outDir, 'pikku-functions.gen.ts')
+        result.functionsFile = join(functionDir, 'pikku-functions.gen.ts')
       }
       if (!result.functionsMetaFile) {
         result.functionsMetaFile = join(
-          result.outDir,
+          functionDir,
           'pikku-functions-meta.gen.ts'
         )
       }
@@ -202,17 +210,14 @@ const _getPikkuCLIConfig = async (
 
       // Channels/WebSocket
       if (!result.channelsFile) {
-        result.channelsFile = join(channelsDir, 'pikku-channels.gen.ts')
+        result.channelsFile = join(channelDir, 'pikku-channels.gen.ts')
       }
       if (!result.channelsMetaFile) {
-        result.channelsMetaFile = join(
-          channelsDir,
-          'pikku-channels-meta.gen.ts'
-        )
+        result.channelsMetaFile = join(channelDir, 'pikku-channels-meta.gen.ts')
       }
       if (!result.channelsMapDeclarationFile) {
         result.channelsMapDeclarationFile = join(
-          channelsDir,
+          channelDir,
           'pikku-channels-map.gen.d.ts'
         )
       }
@@ -227,12 +232,12 @@ const _getPikkuCLIConfig = async (
 
       // Scheduler
       if (!result.schedulersFile) {
-        result.schedulersFile = join(schedulerDir, 'pikku-schedules.gen.ts')
+        result.schedulersFile = join(schedulerDir, 'pikku-scheduler.gen.ts')
       }
       if (!result.schedulersMetaFile) {
         result.schedulersMetaFile = join(
           schedulerDir,
-          'pikku-schedules-meta.gen.ts'
+          'pikku-scheduler-meta.gen.ts'
         )
       }
 
@@ -253,6 +258,11 @@ const _getPikkuCLIConfig = async (
         )
       }
 
+      // 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')
@@ -297,8 +307,14 @@ const _getPikkuCLIConfig = async (
     }
 
     result.filters = result.filters || {}
-    if (tags.length > 0) {
-      result.filters.tags = tags
+    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)) {

package/src/schema-generator.ts

@@ -53,10 +53,10 @@ export async function generateSchemas(
     } catch (e) {
       // Ignore rootless errors
       if (e instanceof RootlessError) {
-        console.error('Error generating schema since it has no root:', schema)
+        logger.error(`Error generating schema since it has no root: ${schema}`)
         return
       }
-      throw e
+      logger.error(`Error generating schema: ${schema}`)
     }
   })
 

package/src/utils.test.ts

@@ -0,0 +1,137 @@
+import { strict as assert } from 'assert'
+import { describe, test } from 'node:test'
+import { getFileImportRelativePath } from './utils.js'
+
+describe('getFileImportRelativePath', () => {
+  test('should return relative path for files in same directory', () => {
+    const from = '/project/src/file1.ts'
+    const to = '/project/src/file2.ts'
+    const packageMappings = {}
+
+    const result = getFileImportRelativePath(from, to, packageMappings)
+
+    assert.strictEqual(result, './file2.js')
+  })
+
+  test('should return relative path for files in different directories', () => {
+    const from = '/project/src/file1.ts'
+    const to = '/project/lib/file2.ts'
+    const packageMappings = {}
+
+    const result = getFileImportRelativePath(from, to, packageMappings)
+
+    assert.strictEqual(result, '../lib/file2.js')
+  })
+
+  test('should use package mapping when files are in different packages', () => {
+    const from = '/project/packages/app/src/file1.ts'
+    const to = '/project/packages/sdk/src/file2.ts'
+    const packageMappings = {
+      'packages/sdk': '@myorg/sdk',
+    }
+
+    const result = getFileImportRelativePath(from, to, packageMappings)
+
+    assert.strictEqual(result, '@myorg/sdk/src/file2.js')
+  })
+
+  test('should NOT use package mapping when files are in same package', () => {
+    const from = '/project/packages/sdk/src/file1.ts'
+    const to = '/project/packages/sdk/lib/file2.ts'
+    const packageMappings = {
+      'packages/sdk': '@myorg/sdk',
+    }
+
+    const result = getFileImportRelativePath(from, to, packageMappings)
+
+    assert.strictEqual(result, '../lib/file2.js')
+  })
+
+  test('should use package mapping when only target file is in mapped package', () => {
+    const from = '/project/apps/web/src/file1.ts'
+    const to = '/project/packages/sdk/src/file2.ts'
+    const packageMappings = {
+      'packages/sdk': '@myorg/sdk',
+    }
+
+    const result = getFileImportRelativePath(from, to, packageMappings)
+
+    assert.strictEqual(result, '@myorg/sdk/src/file2.js')
+  })
+
+  test('should handle multiple package mappings correctly', () => {
+    const from = '/project/packages/app/src/file1.ts'
+    const to = '/project/packages/utils/src/file2.ts'
+    const packageMappings = {
+      'packages/app': '@myorg/app',
+      'packages/utils': '@myorg/utils',
+    }
+
+    const result = getFileImportRelativePath(from, to, packageMappings)
+
+    assert.strictEqual(result, '@myorg/utils/src/file2.js')
+  })
+
+  test('should preserve relative path when both files are in same package directory', () => {
+    const from = '/project/packages/sdk/src/components/file1.ts'
+    const to = '/project/packages/sdk/src/utils/file2.ts'
+    const packageMappings = {
+      'packages/sdk': '@myorg/sdk',
+    }
+
+    const result = getFileImportRelativePath(from, to, packageMappings)
+
+    assert.strictEqual(result, '../utils/file2.js')
+  })
+
+  test('should work with nested package structures', () => {
+    const from = '/project/packages/app/src/file1.ts'
+    const to = '/project/packages/app/lib/nested/file2.ts'
+    const packageMappings = {
+      'packages/app': '@myorg/app',
+      'packages/sdk': '@myorg/sdk',
+    }
+
+    const result = getFileImportRelativePath(from, to, packageMappings)
+
+    assert.strictEqual(result, '../lib/nested/file2.js')
+  })
+
+  test('should handle complex path structures', () => {
+    const from =
+      '/Users/user/project/workspace-starter/packages/sdk/.pikku/pikku-fetch.gen.ts'
+    const to =
+      '/Users/user/project/workspace-starter/packages/functions/.pikku/http/pikku-http-routes-map.gen.d.ts'
+    const packageMappings = {
+      'packages/sdk': '@workspace/sdk',
+      'packages/functions': '@workspace/functions',
+    }
+
+    const result = getFileImportRelativePath(from, to, packageMappings)
+
+    assert.strictEqual(
+      result,
+      '@workspace/functions/.pikku/http/pikku-http-routes-map.gen.d.js'
+    )
+  })
+
+  test('should handle empty package mappings', () => {
+    const from = '/project/src/file1.ts'
+    const to = '/project/lib/file2.ts'
+    const packageMappings = {}
+
+    const result = getFileImportRelativePath(from, to, packageMappings)
+
+    assert.strictEqual(result, '../lib/file2.js')
+  })
+
+  test('should replace .ts extension with .js', () => {
+    const from = '/project/src/file1.ts'
+    const to = '/project/src/file2.tsx'
+    const packageMappings = {}
+
+    const result = getFileImportRelativePath(from, to, packageMappings)
+
+    assert.strictEqual(result, './file2.tsx'.replace('.ts', '.js'))
+  })
+})