@pikku/cli 0.6.6 → 0.6.9

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @pikku/cli
 
+## 0.6.9
+
+### Patch Changes
+
+- 7e7ec0c: chore: show packageVersion in cli header
+
+## 0.6.8
+
+### Patch Changes
+
+- bdcc89a: feat: adding intro logo to cli based commands
+
+## 0.6.7
+
+### Patch Changes
+
+- 7859b28: breaking: changing overrides for addRoute to wrap instead due to random conflict override errors
+- 269a532: fix: fixing some typing issues
+- Updated dependencies [7859b28]
+- Updated dependencies [269a532]
+  - @pikku/core@0.6.11
+
 ## 0.6.6
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -1,6 +1,7 @@
 import { Command } from 'commander'
 import {
   getFileImportRelativePath,
+  logInfo,
   logPikkuLogo,
   PikkuCLIOptions,
   writeFileInDir,
@@ -45,7 +46,7 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
 
   // This is needed since the addRoutes function will add the routes to the visitState
   if (!typesDeclarationFileExists) {
-    console.log(`\x1b[34m• Type file first created, inspecting again...\x1b[0m`)
+    logInfo(`• Type file first created, inspecting again...\x1b[0m`)
     visitState = await inspectorGlob(
       cliConfig.rootDir,
       cliConfig.routeDirectories
@@ -79,9 +80,7 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   await pikkuNext(cliConfig, visitState, options)
 
   if (cliConfig.openAPI) {
-    console.log(
-      `\x1b[34m• OpenAPI requires a reinspection to pickup new generated types..\x1b[0m`
-    )
+    logInfo(`• OpenAPI requires a reinspection to pickup new generated types..`)
     visitState = await inspectorGlob(
       cliConfig.rootDir,
       cliConfig.routeDirectories

package/bin/pikku-fetch.ts

@@ -17,10 +17,10 @@ export const pikkuFetch = async ({
   await logCommandInfoAndTime(
     'Generating fetch wrapper',
     'Generated fetch wrapper',
-    [fetchFile === undefined, 'fetchFile is required in pikku config'],
+    [fetchFile === undefined, "fetchFile isn't set in the pikku config"],
     async () => {
       if (!fetchFile) {
-        throw new Error('fetchFile is required in pikku config')
+        throw new Error("fetchFile is isn't set in the pikku config")
       }
 
       const routesMapDeclarationPath = getFileImportRelativePath(

package/bin/pikku-websocket.ts

@@ -17,10 +17,13 @@ export const pikkuWebSocket = async ({
   await logCommandInfoAndTime(
     'Generating websocket wrapper',
     'Generated websocket wrapper',
-    [websocketFile === undefined, 'websocketFile is required in pikku config'],
+    [
+      websocketFile === undefined,
+      "websocketFile isn't set in the pikku config",
+    ],
     async () => {
       if (!websocketFile) {
-        throw new Error('fetchFile is required in pikku config')
+        throw new Error("fetchFile is isn't set in the pikku config")
       }
 
       const channelsMapDeclarationPath = getFileImportRelativePath(

package/dist/bin/pikku-all.js

@@ -1,4 +1,4 @@
-import { getFileImportRelativePath, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { getFileImportRelativePath, logInfo, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { pikkuRoutes } from './pikku-routes.js';
 import { pikkuFunctionTypes } from './pikku-function-types.js';
@@ -28,7 +28,7 @@ export const action = async (options) => {
     await pikkuFunctionTypes(cliConfig, options, visitState);
     // This is needed since the addRoutes function will add the routes to the visitState
     if (!typesDeclarationFileExists) {
-        console.log(`\x1b[34m• Type file first created, inspecting again...\x1b[0m`);
+        logInfo(`• Type file first created, inspecting again...\x1b[0m`);
         visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
     }
     const routes = await pikkuRoutes(cliConfig, visitState);
@@ -53,7 +53,7 @@ export const action = async (options) => {
     }
     await pikkuNext(cliConfig, visitState, options);
     if (cliConfig.openAPI) {
-        console.log(`\x1b[34m• OpenAPI requires a reinspection to pickup new generated types..\x1b[0m`);
+        logInfo(`• OpenAPI requires a reinspection to pickup new generated types..`);
         visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories);
         await pikkuOpenAPI(cliConfig, visitState);
     }

package/dist/bin/pikku-fetch.js

@@ -2,9 +2,9 @@ import { getFileImportRelativePath, logCommandInfoAndTime, logPikkuLogo, writeFi
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { serializeFetchWrapper } from '../src/http/serialize-fetch-wrapper.js';
 export const pikkuFetch = async ({ fetchFile, routesMapDeclarationFile, packageMappings, }) => {
-    await logCommandInfoAndTime('Generating fetch wrapper', 'Generated fetch wrapper', [fetchFile === undefined, 'fetchFile is required in pikku config'], async () => {
+    await logCommandInfoAndTime('Generating fetch wrapper', 'Generated fetch wrapper', [fetchFile === undefined, "fetchFile isn't set in the pikku config"], async () => {
         if (!fetchFile) {
-            throw new Error('fetchFile is required in pikku config');
+            throw new Error("fetchFile is isn't set in the pikku config");
         }
         const routesMapDeclarationPath = getFileImportRelativePath(fetchFile, routesMapDeclarationFile, packageMappings);
         const content = [serializeFetchWrapper(routesMapDeclarationPath)];

package/dist/bin/pikku-websocket.js

@@ -2,9 +2,12 @@ import { getFileImportRelativePath, logCommandInfoAndTime, logPikkuLogo, writeFi
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { serializeWebsocketWrapper } from '../src/channels/serialize-websocket-wrapper.js';
 export const pikkuWebSocket = async ({ websocketFile, channelsMapDeclarationFile, packageMappings, }) => {
-    await logCommandInfoAndTime('Generating websocket wrapper', 'Generated websocket wrapper', [websocketFile === undefined, 'websocketFile is required in pikku config'], async () => {
+    await logCommandInfoAndTime('Generating websocket wrapper', 'Generated websocket wrapper', [
+        websocketFile === undefined,
+        "websocketFile isn't set in the pikku config",
+    ], async () => {
         if (!websocketFile) {
-            throw new Error('fetchFile is required in pikku config');
+            throw new Error("fetchFile is isn't set in the pikku config");
         }
         const channelsMapDeclarationPath = getFileImportRelativePath(websocketFile, channelsMapDeclarationFile, packageMappings);
         const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)];

package/dist/package.json

@@ -0,0 +1,43 @@
+{
+    "name": "@pikku/cli",
+    "version": "0.6.9",
+    "author": "yasser.fadl@gmail.com",
+    "license": "MIT",
+    "bin": {
+        "pikku": "dist/bin/pikku.js"
+    },
+    "type": "module",
+    "main": "dist/bin/pikku.js",
+    "module": "dist/bin/pikku.js",
+    "scripts": {
+        "tsc": "tsc",
+        "build:esm": "tsc -b",
+        "schema": "ts-json-schema-generator -o cli.schema.json --path 'src/pikku-cli-config.ts' --type 'PikkuCLIConfig'",
+        "build": "yarn build:esm && yarn schema",
+        "ncu": "npx npm-check-updates -x '/.*glob.*/'",
+        "release": "yarn build && npm test",
+        "test": "bash run-tests.sh",
+        "test:watch": "bash run-tests.sh --watch",
+        "test:coverage": "bash run-tests.sh --coverage"
+    },
+    "dependencies": {
+        "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
+        "@pikku/core": "^0.6.11",
+        "@pikku/inspector": "^0.6.2",
+        "@types/cookie": "^0.6.0",
+        "@types/uuid": "^10.0.0",
+        "chalk": "^5.4.1",
+        "commander": "^12",
+        "glob": "^10",
+        "path-to-regexp": "^8.2.0",
+        "ts-json-schema-generator": "^2.3.0",
+        "typescript": "^5.6",
+        "yaml": "^2.6.0"
+    },
+    "devDependencies": {
+        "@types/node": "^22.7.8"
+    },
+    "engines": {
+        "node": ">=18"
+    }
+}

package/dist/src/channels/serialize-typed-channel-map.js

@@ -1,4 +1,5 @@
 import { serializeImportMap } from '../core/serialize-import-map.js';
+import { generateCustomTypes } from '../http/serialize-typed-route-map.js';
 export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, channelsMeta) => {
     const { channels, requiredTypes } = generateChannels(channelsMeta);
     typesMap.customTypes.forEach(({ references }) => {
@@ -7,11 +8,13 @@ export const serializeTypedChannelsMap = (relativeToPath, packageMappings, types
         }
     });
     const imports = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for TypeScript to be aware of channels
  */
     
 ${imports}
+${serializedCustomTypes}
 
 interface ChannelHandler<I, O> {
     input: I;
@@ -67,7 +70,7 @@ function generateChannels(channelsMeta) {
         for (const [key, methods] of Object.entries(routes)) {
             routesStr += `      readonly ${key}: {\n`;
             for (const [method, handler] of Object.entries(methods)) {
-                routesStr += `        readonly ${method}: ChannelHandler<${formatTypeArray(handler.inputTypes)}, ${formatTypeArray(handler.outputTypes)}>,\n`;
+                routesStr += `        readonly ${method}: ChannelHandler<${formatTypeArray(handler.inputTypes)}, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`;
             }
             routesStr += '      },\n';
         }

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

@@ -6,10 +6,10 @@ export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName,
 * This is used to provide the application types in the typescript project
 */
   
-import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, MakeRequired } from '@pikku/core'
-import { CoreHTTPFunctionRoute, AssertRouteParams } from '@pikku/core/http'
-import { CoreScheduledTask } from '@pikku/core/scheduler'
-import { CoreAPIChannel, CoreChannelConnection, CoreChannelDisconnection, CoreChannelMessage, PikkuChannel } from '@pikku/core/channel'
+import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } 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}
 ${sessionServicesTypeImport}
@@ -20,29 +20,27 @@ export type APIFunctionSessionless<In = unknown, Out = never, RequiredServices =
 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 ChannelConnection<Out = never, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<${userSessionTypeName}, ChannelData, Out>) => Promise<void>
-export type ChannelDisconnection<ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<${userSessionTypeName}, ChannelData, never>) => Promise<void>
-export type ChannelMessage<In, Out = never, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<${userSessionTypeName}, ChannelData, Out>, data: In) => Promise<Out | void>
-type APIChannel<ChannelData, Channel extends string, In extends unknown, Out extends unknown> = CoreAPIChannel<ChannelData, Channel, ChannelConnection, ChannelDisconnection, ChannelMessage<In, Out, ChannelData>>
+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>
+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}>
 
-declare module "@pikku/core" {
-  // type APIPermission<In = unknown, RequiredServices = ${servicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
-  // type APIFunction = <In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunction<In, Out, RequiredServices, ${userSessionTypeName}>
-  // type APIFunctionSessionless = <In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunctionSessionless<In, Out, RequiredServices, ${userSessionTypeName}>
-
-  function addChannel<ChannelData, Channel extends string>(
-    channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
-  ): void;
+export const addChannel = <ChannelData, Channel extends string>(
+  channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
+) => {
+  addCoreChannel(channel as any) // TODO
+}
 
-  function addRoute<In, Out, Route extends string>(
-    route: APIRoute<In, Out, Route> & AssertRouteParams<In, Route>
-  ): void;
+export const addRoute = <In, Out, Route extends string>(
+  route: APIRoute<In, Out, Route> & AssertRouteParams<In, Route>
+) => {
+  addCoreHTTP(route)
+}
 
-  function addScheduledTask(
-    task: ScheduledTask
-  ): void;
+export const addScheduledTask = (task: ScheduledTask) => {
+  addCoreScheduledTask(task as any) // TODO
 }
 `;
 };

package/dist/src/http/serialize-typed-route-map.d.ts

@@ -1,3 +1,4 @@
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { MetaInputTypes, TypesMap } from '@pikku/inspector';
 export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
+export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

package/dist/src/http/serialize-typed-route-map.js

@@ -30,7 +30,7 @@ export type RoutesWithMethod<Method extends string> = {
 }[keyof RoutesMap];
   `;
 };
-function generateCustomTypes(typesMap, requiredTypes) {
+export function generateCustomTypes(typesMap, requiredTypes) {
     return `
 // Custom types are those that are defined directly within generics
 // or are broken into simpler types

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

@@ -61,7 +61,7 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, exitPr
                 result.channelsFile = join(result.outDir, 'pikku-channels.gen.ts');
             }
             if (!result.typesDeclarationFile) {
-                result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.d.ts');
+                result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts');
             }
             if (!result.routesMapDeclarationFile) {
                 result.routesMapDeclarationFile = join(result.outDir, 'pikku-routes-map.gen.d.ts');

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

@@ -1,5 +1,5 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator';
-import { writeFileInDir } from '../utils.js';
+import { logInfo, writeFileInDir } from '../utils.js';
 import { mkdir, writeFile } from 'fs/promises';
 export async function generateSchemas(tsconfig, typesMap, routesMeta) {
     const schemasSet = new Set(typesMap.customTypes.keys());
@@ -34,7 +34,7 @@ export async function generateSchemas(tsconfig, typesMap, routesMeta) {
         catch (e) {
             // Ignore rootless errors
             if (e instanceof RootlessError) {
-                console.log('Error generating schema since it has no root:', schema);
+                console.error('Error generating schema since it has no root:', schema);
                 return;
             }
             throw e;
@@ -56,7 +56,7 @@ export async function saveSchemas(schemaParentDir, schemas, typesMap, routesMeta
         ...typesMap.customTypes.keys(),
     ]);
     if (desiredSchemas.size === 0) {
-        console.log(`\x1b[34m• Skipping schemas since none found.\x1b[0m`);
+        logInfo(`• Skipping schemas since none found.\x1b[0m`);
         return;
     }
     await mkdir(`${schemaParentDir}/schemas`, { recursive: true });

package/dist/src/utils.d.ts

@@ -1,4 +1,7 @@
 import { InspectorState } from '@pikku/inspector';
+export declare const logPrimary: (message: string) => void;
+export declare const logSuccess: (message: string) => void;
+export declare const logInfo: (message: string) => void;
 export declare const getFileImportRelativePath: (from: string, to: string, packageMappings: Record<string, string>) => string;
 interface Meta {
     file: string;

package/dist/src/utils.js

@@ -1,6 +1,17 @@
 // import packageInfo from '../package.json'
 import { relative, dirname } from 'path';
 import { mkdir, writeFile } from 'fs/promises';
+import chalk from 'chalk';
+import packageJson from '../package.json';
+export const logPrimary = (message) => {
+    console.log(chalk.green(message));
+};
+export const logSuccess = (message) => {
+    console.log(chalk.green(message));
+};
+export const logInfo = (message) => {
+    console.log(chalk.blue(message));
+};
 export const getFileImportRelativePath = (from, to, packageMappings) => {
     let filePath = relative(dirname(from), to);
     if (!/^\.+\//.test(filePath)) {
@@ -86,21 +97,30 @@ export const writeFileInDir = async (path, content, ignoreModifyComment = false)
     }
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, content, 'utf-8');
-    console.log(`\x1b[32m✓ File written to ${path}\x1b[0m`);
+    logSuccess(`✓ File written to ${path}`);
 };
 export const logCommandInfoAndTime = async (commandStart, commandEnd, [skipCondition, skipMessage = 'none found'], callback) => {
     if (skipCondition === true) {
-        console.log(`\x1b[34m• Skipping ${commandStart} since ${skipMessage}.\x1b[0m`);
+        logInfo(`• Skipping ${commandStart} since ${skipMessage}.`);
         return false;
     }
     const start = Date.now();
-    console.log(`\x1b[34m• ${commandStart}...\x1b[0m`);
+    chalk.blue(`• ${commandStart}...`);
     await callback();
-    console.log(`\x1b[32m✓ ${commandEnd} in ${Date.now() - start}ms.\x1b[0m`);
+    logSuccess(`✓ ${commandEnd} in ${Date.now() - start}ms.`);
     return true;
 };
+const logo = `
+ ______ _ _     _           
+(_____ (_) |   | |          
+ _____) )| |  _| |  _ _   _ 
+|  ____/ | |_/ ) |_/ ) | | |
+| |    | |  _ (|  _ (| |_| |
+|_|    |_|_| \_)_| \_)____/ 
+`;
 export const logPikkuLogo = () => {
-    console.log(`\x1b[33m⚙️ PIKKU CLI ⚙️\n-------------------\x1b[0m`);
+    logPrimary(logo);
+    logPrimary(`⚙️ Welcome to the Pikku CLI (v${packageJson})\n`);
 };
 // TODO: add version back in once the ESM dust settles
 export const DO_NOT_MODIFY_COMMENT = `/**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.6.6",
+  "version": "0.6.9",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -14,7 +14,7 @@
     "build:esm": "tsc -b",
     "schema": "ts-json-schema-generator -o cli.schema.json --path 'src/pikku-cli-config.ts' --type 'PikkuCLIConfig'",
     "build": "yarn build:esm && yarn schema",
-    "ncu": "ncu -x '/.*glob.*/'",
+    "ncu": "npx npm-check-updates -x '/.*glob.*/'",
     "release": "yarn build && npm test",
     "test": "bash run-tests.sh",
     "test:watch": "bash run-tests.sh --watch",
@@ -22,10 +22,11 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
-    "@pikku/core": "^0.6.7",
+    "@pikku/core": "^0.6.11",
     "@pikku/inspector": "^0.6.2",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
+    "chalk": "^5.4.1",
     "commander": "^12",
     "glob": "^10",
     "path-to-regexp": "^8.2.0",

package/src/channels/serialize-typed-channel-map.ts

@@ -1,6 +1,7 @@
 import { ChannelsMeta } from '@pikku/core/channel'
 import { serializeImportMap } from '../core/serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
+import { generateCustomTypes } from '../http/serialize-typed-route-map.js'
 
 export const serializeTypedChannelsMap = (
   relativeToPath: string,
@@ -20,11 +21,13 @@ export const serializeTypedChannelsMap = (
     typesMap,
     requiredTypes
   )
+  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
   return `/**
  * This provides the structure needed for TypeScript to be aware of channels
  */
     
 ${imports}
+${serializedCustomTypes}
 
 interface ChannelHandler<I, O> {
     input: I;
@@ -106,7 +109,7 @@ function generateChannels(channelsMeta: ChannelsMeta) {
       for (const [method, handler] of Object.entries(methods)) {
         routesStr += `        readonly ${method}: ChannelHandler<${formatTypeArray(
           handler.inputTypes
-        )}, ${formatTypeArray(handler.outputTypes)}>,\n`
+        )}, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`
       }
       routesStr += '      },\n'
     }

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

@@ -11,10 +11,10 @@ export const serializePikkuTypes = (
 * This is used to provide the application types in the typescript project
 */
   
-import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, MakeRequired } from '@pikku/core'
-import { CoreHTTPFunctionRoute, AssertRouteParams } from '@pikku/core/http'
-import { CoreScheduledTask } from '@pikku/core/scheduler'
-import { CoreAPIChannel, CoreChannelConnection, CoreChannelDisconnection, CoreChannelMessage, PikkuChannel } from '@pikku/core/channel'
+import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } 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}
 ${sessionServicesTypeImport}
@@ -25,29 +25,27 @@ export type APIFunctionSessionless<In = unknown, Out = never, RequiredServices =
 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 ChannelConnection<Out = never, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<${userSessionTypeName}, ChannelData, Out>) => Promise<void>
-export type ChannelDisconnection<ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<${userSessionTypeName}, ChannelData, never>) => Promise<void>
-export type ChannelMessage<In, Out = never, ChannelData = unknown, RequiredServices extends ${servicesTypeName} = ${servicesTypeName}> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<${userSessionTypeName}, ChannelData, Out>, data: In) => Promise<Out | void>
-type APIChannel<ChannelData, Channel extends string, In extends unknown, Out extends unknown> = CoreAPIChannel<ChannelData, Channel, ChannelConnection, ChannelDisconnection, ChannelMessage<In, Out, ChannelData>>
+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>
+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}>
 
-declare module "@pikku/core" {
-  // type APIPermission<In = unknown, RequiredServices = ${servicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
-  // type APIFunction = <In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunction<In, Out, RequiredServices, ${userSessionTypeName}>
-  // type APIFunctionSessionless = <In = unknown, Out = never, RequiredServices = ${servicesTypeName}> = CoreAPIFunctionSessionless<In, Out, RequiredServices, ${userSessionTypeName}>
-
-  function addChannel<ChannelData, Channel extends string>(
-    channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
-  ): void;
+export const addChannel = <ChannelData, Channel extends string>(
+  channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
+) => {
+  addCoreChannel(channel as any) // TODO
+}
 
-  function addRoute<In, Out, Route extends string>(
-    route: APIRoute<In, Out, Route> & AssertRouteParams<In, Route>
-  ): void;
+export const addRoute = <In, Out, Route extends string>(
+  route: APIRoute<In, Out, Route> & AssertRouteParams<In, Route>
+) => {
+  addCoreHTTP(route)
+}
 
-  function addScheduledTask(
-    task: ScheduledTask
-  ): void;
+export const addScheduledTask = (task: ScheduledTask) => {
+  addCoreScheduledTask(task as any) // TODO
 }
 `
 }

package/src/http/serialize-typed-route-map.ts

@@ -46,7 +46,10 @@ export type RoutesWithMethod<Method extends string> = {
   `
 }
 
-function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>) {
+export function generateCustomTypes(
+  typesMap: TypesMap,
+  requiredTypes: Set<string>
+) {
   return `
 // Custom types are those that are defined directly within generics
 // or are broken into simpler types

package/src/pikku-cli-config.ts

@@ -118,10 +118,7 @@ const _getPikkuCLIConfig = async (
         result.channelsFile = join(result.outDir, 'pikku-channels.gen.ts')
       }
       if (!result.typesDeclarationFile) {
-        result.typesDeclarationFile = join(
-          result.outDir,
-          'pikku-types.gen.d.ts'
-        )
+        result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts')
       }
       if (!result.routesMapDeclarationFile) {
         result.routesMapDeclarationFile = join(

package/src/schema/schema-generator.ts

@@ -1,5 +1,5 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator'
-import { writeFileInDir } from '../utils.js'
+import { logInfo, writeFileInDir } from '../utils.js'
 import { mkdir, writeFile } from 'fs/promises'
 import { JSONValue } from '@pikku/core'
 import { HTTPRoutesMeta } from '@pikku/core/http'
@@ -42,7 +42,7 @@ export async function generateSchemas(
     } catch (e) {
       // Ignore rootless errors
       if (e instanceof RootlessError) {
-        console.log('Error generating schema since it has no root:', schema)
+        console.error('Error generating schema since it has no root:', schema)
         return
       }
       throw e
@@ -80,7 +80,7 @@ export async function saveSchemas(
   ])
 
   if (desiredSchemas.size === 0) {
-    console.log(`\x1b[34m• Skipping schemas since none found.\x1b[0m`)
+    logInfo(`• Skipping schemas since none found.\x1b[0m`)
     return
   }
 

package/src/utils.ts

@@ -2,6 +2,20 @@
 import { relative, dirname } from 'path'
 import { PathToNameAndType, InspectorState } from '@pikku/inspector'
 import { mkdir, writeFile } from 'fs/promises'
+import chalk from 'chalk'
+import packageJson from '../package.json'
+
+export const logPrimary = (message: string) => {
+  console.log(chalk.green(message))
+}
+
+export const logSuccess = (message: string) => {
+  console.log(chalk.green(message))
+}
+
+export const logInfo = (message: string) => {
+  console.log(chalk.blue(message))
+}
 
 export const getFileImportRelativePath = (
   from: string,
@@ -184,7 +198,7 @@ export const writeFileInDir = async (
 
   await mkdir(dirname(path), { recursive: true })
   await writeFile(path, content, 'utf-8')
-  console.log(`\x1b[32m✓ File written to ${path}\x1b[0m`)
+  logSuccess(`✓ File written to ${path}`)
 }
 
 export const logCommandInfoAndTime = async (
@@ -194,22 +208,30 @@ export const logCommandInfoAndTime = async (
   callback: (...args: any[]) => Promise<unknown>
 ): Promise<boolean> => {
   if (skipCondition === true) {
-    console.log(
-      `\x1b[34m• Skipping ${commandStart} since ${skipMessage}.\x1b[0m`
-    )
+    logInfo(`• Skipping ${commandStart} since ${skipMessage}.`)
     return false
   }
 
   const start = Date.now()
-  console.log(`\x1b[34m• ${commandStart}...\x1b[0m`)
+  chalk.blue(`• ${commandStart}...`)
   await callback()
 
-  console.log(`\x1b[32m✓ ${commandEnd} in ${Date.now() - start}ms.\x1b[0m`)
+  logSuccess(`✓ ${commandEnd} in ${Date.now() - start}ms.`)
   return true
 }
 
+const logo = `
+ ______ _ _     _           
+(_____ (_) |   | |          
+ _____) )| |  _| |  _ _   _ 
+|  ____/ | |_/ ) |_/ ) | | |
+| |    | |  _ (|  _ (| |_| |
+|_|    |_|_| \_)_| \_)____/ 
+`
+
 export const logPikkuLogo = () => {
-  console.log(`\x1b[33m⚙️ PIKKU CLI ⚙️\n-------------------\x1b[0m`)
+  logPrimary(logo)
+  logPrimary(`⚙️ Welcome to the Pikku CLI (v${packageJson})\n`)
 }
 
 // TODO: add version back in once the ESM dust settles