@pikku/cli 0.11.3 → 0.12.1

package/src/functions/runtimes/nextjs/pikku-command-nextjs.ts

@@ -1,131 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import { checkRequiredTypes } from '../../../utils/check-required-types.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 { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from './serialize-nextjs-backend-wrapper.js'
-import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from './serialize-nextjs-http-wrapper.js'
-
-export const pikkuNext: any = pikkuSessionlessFunc<void, void>({
-  func: async ({ logger, config, getInspectorState }) => {
-    const {
-      nextBackendFile,
-      nextHTTPFile,
-      httpMapDeclarationFile,
-      rpcMapDeclarationFile,
-      packageMappings,
-      fetchFile,
-    } = config
-
-    // If both files are undefined, clean up any existing files and return
-    if (!nextBackendFile && !nextHTTPFile) {
-      logger.info({
-        message:
-          'Skipping generating nextjs wrapper since nextjs outfile is not defined.',
-        type: 'skip',
-      })
-      return
-    }
-
-    const visitState = await getInspectorState()
-
-    if (nextHTTPFile && !fetchFile) {
-      throw new Error(
-        'fetchFile is required in pikku config in order for nextJS http wrapper to work'
-      )
-    }
-
-    if ((nextBackendFile || nextHTTPFile) && !rpcMapDeclarationFile) {
-      throw new Error(
-        'rpcMapDeclarationFile is required in pikku config in order for nextJS wrapper to work'
-      )
-    }
-
-    if (nextBackendFile) {
-      checkRequiredTypes(visitState.filesAndMethodsErrors, {
-        config: true,
-        singletonServicesFactory: true,
-        wireServicesFactory: true,
-      })
-
-      const {
-        pikkuConfigFactory,
-        singletonServicesFactory,
-        wireServicesFactory,
-      } = visitState.filesAndMethods
-
-      if (
-        !pikkuConfigFactory ||
-        !singletonServicesFactory ||
-        !wireServicesFactory
-      ) {
-        throw new Error('Required types not found')
-      }
-
-      const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`
-      const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`
-      const wireServicesImport = `import { ${wireServicesFactory.variable} as createWireServices } from '${getFileImportRelativePath(nextBackendFile, wireServicesFactory.file, packageMappings)}'`
-
-      const bootstrapPath = getFileImportRelativePath(
-        nextBackendFile,
-        config.bootstrapFile,
-        packageMappings
-      )
-
-      const routesMapDeclarationPath = getFileImportRelativePath(
-        nextBackendFile,
-        httpMapDeclarationFile,
-        packageMappings
-      )
-
-      const rpcMapDeclarationPath = getFileImportRelativePath(
-        nextBackendFile,
-        rpcMapDeclarationFile,
-        packageMappings
-      )
-
-      const content = serializeNextBackendWrapper(
-        bootstrapPath,
-        routesMapDeclarationPath,
-        rpcMapDeclarationPath,
-        pikkuConfigImport,
-        singletonServicesImport,
-        wireServicesImport
-      )
-      await writeFileInDir(logger, nextBackendFile, content)
-    }
-
-    if (nextHTTPFile && fetchFile) {
-      const routesMapDeclarationPath = getFileImportRelativePath(
-        nextHTTPFile,
-        httpMapDeclarationFile,
-        packageMappings
-      )
-
-      const rpcMapDeclarationPath = getFileImportRelativePath(
-        nextHTTPFile,
-        rpcMapDeclarationFile,
-        packageMappings
-      )
-
-      const fetchPath = getFileImportRelativePath(
-        nextHTTPFile,
-        fetchFile,
-        packageMappings
-      )
-
-      const content = serializeNextHTTPWrapper(
-        routesMapDeclarationPath,
-        rpcMapDeclarationPath,
-        fetchPath
-      )
-      await writeFileInDir(logger, nextHTTPFile, content)
-    }
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating nextjs wrapper',
-      commandEnd: 'Generated nextjs wrapper',
-    }),
-  ],
-})

package/src/functions/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts

