@pikku/cli 0.6.19 → 0.7.0

package/dist/src/openapi-spec-generator.js

@@ -0,0 +1,136 @@
+import { pikkuState } from '@pikku/core';
+import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema';
+const convertSchema = 'default' in _convertSchema ? _convertSchema.default : _convertSchema;
+const getErrorResponseForConstructorName = (constructorName) => {
+    const errors = Array.from(pikkuState('misc', 'errors').entries());
+    const foundError = errors.find(([e]) => e.name === constructorName);
+    if (foundError) {
+        return foundError[1];
+    }
+    return undefined;
+};
+const convertSchemasToBodyPayloads = async (routesMeta, schemas) => {
+    const requiredSchemas = new Set(routesMeta
+        .map(({ inputTypes, output }) => [inputTypes?.body, output])
+        .flat()
+        .filter((schema) => !!schema));
+    const convertedEntries = await Promise.all(Object.entries(schemas).map(async ([key, schema]) => {
+        if (requiredSchemas.has(key)) {
+            const convertedSchema = await convertSchema(schema, {
+                convertUnreferencedDefinitions: false,
+                dereference: { circular: 'ignore' },
+            });
+            return [key, convertedSchema];
+        }
+        return;
+    }));
+    return Object.fromEntries(convertedEntries.filter((s) => !!s));
+};
+export async function generateOpenAPISpec(routeMeta, schemas, additionalInfo) {
+    const paths = {};
+    routeMeta.forEach((meta) => {
+        const { route, method, inputTypes, output, params, query, docs } = meta;
+        const path = route.replace(/:(\w+)/g, '{$1}'); // Convert ":param" to "{param}"
+        if (!paths[path]) {
+            paths[path] = {};
+        }
+        const responses = {};
+        docs?.errors?.forEach((error) => {
+            const errorResponse = getErrorResponseForConstructorName(error);
+            if (errorResponse) {
+                responses[errorResponse.status] = {
+                    description: errorResponse.message,
+                };
+            }
+        });
+        const operation = {
+            description: docs?.description ||
+                `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
+            tags: docs?.tags || [route.split('/')[1] || 'default'],
+            parameters: [],
+            responses: {
+                ...responses,
+                '200': {
+                    description: 'Successful response',
+                    content: output
+                        ? {
+                            'application/json': {
+                                schema: typeof output === 'string' &&
+                                    ['boolean', 'string', 'number'].includes(output)
+                                    ? { type: output }
+                                    : { $ref: `#/components/schemas/${output}` },
+                            },
+                        }
+                        : undefined,
+                },
+            },
+        };
+        const bodyType = inputTypes?.body;
+        if (bodyType) {
+            operation.requestBody = {
+                required: true,
+                content: {
+                    'application/json': {
+                        schema: typeof bodyType === 'string' &&
+                            ['boolean', 'string', 'number'].includes(bodyType)
+                            ? { type: bodyType }
+                            : { $ref: `#/components/schemas/${bodyType}` },
+                    },
+                },
+            };
+        }
+        if (params) {
+            operation.parameters = params.map((param) => ({
+                name: param,
+                in: 'path',
+                required: true,
+                schema: { type: 'string' },
+            }));
+        }
+        if (query) {
+            operation.parameters.push(...query.map((query) => ({
+                name: query,
+                in: 'query',
+                required: false,
+                schema: { type: 'string' },
+            })));
+        }
+        paths[path][method] = operation;
+    });
+    return {
+        openapi: '3.1.0',
+        info: additionalInfo.info,
+        servers: additionalInfo.servers,
+        paths,
+        components: {
+            schemas: await convertSchemasToBodyPayloads(routeMeta, schemas),
+            responses: {},
+            parameters: {},
+            examples: {},
+            requestBodies: {},
+            headers: {},
+            securitySchemes: additionalInfo.securitySchemes || {
+                ApiKeyAuth: {
+                    type: 'apiKey',
+                    in: 'header',
+                    name: 'x-api-key',
+                },
+                BearerAuth: {
+                    type: 'http',
+                    scheme: 'bearer',
+                },
+            },
+        },
+        security: additionalInfo.security || [
+            {
+                ApiKeyAuth: [],
+            },
+            {
+                BearerAuth: [],
+            },
+        ],
+        tags: additionalInfo.tags,
+        externalDocs: additionalInfo.externalDocs,
+        // definitions
+    };
+}

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

