@pikku/cli 0.11.2 → 0.12.0

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

@@ -0,0 +1,2 @@
+export declare const pikkuSecretDefinitionTypes: 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>;
+export declare const pikkuVariableDefinitionTypes: 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/package/pikku-command-package-types.js

@@ -0,0 +1,30 @@
+import { pikkuVoidFunc } from '#pikku';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeSecretDefinitionTypes, serializeVariableDefinitionTypes, } from './serialize-package-types.js';
+export const pikkuSecretDefinitionTypes = pikkuVoidFunc({
+    func: async ({ logger, config }) => {
+        const { secretTypesFile } = config;
+        const content = serializeSecretDefinitionTypes();
+        await writeFileInDir(logger, secretTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating Secret definition types',
+            commandEnd: 'Created Secret definition types',
+        }),
+    ],
+});
+export const pikkuVariableDefinitionTypes = pikkuVoidFunc({
+    func: async ({ logger, config }) => {
+        const { variableTypesFile } = config;
+        const content = serializeVariableDefinitionTypes();
+        await writeFileInDir(logger, variableTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating Variable definition types',
+            commandEnd: 'Created Variable definition types',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuPackage: 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/package/pikku-command-package.js

@@ -0,0 +1,58 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializePackageFactories } from './serialize-package.js';
+export const pikkuPackage = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { externalPackageName, packageMappings, packageFile } = config;
+        // Only generate for external packages
+        if (!externalPackageName) {
+            logger.debug({
+                message: 'Skipping package factories - not an external package (externalPackageName not set)',
+                type: 'skip',
+            });
+            return false;
+        }
+        if (!packageFile) {
+            logger.debug({
+                message: 'Skipping package factories - packageFile not configured',
+                type: 'skip',
+            });
+            return false;
+        }
+        const state = await getInspectorState();
+        const { filesAndMethods } = state;
+        const { pikkuConfigFactory, singletonServicesFactory, wireServicesFactory, } = filesAndMethods;
+        const content = serializePackageFactories(packageFile, externalPackageName, pikkuConfigFactory
+            ? {
+                file: pikkuConfigFactory.file,
+                variable: pikkuConfigFactory.variable,
+            }
+            : undefined, singletonServicesFactory
+            ? {
+                file: singletonServicesFactory.file,
+                variable: singletonServicesFactory.variable,
+            }
+            : undefined, wireServicesFactory
+            ? {
+                file: wireServicesFactory.file,
+                variable: wireServicesFactory.variable,
+            }
+            : undefined, packageMappings);
+        if (!content) {
+            logger.info({
+                message: 'Skipping package factories - no service factories found',
+                type: 'skip',
+            });
+            return false;
+        }
+        await writeFileInDir(logger, packageFile, content);
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating package service factories',
+            commandEnd: 'Generated package service factories',
+        }),
+    ],
+});

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

@@ -0,0 +1,2 @@
+export declare const serializeSecretDefinitionTypes: () => string;
+export declare const serializeVariableDefinitionTypes: () => string;

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

@@ -0,0 +1,10 @@
+export const serializeSecretDefinitionTypes = () => {
+    return `export { wireSecret } from '@pikku/core/secret'
+export type { CoreSecret, SecretDefinitionMeta, SecretDefinitionsMeta } from '@pikku/core/secret'
+`;
+};
+export const serializeVariableDefinitionTypes = () => {
+    return `export { wireVariable } from '@pikku/core/variable'
+export type { CoreVariable, VariableDefinitionMeta, VariableDefinitionsMeta } from '@pikku/core/variable'
+`;
+};

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

@@ -0,0 +1,5 @@
+export interface PackageFactoryInfo {
+    file: string;
+    variable: string;
+}
+export declare const serializePackageFactories: (outputPath: string, packageName: string, configFactory: PackageFactoryInfo | undefined, singletonServicesFactory: PackageFactoryInfo | undefined, wireServicesFactory: PackageFactoryInfo | undefined, packageMappings?: Record<string, string>) => string | null;

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