@@ -1,282 +0,0 @@
-export const serializeNextJsBackendWrapper = (
-  bootstrapPath: string,
-  routesMapPath: string,
-  rpcMapPath: string,
-  configImport: string,
-  singleServicesFactoryImport: string,
-  wireServicesImport: string
-) => {
-  return `'server-only'
-
-/**
- * This file provides a wrapper around the PikkuNextJS class to allow for methods to be type checked against your routes.
- * It ensures type safety for route handling methods when integrating with the @pikku/core framework.
- */
-import { PikkuNextJS } from '@pikku/next'
-import { NextRequest } from 'next/server.js'
-import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
-import type { FlattenedRPCMap } from '${rpcMapPath}'
-
-type RouteContext = { params: Promise<Record<string, string | string[]>> }
-
-${configImport}
-${singleServicesFactoryImport}
-${wireServicesImport}
-
-import '${bootstrapPath}'
-
-let _pikku: PikkuNextJS | undefined
-let _removeAPIPrefix = true
-
-export const removeAPIPrefix = (enable: boolean) => {
-  _removeAPIPrefix = enable
-}
-
-/**
- * Initializes and returns an instance of PikkuNextJS with helper methods for handling route requests.
- *
- * @returns An object containing methods for making dynamic and static action requests, as well as session retrieval.
- */
-export const pikku = (_options?: any) => {
-  if (!_pikku) {
-    _pikku = new PikkuNextJS(
-      createConfig as any,
-      createSingletonServices as any,
-      createWireServices
-    )
-  }
-
-  /**
-   * Makes a dynamic action request for a specified route and method.
-   * Dynamic requests may access headers and cookies and are therefore unsuitable for precompile stages.
-   *
-   * @template Route - The route key from the HTTPWiringsMap.
-   * @template Method - The method key from the specified route.
-   * @param route - The route identifier.
-   * @param method - The HTTP method to be used for the request.
-   * @param data - The input data for the request, defaults to null.
-   * @returns A promise that resolves to the output of the route handler.
-   */
-  const dynamicActionRequest = async <
-    Route extends keyof HTTPWiringsMap,
-    Method extends keyof HTTPWiringsMap[Route]
-  >(
-    route: Route,
-    method: Method,
-    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
-  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
-    return _pikku!.actionRequest(route, method, data as any)
-  }
-
-  /**
-   * Makes a static action request for a specified route and method.
-   * Static requests do not depend on headers or cookies and are suitable for precompile stages.
-   *
-   * @template Route - The route key from the HTTPWiringsMap.
-   * @template Method - The method key from the specified route.
-   * @param route - The route identifier.
-   * @param method - The HTTP method to be used for the request.
-   * @param data - The input data for the request, defaults to null.
-   * @returns A promise that resolves to the output of the route handler.
-   */
-  const staticActionRequest = async <
-    Route extends keyof HTTPWiringsMap,
-    Method extends keyof HTTPWiringsMap[Route]
-  >(
-    route: Route,
-    method: Method,
-    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
-  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
-    return _pikku!.staticActionRequest(route, method, data as any)
-  }
-
-  /**
-   * Makes a dynamic POST request for a specified route.
-   *
-   * @template Route - The route key with the POST method.
-   * @param route - The route identifier.
-   * @param data - The input data for the POST request (required if input type is defined).
-   * @returns A promise that resolves to the output of the POST handler.
-   */
-  const dynamicPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
-    return dynamicActionRequest(route, 'POST', args[0] ?? null)
-  }
-
-  /**
-   * Makes a dynamic GET request for a specified route.
-   *
-   * @template Route - The route key with the GET method.
-   * @param route - The route identifier.
-   * @param data - The input data for the GET request (required if input type is defined).
-   * @returns A promise that resolves to the output of the GET handler.
-   */
-  const dynamicGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
-    return dynamicActionRequest(route, 'GET', args[0] ?? null)
-  }
-
-  /**
-   * Makes a dynamic PATCH request for a specified route.
-   *
-   * @template Route - The route key with the PATCH method.
-   * @param route - The route identifier.
-   * @param data - The input data for the PATCH request (required if input type is defined).
-   * @returns A promise that resolves to the output of the PATCH handler.
-   */
-  const dynamicPatch = <Route extends HTTPWiringsWithMethod<'PATCH'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'PATCH'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'PATCH'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> => {
-    return dynamicActionRequest(route, 'PATCH', args[0] ?? null)
-  }
-
-  /**
-   * Makes a dynamic DELETE request for a specified route.
-   *
-   * @template Route - The route key with the DELETE method.
-   * @param route - The route identifier.
-   * @param data - The input data for the DELETE request (required if input type is defined).
-   * @returns A promise that resolves to the output of the DELETE handler.
-   */
-  const dynamicDel = <Route extends HTTPWiringsWithMethod<'DELETE'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'DELETE'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'DELETE'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> => {
-    return dynamicActionRequest(route, 'DELETE', args[0] ?? null)
-  }
-
-  // Static Requests
-
-  /**
-   * Makes a static POST request for a specified route.
-   *
-   * @template Route - The route key with the POST method.
-   * @param route - The route identifier.
-   * @param data - The input data for the POST request (required if input type is defined).
-   * @returns A promise that resolves to the output of the POST handler.
-   */
-  const staticPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
-    return staticActionRequest(route, 'POST', args[0] ?? null)
-  }
-
-  /**
-   * Makes a static GET request for a specified route.
-   *
-   * @template Route - The route key with the GET method.
-   * @param route - The route identifier.
-   * @param data - The input data for the GET request (required if input type is defined).
-   * @returns A promise that resolves to the output of the GET handler.
-   */
-  const staticGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
-    return staticActionRequest(route, 'GET', args[0] ?? null)
-  }
-
-  // RPC Requests
-
-  /**
-   * Makes a dynamic RPC request.
-   *
-   * @template Name - The RPC function name from the FlattenedRPCMap.
-   * @param name - The RPC function identifier.
-   * @param data - The input data for the RPC request (required if input type is defined).
-   * @returns A promise that resolves to the output of the RPC handler.
-   */
-  const rpc = async <Name extends keyof FlattenedRPCMap>(
-    rpcName: Name,
-    ...args: FlattenedRPCMap[Name]['input'] extends null | undefined
-      ? [data?: FlattenedRPCMap[Name]['input']]
-      : [data: NonNullable<FlattenedRPCMap[Name]['input']>]
-  ): Promise<FlattenedRPCMap[Name]['output']> => {
-    return dynamicActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: args[0] ?? null }) as unknown as FlattenedRPCMap[Name]['output']
-  }
-
-  /**
-   * Makes a static RPC request.
-   * Note: In HTTP wrapper context, both rpc and staticRPC behave the same way.
-   *
-   * @template Name - The RPC function name from the FlattenedRPCMap.
-   * @param name - The RPC function identifier.
-   * @param data - The input data for the RPC request (required if input type is defined).
-   * @returns A promise that resolves to the output of the RPC handler.
-   */
-  const staticRPC = async <Name extends keyof FlattenedRPCMap>(
-    rpcName: Name,
-    ...args: FlattenedRPCMap[Name]['input'] extends null | undefined
-      ? [data?: FlattenedRPCMap[Name]['input']]
-      : [data: NonNullable<FlattenedRPCMap[Name]['input']>]
-  ): Promise<FlattenedRPCMap[Name]['output']> => {
-    return staticActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: args[0] ?? null }) as unknown as FlattenedRPCMap[Name]['output']
-  }
-
-  return {
-    rpc,
-    get: dynamicGet,
-    post: dynamicPost,
-    patch: dynamicPatch,
-    del: dynamicDel,
-    staticGet,
-    staticPost,
-    staticRPC,
-  }
-}
-
-/**
- * Pre-bound API request handler for Next.js App Router route handlers.
- * Use this to directly export route handlers without losing context.
- *
- * @param req - The Next.js request object.
- * @param context - Next.js route context (unused by Pikku, but required by Next.js signature).
- * @returns A promise that resolves to a Next.js Response object.
- *
- * @example
- * export const GET = pikkuAPIRequest
- * export const POST = pikkuAPIRequest
- */
-export const pikkuAPIRequest = (
-  req: NextRequest,
-  context: RouteContext
-): Promise<Response> => {
-  if (!_pikku) {
-    _pikku = new PikkuNextJS(
-      createConfig as any,
-      createSingletonServices as any,
-      createWireServices
-    )
-  }
-  if (_removeAPIPrefix) {
-    const url = new URL(req.url)
-    url.pathname = url.pathname.replace(/^\\/api/, '') || '/'
-    req = new NextRequest(url.toString(), {
-      method: req.method,
-      headers: req.headers,
-      body: req.body,
-      duplex: 'half',
-    } as any)
-  }
-  return _pikku.apiRequest(req)
-}
-`
-}

