@pikku/cli 0.6.16 → 0.6.18

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @pikku/cli
 
+## 0.6.18
+
+### Patch Changes
+
+- 60b2265: refactor: supporting request and response objects
+- Updated dependencies [60b2265]
+  - @pikku/inspector@0.6.4
+  - @pikku/core@0.6.22
+
+## 0.6.17
+
+### Patch Changes
+
+- 57f5d8c: refactor: moving getSession out of nextjs wrapper since it bundles all routes and only needs middleware
+- 141d690: feat: creating a nextJS http wrapper for proxying
+- e5a5a12: feat: adding watch command (pikki all --watch)
+- 0ad27a2: chore: switching from glon to tinyblobby
+
 ## 0.6.16
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -6,7 +6,7 @@ import {
   PikkuCLIOptions,
   writeFileInDir,
 } from '../src/utils.js'
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { pikkuHTTP } from './pikku-http.js'
 import { pikkuFunctionTypes } from './pikku-function-types.js'
 import { pikkuHTTPMap } from './pikku-routes-map.js'
@@ -20,10 +20,9 @@ import { pikkuScheduler } from './pikku-scheduler.js'
 import { pikkuSchemas } from './pikku-schemas.js'
 import { pikkuWebSocket } from './pikku-websocket.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
+import chokidar from 'chokidar'
 
-export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
-
+const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
   const imports: string[] = []
   const addImport = (from: string) => {
     imports.push(
@@ -31,13 +30,6 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
     )
   }
 
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    [],
-    options.tags,
-    true
-  )
-
   let typesDeclarationFileExists = true
   let visitState = await inspectorGlob(
     cliConfig.rootDir,
@@ -84,7 +76,9 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
     addImport(`${cliConfig.schemaDirectory}/register.gen.ts`)
   }
 
-  await pikkuNext(cliConfig, visitState, options)
+  if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
+    await pikkuNext(cliConfig, visitState, options)
+  }
 
   if (cliConfig.openAPI) {
     logInfo(`• OpenAPI requires a reinspection to pickup new generated types..`)
@@ -99,6 +93,73 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   await writeFileInDir(cliConfig.bootstrapFile, imports.join('\n'))
 }
 
+const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
+  const configWatcher = chokidar.watch(cliConfig.routeDirectories, {
+    ignoreInitial: true,
+    ignored: /.*\.gen\.tsx?/,
+  })
+
+  let watcher = new chokidar.FSWatcher({})
+
+  const generatorWatcher = () => {
+    watcher.close()
+
+    logInfo(
+      `• Watching directories: \n  - ${cliConfig.routeDirectories.join('\n  - ')}`
+    )
+    watcher = chokidar.watch(cliConfig.routeDirectories, {
+      ignoreInitial: true,
+      ignored: /.*\.gen\.ts/,
+    })
+
+    watcher.on('ready', async () => {
+      const handle = async () => {
+        try {
+          await runAll(cliConfig, options)
+        } catch (err) {
+          console.error(err)
+          console.info()
+        }
+      }
+
+      await handle()
+
+      let timeout: ReturnType<typeof setTimeout> | undefined
+
+      const deduped = (_file: string) => {
+        if (timeout) {
+          clearTimeout(timeout)
+        }
+        timeout = setTimeout(handle, 10)
+      }
+
+      watcher.on('change', deduped)
+      watcher.on('add', deduped)
+      watcher.on('unlink', deduped)
+    })
+  }
+
+  configWatcher.on('ready', generatorWatcher)
+  configWatcher.on('change', generatorWatcher)
+}
+
+export const action = async (options: PikkuCLIOptions): Promise<void> => {
+  logPikkuLogo()
+
+  const cliConfig = await getPikkuCLIConfig(
+    options.config,
+    [],
+    options.tags,
+    true
+  )
+
+  if (options.watch) {
+    watch(cliConfig, options)
+  } else {
+    await runAll(cliConfig, options)
+  }
+}
+
 export const all = (program: Command): void => {
   program
     .command('all', { isDefault: true })
@@ -114,5 +175,6 @@ export const all = (program: Command): void => {
     )
     .option('-c | --config <string>', 'The path to pikku cli config file')
     .option('-t | --tags <tags...>', 'Which tags to filter by')
+    .option('-w | --watch', 'Whether to watch file changes')
     .action(action)
 }

package/bin/pikku-nextjs.ts