@@ -0,0 +1,32 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const serializePackageFactories = (outputPath, packageName, configFactory, singletonServicesFactory, wireServicesFactory, packageMappings = {}) => {
+    const imports = [
+        `import { addPackageServiceFactories } from '@pikku/core'`,
+    ];
+    const factoryEntries = [];
+    if (configFactory) {
+        const filePath = getFileImportRelativePath(outputPath, configFactory.file, packageMappings);
+        imports.push(`import { ${configFactory.variable} as createConfig } from '${filePath}'`);
+        factoryEntries.push(`  createConfig,`);
+    }
+    if (singletonServicesFactory) {
+        const filePath = getFileImportRelativePath(outputPath, singletonServicesFactory.file, packageMappings);
+        imports.push(`import { ${singletonServicesFactory.variable} as createSingletonServices } from '${filePath}'`);
+        factoryEntries.push(`  createSingletonServices,`);
+    }
+    if (wireServicesFactory) {
+        const filePath = getFileImportRelativePath(outputPath, wireServicesFactory.file, packageMappings);
+        imports.push(`import { ${wireServicesFactory.variable} as createWireServices } from '${filePath}'`);
+        factoryEntries.push(`  createWireServices,`);
+    }
+    // Only generate if at least one factory is defined
+    if (factoryEntries.length === 0) {
+        return null;
+    }
+    return `${imports.join('\n')}
+
+addPackageServiceFactories('${packageName}', {
+${factoryEntries.join('\n')}
+})
+`;
+};

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

