@pikku/cli 0.6.11 → 0.6.13

package/dist/bin/pikku-schemas.js

@@ -15,7 +15,7 @@ async function action({ config }) {
         'schemaDirectory',
         'tsconfig',
     ]);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
     await pikkuSchemas(cliConfig, visitState);
 }
 export const schemas = (program) => {

package/dist/bin/pikku-websocket.js

@@ -16,7 +16,7 @@ export const pikkuWebSocket = async ({ websocketFile, channelsMapDeclarationFile
 };
 export const action = async (options) => {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], true);
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], options.tags, true);
     await pikkuWebSocket(cliConfig);
 };
 export const websocket = (program) => {

package/dist/bin/pikku.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { schemas } from './pikku-schemas.js';
-import { routes } from './pikku-routes.js';
+import { routes } from './pikku-http.js';
 import { nextjs } from './pikku-nextjs.js';
 import { all } from './pikku-all.js';
 import { functionTypes } from './pikku-function-types.js';

package/dist/src/core/serialize-pikku-types.d.ts

@@ -1,4 +1,4 @@
 /**
  *
  */
-export declare const serializePikkuTypes: (userSessionTypeImport: string, userSessionTypeName: string, sessionServicesTypeImport: string, servicesTypeName: string) => string;
+export declare const serializePikkuTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, sessionServicesTypeImport: string, servicesTypeName: string) => string;

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

@@ -1,28 +1,30 @@
 /**
  *
  */
-export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName, sessionServicesTypeImport, servicesTypeName) => {
+export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, servicesTypeName) => {
     return `/**
 * This is used to provide the application types in the typescript project
 */
   
-import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } from '@pikku/core'
+import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, PikkuMiddleware } from '@pikku/core'
 import { CoreHTTPFunctionRoute, AssertRouteParams, addRoute as addCoreHTTP } from '@pikku/core/http'
 import { CoreScheduledTask, addScheduledTask as addCoreScheduledTask } from '@pikku/core/scheduler'
 import { CoreAPIChannel, PikkuChannel, addChannel as addCoreChannel } from '@pikku/core/channel'
 
 ${userSessionTypeImport}
+${singletonServicesTypeImport}
 ${sessionServicesTypeImport}
 
-export type APIPermission<In = unknown, RequiredServices = ${servicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
+export type APIPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
+export type APIMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = PikkuMiddleware<RequiredServices, ${userSessionTypeName}>
 
-export type APIFunctionSessionless<In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunctionSessionless<In, Out, RequiredServices, ${userSessionTypeName}>
-export type APIFunction<In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunction<In, Out, RequiredServices, ${userSessionTypeName}>
-type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>>
+export type APIFunctionSessionless<In = unknown, Out = never, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = CoreAPIFunctionSessionless<In, Out, RequiredServices, ${userSessionTypeName}>
+export type APIFunction<In = unknown, Out = never, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = CoreAPIFunction<In, Out, RequiredServices, ${userSessionTypeName}>
+type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>, APIMiddleware>
 
-export type ChannelConnection<Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<${userSessionTypeName}, ChannelData, Out>) => Promise<void>
-export type ChannelDisconnection<ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<${userSessionTypeName}, ChannelData, never>) => Promise<void>
-export type ChannelMessage<In, Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<${userSessionTypeName}, ChannelData, Out>, data: In) => Promise<Out | void>
+export type ChannelConnection<Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<ChannelData, Out>) => Promise<void>
+export type ChannelDisconnection<ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<ChannelData, never>) => Promise<void>
+export type ChannelMessage<In, Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<ChannelData, Out>, data: In) => Promise<Out | void>
 type APIChannel<ChannelData, Channel extends string> = CoreAPIChannel<ChannelData, Channel, ChannelConnection, ChannelDisconnection, ChannelMessage<any, any, ChannelData>, ChannelMessage<any, any, ChannelData>, APIPermission>
 
 type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>, ${userSessionTypeName}>

package/dist/src/http/serialize-fetch-wrapper.js

@@ -6,41 +6,51 @@ import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPat
 export class PikkuFetch extends CorePikkuFetch {
     public async post<Route extends RoutesWithMethod<'POST'>>(
         route: Route,
-        data: RouteHandlerOf<Route, 'POST'>['input'] = null,
-        options?: Omit<RequestInit, 'body'>
+        ...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,
-        data: RouteHandlerOf<Route, 'GET'>['input'] = null,
-        options?: Omit<RequestInit, 'body'>
+        ...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,
-        data: RouteHandlerOf<Route, 'PATCH'>['input'] = null,
-        options?: Omit<RequestInit, 'body'>
+        ...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,
-        data: RouteHandlerOf<Route, 'HEAD'>['input'] = null,
-        options?: Omit<RequestInit, 'body'>
+        ...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,
-        data: RouteHandlerOf<Route, 'DELETE'>['input'] = null,
-        options?: Omit<RequestInit, 'body'>
+        ...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);
     }
 
@@ -48,10 +58,10 @@ export class PikkuFetch extends CorePikkuFetch {
         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)
+        return await super.fetch(route, method as HTTPMethod, data, options);
     }
 }
 
-export const pikkuFetch = new PikkuFetch()
+export const pikkuFetch = new PikkuFetch();
 `;
 };