@@ -1,5 +1,6 @@
 import { Command } from 'commander'
-import { serializeNextJsWrapper } from '../src/nextjs/serialize-nextjs-wrapper.js'
+import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../src/nextjs/serialize-nextjs-backend-wrapper.js'
+import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/nextjs/serialize-nextjs-http-wrapper.js'
 import {
   getFileImportRelativePath,
   getPikkuFilesAndMethods,
@@ -14,11 +15,13 @@ import { inspectorGlob } from '../src/inspector-glob.js'
 
 export const pikkuNext = async (
   {
-    nextJSfile,
+    nextBackendFile,
+    nextHTTPFile,
     routesFile,
     routesMapDeclarationFile,
     schemaDirectory,
     packageMappings,
+    fetchFile,
   }: PikkuCLIConfig,
   visitState: InspectorState,
   options: PikkuCLIOptions
@@ -26,60 +29,91 @@ export const pikkuNext = async (
   return await logCommandInfoAndTime(
     'Generating nextjs wrapper',
     'Generated nextjs wrapper',
-    [nextJSfile === undefined, 'nextjs outfile is not defined'],
+    [
+      nextBackendFile === undefined && nextHTTPFile === undefined,
+      'nextjs outfile is not defined',
+    ],
     async () => {
-      if (!nextJSfile) {
-        throw new Error('nextJSfile is required in pikku config')
+      if (!nextBackendFile && !nextHTTPFile) {
+        throw new Error(
+          'nextBackendFile or nextHTTPFile is required in pikku config for nextJS'
+        )
       }
 
-      const {
-        pikkuConfigFactory,
-        singletonServicesFactory,
-        sessionServicesFactory,
-        userSessionType,
-      } = await getPikkuFilesAndMethods(
-        visitState,
-        packageMappings,
-        nextJSfile,
-        options,
-        {
-          config: true,
-          singletonServicesFactory: true,
-          sessionServicesFactory: true,
-        }
-      )
+      if (nextHTTPFile && !fetchFile) {
+        throw new Error(
+          'fetchFile is required in pikku config in order for nextJS http wrapper to work'
+        )
+      }
+
+      if (nextBackendFile) {
+        const {
+          pikkuConfigFactory,
+          singletonServicesFactory,
+          sessionServicesFactory,
+        } = await getPikkuFilesAndMethods(
+          visitState,
+          packageMappings,
+          nextBackendFile,
+          options,
+          {
+            config: true,
+            singletonServicesFactory: true,
+            sessionServicesFactory: true,
+          }
+        )
+
+        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 sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`
+
+        const routesPath = getFileImportRelativePath(
+          nextBackendFile,
+          routesFile,
+          packageMappings
+        )
 
-      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 routesMapDeclarationPath = getFileImportRelativePath(
+          nextBackendFile,
+          routesMapDeclarationFile,
+          packageMappings
+        )
+        const schemasPath = getFileImportRelativePath(
+          nextBackendFile,
+          `${schemaDirectory}/register.gen.ts`,
+          packageMappings
+        )
 
-      const routesPath = getFileImportRelativePath(
-        nextJSfile,
-        routesFile,
-        packageMappings
-      )
-      const routesMapDeclarationPath = getFileImportRelativePath(
-        nextJSfile,
-        routesMapDeclarationFile,
-        packageMappings
-      )
-      const schemasPath = getFileImportRelativePath(
-        nextJSfile,
-        `${schemaDirectory}/register.gen.ts`,
-        packageMappings
-      )
+        const content = serializeNextBackendWrapper(
+          routesPath,
+          routesMapDeclarationPath,
+          schemasPath,
+          pikkuConfigImport,
+          singletonServicesImport,
+          sessionServicesImport
+        )
+        await writeFileInDir(nextBackendFile, content)
+      }
+
+      if (nextHTTPFile) {
+        const routesPath = getFileImportRelativePath(
+          nextHTTPFile,
+          routesFile,
+          packageMappings
+        )
 
-      const content = serializeNextJsWrapper(
-        routesPath,
-        routesMapDeclarationPath,
-        schemasPath,
-        pikkuConfigImport,
-        singletonServicesImport,
-        sessionServicesImport,
-        userSessionImport
-      )
-      await writeFileInDir(nextJSfile, content)
+        const routesMapDeclarationPath = getFileImportRelativePath(
+          nextHTTPFile,
+          routesMapDeclarationFile,
+          packageMappings
+        )
+
+        const content = serializeNextHTTPWrapper(
+          routesPath,
+          routesMapDeclarationPath
+        )
+        await writeFileInDir(nextHTTPFile, content)
+      }
     }
   )
 }
@@ -88,7 +122,7 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   logPikkuLogo()
   const cliConfig = await getPikkuCLIConfig(
     options.config,
-    ['rootDir', 'schemaDirectory', 'configDir', 'nextJSfile'],
+    ['rootDir', 'schemaDirectory', 'configDir'],
     options.tags,
     true
   )

package/bin/pikku-schemas.ts

@@ -10,6 +10,7 @@ export const pikkuSchemas = async (
   { tsconfig, schemaDirectory, supportsImportAttributes }: PikkuCLIConfig,
   { http }: InspectorState
 ) => {
+  console.log('Generating schemas...', supportsImportAttributes)
   return await logCommandInfoAndTime(
     'Creating schemas',
     'Created schemas',

package/cli.schema.json

@@ -138,7 +138,10 @@
         "fetchFile": {
           "type": "string"
         },
-        "nextJSfile": {
+        "nextBackendFile": {
+          "type": "string"
+        },
+        "nextHTTPFile": {
           "type": "string"
         },
         "openAPI": {

package/dist/bin/pikku-all.js

@@ -13,13 +13,12 @@ import { pikkuScheduler } from './pikku-scheduler.js';
 import { pikkuSchemas } from './pikku-schemas.js';
 import { pikkuWebSocket } from './pikku-websocket.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
-export const action = async (options) => {
-    logPikkuLogo();
+import chokidar from 'chokidar';
+const runAll = async (cliConfig, options) => {
     const imports = [];
     const addImport = (from) => {
         imports.push(`import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`);
     };
-    const cliConfig = await getPikkuCLIConfig(options.config, [], options.tags, true);
     let typesDeclarationFileExists = true;
     let visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
     if (!existsSync(cliConfig.typesDeclarationFile)) {
@@ -51,7 +50,9 @@ export const action = async (options) => {
     if (schemas) {
         addImport(`${cliConfig.schemaDirectory}/register.gen.ts`);
     }
-    await pikkuNext(cliConfig, visitState, options);
+    if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
+        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, cliConfig.filters);
@@ -59,6 +60,55 @@ export const action = async (options) => {
     }
     await writeFileInDir(cliConfig.bootstrapFile, imports.join('\n'));
 };
+const watch = (cliConfig, options) => {
+    const configWatcher = chokidar.watch(cliConfig.routeDirectories, {
+        ignoreInitial: true,
+        ignored: /.*\.gen\.tsx?/,
+    });
+    let watcher = new chokidar.FSWatcher({});
+    const generatorWatcher = () => {
+        watcher.close();
+        logInfo(`• Watching directories: \n  - ${cliConfig.routeDirectories.join('\n  - ')}`);
+        watcher = chokidar.watch(cliConfig.routeDirectories, {
+            ignoreInitial: true,
+            ignored: /.*\.gen\.ts/,
+        });
+        watcher.on('ready', async () => {
+            const handle = async () => {
+                try {
+                    await runAll(cliConfig, options);
+                }
+                catch (err) {
+                    console.error(err);
+                    console.info();
+                }
+            };
+            await handle();
+            let timeout;
+            const deduped = (_file) => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                timeout = setTimeout(handle, 10);
+            };
+            watcher.on('change', deduped);
+            watcher.on('add', deduped);
+            watcher.on('unlink', deduped);
+        });
+    };
+    configWatcher.on('ready', generatorWatcher);
+    configWatcher.on('change', generatorWatcher);
+};
+export const action = async (options) => {
+    logPikkuLogo();
+    const cliConfig = await getPikkuCLIConfig(options.config, [], options.tags, true);
+    if (options.watch) {
+        watch(cliConfig, options);
+    }
+    else {
+        await runAll(cliConfig, options);
+    }
+};
 export const all = (program) => {
     program
         .command('all', { isDefault: true })
@@ -68,5 +118,6 @@ export const all = (program) => {
         .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')
+        .option('-w | --watch', 'Whether to watch file changes')
         .action(action);
 };

package/dist/bin/pikku-nextjs.d.ts

@@ -2,6 +2,6 @@ import { Command } from 'commander';
 import { PikkuCLIOptions } from '../src/utils.js';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
-export declare const pikkuNext: ({ nextJSfile, routesFile, routesMapDeclarationFile, schemaDirectory, packageMappings, }: PikkuCLIConfig, visitState: InspectorState, options: PikkuCLIOptions) => Promise<boolean>;
+export declare const pikkuNext: ({ nextBackendFile, nextHTTPFile, routesFile, routesMapDeclarationFile, schemaDirectory, packageMappings, fetchFile, }: PikkuCLIConfig, visitState: InspectorState, options: PikkuCLIOptions) => Promise<boolean>;
 export declare const action: (options: PikkuCLIOptions) => Promise<void>;
 export declare const nextjs: (program: Command) => void;

package/dist/bin/pikku-nextjs.js

@@ -1,31 +1,45 @@
-import { serializeNextJsWrapper } from '../src/nextjs/serialize-nextjs-wrapper.js';
+import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../src/nextjs/serialize-nextjs-backend-wrapper.js';
+import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/nextjs/serialize-nextjs-http-wrapper.js';
 import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
-export const pikkuNext = async ({ nextJSfile, routesFile, routesMapDeclarationFile, schemaDirectory, packageMappings, }, visitState, options) => {
-    return await logCommandInfoAndTime('Generating nextjs wrapper', 'Generated nextjs wrapper', [nextJSfile === undefined, 'nextjs outfile is not defined'], async () => {
-        if (!nextJSfile) {
-            throw new Error('nextJSfile is required in pikku config');
+export const pikkuNext = async ({ nextBackendFile, nextHTTPFile, routesFile, routesMapDeclarationFile, schemaDirectory, packageMappings, fetchFile, }, visitState, options) => {
+    return await logCommandInfoAndTime('Generating nextjs wrapper', 'Generated nextjs wrapper', [
+        nextBackendFile === undefined && nextHTTPFile === undefined,
+        'nextjs outfile is not defined',
+    ], async () => {
+        if (!nextBackendFile && !nextHTTPFile) {
+            throw new Error('nextBackendFile or nextHTTPFile is required in pikku config for nextJS');
+        }
+        if (nextHTTPFile && !fetchFile) {
+            throw new Error('fetchFile is required in pikku config in order for nextJS http wrapper to work');
+        }
+        if (nextBackendFile) {
+            const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = await getPikkuFilesAndMethods(visitState, packageMappings, nextBackendFile, options, {
+                config: true,
+                singletonServicesFactory: true,
+                sessionServicesFactory: true,
+            });
+            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 sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`;
+            const routesPath = getFileImportRelativePath(nextBackendFile, routesFile, packageMappings);
+            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, routesMapDeclarationFile, packageMappings);
+            const schemasPath = getFileImportRelativePath(nextBackendFile, `${schemaDirectory}/register.gen.ts`, packageMappings);
+            const content = serializeNextBackendWrapper(routesPath, routesMapDeclarationPath, schemasPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
+            await writeFileInDir(nextBackendFile, content);
+        }
+        if (nextHTTPFile) {
+            const routesPath = getFileImportRelativePath(nextHTTPFile, routesFile, packageMappings);
+            const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, routesMapDeclarationFile, packageMappings);
+            const content = serializeNextHTTPWrapper(routesPath, routesMapDeclarationPath);
+            await writeFileInDir(nextHTTPFile, content);
         }
-        const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, userSessionType, } = await getPikkuFilesAndMethods(visitState, packageMappings, nextJSfile, options, {
-            config: true,
-            singletonServicesFactory: true,
-            sessionServicesFactory: true,
-        });
-        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, userSessionImport);
-        await writeFileInDir(nextJSfile, content);
     });
 };
 export const action = async (options) => {
     logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'nextJSfile'], options.tags, true);
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir'], options.tags, true);
     const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
     await pikkuNext(cliConfig, visitState, options);
 };

