@pikku/cli 0.11.3 → 0.12.1

package/dist/src/functions/wirings/functions/pikku-command-addon-types.js

@@ -0,0 +1,33 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { checkRequiredTypes } from '../../../utils/check-required-types.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeAddonTypes } from './serialize-addon-types.js';
+export const pikkuAddonTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        if (!config.addon) {
+            return;
+        }
+        const visitState = await getInspectorState();
+        const { addonTypesFile, packageMappings, servicesFile, secretsFile, variablesFile, } = config;
+        checkRequiredTypes(visitState.filesAndMethodsErrors, {
+            singletonServicesType: true,
+        });
+        const { singletonServicesType, pikkuConfigType } = visitState.filesAndMethods;
+        if (!singletonServicesType) {
+            throw new Error('Required types not found');
+        }
+        const configTypeImport = pikkuConfigType
+            ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(addonTypesFile, pikkuConfigType.typePath, packageMappings)}'`
+            : '// Config type not found, will use fallback';
+        const content = serializeAddonTypes(`import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(addonTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, configTypeImport, `import type { RequiredSingletonServices } from '${getFileImportRelativePath(addonTypesFile, servicesFile, packageMappings)}'`, `import { TypedSecretService } from '${getFileImportRelativePath(addonTypesFile, secretsFile, packageMappings)}'`, `import { TypedVariablesService } from '${getFileImportRelativePath(addonTypesFile, variablesFile, packageMappings)}'`);
+        await writeFileInDir(logger, addonTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating addon types',
+            commandEnd: 'Created addon types',
+        }),
+    ],
+});

package/dist/src/functions/wirings/functions/pikku-command-function-types-split.d.ts

@@ -1 +1 @@
-export declare const pikkuFunctionTypesSplit: any;
+export declare const pikkuFunctionTypesSplit: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/functions/pikku-command-function-types-split.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
@@ -21,7 +21,7 @@ export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
         const configTypeImport = pikkuConfigType
             ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(functionTypesFile, pikkuConfigType.typePath, packageMappings)}'`
             : '// Config type not found, will use fallback';
-        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`, wireServicesType.type, `import type { TypedPikkuRPC, FlattenedRPCMap } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport, config.externalPackageName);
+        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`, wireServicesType.type, `import type { TypedPikkuRPC, FlattenedRPCMap } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport, config.addonName, undefined, config.node?.categories);
         await writeFileInDir(logger, functionTypesFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/functions/pikku-command-function-types.d.ts

@@ -1 +1 @@
-export declare const pikkuFunctionTypes: any;
+export declare const pikkuFunctionTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/functions/pikku-command-function-types.js

@@ -1,17 +1,17 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
 export const pikkuFunctionTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, forgeTypesFile, } = config;
-        const getImportPath = (file) => config.externalPackage
+        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, triggersTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, nodeTypesFile, secretTypesFile, addonTypesFile, } = config;
+        const getImportPath = (file) => config.addon
             ? null
             : getFileImportRelativePath(typesFile, file, packageMappings);