@@ -1,13 +1,18 @@
-import { OpenAPISpecInfo } from './openapi/openapi-spec-generator.js';
+import { OpenAPISpecInfo } from './openapi-spec-generator.js';
 import { InspectorFilters } from '@pikku/inspector';
 export interface PikkuCLICoreOutputFiles {
     outDir?: string;
-    routesFile: string;
+    functionsFile: string;
+    functionsMetaFile: string;
+    httpRoutesFile: string;
+    httpRoutesMetaFile: string;
     channelsFile: string;
+    channelsMetaFile: string;
     schedulersFile: string;
+    schedulersMetaFile: string;
     schemaDirectory: string;
     typesDeclarationFile: string;
-    routesMapDeclarationFile: string;
+    httpRoutesMapDeclarationFile: string;
     channelsMapDeclarationFile: string;
     bootstrapFile: string;
 }
@@ -15,7 +20,7 @@ export type PikkuCLIConfig = {
     $schema?: string;
     extends?: string;
     rootDir: string;
-    routeDirectories: string[];
+    srcDirectories: string[];
     packageMappings: Record<string, string>;
     supportsImportAttributes: boolean;
     configDir: string;

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

@@ -56,20 +56,35 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             if (!result.schemaDirectory) {
                 result.schemaDirectory = join(result.outDir, 'pikku-schemas');
             }
-            if (!result.routesFile) {
-                result.routesFile = join(result.outDir, 'pikku-routes.gen.ts');
+            if (!result.functionsFile) {
+                result.functionsFile = join(result.outDir, 'pikku-functions.gen.ts');
+            }
+            if (!result.functionsMetaFile) {
+                result.functionsMetaFile = join(result.outDir, 'pikku-functions-meta.gen.ts');
+            }
+            if (!result.httpRoutesFile) {
+                result.httpRoutesFile = join(result.outDir, 'pikku-http-routes.gen.ts');
+            }
+            if (!result.httpRoutesMetaFile) {
+                result.httpRoutesMetaFile = join(result.outDir, 'pikku-http-routes-meta.gen.ts');
             }
             if (!result.schedulersFile) {
                 result.schedulersFile = join(result.outDir, 'pikku-schedules.gen.ts');
             }
+            if (!result.schedulersMetaFile) {
+                result.schedulersMetaFile = join(result.outDir, 'pikku-schedules-meta.gen.ts');
+            }
             if (!result.channelsFile) {
                 result.channelsFile = join(result.outDir, 'pikku-channels.gen.ts');
             }
+            if (!result.channelsMetaFile) {
+                result.channelsMetaFile = join(result.outDir, 'pikku-channels-meta.gen.ts');
+            }
             if (!result.typesDeclarationFile) {
                 result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts');
             }
-            if (!result.routesMapDeclarationFile) {
-                result.routesMapDeclarationFile = join(result.outDir, 'pikku-routes-map.gen.d.ts');
+            if (!result.httpRoutesMapDeclarationFile) {
+                result.httpRoutesMapDeclarationFile = join(result.outDir, 'pikku-routes-map.gen.d.ts');
             }
             if (!result.channelsMapDeclarationFile) {
                 result.channelsMapDeclarationFile = join(result.outDir, 'pikku-channels-map.gen.d.ts');

package/dist/src/scheduler/serialize-schedulers.js

@@ -15,8 +15,9 @@ export const serializeSchedulerMeta = (scheduledTasksMeta) => {
     const serializedOutput = [];
     serializedOutput.push("import { pikkuState } from '@pikku/core'");
     serializedOutput.push(`pikkuState('scheduler', 'meta', ${JSON.stringify(scheduledTasksMeta, null, 2)})`);
-    if (scheduledTasksMeta.length > 0) {
-        serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMeta.map((s) => s.name).join("' | '")}'`);
+    const scheduledTasksMetaValues = Object.values(scheduledTasksMeta);
+    if (scheduledTasksMetaValues.length > 0) {
+        serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);
     }
     return serializedOutput.join('\n');
 };

package/dist/src/schema/schema-generator.d.ts

@@ -1,5 +1,5 @@
 import { JSONValue } from '@pikku/core';
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { TypesMap } from '@pikku/inspector';
-export declare function generateSchemas(tsconfig: string, typesMap: TypesMap, routesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
+export declare function generateSchemas(tsconfig: string, typesMaps: TypesMap[], httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
 export declare function saveSchemas(schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, supportsImportAttributes: boolean): Promise<void>;

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

@@ -1,15 +1,28 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator';
 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());
-    for (const { input, output, inputTypes } of routesMeta) {
+export async function generateSchemas(tsconfig, typesMaps, httpRoutesMeta) {
+    const schemasSet = new Set(typesMaps.flatMap((tm) => [...tm.customTypes.keys()]));
+    for (const { input, inputTypes } of httpRoutesMeta) {
         if (input) {
-            schemasSet.add(typesMap.getTypeMeta(input).uniqueName);
-        }
-        if (output) {
-            schemasSet.add(typesMap.getTypeMeta(output).uniqueName);
+            for (const typesMap of typesMaps) {
+                const uniqueName = typesMap.getUniqueName(input);
+                if (uniqueName) {
+                    schemasSet.add(uniqueName);
+                    break;
+                }
+            }
         }
+        // if (output) {
+        //   for (const typesMap of typesMaps) {
+        //     const uniqueName = typesMap.getUniqueName(output)
+        //     if (uniqueName) {
+        //       console.log('Adding output schema:', uniqueName)
+        //       schemasSet.add(uniqueName)
+        //       break
+        //     }
+        //   }
+        // }
         if (inputTypes?.body) {
             schemasSet.add(inputTypes.body);
         }

package/dist/src/schema-generator.d.ts

@@ -0,0 +1,5 @@
+import { JSONValue } from '@pikku/core';
+import { HTTPRoutesMeta } from '@pikku/core/http';
+import { TypesMap } from '@pikku/inspector';
+export declare function generateSchemas(tsconfig: string, typesMaps: TypesMap[], httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
+export declare function saveSchemas(schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, supportsImportAttributes: boolean): Promise<void>;

package/dist/src/schema-generator.js

@@ -0,0 +1,98 @@
+import { createGenerator, RootlessError } from 'ts-json-schema-generator';
+import { logInfo, writeFileInDir } from './utils.js';
+import { mkdir, writeFile } from 'fs/promises';
+export async function generateSchemas(tsconfig, typesMaps, httpRoutesMeta) {
+    const schemasSet = new Set(typesMaps.flatMap((tm) => [...tm.customTypes.keys()]));
+    for (const { input, inputTypes } of httpRoutesMeta) {
+        if (input) {
+            let found = false;
+            for (const typesMap of typesMaps) {
+                try {
+                    const uniqueName = typesMap.getUniqueName(input);
+                    if (uniqueName) {
+                        found = true;
+                        schemasSet.add(uniqueName);
+                        break;
+                    }
+                }
+                catch (e) {
+                }
+            }
+            if (!found) {
+                console.error('Input type not found in any types map:', input);
+            }
+        }
+        // if (output) {
+        //   for (const typesMap of typesMaps) {
+        //     const uniqueName = typesMap.getUniqueName(output)
+        //     if (uniqueName) {
+        //       console.log('Adding output schema:', uniqueName)
+        //       schemasSet.add(uniqueName)
+        //       break
+        //     }
+        //   }
+        // }
+        if (inputTypes?.body) {
+            schemasSet.add(inputTypes.body);
+        }
+        if (inputTypes?.query) {
+            schemasSet.add(inputTypes.query);
+        }
+        if (inputTypes?.params) {
+            schemasSet.add(inputTypes.params);
+        }
+    }
+    const generator = createGenerator({
+        tsconfig,
+        skipTypeCheck: true,
+        topRef: false,
+        discriminatorType: 'open-api',
+    });
+    const schemas = {};
+    schemasSet.forEach((schema) => {
+        try {
+            schemas[schema] = generator.createSchema(schema);
+        }
+        catch (e) {
+            // Ignore rootless errors
+            if (e instanceof RootlessError) {
+                console.error('Error generating schema since it has no root:', schema);
+                return;
+            }
+            throw e;
+        }
+    });
+    return schemas;
+}
+export async function saveSchemas(schemaParentDir, schemas, typesMap, routesMeta, supportsImportAttributes) {
+    await writeFileInDir(`${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
+    const desiredSchemas = new Set([
+        ...routesMeta
+            .map(({ input, output }) => [
+            input ? typesMap.getUniqueName(input) : undefined,
+            output ? typesMap.getUniqueName(output) : undefined,
+        ])
+            .flat()
+            .filter((s) => !!s &&
+            !['boolean', 'string', 'number', 'null', 'undefined'].includes(s)),
+        ...typesMap.customTypes.keys(),
+    ]);
+    if (desiredSchemas.size === 0) {
+        logInfo(`• Skipping schemas since none found.\x1b[0m`);
+        return;
+    }
+    await mkdir(`${schemaParentDir}/schemas`, { recursive: true });
+    await Promise.all(Object.entries(schemas).map(async ([schemaName, schema]) => {
+        if (desiredSchemas.has(schemaName)) {
+            await writeFile(`${schemaParentDir}/schemas/${schemaName}.schema.json`, JSON.stringify(schema), 'utf-8');
+        }
+    }));
+    const schemaImports = Array.from(desiredSchemas)
+        .map((schema) => `
+import * as ${schema} from './schemas/${schema}.schema.json' ${supportsImportAttributes ? `with { type: 'json' }` : ''}
+addSchema('${schema}', ${schema})
+`)
+        .join('\n');
+    await writeFileInDir(`${schemaParentDir}/register.gen.ts`, `import { addSchema } from '@pikku/core/schema'
+${schemaImports}`);
+}

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

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

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

@@ -0,0 +1,67 @@
+export const serializeFetchWrapper = (routesMapPath) => {
+    return `
+import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
+import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
+
+export class PikkuFetch extends CorePikkuFetch {
+    public async post<Route extends RoutesWithMethod<'POST'>>(
+        route: Route,
+        ...args: null extends RouteHandlerOf<Route, 'POST'>['input']
+            ? [data?: Exclude<RouteHandlerOf<Route, 'POST'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: RouteHandlerOf<Route, 'POST'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<RouteHandlerOf<Route, 'POST'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'POST', data, options);
+    }
+
+    public async get<Route extends RoutesWithMethod<'GET'>>(
+        route: Route,
+        ...args: null extends RouteHandlerOf<Route, 'GET'>['input']
+            ? [data?: Exclude<RouteHandlerOf<Route, 'GET'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: RouteHandlerOf<Route, 'GET'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<RouteHandlerOf<Route, 'GET'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'GET', data, options);
+    }
+
+    public async patch<Route extends RoutesWithMethod<'PATCH'>>(
+        route: Route,
+        ...args: null extends RouteHandlerOf<Route, 'PATCH'>['input']
+            ? [data?: Exclude<RouteHandlerOf<Route, 'PATCH'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: RouteHandlerOf<Route, 'PATCH'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<RouteHandlerOf<Route, 'PATCH'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'PATCH', data, options);
+    }
+
+    public async head<Route extends RoutesWithMethod<'HEAD'>>(
+        route: Route,
+        ...args: null extends RouteHandlerOf<Route, 'HEAD'>['input']
+            ? [data?: Exclude<RouteHandlerOf<Route, 'HEAD'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: RouteHandlerOf<Route, 'HEAD'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<RouteHandlerOf<Route, 'HEAD'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'HEAD', data, options);
+    }
+
+    public async delete<Route extends RoutesWithMethod<'DELETE'>>(
+        route: Route,
+        ...args: null extends RouteHandlerOf<Route, 'DELETE'>['input']
+            ? [data?: Exclude<RouteHandlerOf<Route, 'DELETE'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: RouteHandlerOf<Route, 'DELETE'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<RouteHandlerOf<Route, 'DELETE'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'DELETE', data, options);
+    }
+
+    public async fetch<
+        Route extends keyof RoutesMap,
+        Method extends keyof RoutesMap[Route]
+    >(route: Route, method: Method, data: RouteHandlerOf<Route, Method>['input'], options?: Omit<RequestInit, 'body'>): Promise<Response> {
+        return await super.fetch(route, method as HTTPMethod, data, options);
+    }
+}
+
+export const pikkuFetch = new PikkuFetch();
+`;
+};

package/dist/src/serialize-import-map.d.ts

@@ -0,0 +1,2 @@
+import { TypesMap } from '@pikku/inspector';
+export declare const serializeImportMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, requiredTypes: Set<string>) => string;

package/dist/src/serialize-import-map.js

@@ -0,0 +1,24 @@
+import { getFileImportRelativePath } from './utils.js';
+export const serializeImportMap = (relativeToPath, packageMappings, typesMap, requiredTypes) => {
+    const paths = new Map();
+    Array.from(requiredTypes).forEach((requiredType) => {
+        const { originalName, uniqueName, path } = typesMap.getTypeMeta(requiredType);
+        if (!path) {
+            // This is a custom type that exists in file, so we don't need to import it
+            return;
+        }
+        const variables = paths.get(path) || [];
+        if (originalName === uniqueName) {
+            variables.push(originalName);
+        }
+        else {
+            variables.push(`${originalName} as ${uniqueName}`);
+        }
+        paths.set(path, variables);
+    });
+    const imports = [];
+    for (const [path, variables] of paths.entries()) {
+        imports.push(`import type { ${variables.join(', ')} } from '${getFileImportRelativePath(relativeToPath, path, packageMappings)}'`);
+    }
+    return imports.join('\n');
+};

package/dist/src/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/{src/nextjs/serialize-nextjs-backend-wrapper.ts → dist/src/serialize-nextjs-backend-wrapper.js}

@@ -1,12 +1,5 @@
-export const serializeNextJsBackendWrapper = (
-  routesPath: string,
-  routesMapPath: string,
-  schemasPath: string,
-  configImport: string,
-  singleServicesFactoryImport: string,
-  sessionServicesImport: string
-) => {
-  return `'server-only'
+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.
@@ -183,5 +176,5 @@ export const pikku = (_options?: any) => {
     staticPost
   }
 }
-`
-}
+`;
+};

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

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

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

@@ -1,8 +1,5 @@
-export const serializeNextJsHTTPWrapper = (
-  routesMapPath: string,
-  pikkuFetchImport: string
-) => {
-  return `'server-only'
+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.
@@ -159,5 +156,5 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
     staticPost
   }
 }
-`
-}
+`;
+};

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

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

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

@@ -0,0 +1,136 @@
+/**
+ *
+ */
+export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, servicesTypeName) => {
+    return `/**
+* This is used to provide the application types in the typescript project
+*/
+  
+import { CoreAPIPermission, PikkuMiddleware } from '@pikku/core'
+import { CoreAPIFunction, CoreAPIFunctionSessionless } from '@pikku/core/function'
+import { CoreHTTPFunctionRoute, AssertRouteParams, addHTTPRoute as addCoreHTTPRoute } from '@pikku/core/http'
+import { CoreScheduledTask, addScheduledTask as addCoreScheduledTask } from '@pikku/core/scheduler'
+import { CoreAPIChannel, PikkuChannel, addChannel as addCoreChannel } from '@pikku/core/channel'
+
+${userSessionTypeImport}
+${singletonServicesTypeImport}
+${sessionServicesTypeImport}
+
+export type APIPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
+export type APIMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = PikkuMiddleware<RequiredServices, ${userSessionTypeName}>
+
+type APIFunctionSessionless<
+  In = unknown, 
+  Out = never, 
+  ChannelData = null,  // null means optional channel
+  RequiredServices extends Services = Services & (
+    [ChannelData] extends [null] 
+      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
+      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  )
+> = CoreAPIFunctionSessionless<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
+
+type APIFunction<
+  In = unknown, 
+  Out = never, 
+  ChannelData = null,  // null means optional channel
+  RequiredServices extends Services = Services & (
+    [ChannelData] extends [null] 
+      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
+      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  )
+> = CoreAPIFunction<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
+
+type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>, APIMiddleware>
+type APIChannel<ChannelData, Channel extends string> = CoreAPIChannel<ChannelData, Channel, APIFunction<void, unknown> | APIFunction<void, unknown, ChannelData>, APIFunction<void, void> | APIFunction<void, void, ChannelData>, APIFunction<any, any> | APIFunction<any, any, ChannelData>, APIPermission>
+type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>, ${userSessionTypeName}>
+
+export const pikkuFunc = <In, Out = unknown>(
+  func:
+    | APIFunction<In, Out>
+    | {
+        func: APIFunction<In, Out>
+        auth?: true
+        name?: string
+      }
+    | {
+        func: APIFunctionSessionless<In, Out>
+        auth: false
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuSessionlessFunc = <In, Out = unknown>(
+  func:
+    | APIFunctionSessionless<In, Out>
+    | {
+        func: APIFunctionSessionless<In, Out>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelConnectionFunc = <Out = unknown, ChannelData = unknown>(
+  func:
+    | APIFunctionSessionless<void, Out, ChannelData>
+    | {
+        func: APIFunctionSessionless<void, Out, ChannelData>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelDisconnectionFunc = <ChannelData = unknown>(
+  func:
+    | APIFunctionSessionless<void, void, ChannelData>
+    | {
+        func: APIFunction<void, void, ChannelData>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unknown>(
+  func:
+    | APIFunctionSessionless<In, Out, ChannelData>
+    | {
+        func: APIFunctionSessionless<In, Out, ChannelData>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+
+export const pikkuVoidFunc = (
+  func:
+    | APIFunctionSessionless<void, void>
+    | {
+        func: APIFunctionSessionless<void, void>
+        name?: string
+      }
+) => {
+  return typeof func === 'function' ? func : func.func
+}
+   
+export const addChannel = <ChannelData, Channel extends string>(
+  channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
+) => {
+  addCoreChannel(channel as any) // TODO
+}
+
+export const addHTTPRoute = <In, Out, Route extends string>(
+  route: APIRoute<In, Out, Route> & AssertRouteParams<In, Route>
+) => {
+  addCoreHTTPRoute(route)
+}
+
+export const addScheduledTask = (task: ScheduledTask) => {
+  addCoreScheduledTask(task as any) // TODO
+}
+`;
+};

package/dist/src/serialize-scheduler-meta.d.ts

@@ -0,0 +1,2 @@
+import { ScheduledTasksMeta } from '@pikku/core/scheduler';
+export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => string;