@pikku/cli 0.6.12 → 0.6.14

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @pikku/cli
 
+## 0.6.14
+
+### Patch Changes
+
+- ebc04eb: refactor: move all global state into pikku state
+- Updated dependencies [ebc04eb]
+- Updated dependencies [8a14f3a]
+- Updated dependencies [2c47386]
+  - @pikku/core@0.6.17
+
+## 0.6.13
+
+### Patch Changes
+
+- c1d8381: feat: adding filtering by tags to minimize produced payload
+- ee5c874: feat: moving towards using middleware for http and channels
+- Updated dependencies [c1d8381]
+- Updated dependencies [ee5c874]
+  - @pikku/inspector@0.6.3
+  - @pikku/core@0.6.14
+
 ## 0.6.12
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -7,7 +7,7 @@ import {
   writeFileInDir,
 } from '../src/utils.js'
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuRoutes } from './pikku-routes.js'
+import { pikkuHTTP } from './pikku-http.js'
 import { pikkuFunctionTypes } from './pikku-function-types.js'
 import { pikkuHTTPMap } from './pikku-routes-map.js'
 import { existsSync } from 'fs'
@@ -31,12 +31,18 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
     )
   }
 
-  const cliConfig = await getPikkuCLIConfig(options.config, [], true)
+  const cliConfig = await getPikkuCLIConfig(
+    options.config,
+    [],
+    options.tags,
+    true
+  )
 
   let typesDeclarationFileExists = true
   let visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories
+    cliConfig.routeDirectories,
+    cliConfig.filters
   )
 
   if (!existsSync(cliConfig.typesDeclarationFile)) {
@@ -49,11 +55,12 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
     logInfo(`• Type file first created, inspecting again...\x1b[0m`)
     visitState = await inspectorGlob(
       cliConfig.rootDir,
-      cliConfig.routeDirectories
+      cliConfig.routeDirectories,
+      cliConfig.filters
     )
   }
 
-  const routes = await pikkuRoutes(cliConfig, visitState)
+  const routes = await pikkuHTTP(cliConfig, visitState)
   if (routes) {
     await pikkuHTTPMap(cliConfig, visitState)
     await pikkuFetch(cliConfig)
@@ -83,7 +90,8 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
     logInfo(`• OpenAPI requires a reinspection to pickup new generated types..`)
     visitState = await inspectorGlob(
       cliConfig.rootDir,
-      cliConfig.routeDirectories
+      cliConfig.routeDirectories,
+      cliConfig.filters
     )
     await pikkuOpenAPI(cliConfig, visitState)
   }
@@ -105,5 +113,6 @@ export const all = (program: Command): void => {
       'The type of your session services factory'
     )
     .option('-c | --config <string>', 'The path to pikku cli config file')
+    .option('-t | --tags <tags...>', 'Which tags to filter by')
     .action(action)
 }

package/bin/pikku-channels-map.ts

@@ -32,14 +32,16 @@ export const pikkuChannelsMap = async (
 
 async function action(cliOptions: PikkuCLIOptions): Promise<void> {
   logPikkuLogo()
-  const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-    'rootDir',
-    'routeDirectories',
-    'routesFile',
-  ])
+  const cliConfig = await getPikkuCLIConfig(
+    cliOptions.config,
+    ['rootDir', 'routeDirectories', 'routesFile'],
+    cliOptions.tags,
+    false
+  )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories
+    cliConfig.routeDirectories,
+    cliConfig.filters
   )
   await pikkuChannelsMap(cliConfig, visitState)
 }

package/bin/pikku-channels.ts

@@ -36,14 +36,15 @@ export const pikkuChannels = async (
 async function action(cliOptions: PikkuCLIOptions): Promise<void> {
   logPikkuLogo()
 
-  const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-    'rootDir',
-    'routeDirectories',
-    'routesFile',
-  ])
+  const cliConfig = await getPikkuCLIConfig(
+    cliOptions.config,
+    ['rootDir', 'routeDirectories', 'routesFile'],
+    cliOptions.tags
+  )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories
+    cliConfig.routeDirectories,
+    cliConfig.filters
   )
   await pikkuChannels(cliConfig, visitState)
 }

package/bin/pikku-fetch.ts

@@ -40,6 +40,7 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
+    options.tags,
     true
   )
   await pikkuFetch(cliConfig)

