@pikku/cli 0.11.2 → 0.12.0

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

@@ -1,31 +1,46 @@
-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 { generateRuntimeMeta, serializeFunctionImports, } from './serialize-function-imports.js';
+import { serializeFunctionImports } from './serialize-function-imports.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuFunctions = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc } = await getInspectorState();
-        const { functionsMetaFile, functionsMetaJsonFile, functionsMetaMinFile, functionsMetaMinJsonFile, functionsFile, packageMappings, schema, } = config;
-        await writeFileInDir(logger, functionsMetaJsonFile, JSON.stringify(functions.meta, null, 2));
-        const fullJsonImportPath = getFileImportRelativePath(functionsMetaFile, functionsMetaJsonFile, packageMappings);
+        const { functionsMetaFile, functionsMetaJsonFile, functionsFile, packageMappings, schema, } = config;
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(functions.meta);
+        await writeFileInDir(logger, functionsMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(functions.meta)) {
+            const verbosePath = functionsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(functions.meta, null, 2));
+        }
+        const jsonImportPath = getFileImportRelativePath(functionsMetaFile, functionsMetaJsonFile, packageMappings);
         const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-        const fullImportStatement = supportsImportAttributes
-            ? `import metaData from '${fullJsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${fullJsonImportPath}'`;
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState, FunctionsMeta } from '@pikku/core'\n${fullImportStatement}\npikkuState('function', 'meta', metaData as FunctionsMeta)`);
-        const runtimeMeta = generateRuntimeMeta(functions.meta);
-        await writeFileInDir(logger, functionsMetaMinJsonFile, JSON.stringify(runtimeMeta, null, 2));
-        const minJsonImportPath = getFileImportRelativePath(functionsMetaMinFile, functionsMetaMinJsonFile, packageMappings);
-        const minImportStatement = supportsImportAttributes
-            ? `import metaData from '${minJsonImportPath}' with { type: 'json' }`
-            : `import metaData from '${minJsonImportPath}'`;
-        await writeFileInDir(logger, functionsMetaMinFile, `import { pikkuState, FunctionsRuntimeMeta } from '@pikku/core'\n${minImportStatement}\npikkuState('function', 'meta', metaData as FunctionsRuntimeMeta)`);
+        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)
+        // For main packages, only register functions that are invoked via internal RPCs
+        const isExternalPackage = !!config.externalPackageName;
         const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0;
-        if (hasRPCs) {
-            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, rpc.internalFiles, functions.meta, packageMappings));
+        const hasFunctions = functions.files.size > 0;
+        const shouldGenerateFunctionsFile = isExternalPackage
+            ? 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));
         }
-        return hasRPCs;
+        return shouldGenerateFunctionsFile;
     },
     middleware: [
         logCommandInfoAndTime({

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';
@@ -30,7 +30,7 @@ export const serializeServicesMap = (allSingletonServices, allWireServices, requ
         }
     });
     // Services that are always required internally by the framework
-    const defaultServices = ['config', 'logger', 'variables', 'schema'];
+    const defaultServices = ['config', 'logger', 'variables', 'schema', 'secrets'];
     defaultServices.forEach((service) => usedServices.add(service));
     // Create singleton services map: all singleton services with true/false based on usage
     const singletonServicesMap = {};

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

@@ -1,4 +1 @@
-/**
- * Generate JSON schemas from TypeScript types
- */
-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,20 +1,19 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { saveSchemas, generateSchemas, } 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
- */
 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);
-        await saveSchemas(logger, config.schemaDirectory, schemas, visitState.functions.typesMap, visitState.functions.meta, config.schema?.supportsImportAttributes || true, config.schemasFromTypes);
+        if (Object.keys(visitState.schemas).length === 0) {
+            return undefined;
+        }
+        await saveSchemas(logger, config.schemaDirectory, visitState.schemas, visitState.requiredSchemas, config.schema?.supportsImportAttributes ?? true, config.externalPackageName || null);
         return true;
     },
     middleware: [
         logCommandInfoAndTime({
-            commandStart: 'Generating schemas',
-            commandEnd: 'Generated schemas',
+            commandStart: 'Writing schemas',
+            commandEnd: 'Wrote schemas',
         }),
     ],
 });

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

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

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

@@ -0,0 +1,77 @@
+export const serializeExternalTypes = (singletonServicesTypeImport, singletonServicesTypeName, configTypeImport, requiredServicesTypeImport, typedSecretServiceImport, typedVariablesServiceImport) => {
+    return `/**
+ * External package types for pikkuExternalConfig and pikkuExternalServices
+ */
+
+${singletonServicesTypeImport}
+${configTypeImport}
+${requiredServicesTypeImport}
+${typedSecretServiceImport}
+${typedVariablesServiceImport}
+
+${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
+${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
+
+/**
+ * Base services provided to external package service factories.
+ * These are always available from the parent application.
+ */
+export type ExternalBaseServices = {
+  logger: SingletonServices['logger']
+  variables: TypedVariablesService
+  secrets: TypedSecretService
+}
+
+/**
+ * Creates a Pikku config factory for external packages.
+ * Unlike pikkuConfig, this receives ExternalBaseServices (logger, variables, secrets)
+ * from the parent application, so external packages can read variables/secrets during config creation.
+ */
+export const pikkuExternalConfig = <ExistingServices extends Omit<Partial<SingletonServices>, 'variables' | 'secrets'> & ExternalBaseServices>(
+  func: (services: ExistingServices) => Promise<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)
+  }
+}
+
+/**
+ * Creates a Pikku singleton services factory for external packages.
+ * Unlike pikkuServices, this expects the parent application to provide
+ * logger, variables, and secrets - no fallbacks needed.
+ *
+ * @param func - External services factory function that receives config and base services
+ * @returns The singleton services factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createSingletonServices = pikkuExternalServices(async (
+ *   config,
+ *   { secrets }
+ * ) => {
+ *   const creds = await secrets.getSecretJSON<GithubCredentials>('GITHUB_CREDENTIALS')
+ *   const github = new GithubService(creds)
+ *   return { github }
+ * })
+ * \`\`\`
+ */
+export const pikkuExternalServices = <T extends Record<string, any>, ExistingServices extends Omit<Partial<SingletonServices>, 'variables' | 'secrets'> & ExternalBaseServices>(
+  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,6 +1,7 @@
-import { FunctionsMeta, FunctionsRuntimeMeta } from '@pikku/core';
+import { FunctionsMeta } from '@pikku/core';
 export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
     path: string;
     exportedName: string;
-}>, functionsMeta: FunctionsMeta, packageMappings?: Record<string, string>) => string;
-export declare const generateRuntimeMeta: (functions: FunctionsMeta) => FunctionsRuntimeMeta;
+}>, functionsMeta: FunctionsMeta, packageMappings?: Record<string, string>, 
+/** Package name for external packages (e.g., '@pikku/templates-function-external') */
+externalPackageName?: string) => string;

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

@@ -1,5 +1,7 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta, packageMappings = {}) => {
+export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta, packageMappings = {}, 
+/** Package name for external packages (e.g., '@pikku/templates-function-external') */
+externalPackageName) => {
     const serializedImports = [
         `/* Import and register functions used by RPCs */`,
         `import { addFunction } from '@pikku/core'`,
@@ -7,18 +9,25 @@ export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta
     const serializedRegistrations = [];
     // 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 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})`);
+            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})`);
+            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
@@ -28,15 +37,3 @@ export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta
     // 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) => 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;