package/dist/src/inspector-glob.d.ts

@@ -1,2 +1,2 @@
-import { InspectorState } from '@pikku/inspector';
-export declare const inspectorGlob: (rootDir: string, routeDirectories: string[]) => Promise<InspectorState>;
+import { InspectorFilters, InspectorState } from '@pikku/inspector';
+export declare const inspectorGlob: (rootDir: string, routeDirectories: string[], filters: InspectorFilters) => Promise<InspectorState>;

package/dist/src/inspector-glob.js

@@ -2,11 +2,11 @@ import * as path from 'path';
 import { glob } from 'glob';
 import { inspect } from '@pikku/inspector';
 import { logCommandInfoAndTime } from './utils.js';
-export const inspectorGlob = async (rootDir, routeDirectories) => {
+export const inspectorGlob = async (rootDir, routeDirectories, filters) => {
     let result;
     await logCommandInfoAndTime('Inspecting codebase', 'Inspected codebase', [false], async () => {
         const routeFiles = (await Promise.all(routeDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
-        result = await inspect(routeFiles);
+        result = await inspect(routeFiles, filters);
     });
     return result;
 };

package/dist/src/nextjs/serialize-nextjs-wrapper.d.ts

@@ -1 +1 @@
-export declare const serializeNextJsWrapper: (routesPath: string, routesMapPath: string, schemasPath: string, configImport: string, singleServicesFactoryImport: string, sessionServicesImport: string) => string;
+export declare const serializeNextJsWrapper: (routesPath: string, routesMapPath: string, schemasPath: string, configImport: string, singleServicesFactoryImport: string, sessionServicesImport: string, userSessionTypeImport: string) => string;

package/dist/src/nextjs/serialize-nextjs-wrapper.js

@@ -1,16 +1,18 @@
-export const serializeNextJsWrapper = (routesPath, routesMapPath, schemasPath, configImport, singleServicesFactoryImport, sessionServicesImport) => {
+export const serializeNextJsWrapper = (routesPath, routesMapPath, schemasPath, configImport, singleServicesFactoryImport, sessionServicesImport, userSessionTypeImport) => {
     return `'server-only'
-
+  
 /**
  * This file provides a wrapper around the PikkuNextJS class to allow for methods to be type checked against your routes.
- * This ensures type safety for route handling methods when integrating with the \`@pikku/core\` framework.
+ * It ensures type safety for route handling methods when integrating with the @pikku/core framework.
  */
-import { PikkuNextJS } from '@pikku/next'
+import { PikkuMiddleware } from '@pikku/core'
+import { PikkuNextJS, PikkuNextRequest } from '@pikku/next'
 import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
 
 ${configImport}
 ${singleServicesFactoryImport}
 ${sessionServicesImport}
+${userSessionTypeImport}
 
 import '${routesPath}'
 import '${schemasPath}'
@@ -20,7 +22,7 @@ let _pikku: PikkuNextJS | 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.
+ * @returns An object containing methods for making dynamic and static action requests, as well as session retrieval.
  */
 export const pikku = () => {
   if (!_pikku) {
@@ -31,14 +33,28 @@ export const pikku = () => {
     )
   }
 
+  /**
+   * Retrieves the user session using the current PikkuNextJS instance.
+   *
+   * @param request - The Next.js request object.
+   * @param middleware - An array of middleware functions to process the request.
+   * @returns A promise that resolves to the user session.
+   */
+  const getSession = async (
+    request: PikkuNextRequest,
+    middleware: PikkuMiddleware[]
+  ): Promise<UserSession | undefined> => {
+    return _pikku!.getSession(request, middleware) as any
+  }
+
   /**
    * Makes a dynamic action request for a specified route and method.
-   * Dynamic requests may access headers and cookies, making them unsuitable for precompile stages.
+   * Dynamic requests may access headers and cookies and are therefore unsuitable for precompile stages.
    *
    * @template Route - The route key from the RoutesMap.
    * @template Method - The method key from the specified route.
-   * @param route - The route to make the request to.
-   * @param method - The method to be used for the request.
+   * @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.
    */
@@ -59,8 +75,8 @@ export const pikku = () => {
    *
    * @template Route - The route key from the RoutesMap.
    * @template Method - The method key from the specified route.
-   * @param route - The route to make the request to.
-   * @param method - The method to be used for the request.
+   * @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.
    */
@@ -77,6 +93,11 @@ export const pikku = () => {
 
   /**
    * 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, defaults to null.
+   * @returns A promise that resolves to the output of the POST handler.
    */
   const dynamicPost = <Route extends RoutesWithMethod<'POST'>>(
     route: Route,
@@ -87,6 +108,11 @@ export const pikku = () => {
 
   /**
    * 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, defaults to null.
+   * @returns A promise that resolves to the output of the GET handler.
    */
   const dynamicGet = <Route extends RoutesWithMethod<'GET'>>(
     route: Route,
@@ -97,6 +123,11 @@ export const pikku = () => {
 
   /**
    * 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, defaults to null.
+   * @returns A promise that resolves to the output of the PATCH handler.
    */
   const dynamicPatch = <Route extends RoutesWithMethod<'PATCH'>>(
     route: Route,
@@ -107,6 +138,11 @@ export const pikku = () => {
 
   /**
    * 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, defaults to null.
+   * @returns A promise that resolves to the output of the DELETE handler.
    */
   const dynamicDel = <Route extends RoutesWithMethod<'DELETE'>>(
     route: Route,
@@ -115,10 +151,15 @@ export const pikku = () => {
     return dynamicActionRequest(route, 'DELETE', data)
   }
 
-  // Static
+  // 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, defaults to null.
+   * @returns A promise that resolves to the output of the POST handler.
    */
   const staticPost = <Route extends RoutesWithMethod<'POST'>>(
     route: Route,
@@ -129,6 +170,11 @@ export const pikku = () => {
 
   /**
    * 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, defaults to null.
+   * @returns A promise that resolves to the output of the GET handler.
    */
   const staticGet = <Route extends RoutesWithMethod<'GET'>>(
     route: Route,
@@ -138,6 +184,7 @@ export const pikku = () => {
   }
 
   return {
+    getSession,
     get: dynamicGet,
     post: dynamicPost,
     patch: dynamicPatch,
@@ -145,5 +192,6 @@ export const pikku = () => {
     staticGet,
     staticPost
   }
-}`;
+}
+`;
 };

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

@@ -1,4 +1,5 @@
 import { OpenAPISpecInfo } from './openapi/openapi-spec-generator.js';
+import { InspectorFilters } from '@pikku/inspector';
 export interface PikkuCLICoreOutputFiles {
     outDir?: string;
     routesFile: string;
@@ -26,6 +27,7 @@ export type PikkuCLIConfig = {
         outputFile: string;
         additionalInfo: OpenAPISpecInfo;
     };
+    filters: InspectorFilters;
 } & PikkuCLICoreOutputFiles;
-export declare const getPikkuCLIConfig: (configFile: string | undefined, requiredFields: Array<keyof PikkuCLIConfig>, exitProcess?: boolean) => Promise<PikkuCLIConfig>;
+export declare const getPikkuCLIConfig: (configFile: string | undefined, requiredFields: Array<keyof PikkuCLIConfig>, tags?: string[], exitProcess?: boolean) => Promise<PikkuCLIConfig>;
 export declare const validateCLIConfig: (cliConfig: PikkuCLIConfig, required: Array<keyof PikkuCLIConfig>) => void;

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

@@ -1,11 +1,11 @@
 import { join, dirname, resolve, isAbsolute } from 'path';
 import { readdir, readFile } from 'fs/promises';
 const CONFIG_DIR_FILES = ['nextJSfile', 'fetchFile', 'websocketFile'];
-export const getPikkuCLIConfig = async (configFile = undefined, requiredFields, exitProcess = false) => {
-    const config = await _getPikkuCLIConfig(configFile, requiredFields, exitProcess);
+export const getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags = [], exitProcess = false) => {
+    const config = await _getPikkuCLIConfig(configFile, requiredFields, tags, exitProcess);
     return config;
 };
-const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, exitProcess = false) => {
+const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags = [], exitProcess = false) => {
     if (!configFile) {
         let execDirectory = process.cwd();
         const files = await readdir(execDirectory);
@@ -26,7 +26,7 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, exitPr
         const configDir = dirname(configFile);
         const config = JSON.parse(file);
         if (config.extends) {
-            const extendedConfig = await getPikkuCLIConfig(resolve(configDir, config.extends), [], exitProcess);
+            const extendedConfig = await getPikkuCLIConfig(resolve(configDir, config.extends), [], tags, exitProcess);
             result = {
                 ...extendedConfig,
                 ...config,
@@ -88,6 +88,10 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, exitPr
                 }
             }
         }
+        result.filters = result.filters || {};
+        if (tags.length > 0) {
+            result.filters.tags = tags;
+        }
         if (!isAbsolute(result.tsconfig)) {
             result.tsconfig = join(result.rootDir, result.tsconfig);
         }

package/dist/src/utils.d.ts

@@ -12,6 +12,7 @@ interface Meta {
 export type FilesAndMethods = {
     userSessionType: Meta;
     sessionServicesType: Meta;
+    singletonServicesType: Meta;
     pikkuConfigFactory: Meta;
     singletonServicesFactory: Meta;
     sessionServicesFactory: Meta;
@@ -22,10 +23,12 @@ export interface PikkuCLIOptions {
     userSessionType?: string;
     singletonServicesFactoryType?: string;
     sessionServicesFactoryType?: string;
+    tags?: string[];
 }
-export declare const getPikkuFilesAndMethods: ({ sessionServicesTypeImportMap: httpSessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, packageMappings: Record<string, string>, outputFile: string, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }: PikkuCLIOptions, requires?: Partial<{
+export declare const getPikkuFilesAndMethods: ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, packageMappings: Record<string, string>, outputFile: string, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }: PikkuCLIOptions, requires?: Partial<{
     config: boolean;
     sessionServiceType: boolean;
+    singletonServicesType: boolean;
     userSessionType: boolean;
     singletonServicesFactory: boolean;
     sessionServicesFactory: boolean;

package/dist/src/utils.js

@@ -60,8 +60,9 @@ const getMetaTypes = (type, errors, map, desiredType) => {
     }
     return undefined;
 };
-export const getPikkuFilesAndMethods = async ({ sessionServicesTypeImportMap: httpSessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }, packageMappings, outputFile, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }, requires = {
+export const getPikkuFilesAndMethods = async ({ singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }, packageMappings, outputFile, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }, requires = {
     config: false,
+    singletonServicesType: false,
     sessionServiceType: false,
     userSessionType: false,
     singletonServicesFactory: false,
@@ -70,7 +71,8 @@ export const getPikkuFilesAndMethods = async ({ sessionServicesTypeImportMap: ht
     let errors = new Map();
     const result = {
         userSessionType: getMetaTypes('CoreUserSession', requires.userSessionType ? errors : new Map(), userSessionTypeImportMap, configFileType),
-        sessionServicesType: getMetaTypes('CoreServices', requires.sessionServiceType ? errors : new Map(), httpSessionServicesTypeImportMap),
+        singletonServicesType: getMetaTypes('CoreSingletonServices', requires.singletonServicesType ? errors : new Map(), singletonServicesTypeImportMap),
+        sessionServicesType: getMetaTypes('CoreServices', requires.sessionServiceType ? errors : new Map(), sessionServicesTypeImportMap),
         pikkuConfigFactory: getMetaTypes('CoreConfig', requires.config ? errors : new Map(), configFactories, configFileType),
         singletonServicesFactory: getMetaTypes('CreateSingletonServices', requires.singletonServicesFactory ? errors : new Map(), singletonServicesFactories, singletonServicesFactoryType),
         sessionServicesFactory: getMetaTypes('CreateSessionServices', requires.sessionServicesFactory ? errors : new Map(), sessionServicesFactories, sessionServicesFactoryType),
@@ -102,7 +104,7 @@ export const writeFileInDir = async (path, content, ignoreModifyComment = false)
 };
 export const logCommandInfoAndTime = async (commandStart, commandEnd, [skipCondition, skipMessage = 'none found'], callback) => {
     if (skipCondition === true) {
-        logInfo(`• Skipping ${commandStart} since ${skipMessage}.`);
+        logInfo(`• Skipping ${commandStart.charAt(0).toLocaleLowerCase()}${commandStart.slice(1)} since ${skipMessage}.`);
         return false;
     }
     const start = Date.now();

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../bin/pikku-all.ts","../bin/pikku-channels-map.ts","../bin/pikku-channels.ts","../bin/pikku-fetch.ts","../bin/pikku-function-types.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-routes-map.ts","../bin/pikku-routes.ts","../bin/pikku-scheduler.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/utils.ts","../src/channels/serialize-channels.ts","../src/channels/serialize-typed-channel-map.ts","../src/channels/serialize-websocket-wrapper.ts","../src/core/serialize-import-map.ts","../src/core/serialize-pikku-types.ts","../src/http/serialize-fetch-wrapper.ts","../src/http/serialize-route-imports.ts","../src/http/serialize-route-meta.ts","../src/http/serialize-typed-route-map.ts","../src/nextjs/serialize-nextjs-wrapper.ts","../src/openapi/openapi-spec-generator.ts","../src/scheduler/serialize-schedulers.ts","../src/schema/schema-generator.ts"],"version":"5.7.3"}
+{"root":["../bin/pikku-all.ts","../bin/pikku-channels-map.ts","../bin/pikku-channels.ts","../bin/pikku-fetch.ts","../bin/pikku-function-types.ts","../bin/pikku-http.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-routes-map.ts","../bin/pikku-scheduler.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/utils.ts","../src/channels/serialize-channels.ts","../src/channels/serialize-typed-channel-map.ts","../src/channels/serialize-websocket-wrapper.ts","../src/core/serialize-import-map.ts","../src/core/serialize-pikku-types.ts","../src/http/serialize-fetch-wrapper.ts","../src/http/serialize-route-imports.ts","../src/http/serialize-route-meta.ts","../src/http/serialize-typed-route-map.ts","../src/nextjs/serialize-nextjs-wrapper.ts","../src/openapi/openapi-spec-generator.ts","../src/scheduler/serialize-schedulers.ts","../src/schema/schema-generator.ts"],"version":"5.7.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.6.11",
+  "version": "0.6.13",
   "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.6.13",
-    "@pikku/inspector": "^0.6.2",
+    "@pikku/core": "^0.6.14",
+    "@pikku/inspector": "^0.6.3",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",

package/src/core/serialize-pikku-types.ts

@@ -4,6 +4,8 @@
 export const serializePikkuTypes = (
   userSessionTypeImport: string,
   userSessionTypeName: string,
+  singletonServicesTypeImport: string,
+  singletonServicesTypeName: string,
   sessionServicesTypeImport: string,
   servicesTypeName: string
 ) => {
@@ -11,23 +13,25 @@ export const serializePikkuTypes = (
 * This is used to provide the application types in the typescript project
 */
   
-import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } from '@pikku/core'
+import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, PikkuMiddleware } from '@pikku/core'
 import { CoreHTTPFunctionRoute, AssertRouteParams, addRoute as addCoreHTTP } from '@pikku/core/http'
 import { CoreScheduledTask, addScheduledTask as addCoreScheduledTask } from '@pikku/core/scheduler'
 import { CoreAPIChannel, PikkuChannel, addChannel as addCoreChannel } from '@pikku/core/channel'
 
 ${userSessionTypeImport}
+${singletonServicesTypeImport}
 ${sessionServicesTypeImport}
 
-export type APIPermission<In = unknown, RequiredServices = ${servicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
+export type APIPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
+export type APIMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = PikkuMiddleware<RequiredServices, ${userSessionTypeName}>
 
-export type APIFunctionSessionless<In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunctionSessionless<In, Out, RequiredServices, ${userSessionTypeName}>
-export type APIFunction<In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunction<In, Out, RequiredServices, ${userSessionTypeName}>
-type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>>
+export type APIFunctionSessionless<In = unknown, Out = never, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = CoreAPIFunctionSessionless<In, Out, RequiredServices, ${userSessionTypeName}>
+export type APIFunction<In = unknown, Out = never, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = CoreAPIFunction<In, Out, RequiredServices, ${userSessionTypeName}>
+type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>, APIMiddleware>
 
-export type ChannelConnection<Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<${userSessionTypeName}, ChannelData, Out>) => Promise<void>
-export type ChannelDisconnection<ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<${userSessionTypeName}, ChannelData, never>) => Promise<void>
-export type ChannelMessage<In, Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<${userSessionTypeName}, ChannelData, Out>, data: In) => Promise<Out | void>
+export type ChannelConnection<Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<ChannelData, Out>) => Promise<void>
+export type ChannelDisconnection<ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<ChannelData, never>) => Promise<void>
+export type ChannelMessage<In, Out = unknown, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: RequiredServices, channel: PikkuChannel<ChannelData, Out>, data: In) => Promise<Out | void>
 type APIChannel<ChannelData, Channel extends string> = CoreAPIChannel<ChannelData, Channel, ChannelConnection, ChannelDisconnection, ChannelMessage<any, any, ChannelData>, ChannelMessage<any, any, ChannelData>, APIPermission>
 
 type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>, ${userSessionTypeName}>

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

@@ -6,41 +6,51 @@ import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPat
 export class PikkuFetch extends CorePikkuFetch {
     public async post<Route extends RoutesWithMethod<'POST'>>(
         route: Route,
-        data: RouteHandlerOf<Route, 'POST'>['input'] = null,
-        options?: Omit<RequestInit, 'body'>
+        ...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,
-        data: RouteHandlerOf<Route, 'GET'>['input'] = null,
-        options?: Omit<RequestInit, 'body'>
+        ...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,
-        data: RouteHandlerOf<Route, 'PATCH'>['input'] = null,
-        options?: Omit<RequestInit, 'body'>
+        ...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,
-        data: RouteHandlerOf<Route, 'HEAD'>['input'] = null,
-        options?: Omit<RequestInit, 'body'>
+        ...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,
-        data: RouteHandlerOf<Route, 'DELETE'>['input'] = null,
-        options?: Omit<RequestInit, 'body'>
+        ...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);
     }
 
@@ -48,10 +58,10 @@ export class PikkuFetch extends CorePikkuFetch {
         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)
+        return await super.fetch(route, method as HTTPMethod, data, options);
     }
 }
 
-export const pikkuFetch = new PikkuFetch()
+export const pikkuFetch = new PikkuFetch();
 `
 }

package/src/inspector-glob.ts

@@ -1,11 +1,12 @@
 import * as path from 'path'
 import { glob } from 'glob'
-import { InspectorState, inspect } from '@pikku/inspector'
+import { InspectorFilters, InspectorState, inspect } from '@pikku/inspector'
 import { logCommandInfoAndTime } from './utils.js'
 
 export const inspectorGlob = async (
   rootDir: string,
-  routeDirectories: string[]
+  routeDirectories: string[],
+  filters: InspectorFilters
 ) => {
   let result: InspectorState
   await logCommandInfoAndTime(
@@ -20,7 +21,7 @@ export const inspectorGlob = async (
           )
         )
       ).flat()
-      result = await inspect(routeFiles)
+      result = await inspect(routeFiles, filters)
     }
   )
   return result!