package/src/functions/runtimes/nextjs/serialize-nextjs-http-wrapper.ts

@@ -1,215 +0,0 @@
-export const serializeNextJsHTTPWrapper = (
-  routesMapPath: string,
-  rpcMapPath: string,
-  pikkuFetchImport: string
-) => {
-  return `'server-only'
-  
-/**
- * This file provides a wrapper around the PikkuNextJS class to allow for methods to be type checked against your routes.
- * It ensures type safety for route handling methods when integrating with the @pikku/core framework.
- */
-import { CorePikkuFetchOptions } from '@pikku/fetch'
-import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
-import type { FlattenedRPCMap } from '${rpcMapPath}'
-import { PikkuFetch } from '${pikkuFetchImport}'
-
-let _pikku: PikkuFetch | undefined
-
-/**
- * Initializes and returns an instance of PikkuNextJS with helper methods for handling route requests.
- *
- * @returns An object containing methods for making dynamic and static action requests, as well as session retrieval.
- */
-export const pikku = (options?: CorePikkuFetchOptions) => {
-  if (!_pikku) {
-    _pikku = new PikkuFetch(options)
-  }
-
-  const dynamicActionRequest = async <
-    Route extends keyof HTTPWiringsMap,
-    Method extends keyof HTTPWiringsMap[Route]
-  >(
-    route: Route,
-    method: Method,
-    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
-  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
-    return (_pikku! as any)[(method as string).toLowerCase()](route, data as any)
-  }
-
-  /**
-   * Makes a static action request for a specified route and method.
-   * Static requests do not depend on headers or cookies and are suitable for precompile stages.
-   *
-   * @template Route - The route key from the HTTPWiringsMap.
-   * @template Method - The method key from the specified route.
-   * @param route - The route identifier.
-   * @param method - The HTTP method to be used for the request.
-   * @param data - The input data for the request, defaults to null.
-   * @returns A promise that resolves to the output of the route handler.
-   */
-  const staticActionRequest = async <
-    Route extends keyof HTTPWiringsMap,
-    Method extends keyof HTTPWiringsMap[Route]
-  >(
-    route: Route,
-    method: Method,
-    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
-  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
-    return (_pikku! as any)[(method as string).toLowerCase()](route, data as any)
-  }
-
-  /**
-   * Makes a dynamic POST request for a specified route.
-   *
-   * @template Route - The route key with the POST method.
-   * @param route - The route identifier.
-   * @param data - The input data for the POST request (required if input type is defined).
-   * @returns A promise that resolves to the output of the POST handler.
-   */
-  const dynamicPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
-    return dynamicActionRequest(route, 'POST', args[0] ?? null)
-  }
-
-  /**
-   * Makes a dynamic GET request for a specified route.
-   *
-   * @template Route - The route key with the GET method.
-   * @param route - The route identifier.
-   * @param data - The input data for the GET request (required if input type is defined).
-   * @returns A promise that resolves to the output of the GET handler.
-   */
-  const dynamicGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
-    return dynamicActionRequest(route, 'GET', args[0] ?? null)
-  }
-
-  /**
-   * Makes a dynamic PATCH request for a specified route.
-   *
-   * @template Route - The route key with the PATCH method.
-   * @param route - The route identifier.
-   * @param data - The input data for the PATCH request (required if input type is defined).
-   * @returns A promise that resolves to the output of the PATCH handler.
-   */
-  const dynamicPatch = <Route extends HTTPWiringsWithMethod<'PATCH'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'PATCH'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'PATCH'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> => {
-    return dynamicActionRequest(route, 'PATCH', args[0] ?? null)
-  }
-
-  /**
-   * Makes a dynamic DELETE request for a specified route.
-   *
-   * @template Route - The route key with the DELETE method.
-   * @param route - The route identifier.
-   * @param data - The input data for the DELETE request (required if input type is defined).
-   * @returns A promise that resolves to the output of the DELETE handler.
-   */
-  const dynamicDel = <Route extends HTTPWiringsWithMethod<'DELETE'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'DELETE'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'DELETE'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> => {
-    return dynamicActionRequest(route, 'DELETE', args[0] ?? null)
-  }
-
-  // Static Requests
-
-  /**
-   * Makes a static POST request for a specified route.
-   *
-   * @template Route - The route key with the POST method.
-   * @param route - The route identifier.
-   * @param data - The input data for the POST request (required if input type is defined).
-   * @returns A promise that resolves to the output of the POST handler.
-   */
-  const staticPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
-    return staticActionRequest(route, 'POST', args[0] ?? null)
-  }
-
-  /**
-   * Makes a static GET request for a specified route.
-   *
-   * @template Route - The route key with the GET method.
-   * @param route - The route identifier.
-   * @param data - The input data for the GET request (required if input type is defined).
-   * @returns A promise that resolves to the output of the GET handler.
-   */
-  const staticGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
-    route: Route,
-    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
-      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
-      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
-  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
-    return staticActionRequest(route, 'GET', args[0] ?? null)
-  }
-
-  // RPC Requests
-
-  /**
-   * Makes a dynamic RPC request.
-   *
-   * @template Name - The RPC function name from the FlattenedRPCMap.
-   * @param name - The RPC function identifier.
-   * @param data - The input data for the RPC request (required if input type is defined).
-   * @returns A promise that resolves to the output of the RPC handler.
-   */
-  const rpc = async <Name extends keyof FlattenedRPCMap>(
-    rpcName: Name,
-    ...args: FlattenedRPCMap[Name]['input'] extends null | undefined
-      ? [data?: FlattenedRPCMap[Name]['input']]
-      : [data: NonNullable<FlattenedRPCMap[Name]['input']>]
-  ): Promise<FlattenedRPCMap[Name]['output']> => {
-    return dynamicActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: args[0] ?? null }) as unknown as FlattenedRPCMap[Name]['output']
-  }
-
-  /**
-   * Makes a static RPC request.
-   * Note: In HTTP wrapper context, both rpc and rpcStatic behave the same way.
-   *
-   * @template Name - The RPC function name from the FlattenedRPCMap.
-   * @param name - The RPC function identifier.
-   * @param data - The input data for the RPC request (required if input type is defined).
-   * @returns A promise that resolves to the output of the RPC handler.
-   */
-  const staticRPC = async <Name extends keyof FlattenedRPCMap>(
-    rpcName: Name,
-    ...args: FlattenedRPCMap[Name]['input'] extends null | undefined
-      ? [data?: FlattenedRPCMap[Name]['input']]
-      : [data: NonNullable<FlattenedRPCMap[Name]['input']>]
-  ): Promise<FlattenedRPCMap[Name]['output']> => {
-    return staticActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: args[0] ?? null }) as unknown as FlattenedRPCMap[Name]['output']
-  }
-
-  return {
-    rpc,
-    get: dynamicGet,
-    post: dynamicPost,
-    patch: dynamicPatch,
-    del: dynamicDel,
-    staticGet,
-    staticPost,
-    staticRPC
-  }
-}
-`
-}

