@pikku/cli 0.8.2 → 0.9.0

package/src/{events → wirings}/http/pikku-http-routes.ts

@@ -18,21 +18,21 @@ export const pikkuHTTP: PikkuCommand = async (
     'Found HTTP routes',
     [visitState.http.files.size === 0],
     async () => {
-      const { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig
+      const { httpWiringsFile, httpWiringMetaFile, packageMappings } = cliConfig
       const { http } = visitState
       await writeFileInDir(
         logger,
-        httpRoutesFile,
+        httpWiringsFile,
         serializeFileImports(
-          'addHTTPRoute',
-          httpRoutesFile,
+          'wireHTTP',
+          httpWiringsFile,
           http.files,
           packageMappings
         )
       )
       await writeFileInDir(
         logger,
-        httpRoutesMetaFile,
+        httpWiringMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
       )
     }

package/src/wirings/http/serialize-fetch-wrapper.ts

@@ -0,0 +1,67 @@
+export const serializeFetchWrapper = (routesMapPath: string) => {
+  return `
+import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
+import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
+
+export class PikkuFetch extends CorePikkuFetch {
+    public async post<Route extends HTTPWiringsWithMethod<'POST'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'POST'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'POST'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'POST'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'POST', data, options);
+    }
+
+    public async get<Route extends HTTPWiringsWithMethod<'GET'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'GET'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'GET'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'GET'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'GET', data, options);
+    }
+
+    public async patch<Route extends HTTPWiringsWithMethod<'PATCH'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'PATCH'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'PATCH'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'PATCH'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'PATCH', data, options);
+    }
+
+    public async head<Route extends HTTPWiringsWithMethod<'HEAD'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'HEAD'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'HEAD'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'HEAD'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'HEAD'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'HEAD', data, options);
+    }
+
+    public async delete<Route extends HTTPWiringsWithMethod<'DELETE'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'DELETE'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'DELETE'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'DELETE'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'DELETE', data, options);
+    }
+
+    public async fetch<
+        Route extends keyof HTTPWiringsMap,
+        Method extends keyof HTTPWiringsMap[Route]
+    >(route: Route, method: Method, data: HTTPWiringHandlerOf<Route, Method>['input'], options?: Omit<RequestInit, 'body'>): Promise<Response> {
+        return await super.fetch(route, method as HTTPMethod, data, options);
+    }
+}
+
+export const pikkuFetch = new PikkuFetch();
+`
+}

package/src/{events → wirings}/http/serialize-typed-http-map.ts

@@ -1,22 +1,22 @@
-import { HTTPRoutesMeta } from '@pikku/core/http'
+import { HTTPWiringsMeta } 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 = (
+export const serializeTypedHTTPWiringsMap = (
   relativeToPath: string,
   packageMappings: Record<string, string>,
   typesMap: TypesMap,
   functionsMeta: FunctionsMeta,
-  routesMeta: HTTPRoutesMeta,
+  wiringsMeta: HTTPWiringsMeta,
   metaTypes: MetaInputTypes
 ) => {
   const requiredTypes = new Set<string>()
   const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
   const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap)
-  const serializedRoutes = generateRoutes(
-    routesMeta,
+  const serializedHTTPWirings = generateHTTPWirings(
+    wiringsMeta,
     functionsMeta,
     typesMap,
     requiredTypes
@@ -37,26 +37,26 @@ ${serializedImportMap}
 ${serializedCustomTypes}
 ${serializedMetaTypes}
 
-interface RouteHandler<I, O> {
+interface HTTPWiringHandler<I, O> {
     input: I;
     output: O;
 }
 
-${serializedRoutes}
+${serializedHTTPWirings}
 
-export type RouteHandlerOf<Route extends keyof RoutesMap, Method extends keyof RoutesMap[Route]> =
-    RoutesMap[Route][Method] extends { input: infer I; output: infer O }
-        ? RouteHandler<I, O>
+export type HTTPWiringHandlerOf<HTTPWiring extends keyof HTTPWiringsMap, Method extends keyof HTTPWiringsMap[HTTPWiring]> =
+    HTTPWiringsMap[HTTPWiring][Method] extends { input: infer I; output: infer O }
+        ? HTTPWiringHandler<I, O>
         : never;
 
-export type RoutesWithMethod<Method extends string> = {
-  [Route in keyof RoutesMap]: Method extends keyof RoutesMap[Route] ? Route : never;
-}[keyof RoutesMap];
+export type HTTPWiringsWithMethod<Method extends string> = {
+  [HTTPWiring in keyof HTTPWiringsMap]: Method extends keyof HTTPWiringsMap[HTTPWiring] ? HTTPWiring : never;
+}[keyof HTTPWiringsMap];
   `
 }
 
-function generateRoutes(
-  routesMeta: HTTPRoutesMeta,
+function generateHTTPWirings(
+  routesMeta: HTTPWiringsMeta,
   functionsMeta: FunctionsMeta,
   typesMap: TypesMap,
   requiredTypes: Set<string>
@@ -98,12 +98,12 @@ function generateRoutes(
   }
 
   // Build the routes object as a string
-  let routesStr = 'export type RoutesMap = {\n'
+  let routesStr = 'export type HTTPWiringsMap = {\n'
 
   for (const [routePath, methods] of Object.entries(routesObj)) {
     routesStr += `  readonly '${routePath}': {\n`
     for (const [method, handler] of Object.entries(methods)) {
-      routesStr += `    readonly ${method.toUpperCase()}: RouteHandler<${handler.inputType}, ${handler.outputType}>,\n`
+      routesStr += `    readonly ${method.toUpperCase()}: HTTPWiringHandler<${handler.inputType}, ${handler.outputType}>,\n`
     }
     routesStr += '  },\n'
   }

package/src/{events → wirings}/mcp/pikku-command-mcp.ts

@@ -62,7 +62,7 @@ const generateArgumentsFromSchema = async (
 
 export const pikkuMCP: PikkuCommand = async (
   logger,
-  { mcpEndpointsFile, mcpEndpointsMetaFile, packageMappings, schemaDirectory },
+  { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory },
   { mcpEndpoints, functions }
 ) => {
   return await logCommandInfoAndTime(
@@ -73,10 +73,10 @@ export const pikkuMCP: PikkuCommand = async (
     async () => {
       await writeFileInDir(
         logger,
-        mcpEndpointsFile,
+        mcpWiringsFile,
         serializeFileImports(
-          'addMCPResource or addMCPTool',
-          mcpEndpointsFile,
+          'wireMCPResource or wireMCPTool',
+          mcpWiringsFile,
           mcpEndpoints.files,
           packageMappings
         )
@@ -99,7 +99,7 @@ export const pikkuMCP: PikkuCommand = async (
 
       await writeFileInDir(
         logger,
-        mcpEndpointsMetaFile,
+        mcpWiringsMetaFile,
         `import { pikkuState } from '@pikku/core'
 pikkuState('mcp', 'resourcesMeta', ${JSON.stringify(mcpEndpoints.resourcesMeta, null, 2)})
 pikkuState('mcp', 'toolsMeta', ${JSON.stringify(mcpEndpoints.toolsMeta, null, 2)})

package/src/{events → wirings}/queue/pikku-command-queue-service.ts

@@ -8,26 +8,29 @@ import { PikkuCommandWithoutState } from '../../types.js'
 
 export const pikkuQueueService: PikkuCommandWithoutState = async (
   logger,
-  { queueFile, queueMapDeclarationFile, packageMappings }
+  { queueWiringsFile, queueMapDeclarationFile, packageMappings }
 ) => {
   return await logCommandInfoAndTime(
     logger,
     'Generating queue service wrapper',
     'Generated queue service wrapper',
-    [queueFile === undefined, "queueFile isn't set in the pikku config"],
+    [
+      queueWiringsFile === undefined,
+      "queueWiringsFile isn't set in the pikku config",
+    ],
     async () => {
-      if (!queueFile) {
-        throw new Error("queueFile is isn't set in the pikku config")
+      if (!queueWiringsFile) {
+        throw new Error("queueWiringsFile is isn't set in the pikku config")
       }
 
       const queueMapDeclarationPath = getFileImportRelativePath(
-        queueFile,
+        queueWiringsFile,
         queueMapDeclarationFile,
         packageMappings
       )
 
       const content = [serializeQueueWrapper(queueMapDeclarationPath)]
-      await writeFileInDir(logger, queueFile, content.join('\n'))
+      await writeFileInDir(logger, queueWiringsFile, content.join('\n'))
     }
   )
 }

package/src/{events → wirings}/queue/pikku-command-queue.ts

@@ -19,20 +19,23 @@ export const pikkuQueue: PikkuCommand = async (
     'Found queue',
     [visitState.queueWorkers.files.size === 0],
     async () => {
-      const { queueWorkersFile, queueWorkersMetaFile, packageMappings } =
-        cliConfig
+      const {
+        queueWorkersWiringFile,
+        queueWorkersWiringMetaFile,
+        packageMappings,
+      } = cliConfig
       const { queueWorkers } = visitState
       await writeFileInDir(
         logger,
-        queueWorkersMetaFile,
+        queueWorkersWiringMetaFile,
         serializeQueueMeta(queueWorkers.meta)
       )
       await writeFileInDir(
         logger,
-        queueWorkersFile,
+        queueWorkersWiringFile,
         serializeFileImports(
           'addQueueWorkers',
-          queueWorkersFile,
+          queueWorkersWiringFile,
           queueWorkers.files,
           packageMappings
         )

package/src/{events → wirings}/queue/pikku-queue.ts

@@ -17,20 +17,23 @@ export const pikkuQueue: PikkuCommand = async (
     'Found queue',
     [visitState.queueWorkers.files.size === 0],
     async () => {
-      const { queueWorkersFile, queueWorkersMetaFile, packageMappings } =
-        cliConfig
+      const {
+        queueWorkersWiringFile,
+        queueWorkersWiringMetaFile,
+        packageMappings,
+      } = cliConfig
       const { queueWorkers } = visitState
       await writeFileInDir(
         logger,
-        queueWorkersMetaFile,
+        queueWorkersWiringMetaFile,
         serializeQueueMeta(queueWorkers.meta)
       )
       await writeFileInDir(
         logger,
-        queueWorkersFile,
+        queueWorkersWiringFile,
         serializeFileImports(
           'addQueueWorkers',
-          queueWorkersFile,
+          queueWorkersWiringFile,
           queueWorkers.files,
           packageMappings
         )

package/src/{events → wirings}/rpc/pikku-command-rpc-client.ts

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

package/src/{events → wirings}/rpc/pikku-command-rpc.ts

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

package/src/{events → wirings}/rpc/pikku-rpc.ts

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

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

@@ -0,0 +1,68 @@
+export const serializeRPCWrapper = (rpcMapPath: string) => {
+  return `
+import { PikkuFetch } from "./pikku-fetch.gen.js"
+import type { RPCInvoke } from '${rpcMapPath}'
+
+/**
+ * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC) 
+ * to your Pikku server. It wraps the underlying HTTP client and provides a 
+ * simple interface for invoking server-side functions.
+ */
+export class PikkuRPC {
+    /** The underlying HTTP client used for making RPC calls */
+    pikkuFetch = new PikkuFetch()
+
+    /**
+     * Sets a custom PikkuFetch instance to use for RPC calls.
+     * This allows you to configure custom settings or use a shared client instance.
+     * 
+     * @param pikkuFetch - The PikkuFetch instance to use
+     */
+    setPikkuFetch(pikkuFetch: PikkuFetch): void {
+        this.pikkuFetch = pikkuFetch
+    }
+
+    /**
+     * Sets the base server URL for all RPC calls.
+     * 
+     * @param serverUrl - The base URL of your Pikku server (e.g., 'https://api.example.com')
+     */
+    setServerUrl(serverUrl: string): void {
+        this.pikkuFetch.setServerUrl(serverUrl)
+    }
+
+    /**
+     * Sets the JWT token for authorization on all RPC calls.
+     * 
+     * @param jwt - The JWT token to use for authorization, or null to remove authorization
+     */
+    setAuthorizationJWT(jwt: string | null): void {
+        this.pikkuFetch.setAuthorizationJWT(jwt)
+    }
+
+    /**
+     * Sets the API key for authorization on all RPC calls.
+     * 
+     * @param apiKey - The API key to use for authorization, or null to remove the API key
+     */
+    setAPIKey(apiKey: string | null): void {
+        this.pikkuFetch.setAPIKey(apiKey)
+    }
+
+    /**
+     * Invokes a remote procedure call on the server.
+     * This is a generic method that routes to the appropriate server function
+     * based on the function name and passes the provided data.
+     * 
+     * @param name - The name of the server function to invoke
+     * @param data - The data to pass to the server function
+     * @returns A promise that resolves with the function's return value
+     */
+    invoke: RPCInvoke = async (name, data) => {
+       return await this.pikkuFetch.post('/rpc', { name, data })
+    }
+}
+
+export const pikkuRPC = new PikkuRPC();
+`
+}

package/src/{events → wirings}/scheduler/pikku-command-scheduler.ts

@@ -17,19 +17,23 @@ export const pikkuScheduler: PikkuCommand = async (
     'Found scheduled tasks',
     [visitState.scheduledTasks.files.size === 0],
     async () => {
-      const { schedulersFile, schedulersMetaFile, packageMappings } = cliConfig
+      const {
+        schedulersWiringFile,
+        schedulersWiringMetaFile,
+        packageMappings,
+      } = cliConfig
       const { scheduledTasks } = visitState
       await writeFileInDir(
         logger,
-        schedulersMetaFile,
+        schedulersWiringMetaFile,
         serializeSchedulerMeta(scheduledTasks.meta)
       )
       await writeFileInDir(
         logger,
-        schedulersFile,
+        schedulersWiringFile,
         serializeFileImports(
           'addScheduledTasks',
-          schedulersFile,
+          schedulersWiringFile,
           scheduledTasks.files,
           packageMappings
         )

package/src/events/http/serialize-fetch-wrapper.ts

@@ -1,67 +0,0 @@
-export const serializeFetchWrapper = (routesMapPath: string) => {
-  return `
-import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
-import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
-
-export class PikkuFetch extends CorePikkuFetch {
-    public async post<Route extends RoutesWithMethod<'POST'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'POST'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'POST'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'POST'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'POST'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'POST', data, options);
-    }
-
-    public async get<Route extends RoutesWithMethod<'GET'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'GET'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'GET'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'GET'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'GET'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'GET', data, options);
-    }
-
-    public async patch<Route extends RoutesWithMethod<'PATCH'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'PATCH'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'PATCH'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'PATCH'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'PATCH'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'PATCH', data, options);
-    }
-
-    public async head<Route extends RoutesWithMethod<'HEAD'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'HEAD'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'HEAD'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'HEAD'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'HEAD'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'HEAD', data, options);
-    }
-
-    public async delete<Route extends RoutesWithMethod<'DELETE'>>(
-        route: Route,
-        ...args: null extends RouteHandlerOf<Route, 'DELETE'>['input']
-            ? [data?: Exclude<RouteHandlerOf<Route, 'DELETE'>['input'], null>, options?: Omit<RequestInit, 'body'>]
-            : [data: RouteHandlerOf<Route, 'DELETE'>['input'], options?: Omit<RequestInit, 'body'>]
-    ): Promise<RouteHandlerOf<Route, 'DELETE'>['output']> {
-        const [data, options] = args;
-        return super.api(route, 'DELETE', data, options);
-    }
-
-    public async fetch<
-        Route extends keyof RoutesMap,
-        Method extends keyof RoutesMap[Route]
-    >(route: Route, method: Method, data: RouteHandlerOf<Route, Method>['input'], options?: Omit<RequestInit, 'body'>): Promise<Response> {
-        return await super.fetch(route, method as HTTPMethod, data, options);
-    }
-}
-
-export const pikkuFetch = new PikkuFetch();
-`
-}

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

@@ -1,29 +0,0 @@
-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();
-`
-}