-        // Forge types are included for external packages (they need wireForgeNode/wireForgeCredential)
-        const getForgeImportPath = (file) => getFileImportRelativePath(typesFile, file, packageMappings);
-        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getImportPath(httpTypesFile), getImportPath(channelsTypesFile), getImportPath(schedulersTypesFile), getImportPath(queueTypesFile), getImportPath(mcpTypesFile), getImportPath(cliTypesFile), getForgeImportPath(forgeTypesFile));
+        // Node and trigger types are included for addon packages
+        const getAlwaysImportPath = (file) => getFileImportRelativePath(typesFile, file, packageMappings);
+        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getImportPath(httpTypesFile), getImportPath(channelsTypesFile), getAlwaysImportPath(triggersTypesFile), getImportPath(schedulersTypesFile), getImportPath(queueTypesFile), getImportPath(mcpTypesFile), getImportPath(cliTypesFile), getAlwaysImportPath(nodeTypesFile), getAlwaysImportPath(secretTypesFile), config.addon ? getAlwaysImportPath(addonTypesFile) : null);
         await writeFileInDir(logger, typesFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/functions/pikku-command-functions.d.ts

@@ -1 +1 @@
-export declare const pikkuFunctions: any;
+export declare const pikkuFunctions: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/functions/pikku-command-functions.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeFunctionImports } from './serialize-function-imports.js';
@@ -21,24 +21,18 @@ export const pikkuFunctions = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        const packageName = config.externalPackageName
-            ? `'${config.externalPackageName}'`
-            : 'null';
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState, FunctionsMeta } from '@pikku/core'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`);
-        // For external packages, register ALL functions (they'll be invoked by consumers)
+        const packageName = config.addonName ? `'${config.addonName}'` : 'null';
+        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core/internal'\nimport type { FunctionsMeta } from '@pikku/core'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`);
+        // For addon packages, register ALL functions (they'll be invoked by consumers)
         // For main packages, only register functions that are invoked via internal RPCs
-        const isExternalPackage = !!config.externalPackageName;
+        const isAddon = !!config.addonName;
         const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0;
         const hasFunctions = functions.files.size > 0;
-        const shouldGenerateFunctionsFile = isExternalPackage
-            ? hasFunctions
-            : hasRPCs;
+        const shouldGenerateFunctionsFile = isAddon ? hasFunctions : hasRPCs;
         if (shouldGenerateFunctionsFile) {
-            // For external packages, use all function files; for main packages, use internal RPC files
-            const filesToRegister = isExternalPackage
-                ? functions.files
-                : rpc.internalFiles;
-            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, filesToRegister, functions.meta, packageMappings, config.externalPackageName));
+            // For addon packages, use all function files; for main packages, use internal RPC files
+            const filesToRegister = isAddon ? functions.files : rpc.internalFiles;
+            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, filesToRegister, functions.meta, packageMappings, config.addonName));
         }
         return shouldGenerateFunctionsFile;
     },

package/dist/src/functions/wirings/functions/pikku-command-services.d.ts

@@ -1,2 +1,2 @@
 export declare const serializeServicesMap: (allSingletonServices: string[], allWireServices: string[], requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, wireServicesImport: string) => string;
-export declare const pikkuServices: any;
+export declare const pikkuServices: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/functions/pikku-command-services.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';

package/dist/src/functions/wirings/functions/schemas.d.ts

@@ -1,4 +1 @@
-/**
- * Generate JSON schemas from TypeScript types and Zod schemas
- */
-export declare const pikkuSchemas: any;
+export declare const pikkuSchemas: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/functions/schemas.js

@@ -1,21 +1,19 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { saveSchemas, generateSchemas, generateZodSchemas, } from '../../../utils/schema-generator.js';
+import { pikkuSessionlessFunc } from '#pikku';
+import { saveSchemas } from '../../../utils/serialize-schemas.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-/**
- * Generate JSON schemas from TypeScript types and Zod schemas
- */
 export const pikkuSchemas = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes, config.schema?.additionalProperties, visitState.zodLookup);
-        const zodSchemas = await generateZodSchemas(logger, visitState.zodLookup, visitState.functions.typesMap);
-        await saveSchemas(logger, config.schemaDirectory, { ...schemas, ...zodSchemas }, visitState.functions.typesMap, visitState.functions.meta, config.schema?.supportsImportAttributes || true, config.schemasFromTypes, visitState.zodLookup, config.externalPackageName || null);
+        if (Object.keys(visitState.schemas).length === 0) {
+            return undefined;
+        }
+        await saveSchemas(logger, config.schemaDirectory, visitState.schemas, visitState.requiredSchemas, config.schema?.supportsImportAttributes ?? true, config.addonName || null);
         return true;
     },
     middleware: [
         logCommandInfoAndTime({
-            commandStart: 'Generating schemas',
-            commandEnd: 'Generated schemas',
+            commandStart: 'Writing schemas',
+            commandEnd: 'Wrote schemas',
         }),
     ],
 });

