@pikku/inspector 0.11.1 → 0.12.0

package/dist/utils/serialize-middleware-groups-meta.js

@@ -0,0 +1,28 @@
+const serializeGroupMap = (groupMap) => {
+    const result = {};
+    for (const [key, meta] of groupMap.entries()) {
+        result[key] = {
+            exportName: meta.exportName,
+            sourceFile: meta.sourceFile,
+            position: meta.position,
+            services: meta.services,
+            count: meta.count,
+            instanceIds: meta.instanceIds,
+            isFactory: meta.isFactory,
+        };
+    }
+    return result;
+};
+export const serializeMiddlewareGroupsMeta = (state) => {
+    return {
+        definitions: state.middleware.definitions,
+        instances: state.middleware.instances,
+        httpGroups: serializeGroupMap(state.http.routeMiddleware),
+        tagGroups: serializeGroupMap(state.middleware.tagMiddleware),
+        channelMiddleware: {
+            definitions: state.channelMiddleware.definitions,
+            instances: state.channelMiddleware.instances,
+            tagGroups: serializeGroupMap(state.channelMiddleware.tagMiddleware),
+        },
+    };
+};

package/dist/utils/serialize-openapi-json.d.ts

@@ -0,0 +1,85 @@
+import type { FunctionsMeta } from '@pikku/core';
+import type { HTTPWiringsMeta } from '@pikku/core/http';
+import type { InspectorLogger } from '../types.js';
+interface ErrorDetails {
+    status: number;
+    message: string;
+}
+interface OpenAPISpec {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        };
+        license?: {
+            name: string;
+            url?: string;
+        };
+    };
+    servers: {
+        url: string;
+        description?: string;
+    }[];
+    paths: Record<string, any>;
+    components: {
+        schemas: Record<string, any>;
+        responses?: Record<string, any>;
+        parameters?: Record<string, any>;
+        examples?: Record<string, any>;
+        requestBodies?: Record<string, any>;
+        headers?: Record<string, any>;
+        securitySchemes?: Record<string, any>;
+    };
+    security?: {
+        [key: string]: any[];
+    }[];
+    tags?: {
+        name: string;
+        description?: string;
+    }[];
+    externalDocs?: {
+        description?: string;
+        url: string;
+    };
+}
+export interface OpenAPISpecInfo {
+    info: {
+        title: string;
+        version: string;
+        description: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        };
+        license?: {
+            name: string;
+            url?: string;
+        };
+    };
+    servers: {
+        url: string;
+        description?: string;
+    }[];
+    tags?: {
+        name: string;
+        description?: string;
+    }[];
+    externalDocs?: {
+        description?: string;
+        url: string;
+    };
+    securitySchemes?: Record<string, any>;
+    security?: {
+        [key: string]: any[];
+    }[];
+}
+export declare function generateOpenAPISpec(logger: InspectorLogger, functionsMeta: FunctionsMeta, httpMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo, errors?: Map<any, ErrorDetails>): Promise<OpenAPISpec>;
+export {};

package/dist/utils/serialize-openapi-json.js

