@pikku/cli 0.9.6 → 0.9.8

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @pikku/cli
 
+## 0.9.8
+
+### Patch Changes
+
+- ea89575: feat: adding the ability for custom schema validation / retrieving schemas to use (for example with openapi json_response)
+- Updated dependencies [ea89575]
+  - @pikku/core@0.9.8
+
+## 0.9.7
+
+### Patch Changes
+
+- 4fd5e19: fix: removing rpcMeta and duplicate imports
+- d1babed: fix: pikkuVoidFunc should use a sessionless function -- Since its used mostly by scheduled tasks
+
 ## 0.9.6
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -115,7 +115,6 @@ const runAll = async (
   await pikkuRPCInternalMap(logger, cliConfig, visitState)
   await pikkuRPCExposedMap(logger, cliConfig, visitState)
   await pikkuRPCClient(logger, cliConfig)
-  allImports.push(cliConfig.rpcWiringMetaFile)
 
   const schemas = await pikkuSchemas(logger, cliConfig, visitState)
   if (schemas) {
@@ -127,7 +126,7 @@ const runAll = async (
     logger,
     cliConfig,
     cliConfig.bootstrapFiles.rpc,
-    [cliConfig.rpcWiringMetaFile],
+    [],
     schemas
   )
 

package/cli.schema.json

@@ -269,10 +269,13 @@
         "rootDir": {
           "type": "string"
         },
-        "rpcMapDeclarationFile": {
+        "rpcInternalMapDeclarationFile": {
           "type": "string"
         },
-        "rpcWiringMetaFile": {
+        "rpcInternalWiringMetaFile": {
+          "type": "string"
+        },
+        "rpcMapDeclarationFile": {
           "type": "string"
         },
         "rpcWiringsFile": {
@@ -287,6 +290,12 @@
         "schemaDirectory": {
           "type": "string"
         },
+        "schemasFromTypes": {
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
         "servicesFile": {
           "type": "string"
         },
@@ -330,8 +339,9 @@
         "queueWorkersWiringFile",
         "queueWorkersWiringMetaFile",
         "rootDir",
+        "rpcInternalMapDeclarationFile",
+        "rpcInternalWiringMetaFile",
         "rpcMapDeclarationFile",
-        "rpcWiringMetaFile",
         "schedulersWiringFile",
         "schedulersWiringMetaFile",
         "schemaDirectory",

package/dist/bin/pikku-all.js

@@ -67,13 +67,12 @@ const runAll = async (logger, cliConfig, options) => {
     await pikkuRPCInternalMap(logger, cliConfig, visitState);
     await pikkuRPCExposedMap(logger, cliConfig, visitState);
     await pikkuRPCClient(logger, cliConfig);
-    allImports.push(cliConfig.rpcWiringMetaFile);
     const schemas = await pikkuSchemas(logger, cliConfig, visitState);
     if (schemas) {
         allImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`);
     }
     // RPC bootstrap is always generated since RPC is always present
-    await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.rpc, [cliConfig.rpcWiringMetaFile], schemas);
+    await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.rpc, [], schemas);
     const http = await pikkuHTTP(logger, cliConfig, visitState);
     if (http) {
         await pikkuHTTPMap(logger, cliConfig, visitState);

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

@@ -16,7 +16,6 @@ export interface PikkuCLICoreOutputFiles {
     channelsMapDeclarationFile: string;
     rpcInternalWiringMetaFile: string;
     rpcInternalMapDeclarationFile: string;
-    rpcWiringMetaFile: string;
     rpcMapDeclarationFile: string;
     schedulersWiringFile: string;
     schedulersWiringMetaFile: string;
@@ -50,6 +49,7 @@ export type PikkuCLIConfig = {
         additionalInfo: OpenAPISpecInfo;
     };
     middlewareServices?: string[];
+    schemasFromTypes?: string[];
     filters: InspectorFilters;
 } & PikkuCLICoreOutputFiles;
 export declare const getPikkuCLIConfig: (configFile: string | undefined, requiredFields: Array<keyof PikkuCLIConfig>, filters?: InspectorFilters, exitProcess?: boolean) => Promise<PikkuCLIConfig>;

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

@@ -111,9 +111,6 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, filter
                 result.rpcInternalMapDeclarationFile = join(internalRPCDirectory, 'pikku-rpc-wirings-map.internal.gen.d.ts');
             }
             // External
-            if (!result.rpcWiringMetaFile) {
-                result.rpcWiringMetaFile = join(externalRPCDirectory, 'pikku-rpc-wirings-meta.gen.ts');
-            }
             if (!result.rpcMapDeclarationFile) {
                 result.rpcMapDeclarationFile = join(externalRPCDirectory, 'pikku-rpc-wirings-map.gen.d.ts');
             }

package/dist/src/pikku-command-schemas.js

@@ -1,8 +1,8 @@
 import { generateSchemas, saveSchemas } from './schema-generator.js';
 import { logCommandInfoAndTime } from './utils.js';
-export const pikkuSchemas = async (logger, { tsconfig, schemaDirectory, supportsImportAttributes }, { functions, http }) => {
+export const pikkuSchemas = async (logger, { tsconfig, schemaDirectory, supportsImportAttributes, schemasFromTypes }, { functions, http }) => {
     return await logCommandInfoAndTime(logger, 'Creating schemas', 'Created schemas', [false], async () => {
-        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta);
-        await saveSchemas(logger, schemaDirectory, schemas, functions.typesMap, functions.meta, supportsImportAttributes);
+        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes);
+        await saveSchemas(logger, schemaDirectory, schemas, functions.typesMap, functions.meta, supportsImportAttributes, schemasFromTypes);
     });
 };

package/dist/src/schema-generator.d.ts

@@ -2,5 +2,5 @@ import { CLILogger } from './utils.js';
 import { FunctionsMeta, JSONValue } from '@pikku/core';
 import { HTTPWiringsMeta } from '@pikku/core/http';
 import { TypesMap } from '@pikku/inspector';
-export declare function generateSchemas(logger: CLILogger, tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpWiringsMeta: HTTPWiringsMeta): Promise<Record<string, JSONValue>>;
-export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean): Promise<void>;
+export declare function generateSchemas(logger: CLILogger, tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpWiringsMeta: HTTPWiringsMeta, additionalTypes?: string[]): Promise<Record<string, JSONValue>>;
+export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean, additionalTypes?: string[]): Promise<void>;

package/dist/src/schema-generator.js

@@ -1,7 +1,7 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator';
 import { writeFileInDir } from './utils.js';
 import { mkdir, writeFile } from 'fs/promises';
-export async function generateSchemas(logger, tsconfig, typesMap, functionMeta, httpWiringsMeta) {
+export async function generateSchemas(logger, tsconfig, typesMap, functionMeta, httpWiringsMeta, additionalTypes) {
     const schemasSet = new Set(typesMap.customTypes.keys());
     for (const { inputs, outputs } of Object.values(functionMeta)) {
         const types = [...(inputs || []), ...(outputs || [])];
@@ -25,6 +25,12 @@ export async function generateSchemas(logger, tsconfig, typesMap, functionMeta,
             }
         }
     }
+    // Add additional types from schemasFromTypes config
+    if (additionalTypes) {
+        for (const type of additionalTypes) {
+            schemasSet.add(type);
+        }
+    }
     const generator = createGenerator({
         tsconfig,
         skipTypeCheck: true,
@@ -53,7 +59,7 @@ export async function generateSchemas(logger, tsconfig, typesMap, functionMeta,
     });
     return schemas;
 }
-export async function saveSchemas(logger, schemaParentDir, schemas, typesMap, functionsMeta, supportsImportAttributes) {
+export async function saveSchemas(logger, schemaParentDir, schemas, typesMap, functionsMeta, supportsImportAttributes, additionalTypes) {
     await writeFileInDir(logger, `${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
     const desiredSchemas = new Set([
         ...Object.values(functionsMeta)
@@ -65,6 +71,7 @@ export async function saveSchemas(logger, schemaParentDir, schemas, typesMap, fu
             .filter((s) => !!s &&
             !['boolean', 'string', 'number', 'null', 'undefined'].includes(s)),
         ...typesMap.customTypes.keys(),
+        ...(additionalTypes || []),
     ]);
     if (desiredSchemas.size === 0) {
         logger.info(`• Skipping schemas since none found.\x1b[0m`);
@@ -76,7 +83,9 @@ export async function saveSchemas(logger, schemaParentDir, schemas, typesMap, fu
             await writeFile(`${schemaParentDir}/schemas/${schemaName}.schema.json`, JSON.stringify(schema), 'utf-8');
         }
     }));
-    const schemaImports = Array.from(desiredSchemas)
+    // Only include schemas that were successfully generated
+    const availableSchemas = Array.from(desiredSchemas).filter((schema) => schemas[schema]);
+    const schemaImports = availableSchemas
         .map((schema) => `
 import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
 addSchema('${schema}', ${schema})

package/dist/src/schemas.js

@@ -1,8 +1,8 @@
 import { saveSchemas, generateSchemas } from './schema-generator.js';
 import { logCommandInfoAndTime } from './utils.js';
-export const pikkuSchemas = async (logger, { tsconfig, schemaDirectory, supportsImportAttributes }, { functions, http }) => {
+export const pikkuSchemas = async (logger, { tsconfig, schemaDirectory, supportsImportAttributes, schemasFromTypes }, { functions, http }) => {
     return await logCommandInfoAndTime(logger, 'Creating schemas', 'Created schemas', [false], async () => {
-        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta);
-        await saveSchemas(logger, schemaDirectory, schemas, functions.typesMap, functions.meta, supportsImportAttributes);
+        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes);
+        await saveSchemas(logger, schemaDirectory, schemas, functions.typesMap, functions.meta, supportsImportAttributes, schemasFromTypes);
     });
 };

package/dist/src/serialize-import-map.js

@@ -72,11 +72,11 @@ export const serializeImportMap = (relativeToPath, packageMappings, typesMap, re
         if (uniqueName === '__object') {
             return;
         }
-        if (originalName === uniqueName) {
-            variables.push(originalName);
-        }
-        else {
-            variables.push(`${originalName} as ${uniqueName}`);
+        const importName = originalName === uniqueName
+            ? originalName
+            : `${originalName} as ${uniqueName}`;
+        if (!variables.includes(importName)) {
+            variables.push(importName);
         }
         paths.set(path, variables);
     });

package/dist/src/serialize-pikku-types.js

@@ -340,7 +340,7 @@ export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unkn
 export const pikkuVoidFunc = (
   func:
     | PikkuFunctionSessionless<void, void>
-    | CorePikkuFunctionConfig<PikkuFunction<void, void>, PikkuPermission<void>>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void>, PikkuPermission<void>>
 ) => {
   return typeof func === 'function' ? func : func.func
 }

package/dist/src/wirings/http/pikku-command-openapi.js

@@ -2,12 +2,12 @@ import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
 import { generateSchemas } from '../../schema-generator.js';
 import { generateOpenAPISpec } from './openapi-spec-generator.js';
 import { stringify } from 'yaml';
-export const pikkuOpenAPI = async (logger, { tsconfig, openAPI }, { http, functions }) => {
+export const pikkuOpenAPI = async (logger, { tsconfig, openAPI, schemasFromTypes }, { http, functions }) => {
     return await logCommandInfoAndTime(logger, 'Creating OpenAPI spec', 'Created OpenAPI spec', [openAPI?.outputFile === undefined, 'openAPI outfile is not defined'], async () => {
         if (!openAPI?.outputFile) {
             throw new Error('openAPI is required');
         }
-        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta);
+        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes);
         const openAPISpec = await generateOpenAPISpec(functions.meta, http.meta, schemas, openAPI.additionalInfo);
         if (openAPI.outputFile.endsWith('.json')) {
             await writeFileInDir(logger, openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), { ignoreModifyComment: true });

package/dist/src/wirings/rpc/pikku-command-rpc-client.js

@@ -1,6 +1,6 @@
 import { serializeRPCWrapper } from './serialize-rpc-wrapper.js';
 import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const pikkuRPCClient = async (logger, { rpcWiringsFile, rpcMapDeclarationFile, rpcInternalMapDeclarationFile, packageMappings, }) => {
+export const pikkuRPCClient = async (logger, { rpcWiringsFile, rpcMapDeclarationFile, packageMappings }) => {
     return await logCommandInfoAndTime(logger, 'Generating RPC wrappers', 'Generated RPC wrappers', [
         rpcWiringsFile === undefined || rpcWiringsFile === null,
         "rpcWiringsFile isn't set in the pikku config",

package/dist/src/wirings/rpc/pikku-command-rpc.js

@@ -1,11 +1,8 @@
 import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-export const pikkuRPC = async (logger, { rpcInternalWiringMetaFile, rpcWiringMetaFile }, { rpc }) => {
+export const pikkuRPC = async (logger, { rpcInternalWiringMetaFile }, { rpc }) => {
     return await logCommandInfoAndTime(logger, 'Finding RPCs tasks', 'Found RPCs', [false], async () => {
         if (rpc.internalFiles.size > 0) {
             await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`);
         }
-        if (rpc.exposedFiles.size > 0) {
-            await writeFileInDir(logger, rpcWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.exposedFiles, null, 2)})`);
-        }
     });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,7 +22,7 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.0.2",
-    "@pikku/core": "^0.9.6",
+    "@pikku/core": "^0.9.8",
     "@pikku/inspector": "^0.9.4",
     "@types/cookie": "^1.0.0",
     "@types/uuid": "^10.0.0",

package/run-tests.sh

@@ -46,7 +46,7 @@ if [ "$watch_mode" = true ]; then
 fi
 
 if [ "$coverage_mode" = true ]; then
-  node_cmd="$node_cmd --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
+  node_cmd="$node_cmd --test-coverage-include=\"src/**/*.{ts,js}\" --test-coverage-exclude=\"**/dist/**\" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
 fi
 
 # Execute the node command with the expanded list of files

package/src/pikku-cli-config.ts

@@ -32,7 +32,6 @@ export interface PikkuCLICoreOutputFiles {
   rpcInternalMapDeclarationFile: string
 
   // RPC Exposed
-  rpcWiringMetaFile: string
   rpcMapDeclarationFile: string
 
   // Schedulers
@@ -84,6 +83,8 @@ export type PikkuCLIConfig = {
 
   middlewareServices?: string[]
 
+  schemasFromTypes?: string[]
+
   filters: InspectorFilters
 } & PikkuCLICoreOutputFiles
 
@@ -253,12 +254,6 @@ const _getPikkuCLIConfig = async (
       }
 
       // External
-      if (!result.rpcWiringMetaFile) {
-        result.rpcWiringMetaFile = join(
-          externalRPCDirectory,
-          'pikku-rpc-wirings-meta.gen.ts'
-        )
-      }
       if (!result.rpcMapDeclarationFile) {
         result.rpcMapDeclarationFile = join(
           externalRPCDirectory,

package/src/pikku-command-schemas.ts

@@ -4,7 +4,7 @@ import { PikkuCommand } from './types.js'
 
 export const pikkuSchemas: PikkuCommand = async (
   logger,
-  { tsconfig, schemaDirectory, supportsImportAttributes },
+  { tsconfig, schemaDirectory, supportsImportAttributes, schemasFromTypes },
   { functions, http }
 ) => {
   return await logCommandInfoAndTime(
@@ -18,7 +18,8 @@ export const pikkuSchemas: PikkuCommand = async (
         tsconfig,
         functions.typesMap,
         functions.meta,
-        http.meta
+        http.meta,
+        schemasFromTypes
       )
       await saveSchemas(
         logger,
@@ -26,7 +27,8 @@ export const pikkuSchemas: PikkuCommand = async (
         schemas,
         functions.typesMap,
         functions.meta,
-        supportsImportAttributes
+        supportsImportAttributes,
+        schemasFromTypes
       )
     }
   )

package/src/schema-generator.ts

@@ -10,7 +10,8 @@ export async function generateSchemas(
   tsconfig: string,
   typesMap: TypesMap,
   functionMeta: FunctionsMeta,
-  httpWiringsMeta: HTTPWiringsMeta
+  httpWiringsMeta: HTTPWiringsMeta,
+  additionalTypes?: string[]
 ): Promise<Record<string, JSONValue>> {
   const schemasSet = new Set(typesMap.customTypes.keys())
   for (const { inputs, outputs } of Object.values(functionMeta)) {
@@ -37,6 +38,13 @@ export async function generateSchemas(
     }
   }
 
+  // Add additional types from schemasFromTypes config
+  if (additionalTypes) {
+    for (const type of additionalTypes) {
+      schemasSet.add(type)
+    }
+  }
+
   const generator = createGenerator({
     tsconfig,
     skipTypeCheck: true,
@@ -72,7 +80,8 @@ export async function saveSchemas(
   schemas: Record<string, JSONValue>,
   typesMap: TypesMap,
   functionsMeta: FunctionsMeta,
-  supportsImportAttributes: boolean
+  supportsImportAttributes: boolean,
+  additionalTypes?: string[]
 ) {
   await writeFileInDir(
     logger,
@@ -80,7 +89,7 @@ export async function saveSchemas(
     'export const empty = null;'
   )
 
-  const desiredSchemas = new Set([
+  const desiredSchemas = new Set<string>([
     ...Object.values(functionsMeta)
       .map(({ inputs, outputs }) => [
         inputs?.[0] ? typesMap.getUniqueName(inputs[0]) : undefined,
@@ -88,11 +97,12 @@ export async function saveSchemas(
       ])
       .flat()
       .filter(
-        (s) =>
+        (s): s is string =>
           !!s &&
           !['boolean', 'string', 'number', 'null', 'undefined'].includes(s)
       ),
     ...typesMap.customTypes.keys(),
+    ...(additionalTypes || []),
   ])
 
   if (desiredSchemas.size === 0) {
@@ -113,7 +123,12 @@ export async function saveSchemas(
     })
   )
 
-  const schemaImports = Array.from(desiredSchemas)
+  // Only include schemas that were successfully generated
+  const availableSchemas = Array.from(desiredSchemas).filter(
+    (schema) => schemas[schema]
+  )
+
+  const schemaImports = availableSchemas
     .map(
       (schema) => `
 import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}

package/src/schemas.ts

@@ -4,7 +4,7 @@ import { PikkuCommand } from './types.js'
 
 export const pikkuSchemas: PikkuCommand = async (
   logger,
-  { tsconfig, schemaDirectory, supportsImportAttributes },
+  { tsconfig, schemaDirectory, supportsImportAttributes, schemasFromTypes },
   { functions, http }
 ) => {
   return await logCommandInfoAndTime(
@@ -18,7 +18,8 @@ export const pikkuSchemas: PikkuCommand = async (
         tsconfig,
         functions.typesMap,
         functions.meta,
-        http.meta
+        http.meta,
+        schemasFromTypes
       )
       await saveSchemas(
         logger,
@@ -26,7 +27,8 @@ export const pikkuSchemas: PikkuCommand = async (
         schemas,
         functions.typesMap,
         functions.meta,
-        supportsImportAttributes
+        supportsImportAttributes,
+        schemasFromTypes
       )
     }
   )

package/src/serialize-import-map.ts

@@ -86,10 +86,12 @@ export const serializeImportMap = (
       return
     }
 
-    if (originalName === uniqueName) {
-      variables.push(originalName)
-    } else {
-      variables.push(`${originalName} as ${uniqueName}`)
+    const importName =
+      originalName === uniqueName
+        ? originalName
+        : `${originalName} as ${uniqueName}`
+    if (!variables.includes(importName)) {
+      variables.push(importName)
     }
     paths.set(path, variables)
   })

package/src/serialize-pikku-types.ts

@@ -348,7 +348,7 @@ export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unkn
 export const pikkuVoidFunc = (
   func:
     | PikkuFunctionSessionless<void, void>
-    | CorePikkuFunctionConfig<PikkuFunction<void, void>, PikkuPermission<void>>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void>, PikkuPermission<void>>
 ) => {
   return typeof func === 'function' ? func : func.func
 }

package/src/wirings/http/pikku-command-openapi.ts

@@ -6,7 +6,7 @@ import { PikkuCommand } from '../../types.js'
 
 export const pikkuOpenAPI: PikkuCommand = async (
   logger,
-  { tsconfig, openAPI },
+  { tsconfig, openAPI, schemasFromTypes },
   { http, functions }
 ) => {
   return await logCommandInfoAndTime(
@@ -23,7 +23,8 @@ export const pikkuOpenAPI: PikkuCommand = async (
         tsconfig,
         functions.typesMap,
         functions.meta,
-        http.meta
+        http.meta,
+        schemasFromTypes
       )
       const openAPISpec = await generateOpenAPISpec(
         functions.meta,

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

@@ -8,12 +8,7 @@ import { PikkuCommandWithoutState } from '../../types.js'
 
 export const pikkuRPCClient: PikkuCommandWithoutState = async (
   logger,
-  {
-    rpcWiringsFile,
-    rpcMapDeclarationFile,
-    rpcInternalMapDeclarationFile,
-    packageMappings,
-  }
+  { rpcWiringsFile, rpcMapDeclarationFile, packageMappings }
 ) => {
   return await logCommandInfoAndTime(
     logger,

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

@@ -3,7 +3,7 @@ import { PikkuCommand } from '../../types.js'
 
 export const pikkuRPC: PikkuCommand = async (
   logger,
-  { rpcInternalWiringMetaFile, rpcWiringMetaFile },
+  { rpcInternalWiringMetaFile },
   { rpc }
 ) => {
   return await logCommandInfoAndTime(
@@ -19,14 +19,6 @@ export const pikkuRPC: PikkuCommand = async (
           `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`
         )
       }
-
-      if (rpc.exposedFiles.size > 0) {
-        await writeFileInDir(
-          logger,
-          rpcWiringMetaFile,
-          `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.exposedFiles, null, 2)})`
-        )
-      }
     }
   )
 }