@@ -1 +1 @@
-export declare const pikkuPermissions: any;
+export declare const pikkuPermissions: 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/permissions/pikku-command-permissions.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 { serializePermissionsImports } from './serialize-permissions-imports.js';
@@ -8,12 +8,17 @@ export const pikkuPermissions = pikkuSessionlessFunc({
         const { permissions } = state;
         const { permissionsFile, packageMappings } = config;
         let filesGenerated = false;
-        // Check if there are any permission group factories
+        const hasHTTPGroups = state.http.routePermissions.size > 0;
+        const hasTagGroups = state.permissions.tagPermissions.size > 0;
+        const hasIndividual = Object.keys(state.permissions.definitions).length > 0;
+        if (hasHTTPGroups || hasTagGroups || hasIndividual) {
+            const metaData = state.permissionsGroupsMeta;
+            await writeFileInDir(logger, config.permissionsGroupsMetaJsonFile, JSON.stringify(metaData, null, 2));
+            filesGenerated = true;
+        }
         const hasHTTPFactories = Array.from(state.http.routePermissions.values()).some((meta) => meta.exportName && meta.isFactory);
         const hasTagFactories = Array.from(state.permissions.tagPermissions.values()).some((meta) => meta.exportName && meta.isFactory);
-        const hasFactories = hasHTTPFactories || hasTagFactories;
-        // Generate permissions imports file if there are factories
-        if (hasFactories) {
+        if (hasHTTPFactories || hasTagFactories) {
             await writeFileInDir(logger, permissionsFile, serializePermissionsImports(permissionsFile, permissions, state.http, packageMappings));
             filesGenerated = true;
         }

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

@@ -1 +1 @@
-export declare const pikkuQueueMap: any;
+export declare const pikkuQueueMap: 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/queue/pikku-command-queue-map.js

@@ -1,12 +1,12 @@
-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 { serializeQueueMap } from './serialize-queue-map.js';
 export const pikkuQueueMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { queueWorkers, functions } = await getInspectorState();
+        const { queueWorkers, functions, resolvedIOTypes } = await getInspectorState();
         const { queueMapDeclarationFile, packageMappings } = config;
-        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
+        const content = serializeQueueMap(logger, queueMapDeclarationFile, packageMappings, functions.typesMap, queueWorkers.meta, resolvedIOTypes);
         await writeFileInDir(logger, queueMapDeclarationFile, content);
     },
     middleware: [

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

@@ -1 +1 @@
-export declare const pikkuQueueService: any;
+export declare const pikkuQueueService: 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/queue/pikku-command-queue-service.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 { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -8,7 +8,7 @@ export const pikkuQueueService = pikkuSessionlessFunc({
         const { queueWiringsFile, queueMapDeclarationFile, packageMappings } = config;
         // If queueWiringsFile is not set, clean up any existing file and return
         if (!queueWiringsFile) {
-            logger.info({
+            logger.debug({
                 message: "Skipping generating queue service wrapper since queueWiringsFile isn't set in the pikku config.",
                 type: 'skip',
             });

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

@@ -1 +1 @@
-export declare const pikkuQueueTypes: any;
+export declare const pikkuQueueTypes: 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/queue/pikku-command-queue-types.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 { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

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

@@ -1 +1 @@
-export declare const pikkuQueue: any;
+export declare const pikkuQueue: 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/queue/pikku-command-queue.js

@@ -1,16 +1,24 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeQueueMeta, serializeQueueMetaTS, } from './serialize-queue-meta.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuQueue = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         const { queueWorkersWiringFile, queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { queueWorkers } = visitState;
-        // Write JSON file
-        await writeFileInDir(logger, queueWorkersWiringMetaJsonFile, JSON.stringify(serializeQueueMeta(queueWorkers.meta), null, 2));
+        const fullMeta = serializeQueueMeta(queueWorkers.meta);
+        // Write minimal JSON file (runtime-only fields)
+        const minimalMeta = stripVerboseFields(fullMeta);
+        await writeFileInDir(logger, queueWorkersWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(fullMeta)) {
+            const verbosePath = queueWorkersWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(fullMeta, null, 2));
+        }
         // Calculate relative path from TS file to JSON file
         const jsonImportPath = getFileImportRelativePath(queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings);
         // Write TypeScript file that imports JSON

package/dist/src/functions/wirings/queue/pikku-queue-map.d.ts

@@ -1 +1 @@
-export declare const pikkuQueueMap: any;
+export declare const pikkuQueueMap: 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/queue/pikku-queue-map.js

@@ -1,12 +1,12 @@
-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 { serializeQueueMap } from './serialize-queue-map.js';
 export const pikkuQueueMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { queueWorkers, functions } = await getInspectorState();
+        const { queueWorkers, functions, resolvedIOTypes } = await getInspectorState();
         const { queueMapDeclarationFile, packageMappings } = config;
-        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
+        const content = serializeQueueMap(logger, queueMapDeclarationFile, packageMappings, functions.typesMap, queueWorkers.meta, resolvedIOTypes);
         await writeFileInDir(logger, queueMapDeclarationFile, content);
     },
     middleware: [

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

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

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -9,16 +9,8 @@ export const pikkuQueue = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         const { queueWorkersWiringFile, queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { queueWorkers } = visitState;
-        // Add remote RPC worker to queue metadata if it exists
-        const queueMeta = { ...queueWorkers.meta };
-        if (config.rpc?.remoteRpcWorkersPath) {
-            queueMeta['pikku-remote-internal-rpc'] = {
-                pikkuFuncName: 'pikkuRemoteInternalRPC',
-                queueName: 'pikku-remote-internal-rpc',
-            };
-        }
         // Write JSON file
-        await writeFileInDir(logger, queueWorkersWiringMetaJsonFile, JSON.stringify(serializeQueueMeta(queueMeta), null, 2));
+        await writeFileInDir(logger, queueWorkersWiringMetaJsonFile, JSON.stringify(serializeQueueMeta(queueWorkers.meta), null, 2));
         // Calculate relative path from TS file to JSON file
         const jsonImportPath = getFileImportRelativePath(queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings);
         // Write TypeScript file that imports JSON

package/dist/src/functions/wirings/queue/serialize-queue-map.d.ts

@@ -1,4 +1,7 @@
 import type { QueueWorkersMeta } from '@pikku/core/queue';
 import { TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeQueueMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, queueWorkersMeta: QueueWorkersMeta) => string;
+import { Logger } from '@pikku/core/services';
+export declare const serializeQueueMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, queueWorkersMeta: QueueWorkersMeta, resolvedIOTypes: Record<string, {
+    inputType: string;
+    outputType: string;
+}>) => string;

package/dist/src/functions/wirings/queue/serialize-queue-map.js

@@ -1,14 +1,14 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
-export const serializeQueueMap = (relativeToPath, packageMappings, typesMap, functionsMeta, queueWorkersMeta) => {
+import { generateCustomTypes } from '@pikku/inspector';
+export const serializeQueueMap = (logger, relativeToPath, packageMappings, typesMap, queueWorkersMeta, resolvedIOTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedQueues = generateQueues(queueWorkersMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedQueues = generateQueues(queueWorkersMeta, resolvedIOTypes, requiredTypes);
+    const serializedImportMap = serializeImportMap(logger, relativeToPath, packageMappings, typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for typescript to be aware of Queue workers and their input/output types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 
@@ -45,27 +45,16 @@ export type TypedPikkuQueue = {
 }
   `;
 };
-function generateQueues(queueWorkersMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect queues
+function generateQueues(queueWorkersMeta, resolvedIOTypes, requiredTypes) {
     const queuesObj = {};
-    // Iterate through Queue metadata
-    for (const [queueName, { pikkuFuncName }] of Object.entries(queueWorkersMeta)) {
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            throw new Error(`Function ${queueName} not found in functionsMeta. Please check your configuration.`);
+    for (const [queueName, { pikkuFuncId }] of Object.entries(queueWorkersMeta)) {
+        const resolved = resolvedIOTypes[pikkuFuncId];
+        if (!resolved) {
+            throw new Error(`Function ${pikkuFuncId} not found in resolvedIOTypes. Please check your configuration.`);
         }
-        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
-        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-        // Store the input and output types for QueueHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add Queue entry
-        queuesObj[queueName] = {
-            inputType,
-            outputType,
-        };
+        requiredTypes.add(resolved.inputType);
+        requiredTypes.add(resolved.outputType);
+        queuesObj[queueName] = resolved;
     }
     // Build the Queues object as a string
     let queuesStr = 'export type QueueMap = {\n';

package/dist/src/functions/wirings/queue/serialize-queue-meta.js

@@ -1,15 +1,14 @@
+import { serializeMetaTS } from '../../../utils/serialize-meta-ts.js';
 export const serializeQueueMeta = (queueWorkersMeta) => {
     return queueWorkersMeta;
 };
 export const serializeQueueMetaTS = (jsonImportPath, supportsImportAttributes) => {
-    const importStatement = supportsImportAttributes
-        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-        : `import metaData from '${jsonImportPath}'`;
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push("import { QueueWorkersMeta } from '@pikku/core/queue'");
-    serializedOutput.push(importStatement);
-    serializedOutput.push('');
-    serializedOutput.push("pikkuState('queue', 'meta', metaData as QueueWorkersMeta)");
-    return serializedOutput.join('\n');
+    return serializeMetaTS({
+        jsonImportPath,
+        supportsImportAttributes,
+        pikkuStateNamespace: 'queue',
+        pikkuStateKey: 'meta',
+        metaTypeImport: '@pikku/core/queue',
+        metaTypeName: 'QueueWorkersMeta',
+    });
 };

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

@@ -24,7 +24,7 @@ type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out, 'sessio
  * @param queueWorker - Queue worker definition with job handler
  */
 export const wireQueueWorker = (queueWorker: QueueWiring<any, any>) => {
-  wireQueueWorkerCore(queueWorker as any) // TODO
+  wireQueueWorkerCore(queueWorker as any)
 }
 `;
 };

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

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

package/dist/src/functions/wirings/rpc/pikku-command-public-rpc.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 { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -9,7 +9,7 @@ export const pikkuPublicRPC = pikkuSessionlessFunc({
         if (config.rpc?.publicRpcPath) {
             const publicRpcPath = join(config.rootDir, config.rpc.publicRpcPath);
             const pathToPikkuTypes = getFileImportRelativePath(publicRpcPath, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, publicRpcPath, serializePublicRPC(pathToPikkuTypes));
+            await writeFileInDir(logger, publicRpcPath, serializePublicRPC(pathToPikkuTypes, config.rpc.publicRpcRequireAuth ?? true));
             return true;
         }
         return false;

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

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

package/dist/src/functions/wirings/rpc/pikku-command-remote-rpc.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 { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

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

@@ -1 +1 @@
-export declare const pikkuRPCClient: any;
+export declare const pikkuRPCClient: 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/rpc/pikku-command-rpc-client.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 { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -8,7 +8,7 @@ export const pikkuRPCClient = pikkuSessionlessFunc({
         const { rpcWiringsFile, rpcMapDeclarationFile, packageMappings } = config;
         // If rpcWiringsFile is not set, clean up any existing file and return
         if (!rpcWiringsFile) {
-            logger.info({
+            logger.debug({
                 message: "Skipping generating RPC wrappers since rpcWiringsFile isn't set in the pikku config.",
                 type: 'skip',
             });

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

@@ -1,2 +1,2 @@
-export declare const pikkuRPCInternalMap: any;
-export declare const pikkuRPCExposedMap: any;
+export declare const pikkuRPCInternalMap: 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>;
+export declare const pikkuRPCExposedMap: 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/rpc/pikku-command-rpc-map.js

@@ -1,12 +1,15 @@
-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 { serializeTypedRPCMap } from './serialize-typed-rpc-map.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuRPCInternalMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { functions, rpc } = await getInspectorState();
-        const { rpcInternalMapDeclarationFile, packageMappings } = config;
-        const content = serializeTypedRPCMap(rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.internalMeta);
+        const { functions, rpc, resolvedIOTypes } = await getInspectorState();
+        const { rpcInternalMapDeclarationFile, packageMappings, externalPackages, workflowMapDeclarationFile, agentMapDeclarationFile, } = config;
+        const workflowMapPath = getFileImportRelativePath(rpcInternalMapDeclarationFile, workflowMapDeclarationFile, packageMappings);
+        const agentMapPath = getFileImportRelativePath(rpcInternalMapDeclarationFile, agentMapDeclarationFile, packageMappings);
+        const content = serializeTypedRPCMap(logger, rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, rpc.internalMeta, resolvedIOTypes, externalPackages, workflowMapPath, agentMapPath);
         await writeFileInDir(logger, rpcInternalMapDeclarationFile, content);
     },
     middleware: [
@@ -18,9 +21,11 @@ export const pikkuRPCInternalMap = pikkuSessionlessFunc({
 });
 export const pikkuRPCExposedMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { functions, rpc } = await getInspectorState();
-        const { rpcMapDeclarationFile, packageMappings } = config;
-        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.exposedMeta);
+        const { functions, rpc, resolvedIOTypes } = await getInspectorState();
+        const { rpcMapDeclarationFile, packageMappings, externalPackages, workflowMapDeclarationFile, agentMapDeclarationFile, } = config;
+        const workflowMapPath = getFileImportRelativePath(rpcMapDeclarationFile, workflowMapDeclarationFile, packageMappings);
+        const agentMapPath = getFileImportRelativePath(rpcMapDeclarationFile, agentMapDeclarationFile, packageMappings);
+        const content = serializeTypedRPCMap(logger, rpcMapDeclarationFile, packageMappings, functions.typesMap, rpc.exposedMeta, resolvedIOTypes, externalPackages, workflowMapPath, agentMapPath);
         await writeFileInDir(logger, rpcMapDeclarationFile, content);
     },
     middleware: [

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

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

package/dist/src/functions/wirings/rpc/pikku-command-rpc.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 { getFileImportRelativePath } from '../../../utils/file-import-path.js';
@@ -13,7 +13,10 @@ export const pikkuRPC = pikkuSessionlessFunc({
             const importStatement = supportsImportAttributes
                 ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
                 : `import metaData from '${jsonImportPath}'`;
-            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\n${importStatement}\npikkuState('rpc', 'meta', metaData as Record<string, string>)`);
+            const packageNameArg = config.externalPackageName
+                ? `'${config.externalPackageName}'`
+                : 'null';
+            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\n${importStatement}\npikkuState(${packageNameArg}, 'rpc', 'meta', metaData as Record<string, string>)`);
             return true;
         }
         return false;

package/dist/src/functions/wirings/rpc/serialize-public-rpc.d.ts

@@ -1,4 +1,4 @@
 /**
  * Generate public RPC HTTP endpoint
  */
-export declare const serializePublicRPC: (pathToPikkuTypes: string) => string;
+export declare const serializePublicRPC: (pathToPikkuTypes: string, requireAuth?: boolean) => string;

package/dist/src/functions/wirings/rpc/serialize-public-rpc.js

@@ -1,7 +1,8 @@
 /**
  * Generate public RPC HTTP endpoint
  */
-export const serializePublicRPC = (pathToPikkuTypes) => {
+export const serializePublicRPC = (pathToPikkuTypes, requireAuth = true) => {
+    const authFlag = requireAuth ? 'true' : 'false';
     return `/**
  * Auto-generated public RPC HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
@@ -13,24 +14,28 @@ import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
  * This is used for public HTTP access to exposed server functions
  */
 export const rpcCaller = pikkuSessionlessFunc<
-  { rpcName: string, data?: any },
-  any
+  { rpcName: string; data?: unknown },
+  unknown
 >({
-  func: async (services, { rpcName, data }, { rpc }) => {
-    return await (rpc.invokeExposed as any)(rpcName, data)
+  auth: ${authFlag},
+  func: async (_services, { rpcName, data }, { rpc }) => {
+    return await rpc.exposed(rpcName, data)
   },
 })
 
 wireHTTP({
   route: "/rpc/:rpcName",
   method: "options",
-  auth: false,
+  tags: ['pikku:public'],
+  auth: ${authFlag},
   func: pikkuSessionlessFunc<{ rpcName: string }>(async () => void 0),
 });
 
 wireHTTP({
   route: '/rpc/:rpcName',
   method: 'post',
+  tags: ['pikku:public'],
+  auth: ${authFlag},
   func: rpcCaller,
 })
 `;