package/bin/pikku-function-types.ts

@@ -9,7 +9,7 @@ import {
   PikkuCLIOptions,
   writeFileInDir,
 } from '../src/utils.js'
-import { pikkuRoutes } from './pikku-routes.js'
+import { pikkuHTTP } from './pikku-http.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 import { serializePikkuTypes } from '../src/core/serialize-pikku-types.js'
 
@@ -23,17 +23,24 @@ export const pikkuFunctionTypes = async (
     'Created api types',
     [false],
     async () => {
-      const { userSessionType, sessionServicesType } =
+      const { userSessionType, sessionServicesType, singletonServicesType } =
         await getPikkuFilesAndMethods(
           visitState,
           packageMappings,
           typesFile,
           options,
-          { userSessionType: true, sessionServiceType: true }
+          {
+            userSessionType: true,
+            sessionServiceType: true,
+            singletonServicesType: true,
+          }
         )
+
       const content = serializePikkuTypes(
         `import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`,
         userSessionType.type,
+        `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`,
+        singletonServicesType.type,
         `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`,
         sessionServicesType.type
       )
@@ -45,17 +52,18 @@ export const pikkuFunctionTypes = async (
 async function action(cliOptions: PikkuCLIOptions): Promise<void> {
   logPikkuLogo()
 
-  const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-    'rootDir',
-    'routeDirectories',
-    'typesDeclarationFile',
-  ])
+  const cliConfig = await getPikkuCLIConfig(
+    cliOptions.config,
+    ['rootDir', 'routeDirectories', 'typesDeclarationFile'],
+    cliOptions.tags
+  )
 
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories
+    cliConfig.routeDirectories,
+    cliConfig.filters
   )
-  await pikkuRoutes(cliConfig, visitState)
+  await pikkuHTTP(cliConfig, visitState)
 }
 
 export const functionTypes = (program: Command): void => {

package/bin/{pikku-routes.ts → pikku-http.ts}

@@ -11,13 +11,13 @@ import {
 import { serializeRoutes } from '../src/http/serialize-route-imports.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 
-export const pikkuRoutes = async (
+export const pikkuHTTP = async (
   cliConfig: PikkuCLIConfig,
   visitState: InspectorState
 ) => {
   return await logCommandInfoAndTime(
-    'Finding routes',
-    'Found routes',
+    'Finding HTTP routes',
+    'Found HTTP routes',
     [visitState.http.files.size === 0],
     async () => {
       const { routesFile, packageMappings } = cliConfig
@@ -34,16 +34,17 @@ export const pikkuRoutes = async (
 async function action(cliOptions: PikkuCLIOptions): Promise<void> {
   logPikkuLogo()
 
-  const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-    'rootDir',
-    'routeDirectories',
-    'routesFile',
-  ])
+  const cliConfig = await getPikkuCLIConfig(
+    cliOptions.config,
+    ['rootDir', 'routeDirectories', 'routesFile'],
+    cliOptions.tags
+  )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories
+    cliConfig.routeDirectories,
+    cliConfig.filters
   )
-  await pikkuRoutes(cliConfig, visitState)
+  await pikkuHTTP(cliConfig, visitState)
 }
 
 export const routes = (program: Command): void => {

package/bin/pikku-nextjs.ts

@@ -36,6 +36,7 @@ export const pikkuNext = async (
         pikkuConfigFactory,
         singletonServicesFactory,
         sessionServicesFactory,
+        userSessionType,
       } = await getPikkuFilesAndMethods(
         visitState,
         packageMappings,
@@ -51,6 +52,7 @@ export const pikkuNext = async (
       const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextJSfile, pikkuConfigFactory.file, packageMappings)}'`
       const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextJSfile, singletonServicesFactory.file, packageMappings)}'`
       const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextJSfile, sessionServicesFactory.file, packageMappings)}'`
+      const userSessionImport = `import type { ${userSessionType.type} as UserSession } from '${getFileImportRelativePath(nextJSfile, userSessionType.file, packageMappings)}'`
 
       const routesPath = getFileImportRelativePath(
         nextJSfile,
@@ -74,7 +76,8 @@ export const pikkuNext = async (
         schemasPath,
         pikkuConfigImport,
         singletonServicesImport,
-        sessionServicesImport
+        sessionServicesImport,
+        userSessionImport
       )
       await writeFileInDir(nextJSfile, content)
     }
@@ -86,11 +89,13 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir', 'nextJSfile'],
+    options.tags,
     true
   )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories
