@pikku/cli 0.7.3 → 0.7.5

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @pikku/cli
 
+## 0.7.5
+
+### Patch Changes
+
+- faa1369: refactor: moving function imports into pikku-fun.gen file
+- Updated dependencies [faa1369]
+  - @pikku/inspector@0.7.6
+
+## 0.7.4
+
+### Patch Changes
+
+- 6af8a19: fix: always write functions meta data
+- Updated dependencies [6af8a19]
+  - @pikku/core@0.7.7
+
 ## 0.7.3
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -70,7 +70,6 @@ const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
   await pikkuRPC(cliConfig, visitState)
   await pikkuRPCMap(cliConfig, visitState)
   addImport(cliConfig.rpcMetaFile, 'meta')
-  addImport(cliConfig.rpcFile, 'events')
 
   const routes = await pikkuHTTP(cliConfig, visitState)
   if (routes) {

package/bin/pikku-functions.ts

@@ -1,18 +1,77 @@
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
-import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js'
+import {
+  getFileImportRelativePath,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../src/utils/utils.js'
+
+export const serializeFunctionImports = (
+  outputPath: string,
+  functionsMap: Map<string, { path: string; exportedName: string }>,
+  packageMappings: Record<string, string> = {}
+) => {
+  const serializedImports: string[] = [
+    `/* Import and register RPCs */`,
+    `import { addFunction } from '@pikku/core'`,
+  ]
+
+  const serializedRegistrations: string[] = []
+
+  // Sort by function name for consistent output
+  const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) =>
+    a[0].localeCompare(b[0])
+  )
+
+  for (const [name, { path, exportedName }] of sortedEntries) {
+    const filePath = getFileImportRelativePath(
+      outputPath,
+      path,
+      packageMappings
+    )
+
+    // For directly exported functions, we can just import and register them
+    if (name === exportedName) {
+      serializedImports.push(`import { ${exportedName} } from '${filePath}'`)
+      serializedRegistrations.push(
+        `addFunction('${name}', { func: ${exportedName} })`
+      )
+    }
+    // For renamed functions, we need to import and alias them
+    else {
+      serializedImports.push(
+        `import { ${exportedName} as ${name} } from '${filePath}'`
+      )
+      serializedRegistrations.push(`addFunction('${name}', ${name})`)
+    }
+  }
+
+  // Add a blank line between imports and registrations
+  if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
+    serializedImports.push('')
+  }
+
+  // Combine the imports and registrations
+  return [...serializedImports, ...serializedRegistrations].join('\n')
+}
 
 export const pikkuFunctions = async (
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
+  { functionsMetaFile, functionsFile, packageMappings }: PikkuCLIConfig,
+  { functions }: InspectorState
 ) => {
   return await logCommandInfoAndTime(
-    'Finding Pikku functions',
-    'Found Pikku functions',
-    [true],
+    'Serializing Pikku functions',
+    'Serialized Pikku functions',
+    [false],
     async () => {
-      const { functionsMetaFile } = cliConfig
-      const { functions } = visitState
+      await writeFileInDir(
+        functionsFile,
+        serializeFunctionImports(
+          functionsFile,
+          functions.files,
+          packageMappings
+        )
+      )
       await writeFileInDir(
         functionsMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`

package/bin/pikku-rpc-map.ts

@@ -10,7 +10,7 @@ export const pikkuRPCMap = async (
   return await logCommandInfoAndTime(
     'Creating RPC map',
     'Created RPC map',
-    [rpc.files.size === 0],
+    [false],
     async () => {
       const content = serializeTypedRPCMap(
         rpcMapDeclarationFile,

package/bin/pikku-rpc.ts

@@ -1,73 +1,16 @@
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  writeFileInDir,
-} from '../src/utils/utils.js'
-
-export const serializeRPCImports = (
-  outputPath: string,
-  functionsMap: Map<string, { path: string; exportedName: string }>,
-  packageMappings: Record<string, string> = {}
-) => {
-  const serializedImports: string[] = [
-    `/* Import and register RPCs */`,
-    `import { addFunction } from '@pikku/core'`,
-  ]
-
-  const serializedRegistrations: string[] = []
-
-  // Sort by function name for consistent output
-  const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) =>
-    a[0].localeCompare(b[0])
-  )
-
-  for (const [name, { path, exportedName }] of sortedEntries) {
-    const filePath = getFileImportRelativePath(
-      outputPath,
-      path,
-      packageMappings
-    )
-
-    // For directly exported functions, we can just import and register them
-    if (name === exportedName) {
-      serializedImports.push(`import { ${exportedName} } from '${filePath}'`)
-      serializedRegistrations.push(
-        `addFunction('${name}', { func: ${exportedName} })`
-      )
-    }
-    // For renamed functions, we need to import and alias them
-    else {
-      serializedImports.push(
-        `import { ${exportedName} as ${name} } from '${filePath}'`
-      )
-      serializedRegistrations.push(`addFunction('${name}', ${name})`)
-    }
-  }
-
-  // Add a blank line between imports and registrations
-  if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
-    serializedImports.push('')
-  }
-
-  // Combine the imports and registrations
-  return [...serializedImports, ...serializedRegistrations].join('\n')
-}
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js'
 
 export const pikkuRPC = async (
-  { rpcFile, rpcMetaFile, packageMappings }: PikkuCLIConfig,
+  { rpcMetaFile }: PikkuCLIConfig,
   { rpc }: InspectorState
 ) => {
   return await logCommandInfoAndTime(
     'Finding RPCs tasks',
     'Found RPCs',
-    [rpc.files.size === 0],
+    [false],
     async () => {
-      await writeFileInDir(
-        rpcFile,
-        serializeRPCImports(rpcFile, rpc.files, packageMappings)
-      )
       await writeFileInDir(
         rpcMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`

package/dist/bin/pikku-all.js

@@ -50,7 +50,6 @@ const runAll = async (cliConfig, options) => {
     await pikkuRPC(cliConfig, visitState);
     await pikkuRPCMap(cliConfig, visitState);
     addImport(cliConfig.rpcMetaFile, 'meta');
-    addImport(cliConfig.rpcFile, 'events');
     const routes = await pikkuHTTP(cliConfig, visitState);
     if (routes) {
         await pikkuHTTPMap(cliConfig, visitState);

package/dist/bin/pikku-functions.d.ts

@@ -1,3 +1,7 @@
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
-export declare const pikkuFunctions: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
+export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
+    path: string;
+    exportedName: string;
+}>, packageMappings?: Record<string, string>) => string;
+export declare const pikkuFunctions: ({ functionsMetaFile, functionsFile, packageMappings }: PikkuCLIConfig, { functions }: InspectorState) => Promise<boolean>;

package/dist/bin/pikku-functions.js

@@ -1,8 +1,35 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js';
-export const pikkuFunctions = async (cliConfig, visitState) => {
-    return await logCommandInfoAndTime('Finding Pikku functions', 'Found Pikku functions', [true], async () => {
-        const { functionsMetaFile } = cliConfig;
-        const { functions } = visitState;
+import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../src/utils/utils.js';
+export const serializeFunctionImports = (outputPath, functionsMap, packageMappings = {}) => {
+    const serializedImports = [
+        `/* Import and register RPCs */`,
+        `import { addFunction } from '@pikku/core'`,
+    ];
+    const serializedRegistrations = [];
+    // Sort by function name for consistent output
+    const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [name, { path, exportedName }] of sortedEntries) {
+        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
+        // For directly exported functions, we can just import and register them
+        if (name === exportedName) {
+            serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
+            serializedRegistrations.push(`addFunction('${name}', { func: ${exportedName} })`);
+        }
+        // For renamed functions, we need to import and alias them
+        else {
+            serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
+            serializedRegistrations.push(`addFunction('${name}', ${name})`);
+        }
+    }
+    // Add a blank line between imports and registrations
+    if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
+        serializedImports.push('');
+    }
+    // Combine the imports and registrations
+    return [...serializedImports, ...serializedRegistrations].join('\n');
+};
+export const pikkuFunctions = async ({ functionsMetaFile, functionsFile, packageMappings }, { functions }) => {
+    return await logCommandInfoAndTime('Serializing Pikku functions', 'Serialized Pikku functions', [false], async () => {
+        await writeFileInDir(functionsFile, serializeFunctionImports(functionsFile, functions.files, packageMappings));
         await writeFileInDir(functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
     });
 };

package/dist/bin/pikku-rpc-map.js

@@ -1,7 +1,7 @@
 import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js';
 import { serializeTypedRPCMap } from '../src/serialize-typed-rpc-map.js';
 export const pikkuRPCMap = async ({ rpcMapDeclarationFile, packageMappings }, { functions, rpc }) => {
-    return await logCommandInfoAndTime('Creating RPC map', 'Created RPC map', [rpc.files.size === 0], async () => {
+    return await logCommandInfoAndTime('Creating RPC map', 'Created RPC map', [false], async () => {
         const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.meta);
         await writeFileInDir(rpcMapDeclarationFile, content);
     });

package/dist/bin/pikku-rpc.d.ts

@@ -1,7 +1,3 @@
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
-export declare const serializeRPCImports: (outputPath: string, functionsMap: Map<string, {
-    path: string;
-    exportedName: string;
-}>, packageMappings?: Record<string, string>) => string;
-export declare const pikkuRPC: ({ rpcFile, rpcMetaFile, packageMappings }: PikkuCLIConfig, { rpc }: InspectorState) => Promise<boolean>;
+export declare const pikkuRPC: ({ rpcMetaFile }: PikkuCLIConfig, { rpc }: InspectorState) => Promise<boolean>;

package/dist/bin/pikku-rpc.js

@@ -1,35 +1,6 @@
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../src/utils/utils.js';
-export const serializeRPCImports = (outputPath, functionsMap, packageMappings = {}) => {
-    const serializedImports = [
-        `/* Import and register RPCs */`,
-        `import { addFunction } from '@pikku/core'`,
-    ];
-    const serializedRegistrations = [];
-    // Sort by function name for consistent output
-    const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
-    for (const [name, { path, exportedName }] of sortedEntries) {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        // For directly exported functions, we can just import and register them
-        if (name === exportedName) {
-            serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', { func: ${exportedName} })`);
-        }
-        // For renamed functions, we need to import and alias them
-        else {
-            serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', ${name})`);
-        }
-    }
-    // Add a blank line between imports and registrations
-    if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
-        serializedImports.push('');
-    }
-    // Combine the imports and registrations
-    return [...serializedImports, ...serializedRegistrations].join('\n');
-};
-export const pikkuRPC = async ({ rpcFile, rpcMetaFile, packageMappings }, { rpc }) => {
-    return await logCommandInfoAndTime('Finding RPCs tasks', 'Found RPCs', [rpc.files.size === 0], async () => {
-        await writeFileInDir(rpcFile, serializeRPCImports(rpcFile, rpc.files, packageMappings));
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js';
+export const pikkuRPC = async ({ rpcMetaFile }, { rpc }) => {
+    return await logCommandInfoAndTime('Finding RPCs tasks', 'Found RPCs', [false], async () => {
         await writeFileInDir(rpcMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
     });
 };

package/dist/src/pikku-cli-config.d.ts

@@ -12,7 +12,6 @@ export interface PikkuCLICoreOutputFiles {
     channelsFile: string;
     channelsMetaFile: string;
     channelsMapDeclarationFile: string;
-    rpcFile: string;
     rpcMetaFile: string;
     rpcMapDeclarationFile: string;
     schedulersFile: string;

package/dist/src/pikku-cli-config.js

@@ -62,9 +62,6 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             if (!result.functionsMetaFile) {
                 result.functionsMetaFile = join(result.outDir, 'pikku-functions-meta.gen.ts');
             }
-            if (!result.rpcFile) {
-                result.rpcFile = join(result.outDir, 'pikku-rpc.gen.ts');
-            }
             if (!result.rpcMetaFile) {
                 result.rpcMetaFile = join(result.outDir, 'pikku-rpc-meta.gen.ts');
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "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.7.5",
-    "@pikku/inspector": "^0.7.4",
+    "@pikku/core": "^0.7.7",
+    "@pikku/inspector": "^0.7.6",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",

package/src/pikku-cli-config.ts

@@ -26,7 +26,6 @@ export interface PikkuCLICoreOutputFiles {
   channelsMapDeclarationFile: string
 
   // RPC
-  rpcFile: string
   rpcMetaFile: string
   rpcMapDeclarationFile: string
 
@@ -153,9 +152,6 @@ const _getPikkuCLIConfig = async (
           'pikku-functions-meta.gen.ts'
         )
       }
-      if (!result.rpcFile) {
-        result.rpcFile = join(result.outDir, 'pikku-rpc.gen.ts')
-      }
       if (!result.rpcMetaFile) {
         result.rpcMetaFile = join(result.outDir, 'pikku-rpc-meta.gen.ts')
       }