@dusted/anqst 1.0.1 → 1.5.1

package/dist/src/boundary-codecs.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTsBoundaryCodecHelpers = exports.renderCppBoundaryCodecHelpers = void 0;
+exports.buildBoundaryCodecCatalog = buildBoundaryCodecCatalog;
+exports.getBoundaryPayloadSite = getBoundaryPayloadSite;
+exports.getBoundaryParameterSite = getBoundaryParameterSite;
+const debug_dump_1 = require("./debug-dump");
+const boundary_codec_model_1 = require("./boundary-codec-model");
+const boundary_codec_analysis_1 = require("./boundary-codec-analysis");
+const boundary_codec_plan_1 = require("./boundary-codec-plan");
+var boundary_codec_render_1 = require("./boundary-codec-render");
+Object.defineProperty(exports, "renderCppBoundaryCodecHelpers", { enumerable: true, get: function () { return boundary_codec_render_1.renderCppBoundaryCodecHelpers; } });
+Object.defineProperty(exports, "renderTsBoundaryCodecHelpers", { enumerable: true, get: function () { return boundary_codec_render_1.renderTsBoundaryCodecHelpers; } });
+function renderAnalysisNode(node, level, lines, visitedNamed = new Set()) {
+    const pad = "  ".repeat(level);
+    if (node.nodeKind === "leaf") {
+        lines.push(`${pad}- leaf ${node.path.join(".")} :: ${node.leaf.logicalKind} -> ${node.leaf.region}`);
+        return;
+    }
+    if (node.nodeKind === "finite-domain") {
+        lines.push(`${pad}- finite-domain ${node.path.join(".")} :: ${node.domain.primitive} {${node.domain.variants.map((variant) => variant.tsLiteralText).join(", ")}}`);
+        return;
+    }
+    if (node.nodeKind === "array") {
+        lines.push(`${pad}- array ${node.path.join(".")} :: count metadata required`);
+        renderAnalysisNode(node.element, level + 1, lines, visitedNamed);
+        return;
+    }
+    if (node.nodeKind === "named") {
+        lines.push(`${pad}- named ${node.name}`);
+        if (visitedNamed.has(node.name)) {
+            lines.push(`${pad}  [recursive]`);
+            return;
+        }
+        visitedNamed.add(node.name);
+        renderAnalysisNode(node.target, level + 1, lines, visitedNamed);
+        return;
+    }
+    lines.push(`${pad}- struct ${node.path.join(".")}`);
+    for (const field of node.fields) {
+        lines.push(`${pad}  field ${field.name}${field.optional ? "?" : ""}`);
+        renderAnalysisNode(field.node, level + 2, lines, visitedNamed);
+    }
+}
+function renderPlanNode(node, level, lines, visitedNamed = new Set()) {
+    const pad = "  ".repeat(level);
+    const loweringText = (lowering) => `ts:${lowering.tsEncode.mode}/${lowering.tsDecode.mode} cpp:${lowering.cppEncode.mode}/${lowering.cppDecode.mode}`;
+    if (node.nodeKind === "leaf") {
+        if (node.blobEntryId) {
+            lines.push(`${pad}- blob leaf ${node.path.join(".")} packing=${node.selectedPacking} lowering=${loweringText(node.lowering)} -> ${node.blobEntryId}`);
+        }
+        else {
+            lines.push(`${pad}- ${node.leaf.region} leaf ${node.path.join(".")} packing=${node.selectedPacking} lowering=${loweringText(node.lowering)} -> ${node.itemEntryId}`);
+        }
+        return;
+    }
+    if (node.nodeKind === "finite-domain") {
+        if (node.representation.kind === "identity-text") {
+            lines.push(`${pad}- finite-domain ${node.path.join(".")} identity-text lowering=${loweringText(node.lowering)} -> ${node.itemEntryId}`);
+        }
+        else {
+            lines.push(`${pad}- finite-domain ${node.path.join(".")} code=${node.representation.scalarKind} lowering=${loweringText(node.lowering)} -> ${node.blobEntryId}`);
+        }
+        return;
+    }
+    if (node.nodeKind === "array") {
+        lines.push(`${pad}- array ${node.path.join(".")} extent=${node.extentStrategy}${node.countEntryId ? ` count=${node.countEntryId}` : ""}`);
+        renderPlanNode(node.element, level + 1, lines, visitedNamed);
+        return;
+    }
+    if (node.nodeKind === "named") {
+        lines.push(`${pad}- named ${node.name}`);
+        if (visitedNamed.has(node.name)) {
+            lines.push(`${pad}  [recursive]`);
+            return;
+        }
+        visitedNamed.add(node.name);
+        renderPlanNode(node.target, level + 1, lines, visitedNamed);
+        return;
+    }
+    lines.push(`${pad}- struct ${node.path.join(".")} ordering=${node.ordering}`);
+    for (const field of node.fields) {
+        lines.push(`${pad}  field ${field.name}${field.optional ? `? presence=${field.presenceStrategy}:${field.presenceEntryId}` : ""}`);
+        renderPlanNode(field.node, level + 2, lines, visitedNamed);
+    }
+}
+function renderBoundaryDebugSummaries(plans) {
+    const analysisChunks = [];
+    const planChunks = [];
+    for (const plan of plans) {
+        analysisChunks.push(`codec ${plan.codecId} :: ${plan.typeText}`);
+        analysisChunks.push(`summary ${JSON.stringify(plan.analysis.summary)}`);
+        renderAnalysisNode(plan.analysis.root, 1, analysisChunks);
+        analysisChunks.push("");
+        planChunks.push(`codec ${plan.codecId} :: ${plan.typeText}`);
+        planChunks.push(`decodePolicy=${plan.decodePolicy} blob=${plan.blobEntries.length} items=${plan.itemEntries.length} kinds=${plan.requirements.itemKinds.join(",") || "none"} itemCountHeaderKinds=${plan.requirements.itemCountHeaderKinds.join(",") || "none"}`);
+        renderPlanNode(plan.root, 1, planChunks);
+        planChunks.push("");
+    }
+    return {
+        analyses: `${analysisChunks.join("\n")}\n`,
+        plans: `${planChunks.join("\n")}\n`
+    };
+}
+function buildBoundaryCodecCatalog(spec) {
+    const analyzer = new boundary_codec_analysis_1.BoundaryTransportAnalyzer(spec);
+    const plans = [];
+    const plansByCodecId = new Map();
+    const codecIdByTypeText = new Map();
+    const payloadSites = new Map();
+    const parameterSites = new Map();
+    const usedCodecIds = new Set();
+    const ensureCodec = (typeText, pathHintParts) => {
+        const existing = codecIdByTypeText.get(typeText);
+        if (existing)
+            return existing;
+        const proposed = `AnQstStructured_${(0, boundary_codec_model_1.sanitizeIdentifier)((0, boundary_codec_model_1.stripAnQstType)(typeText).replace(/\s+/g, "_"))}`;
+        let codecId = proposed;
+        let suffix = 2;
+        while (usedCodecIds.has(codecId)) {
+            codecId = `${proposed}_${suffix++}`;
+        }
+        usedCodecIds.add(codecId);
+        codecIdByTypeText.set(typeText, codecId);
+        const analysis = analyzer.analyzeTypeText(typeText, pathHintParts);
+        const plan = (0, boundary_codec_plan_1.buildBoundaryCodecPlan)(codecId, analysis);
+        plans.push(plan);
+        plansByCodecId.set(codecId, plan);
+        return codecId;
+    };
+    for (const service of spec.services) {
+        for (const member of service.members) {
+            if (member.payloadTypeText && member.payloadTypeText.trim() !== "void") {
+                const site = {
+                    siteKey: (0, boundary_codec_model_1.codecSiteKey)("payload", service.name, member.name, null),
+                    kind: "payload",
+                    serviceName: service.name,
+                    memberName: member.name,
+                    parameterName: null,
+                    typeText: member.payloadTypeText,
+                    codecId: ensureCodec(member.payloadTypeText, [service.name, member.name, "Payload"])
+                };
+                payloadSites.set(site.siteKey, site);
+            }
+            for (const parameter of member.parameters) {
+                const site = {
+                    siteKey: (0, boundary_codec_model_1.codecSiteKey)("parameter", service.name, member.name, parameter.name),
+                    kind: "parameter",
+                    serviceName: service.name,
+                    memberName: member.name,
+                    parameterName: parameter.name,
+                    typeText: parameter.typeText,
+                    codecId: ensureCodec(parameter.typeText, [service.name, member.name, parameter.name])
+                };
+                parameterSites.set(site.siteKey, site);
+            }
+        }
+    }
+    const debug = renderBoundaryDebugSummaries(plans);
+    (0, debug_dump_1.writeDebugFile)(process.cwd(), "codecs/boundary-transport-analysis.txt", debug.analyses);
+    (0, debug_dump_1.writeDebugFile)(process.cwd(), "codecs/boundary-plans.txt", debug.plans);
+    return {
+        plans,
+        plansByCodecId,
+        payloadSites,
+        parameterSites
+    };
+}
+function getBoundaryPayloadSite(catalog, serviceName, memberName) {
+    return catalog.payloadSites.get((0, boundary_codec_model_1.codecSiteKey)("payload", serviceName, memberName, null));
+}
+function getBoundaryParameterSite(catalog, serviceName, memberName, parameterName) {
+    return catalog.parameterSites.get((0, boundary_codec_model_1.codecSiteKey)("parameter", serviceName, memberName, parameterName));
+}