+    cliConfig.routeDirectories,
+    cliConfig.filters
   )
   await pikkuNext(cliConfig, visitState, options)
 }

package/bin/pikku-openapi.ts

@@ -46,18 +46,17 @@ export const pikkuOpenAPI = async (
   )
 }
 
-async function action({ config }: PikkuCLIOptions): Promise<void> {
+async function action({ config, tags }: PikkuCLIOptions): Promise<void> {
   logPikkuLogo()
-  const cliConfig = await getPikkuCLIConfig(config, [
-    'rootDir',
-    'routesFile',
-    'openAPI',
-    'schemaDirectory',
-    'tsconfig',
-  ])
+  const cliConfig = await getPikkuCLIConfig(
+    config,
+    ['rootDir', 'routesFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
+    tags
+  )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories
+    cliConfig.routeDirectories,
+    cliConfig.filters
   )
   await pikkuOpenAPI(cliConfig, visitState)
 }

package/bin/pikku-routes-map.ts

@@ -33,14 +33,15 @@ export const pikkuHTTPMap = async (
 
 async function action(cliOptions: PikkuCLIOptions): Promise<void> {
   logPikkuLogo()
-  const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-    'rootDir',
-    'routeDirectories',
-    'routesFile',
-  ])
+  const cliConfig = await getPikkuCLIConfig(
+    cliOptions.config,
+    ['rootDir', 'routeDirectories', 'routesFile'],
+    cliOptions.tags
+  )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories
+    cliConfig.routeDirectories,
+    cliConfig.filters
   )
   await pikkuHTTPMap(cliConfig, visitState)
 }

package/bin/pikku-scheduler.ts

@@ -37,17 +37,18 @@ export const pikkuScheduler = async (
   )
 }
 
-async function action(cliOptions: PikkuCLIOptions): Promise<void> {
+async function action(options: PikkuCLIOptions): Promise<void> {
   logPikkuLogo()
 
-  const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-    'rootDir',
-    'routeDirectories',
-    'routesFile',
-  ])
+  const cliConfig = await getPikkuCLIConfig(
+    options.config,
+    ['rootDir', 'routeDirectories', 'routesFile'],
+    options.tags
+  )
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories
+    cliConfig.routeDirectories,
+    cliConfig.filters
   )
   await pikkuScheduler(cliConfig, visitState)
 }

package/bin/pikku-schemas.ts

@@ -37,7 +37,8 @@ async function action({ config }: { config?: string }): Promise<void> {
   ])
   const visitState = await inspectorGlob(
     cliConfig.rootDir,
-    cliConfig.routeDirectories
+    cliConfig.routeDirectories,
+    cliConfig.filters
   )
   await pikkuSchemas(cliConfig, visitState)
 }

package/bin/pikku-websocket.ts

@@ -43,6 +43,7 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
+    options.tags,
     true
   )
   await pikkuWebSocket(cliConfig)

package/bin/pikku.ts

@@ -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/bin/pikku-all.js

@@ -1,6 +1,6 @@
 import { getFileImportRelativePath, logInfo, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuRoutes } from './pikku-routes.js';
+import { pikkuHTTP } from './pikku-http.js';
 import { pikkuFunctionTypes } from './pikku-function-types.js';
 import { pikkuHTTPMap } from './pikku-routes-map.js';
 import { existsSync } from 'fs';