package/dist/bin/pikku-schemas.js

@@ -3,6 +3,7 @@ import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { logCommandInfoAndTime, logPikkuLogo } from '../src/utils.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 export const pikkuSchemas = async ({ tsconfig, schemaDirectory, supportsImportAttributes }, { http }) => {
+    console.log('Generating schemas...', supportsImportAttributes);
     return await logCommandInfoAndTime('Creating schemas', 'Created schemas', [false], async () => {
         const schemas = await generateSchemas(tsconfig, http.typesMap, http.meta);
         await saveSchemas(schemaDirectory, schemas, http.typesMap, http.meta, supportsImportAttributes);

package/dist/src/inspector-glob.js

@@ -1,5 +1,5 @@
 import * as path from 'path';
-import { glob } from 'glob';
+import { glob } from 'tinyglobby';
 import { inspect } from '@pikku/inspector';
 import { logCommandInfoAndTime } from './utils.js';
 export const inspectorGlob = async (rootDir, routeDirectories, filters) => {

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

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

package/dist/src/nextjs/{serialize-nextjs-wrapper.js → serialize-nextjs-backend-wrapper.js}

@@ -1,18 +1,16 @@
-export const serializeNextJsWrapper = (routesPath, routesMapPath, schemasPath, configImport, singleServicesFactoryImport, sessionServicesImport, userSessionTypeImport) => {
+export const serializeNextJsBackendWrapper = (routesPath, routesMapPath, schemasPath, configImport, singleServicesFactoryImport, sessionServicesImport) => {
     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 { PikkuMiddleware } from '@pikku/core'
-import { PikkuNextJS, PikkuNextRequest } from '@pikku/next'
+import { PikkuNextJS } from '@pikku/next'
 import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
 
 ${configImport}
 ${singleServicesFactoryImport}
 ${sessionServicesImport}
-${userSessionTypeImport}
 
 import '${routesPath}'
 import '${schemasPath}'
@@ -24,7 +22,7 @@ let _pikku: PikkuNextJS | undefined
  *
  * @returns An object containing methods for making dynamic and static action requests, as well as session retrieval.
  */
-export const pikku = () => {
+export const pikku = (_options?: any) => {
   if (!_pikku) {
     _pikku = new PikkuNextJS(
       createConfig as any,
@@ -33,20 +31,6 @@ 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 and are therefore unsuitable for precompile stages.
@@ -184,7 +168,6 @@ export const pikku = () => {
   }
 
   return {
-    getSession,
     get: dynamicGet,
     post: dynamicPost,
     patch: dynamicPatch,

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

@@ -0,0 +1 @@
+export declare const serializeNextJsHTTPWrapper: (routesMapPath: string, pikkuFetchImport: string) => string;

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

@@ -0,0 +1,160 @@
+export const serializeNextJsHTTPWrapper = (routesMapPath, pikkuFetchImport) => {
+    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 { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
+
+let _pikku: PikkuFetch | undefined
+
+${pikkuFetchImport}
+
+/**
+ * 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 RoutesMap,
+    Method extends keyof RoutesMap[Route]
+  >(
+    route: Route,
+    method: Method,
+    data: RouteHandlerOf<Route, Method>['input'] = null
+  ): Promise<RouteHandlerOf<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 RoutesMap.
+   * @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 RoutesMap,
+    Method extends keyof RoutesMap[Route]
+  >(
+    route: Route,
+    method: Method,
+    data: RouteHandlerOf<Route, Method>['input'] = null
+  ): Promise<RouteHandlerOf<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, defaults to null.
+   * @returns A promise that resolves to the output of the POST handler.
+   */
+  const dynamicPost = <Route extends RoutesWithMethod<'POST'>>(
+    route: Route,
+    data: RouteHandlerOf<Route, 'POST'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'POST'>['output']> => {
+    return dynamicActionRequest(route, 'POST', data)
+  }
+
+  /**
+   * 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,
+    data: RouteHandlerOf<Route, 'GET'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'GET'>['output']> => {
+    return dynamicActionRequest(route, 'GET', data)
+  }
+
+  /**
+   * 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,
+    data: RouteHandlerOf<Route, 'PATCH'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'PATCH'>['output']> => {
+    return dynamicActionRequest(route, 'PATCH', data)
+  }
+
+  /**
+   * 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,
+    data: RouteHandlerOf<Route, 'DELETE'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'DELETE'>['output']> => {
+    return dynamicActionRequest(route, 'DELETE', data)
+  }
+
+  // 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,
+    data: RouteHandlerOf<Route, 'POST'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'POST'>['output']> => {
+    return staticActionRequest(route, 'POST', data)
+  }
+
+  /**
+   * 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,
+    data: RouteHandlerOf<Route, 'GET'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'GET'>['output']> => {
+    return staticActionRequest(route, 'GET', data)
+  }
+
+  return {
+    get: dynamicGet,
+    post: dynamicPost,
+    patch: dynamicPatch,
+    del: dynamicDel,
+    staticGet,
+    staticPost
+  }
+}
+`;
+};

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

@@ -20,7 +20,8 @@ export type PikkuCLIConfig = {
     supportsImportAttributes: boolean;
     configDir: string;
     tsconfig: string;
-    nextJSfile?: string;
+    nextBackendFile?: string;
+    nextHTTPFile?: string;
     fetchFile?: string;
     websocketFile?: string;
     openAPI?: {

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

@@ -1,6 +1,11 @@
 import { join, dirname, resolve, isAbsolute } from 'path';
 import { readdir, readFile } from 'fs/promises';
-const CONFIG_DIR_FILES = ['nextJSfile', 'fetchFile', 'websocketFile'];
+const CONFIG_DIR_FILES = [
+    'nextBackendFile',
+    'nextHTTPFile',
+    'fetchFile',
+    'websocketFile',
+];
 export const getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags = [], exitProcess = false) => {
     const config = await _getPikkuCLIConfig(configFile, requiredFields, tags, exitProcess);
     return config;

package/dist/src/schema/schema-generator.js

@@ -69,11 +69,8 @@ export async function saveSchemas(schemaParentDir, schemas, typesMap, routesMeta
         .map((schema) => `
 import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
 addSchema('${schema}', ${schema})
-// addSchema('${schema}', require('./schemas/${schema}.schema.json'))
 `)
         .join('\n');
     await writeFileInDir(`${schemaParentDir}/register.gen.ts`, `import { addSchema } from '@pikku/core/schema'
-// import { createRequire } from "module"
-// const require = createRequire(import.meta.url)
 ${schemaImports}`);
 }

package/dist/src/utils.d.ts

@@ -18,6 +18,7 @@ export type FilesAndMethods = {
     sessionServicesFactory: Meta;
 };
 export interface PikkuCLIOptions {
+    watch?: boolean;
     config?: string;
     configFileType?: string;
     userSessionType?: string;

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-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"}
+{"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-backend-wrapper.ts","../src/nextjs/serialize-nextjs-http-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.16",
+  "version": "0.6.18",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,14 +22,15 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
-    "@pikku/core": "^0.6.19",
-    "@pikku/inspector": "^0.6.3",
+    "@pikku/core": "^0.6.22",
+    "@pikku/inspector": "^0.6.4",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",
+    "chokidar": "^4.0.3",
     "commander": "^12",
-    "glob": "^10",
     "path-to-regexp": "^8.2.0",
+    "tinyglobby": "^0.2.12",
     "ts-json-schema-generator": "^2.3.0",
     "typescript": "^5.6",
     "yaml": "^2.6.0"

package/src/inspector-glob.ts

@@ -1,5 +1,5 @@
 import * as path from 'path'
-import { glob } from 'glob'
+import { glob } from 'tinyglobby'
 import { InspectorFilters, InspectorState, inspect } from '@pikku/inspector'
 import { logCommandInfoAndTime } from './utils.js'
 

package/src/nextjs/{serialize-nextjs-wrapper.ts → serialize-nextjs-backend-wrapper.ts}

@@ -1,11 +1,10 @@
-export const serializeNextJsWrapper = (
+export const serializeNextJsBackendWrapper = (
   routesPath: string,
   routesMapPath: string,
   schemasPath: string,
   configImport: string,
   singleServicesFactoryImport: string,
-  sessionServicesImport: string,
-  userSessionTypeImport: string
+  sessionServicesImport: string
 ) => {
   return `'server-only'
   
@@ -13,14 +12,12 @@ export const serializeNextJsWrapper = (
  * 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 { PikkuMiddleware } from '@pikku/core'
-import { PikkuNextJS, PikkuNextRequest } from '@pikku/next'
+import { PikkuNextJS } from '@pikku/next'
 import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
 
 ${configImport}
 ${singleServicesFactoryImport}
 ${sessionServicesImport}
-${userSessionTypeImport}
 
 import '${routesPath}'
 import '${schemasPath}'
@@ -32,7 +29,7 @@ let _pikku: PikkuNextJS | undefined
  *
  * @returns An object containing methods for making dynamic and static action requests, as well as session retrieval.
  */
-export const pikku = () => {
+export const pikku = (_options?: any) => {
   if (!_pikku) {
     _pikku = new PikkuNextJS(
       createConfig as any,
@@ -41,20 +38,6 @@ 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 and are therefore unsuitable for precompile stages.
@@ -192,7 +175,6 @@ export const pikku = () => {
   }
 
   return {
-    getSession,
     get: dynamicGet,
     post: dynamicPost,
     patch: dynamicPatch,

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

@@ -0,0 +1,163 @@
+export const serializeNextJsHTTPWrapper = (
+  routesMapPath: 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 { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
+
+let _pikku: PikkuFetch | undefined
+
+${pikkuFetchImport}
+
+/**
+ * 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 RoutesMap,
+    Method extends keyof RoutesMap[Route]
+  >(
+    route: Route,
+    method: Method,
+    data: RouteHandlerOf<Route, Method>['input'] = null
+  ): Promise<RouteHandlerOf<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 RoutesMap.
+   * @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 RoutesMap,
+    Method extends keyof RoutesMap[Route]
+  >(
+    route: Route,
+    method: Method,
+    data: RouteHandlerOf<Route, Method>['input'] = null
+  ): Promise<RouteHandlerOf<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, defaults to null.
+   * @returns A promise that resolves to the output of the POST handler.
+   */
+  const dynamicPost = <Route extends RoutesWithMethod<'POST'>>(
+    route: Route,
+    data: RouteHandlerOf<Route, 'POST'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'POST'>['output']> => {
+    return dynamicActionRequest(route, 'POST', data)
+  }
+
+  /**
+   * 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,
+    data: RouteHandlerOf<Route, 'GET'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'GET'>['output']> => {
+    return dynamicActionRequest(route, 'GET', data)
+  }
+
+  /**
+   * 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,
+    data: RouteHandlerOf<Route, 'PATCH'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'PATCH'>['output']> => {
+    return dynamicActionRequest(route, 'PATCH', data)
+  }
+
+  /**
+   * 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,
+    data: RouteHandlerOf<Route, 'DELETE'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'DELETE'>['output']> => {
+    return dynamicActionRequest(route, 'DELETE', data)
+  }
+
+  // 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,
+    data: RouteHandlerOf<Route, 'POST'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'POST'>['output']> => {
+    return staticActionRequest(route, 'POST', data)
+  }
+
+  /**
+   * 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,
+    data: RouteHandlerOf<Route, 'GET'>['input'] = null
+  ): Promise<RouteHandlerOf<Route, 'GET'>['output']> => {
+    return staticActionRequest(route, 'GET', data)
+  }
+
+  return {
+    get: dynamicGet,
+    post: dynamicPost,
+    patch: dynamicPatch,
+    del: dynamicDel,
+    staticGet,
+    staticPost
+  }
+}
+`
+}

package/src/pikku-cli-config.ts

@@ -28,7 +28,8 @@ export type PikkuCLIConfig = {
   configDir: string
   tsconfig: string
 
-  nextJSfile?: string
+  nextBackendFile?: string
+  nextHTTPFile?: string
   fetchFile?: string
   websocketFile?: string
 
@@ -40,7 +41,12 @@ export type PikkuCLIConfig = {
   filters: InspectorFilters
 } & PikkuCLICoreOutputFiles
 
-const CONFIG_DIR_FILES = ['nextJSfile', 'fetchFile', 'websocketFile']
+const CONFIG_DIR_FILES = [
+  'nextBackendFile',
+  'nextHTTPFile',
+  'fetchFile',
+  'websocketFile',
+]
 
 export const getPikkuCLIConfig = async (
   configFile: string | undefined = undefined,

package/src/schema/schema-generator.ts

@@ -102,7 +102,6 @@ export async function saveSchemas(
       (schema) => `
 import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
 addSchema('${schema}', ${schema})
-// addSchema('${schema}', require('./schemas/${schema}.schema.json'))
 `
     )
     .join('\n')
@@ -110,8 +109,6 @@ addSchema('${schema}', ${schema})
   await writeFileInDir(
     `${schemaParentDir}/register.gen.ts`,
     `import { addSchema } from '@pikku/core/schema'
-// import { createRequire } from "module"
-// const require = createRequire(import.meta.url)
 ${schemaImports}`
   )
 }

package/src/utils.ts

@@ -59,6 +59,7 @@ export type FilesAndMethods = {
 }
 
 export interface PikkuCLIOptions {
+  watch?: boolean
   config?: string
   configFileType?: string
   userSessionType?: string

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

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