package/dist/src/functions/wirings/functions/serialize-addon-types.d.ts

@@ -0,0 +1 @@
+export declare const serializeAddonTypes: (singletonServicesTypeImport: string, singletonServicesTypeName: string, configTypeImport: string, requiredServicesTypeImport: string, typedSecretServiceImport: string, typedVariablesServiceImport: string) => string;

package/dist/src/functions/wirings/functions/serialize-addon-types.js

@@ -0,0 +1,78 @@
+export const serializeAddonTypes = (singletonServicesTypeImport, singletonServicesTypeName, configTypeImport, requiredServicesTypeImport, typedSecretServiceImport, typedVariablesServiceImport) => {
+    return `/**
+ * Addon package types for pikkuAddonConfig and pikkuAddonServices
+ */
+
+import type { CreateConfig } from '@pikku/core'
+${singletonServicesTypeImport}
+${configTypeImport}
+${requiredServicesTypeImport}
+${typedSecretServiceImport}
+${typedVariablesServiceImport}
+
+${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
+${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
+
+/**
+ * Base services provided to addon package service factories.
+ * These are always available from the parent application.
+ */
+export type AddonBaseServices = {
+  logger: SingletonServices['logger']
+  variables: TypedVariablesService
+  secrets: TypedSecretService
+}
+
+/**
+ * Creates a Pikku config factory for addon packages.
+ * Unlike pikkuConfig, this receives AddonBaseServices (logger, variables, secrets)
+ * from the parent application, so addon packages can read variables/secrets during config creation.
+ */
+export const pikkuAddonConfig = <ExistingServices extends Omit<Partial<SingletonServices>, 'variables' | 'secrets'> & AddonBaseServices>(
+  func: (services: ExistingServices) => Promise<Config>
+): CreateConfig<Config> => {
+  return (async (_variables: any, existingServices?: Partial<SingletonServices>): Promise<Config> => {
+    const { secrets, variables, ...rest } = (existingServices ?? {}) as unknown as SingletonServices
+    return func({ ...rest, secrets: new TypedSecretService(secrets), variables: new TypedVariablesService(variables) } as ExistingServices)
+  }) as unknown as CreateConfig<Config>
+}
+
+/**
+ * Creates a Pikku singleton services factory for addon packages.
+ * Unlike pikkuServices, this expects the parent application to provide
+ * logger, variables, and secrets - no fallbacks needed.
+ *
+ * @param func - Addon services factory function that receives config and base services
+ * @returns The singleton services factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createSingletonServices = pikkuAddonServices(async (
+ *   config,
+ *   { secrets }
+ * ) => {
+ *   const creds = await secrets.getSecretJSON<GithubCredentials>('GITHUB_CREDENTIALS')
+ *   const github = new GithubService(creds)
+ *   return { github }
+ * })
+ * \`\`\`
+ */
+export const pikkuAddonServices = <T extends Record<string, any>, ExistingServices extends Omit<Partial<SingletonServices>, 'variables' | 'secrets'> & AddonBaseServices>(
+  func: (config: Config, services: ExistingServices) => Promise<T>
+) => {
+  return async (config: Config, existingServices?: Partial<SingletonServices>): Promise<RequiredSingletonServices> => {
+    const { logger, variables, secrets } = (existingServices ?? {}) as unknown as SingletonServices
+    const typedVariables = new TypedVariablesService(variables)
+    const typedSecrets = new TypedSecretService(secrets)
+    const result = await func(config, { ...existingServices, logger, variables: typedVariables, secrets: typedSecrets } as ExistingServices)
+    return {
+      config,
+      logger,
+      variables: typedVariables,
+      secrets: typedSecrets,
+      ...result,
+    } as unknown as RequiredSingletonServices
+  }
+}
+`;
+};