@@ -19,9 +19,9 @@ export const action = async (options) => {
     const addImport = (from) => {
         imports.push(`import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`);
     };
-    const cliConfig = await getPikkuCLIConfig(options.config, [], true);
+    const cliConfig = await getPikkuCLIConfig(options.config, [], options.tags, true);
     let typesDeclarationFileExists = true;
-    let visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    let visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
     if (!existsSync(cliConfig.typesDeclarationFile)) {
         typesDeclarationFileExists = false;
     }
@@ -29,9 +29,9 @@ export const action = async (options) => {
     // This is needed since the addRoutes function will add the routes to the visitState
     if (!typesDeclarationFileExists) {
         logInfo(`• Type file first created, inspecting again...\x1b[0m`);
-        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
     }
-    const routes = await pikkuRoutes(cliConfig, visitState);
+    const routes = await pikkuHTTP(cliConfig, visitState);
     if (routes) {
         await pikkuHTTPMap(cliConfig, visitState);
         await pikkuFetch(cliConfig);
@@ -54,7 +54,7 @@ export const action = async (options) => {
     await pikkuNext(cliConfig, visitState, options);
     if (cliConfig.openAPI) {
         logInfo(`• OpenAPI requires a reinspection to pickup new generated types..`);
-        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
         await pikkuOpenAPI(cliConfig, visitState);
     }
     await writeFileInDir(cliConfig.bootstrapFile, imports.join('\n'));
@@ -67,5 +67,6 @@ export const all = (program) => {
         .option('-ss | --singleton-services-factory-type', 'The type of your singleton services factory')
         .option('-se | --session-services-factory-type', 'The type of your session services factory')
         .option('-c | --config <string>', 'The path to pikku cli config file')
+        .option('-t | --tags <tags...>', 'Which tags to filter by')
         .action(action);
 };

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

@@ -10,12 +10,8 @@ export const pikkuChannelsMap = async ({ channelsMapDeclarationFile, packageMapp
 };
 async function action(cliOptions) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-        'rootDir',
-        'routeDirectories',
-        'routesFile',
-    ]);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'routeDirectories', 'routesFile'], cliOptions.tags, false);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
     await pikkuChannelsMap(cliConfig, visitState);
 }
 export const channelsMap = (program) => {

package/dist/bin/pikku-channels.js

@@ -15,12 +15,8 @@ export const pikkuChannels = async (cliConfig, visitState) => {
 };
 async function action(cliOptions) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-        'rootDir',
-        'routeDirectories',
-        'routesFile',
-    ]);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'routeDirectories', 'routesFile'], cliOptions.tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
     await pikkuChannels(cliConfig, visitState);
 }
 export const channels = (program) => {

package/dist/bin/pikku-fetch.js

@@ -13,7 +13,7 @@ export const pikkuFetch = async ({ fetchFile, routesMapDeclarationFile, packageM
 };
 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 pikkuFetch(cliConfig);
 };
 export const fetch = (program) => {

package/dist/bin/pikku-function-types.js

@@ -1,24 +1,24 @@
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
-import { pikkuRoutes } from './pikku-routes.js';
+import { pikkuHTTP } from './pikku-http.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 import { serializePikkuTypes } from '../src/core/serialize-pikku-types.js';
 export const pikkuFunctionTypes = async ({ typesDeclarationFile: typesFile, packageMappings }, options, visitState) => {
     await logCommandInfoAndTime('Creating api types', 'Created api types', [false], async () => {
-        const { userSessionType, sessionServicesType } = await getPikkuFilesAndMethods(visitState, packageMappings, typesFile, options, { userSessionType: true, sessionServiceType: true });
-        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type);
+        const { userSessionType, sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(visitState, packageMappings, typesFile, options, {
+            userSessionType: true,
+            sessionServiceType: true,
+            singletonServicesType: true,
+        });
+        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type);
         await writeFileInDir(typesFile, content);
     });
 };
 async function action(cliOptions) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-        'rootDir',
-        'routeDirectories',
-        'typesDeclarationFile',
-    ]);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
-    await pikkuRoutes(cliConfig, visitState);
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'routeDirectories', 'typesDeclarationFile'], cliOptions.tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+    await pikkuHTTP(cliConfig, visitState);
 }
 export const functionTypes = (program) => {
     program

package/dist/bin/{pikku-routes.d.ts → pikku-http.d.ts}

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
-export declare const pikkuRoutes: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
+export declare const pikkuHTTP: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
 export declare const routes: (program: Command) => void;

package/dist/bin/{pikku-routes.js → pikku-http.js}

@@ -3,8 +3,8 @@ import { serializeHTTPRoutesMeta } from '../src/http/serialize-route-meta.js';
 import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
 import { serializeRoutes } from '../src/http/serialize-route-imports.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
-export const pikkuRoutes = async (cliConfig, visitState) => {
-    return await logCommandInfoAndTime('Finding routes', 'Found routes', [visitState.http.files.size === 0], async () => {
+export const pikkuHTTP = async (cliConfig, visitState) => {
+    return await logCommandInfoAndTime('Finding HTTP routes', 'Found HTTP routes', [visitState.http.files.size === 0], async () => {
         const { routesFile, packageMappings } = cliConfig;
         const { http } = visitState;
         const content = [
@@ -16,13 +16,9 @@ export const pikkuRoutes = async (cliConfig, visitState) => {
 };
 async function action(cliOptions) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-        'rootDir',
-        'routeDirectories',
-        'routesFile',
-    ]);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
-    await pikkuRoutes(cliConfig, visitState);
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'routeDirectories', 'routesFile'], cliOptions.tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
+    await pikkuHTTP(cliConfig, visitState);
 }
 export const routes = (program) => {
     program

package/dist/bin/pikku-nextjs.js

@@ -7,7 +7,7 @@ export const pikkuNext = async ({ nextJSfile, routesFile, routesMapDeclarationFi
         if (!nextJSfile) {
             throw new Error('nextJSfile is required in pikku config');
         }
-        const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = await getPikkuFilesAndMethods(visitState, packageMappings, nextJSfile, options, {
+        const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, userSessionType, } = await getPikkuFilesAndMethods(visitState, packageMappings, nextJSfile, options, {
             config: true,
             singletonServicesFactory: true,
             sessionServicesFactory: true,
@@ -15,17 +15,18 @@ export const pikkuNext = async ({ nextJSfile, routesFile, routesMapDeclarationFi
         const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextJSfile, pikkuConfigFactory.file, packageMappings)}'`;
         const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextJSfile, singletonServicesFactory.file, packageMappings)}'`;
         const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextJSfile, sessionServicesFactory.file, packageMappings)}'`;
+        const userSessionImport = `import type { ${userSessionType.type} as UserSession } from '${getFileImportRelativePath(nextJSfile, userSessionType.file, packageMappings)}'`;
         const routesPath = getFileImportRelativePath(nextJSfile, routesFile, packageMappings);
         const routesMapDeclarationPath = getFileImportRelativePath(nextJSfile, routesMapDeclarationFile, packageMappings);
         const schemasPath = getFileImportRelativePath(nextJSfile, `${schemaDirectory}/register.gen.ts`, packageMappings);
-        const content = serializeNextJsWrapper(routesPath, routesMapDeclarationPath, schemasPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
+        const content = serializeNextJsWrapper(routesPath, routesMapDeclarationPath, schemasPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport, userSessionImport);
         await writeFileInDir(nextJSfile, content);
     });
 };
 export const action = async (options) => {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'nextJSfile'], true);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'nextJSfile'], options.tags, true);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
     await pikkuNext(cliConfig, visitState, options);
 };
 export const nextjs = (program) => {

package/dist/bin/pikku-openapi.js

@@ -20,16 +20,10 @@ export const pikkuOpenAPI = async ({ tsconfig, openAPI }, { http }) => {
         }
     });
 };