package/src/functions/wirings/channels/pikku-channels.ts

@@ -1,59 +0,0 @@
-import { pikkuVoidFunc } 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 { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-export const pikkuChannels: any = pikkuVoidFunc({
-  func: async ({ logger, config, getInspectorState }) => {
-    const visitState = await getInspectorState()
-    const {
-      channelsWiringFile,
-      channelsWiringMetaFile,
-      channelsWiringMetaJsonFile,
-      packageMappings,
-      schema,
-    } = config
-    const { channels } = visitState
-
-    await writeFileInDir(
-      logger,
-      channelsWiringFile,
-      serializeFileImports(
-        'addChannel',
-        channelsWiringFile,
-        channels.files,
-        packageMappings
-      )
-    )
-
-    await writeFileInDir(
-      logger,
-      channelsWiringMetaJsonFile,
-      JSON.stringify(channels.meta, null, 2)
-    )
-
-    const jsonImportPath = getFileImportRelativePath(
-      channelsWiringMetaFile,
-      channelsWiringMetaJsonFile,
-      packageMappings
-    )
-
-    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
-    const importStatement = supportsImportAttributes
-      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-      : `import metaData from '${jsonImportPath}'`
-
-    await writeFileInDir(
-      logger,
-      channelsWiringMetaFile,
-      `import { pikkuState } from '@pikku/core'\nimport { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)`
-    )
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Finding Channels',
-      commandEnd: 'Found channels',
-    }),
-  ],
-})