@@ -0,0 +1,151 @@
+import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema';
+const convertSchema = 'default' in _convertSchema ? _convertSchema.default : _convertSchema;
+const getErrorResponseForConstructorName = (constructorName, errors) => {
+    const entries = Array.from(errors.entries());
+    const foundError = entries.find(([e]) => e.name === constructorName);
+    if (foundError) {
+        return foundError[1];
+    }
+    return undefined;
+};
+const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas) => {
+    const requiredSchemas = new Set();
+    for (const routeMeta of Object.values(routesMeta)) {
+        for (const { inputTypes, pikkuFuncId } of Object.values(routeMeta)) {
+            const output = functionsMeta[pikkuFuncId]?.outputs?.[0];
+            if (inputTypes?.body) {
+                requiredSchemas.add(inputTypes?.body);
+            }
+            if (output) {
+                requiredSchemas.add(output);
+            }
+        }
+    }
+    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(logger, functionsMeta, httpMeta, schemas, additionalInfo, errors) {
+    const paths = {};
+    const errorsMap = errors ?? new Map();
+    for (const routeMeta of Object.values(httpMeta)) {
+        for (const meta of Object.values(routeMeta)) {
+            const { route, method, inputTypes, pikkuFuncId, params, query, errors, description, tags, } = meta;
+            const functionMeta = functionsMeta[pikkuFuncId];
+            if (!functionMeta) {
+                logger.error(`• No function metadata found for '${pikkuFuncId}' in route '${route}'.`);
+                continue;
+            }
+            const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+            const path = route.replace(/:(\w+)/g, '{$1}');
+            if (!paths[path]) {
+                paths[path] = {};
+            }
+            const responses = {};
+            errors?.forEach((error) => {
+                const errorResponse = getErrorResponseForConstructorName(error, errorsMap);
+                if (errorResponse) {
+                    responses[errorResponse.status] = {
+                        description: errorResponse.message,
+                    };
+                }
+            });
+            const operation = {
+                description: description ||
+                    `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
+                tags: 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(functionsMeta, httpMeta, 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,
+    };
+}

package/dist/utils/serialize-permissions-groups-meta.d.ts

@@ -0,0 +1,6 @@
+import type { InspectorState } from '../types.js';
+export declare const serializePermissionsGroupsMeta: (state: InspectorState) => {
+    definitions: Record<string, import("../types.js").InspectorPermissionDefinition>;
+    httpGroups: Record<string, any>;
+    tagGroups: Record<string, any>;
+};

package/dist/utils/serialize-permissions-groups-meta.js

@@ -0,0 +1,31 @@
+export const serializePermissionsGroupsMeta = (state) => {
+    const httpGroups = {};
+    for (const [pattern, meta] of state.http.routePermissions.entries()) {
+        httpGroups[pattern] = {
+            exportName: meta.exportName,
+            sourceFile: meta.sourceFile,
+            position: meta.position,
+            services: meta.services,
+            count: meta.count,
+            instanceIds: meta.instanceIds,
+            isFactory: meta.isFactory,
+        };
+    }
+    const tagGroups = {};
+    for (const [tag, meta] of state.permissions.tagPermissions.entries()) {
+        tagGroups[tag] = {
+            exportName: meta.exportName,
+            sourceFile: meta.sourceFile,
+            position: meta.position,
+            services: meta.services,
+            count: meta.count,
+            instanceIds: meta.instanceIds,
+            isFactory: meta.isFactory,
+        };
+    }
+    return {
+        definitions: state.permissions.definitions,
+        httpGroups,
+        tagGroups,
+    };
+};

package/dist/utils/workflow/dsl/deserialize-dsl-workflow.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Deserialize workflow JSON back to DSL code
+ * Converts the serialized workflow graph format back to TypeScript DSL code
+ */
+import type { SerializedWorkflowGraph } from '../graph/workflow-graph.types.js';
+interface DeserializeOptions {
+    /** Import path for pikkuWorkflowFunc */
+    pikkuImportPath?: string;
+    /** Whether to include type annotations */
+    includeTypes?: boolean;
+}
+/**
+ * Deserialize a workflow graph to DSL code
+ */
+export declare function deserializeDslWorkflow(workflow: SerializedWorkflowGraph, options?: DeserializeOptions): string;
+/**
+ * Deserialize a graph workflow to pikkuWorkflowGraph code
+ */
+export declare function deserializeGraphWorkflow(workflow: SerializedWorkflowGraph, options?: DeserializeOptions): string;
+/**
+ * Deserialize all workflows from JSON to DSL code
+ */
+export declare function deserializeAllDslWorkflows(workflows: Record<string, SerializedWorkflowGraph>, options?: DeserializeOptions): Record<string, string>;
+export {};