-async function action({ config }) {
+async function action({ config, tags }) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(config, [
-        'rootDir',
-        'routesFile',
-        'openAPI',
-        'schemaDirectory',
-        'tsconfig',
-    ]);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    const cliConfig = await getPikkuCLIConfig(config, ['rootDir', 'routesFile', 'openAPI', 'schemaDirectory', 'tsconfig'], tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
     await pikkuOpenAPI(cliConfig, visitState);
 }
 export const openapi = (program) => {

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

@@ -10,12 +10,8 @@ export const pikkuHTTPMap = async ({ routesMapDeclarationFile, packageMappings }
 };
 async function action(cliOptions) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-        'rootDir',
-        'routeDirectories',
-        'routesFile',
-    ]);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'routeDirectories', 'routesFile'], cliOptions.tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
     await pikkuHTTPMap(cliConfig, visitState);
 }
 export const routesMap = (program) => {

package/dist/bin/pikku-scheduler.js

@@ -13,14 +13,10 @@ export const pikkuScheduler = async (cliConfig, visitState) => {
         await writeFileInDir(schedulersFile, content.join('\n\n'));
     });
 };
-async function action(cliOptions) {
+async function action(options) {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, [
-        'rootDir',
-        'routeDirectories',
-        'routesFile',
-    ]);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'routeDirectories', 'routesFile'], options.tags);
+    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
     await pikkuScheduler(cliConfig, visitState);
 }
 export const schedules = (program) => {