package/dist/src/functions/wirings/functions/serialize-function-imports.d.ts

@@ -1,8 +1,7 @@
-import { FunctionsMeta, FunctionsRuntimeMeta } from '@pikku/core';
+import type { FunctionsMeta } from '@pikku/core';
 export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
     path: string;
     exportedName: string;
 }>, functionsMeta: FunctionsMeta, packageMappings?: Record<string, string>, 
-/** Package name for external packages (e.g., '@pikku/templates-function-external') */
-externalPackageName?: string) => string;
-export declare const generateRuntimeMeta: (functions: FunctionsMeta) => FunctionsRuntimeMeta;
+/** Package name for addon packages (e.g., '@pikku/templates-function-addon') */
+addonName?: string) => string;

package/dist/src/functions/wirings/functions/serialize-function-imports.js

@@ -1,7 +1,7 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta, packageMappings = {}, 
-/** Package name for external packages (e.g., '@pikku/templates-function-external') */
-externalPackageName) => {
+/** Package name for addon packages (e.g., '@pikku/templates-function-addon') */
+addonName) => {
     const serializedImports = [
         `/* Import and register functions used by RPCs */`,
         `import { addFunction } from '@pikku/core'`,
@@ -10,19 +10,24 @@ externalPackageName) => {
     // Sort by function name for consistent output
     const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
     // Third argument to addFunction is the package name (null for main package)
-    const packageArg = externalPackageName ? `, '${externalPackageName}'` : '';
+    const packageArg = addonName ? `, '${addonName}'` : '';
+    const usedAliases = new Set();
     for (const [name, { path, exportedName }] of sortedEntries) {
         const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        // pikkuFunc/pikkuSessionlessFunc/pikkuVoidFunc always return config objects
-        // For directly exported functions, we can just import and register them
         if (name === exportedName) {
+            usedAliases.add(exportedName);
             serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
             serializedRegistrations.push(`addFunction('${name}', ${exportedName}${packageArg})`);
         }
-        // For renamed functions, we need to import and alias them
         else {
-            serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', ${name}${packageArg})`);
+            let safeAlias = name.replace(/[^a-zA-Z0-9_$]/g, '_');
+            let suffix = 2;
+            while (usedAliases.has(safeAlias)) {
+                safeAlias = `${name.replace(/[^a-zA-Z0-9_$]/g, '_')}_${suffix++}`;
+            }
+            usedAliases.add(safeAlias);
+            serializedImports.push(`import { ${exportedName} as ${safeAlias} } from '${filePath}'`);
+            serializedRegistrations.push(`addFunction('${name}', ${safeAlias}${packageArg})`);
         }
     }
     // Add a blank line between imports and registrations
@@ -32,15 +37,3 @@ externalPackageName) => {
     // Combine the imports and registrations
     return [...serializedImports, ...serializedRegistrations].join('\n');
 };
-export const generateRuntimeMeta = (functions) => {
-    const runtimeMeta = {};
-    for (const [key, { pikkuFuncName, inputSchemaName, outputSchemaName, expose },] of Object.entries(functions)) {
-        runtimeMeta[key] = {
-            pikkuFuncName,
-            inputSchemaName,
-            outputSchemaName,
-            expose,
-        };
-    }
-    return runtimeMeta;
-};

package/dist/src/functions/wirings/functions/serialize-function-types.d.ts

@@ -1,4 +1,4 @@
 /**
  * Generates core function, middleware, and permission type definitions
  */
-export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, wireServicesTypeImport: string, wireServicesTypeName: string, rpcMapTypeImport: string, requiredServicesTypeImport: string, configTypeImport: string, packageName?: string) => string;
+export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, wireServicesTypeImport: string, wireServicesTypeName: string, rpcMapTypeImport: string, requiredServicesTypeImport: string, configTypeImport: string, packageName?: string, workflowTypesImport?: string, nodeCategories?: string[]) => string;