@dusted/anqst 1.5.0 → 1.6.0

package/dist/src/boundary-codec-analysis.js

@@ -0,0 +1,468 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundaryTransportAnalyzer = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const errors_1 = require("./errors");
+const boundary_codec_model_1 = require("./boundary-codec-model");
+const boundary_codec_leaves_1 = require("./boundary-codec-leaves");
+const BUILTIN_TYPE_REFS = new Set(["Array", "ReadonlyArray", "Record", "Map", "Partial", "Promise"]);
+function isStringLikeUnion(node) {
+    return node.types.every((part) => {
+        if (typescript_1.default.isLiteralTypeNode(part) && typescript_1.default.isStringLiteral(part.literal))
+            return true;
+        return part.kind === typescript_1.default.SyntaxKind.StringKeyword;
+    });
+}
+function isBooleanLikeUnion(node) {
+    return node.types.every((part) => {
+        if (typescript_1.default.isLiteralTypeNode(part)) {
+            return part.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword || part.literal.kind === typescript_1.default.SyntaxKind.FalseKeyword;
+        }
+        return part.kind === typescript_1.default.SyntaxKind.BooleanKeyword;
+    });
+}
+function isNumberLikeUnion(node) {
+    return node.types.every((part) => {
+        if (typescript_1.default.isLiteralTypeNode(part) && typescript_1.default.isNumericLiteral(part.literal))
+            return true;
+        return part.kind === typescript_1.default.SyntaxKind.NumberKeyword || part.kind === typescript_1.default.SyntaxKind.BigIntKeyword;
+    });
+}
+function filterNullishUnionParts(types) {
+    return types.filter((part) => part.kind !== typescript_1.default.SyntaxKind.NullKeyword && part.kind !== typescript_1.default.SyntaxKind.UndefinedKeyword);
+}
+function collectFiniteStringLiterals(node) {
+    const values = [];
+    for (const part of node.types) {
+        if (!typescript_1.default.isLiteralTypeNode(part) || !typescript_1.default.isStringLiteral(part.literal))
+            return null;
+        values.push(part.literal.text);
+    }
+    return values;
+}
+function collectFiniteBooleanLiterals(node) {
+    const values = [];
+    for (const part of node.types) {
+        if (!typescript_1.default.isLiteralTypeNode(part))
+            return null;
+        if (part.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword) {
+            values.push(true);
+            continue;
+        }
+        if (part.literal.kind === typescript_1.default.SyntaxKind.FalseKeyword) {
+            values.push(false);
+            continue;
+        }
+        return null;
+    }
+    return values;
+}
+function collectFiniteNumberLiterals(node) {
+    const values = [];
+    for (const part of node.types) {
+        if (!typescript_1.default.isLiteralTypeNode(part) || !typescript_1.default.isNumericLiteral(part.literal))
+            return null;
+        values.push(Number(part.literal.text));
+    }
+    return values;
+}
+function finiteDomainSymbolForValue(value) {
+    if (typeof value === "boolean")
+        return value ? "True" : "False";
+    if (typeof value === "number") {
+        const text = Number.isInteger(value) ? `${value}` : `${value}`.replace(/\./g, "_");
+        return (0, boundary_codec_model_1.sanitizeIdentifier)(`Value_${text.replace(/-/g, "neg_")}`);
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return "Empty";
+    const direct = (0, boundary_codec_model_1.sanitizeIdentifier)(trimmed);
+    return direct.length > 0 ? direct : "Value";
+}
+function buildFiniteDomain(primitive, values) {
+    const seen = new Set();
+    const variants = [];
+    for (const value of values) {
+        const key = `${typeof value}:${String(value)}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        variants.push({
+            code: variants.length,
+            symbolicName: finiteDomainSymbolForValue(value),
+            tsLiteralText: typeof value === "string" ? JSON.stringify(value) : `${value}`,
+            value
+        });
+    }
+    return { primitive, variants };
+}
+function unsupported(path, typeText, reason) {
+    throw new errors_1.VerifyError(`Boundary codec planning failed for '${path.join(".") || typeText}': ${reason} (${typeText}).`);
+}
+class BoundaryTransportAnalyzer {
+    constructor(spec) {
+        this.spec = spec;
+        this.declNodes = new Map();
+        this.namedNodes = new Map();
+        for (const decl of this.collectDecls()) {
+            const node = (0, boundary_codec_model_1.parseTypeDeclNode)(decl.nodeText);
+            if (node) {
+                this.declNodes.set(decl.name, node);
+            }
+        }
+    }
+    analyzeTypeText(typeText, path) {
+        const rootNode = (0, boundary_codec_model_1.parseTypeNodeFromText)(typeText);
+        const root = this.resolveTypeNode(rootNode, typeText, path, [], this.defaultIdentityParts(rootNode, typeText, path));
+        return {
+            typeText,
+            tsTypeText: (0, boundary_codec_model_1.stripAnQstType)(typeText),
+            root,
+            summary: summarizeAnalysis(root)
+        };
+    }
+    collectDecls() {
+        const out = new Map();
+        for (const decl of this.spec.namespaceTypeDecls)
+            out.set(decl.name, decl);
+        for (const decl of this.spec.importedTypeDecls.values())
+            out.set(decl.name, decl);
+        return [...out.values()];
+    }
+    nodeMeta(typeText, path, identityParts) {
+        const normalizedParts = identityParts.filter((part) => part.trim().length > 0);
+        return {
+            typeText,
+            path,
+            typeIdentityKey: normalizedParts.join("::") || (0, boundary_codec_model_1.stripAnQstType)(typeText).trim(),
+            cppNameHintParts: normalizedParts.length > 0 ? normalizedParts : (path.length > 0 ? path : [(0, boundary_codec_model_1.stripAnQstType)(typeText).trim() || "AnonymousType"])
+        };
+    }
+    defaultIdentityParts(node, typeText, path) {
+        if (typescript_1.default.isTypeReferenceNode(node)) {
+            const name = (0, boundary_codec_model_1.qNameText)(node.typeName);
+            if (!name.startsWith("AnQst.Type.") && !BUILTIN_TYPE_REFS.has(name)) {
+                return [name];
+            }
+        }
+        return path.length > 0 ? [...path] : [(0, boundary_codec_model_1.stripAnQstType)(typeText).trim() || "AnonymousType"];
+    }
+    createFiniteDomainAnalysis(typeText, path, identityParts, domain) {
+        return {
+            nodeKind: "finite-domain",
+            ...this.nodeMeta(typeText, path, identityParts),
+            domain
+        };
+    }
+    createStructAnalysis(typeText, path, members, stack, identityParts) {
+        const fields = members
+            .filter((member) => {
+            return typescript_1.default.isPropertySignature(member) && !!member.type && typescript_1.default.isIdentifier(member.name);
+        })
+            .map((member) => {
+            const fieldPath = [...path, member.name.text];
+            const fieldIdentityParts = [...identityParts, member.name.text];
+            const child = this.resolveTypeNode(member.type, member.type.getText(), fieldPath, stack, fieldIdentityParts);
+            return {
+                name: member.name.text,
+                optional: !!member.questionToken,
+                typeText: member.type.getText(),
+                path: fieldPath,
+                typeIdentityKey: child.typeIdentityKey,
+                cppNameHintParts: child.cppNameHintParts,
+                reconstructionKey: member.name.text,
+                node: child
+            };
+        });
+        return {
+            nodeKind: "struct",
+            ...this.nodeMeta(typeText, path, identityParts),
+            fields,
+            reconstruction: "object"
+        };
+    }
+    resolveNamedReference(name, decl) {
+        const existing = this.namedNodes.get(name);
+        if (existing) {
+            return existing;
+        }
+        const placeholder = {
+            nodeKind: "named",
+            ...this.nodeMeta(name, [name], [name]),
+            name,
+            target: null
+        };
+        this.namedNodes.set(name, placeholder);
+        placeholder.target = typescript_1.default.isInterfaceDeclaration(decl)
+            ? this.createStructAnalysis(name, [name], decl.members, [name], [name])
+            : this.resolveTypeNode(decl.type, name, [name], [name], [name]);
+        return placeholder;
+    }
+    resolveTypeNode(node, typeText, path, stack, identityParts) {
+        if (typescript_1.default.isParenthesizedTypeNode(node)) {
+            return this.resolveTypeNode(node.type, typeText, path, stack, identityParts);
+        }
+        if (typescript_1.default.isTypeLiteralNode(node)) {
+            return this.createStructAnalysis(typeText, path, node.members, stack, identityParts);
+        }
+        if (typescript_1.default.isArrayTypeNode(node)) {
+            return {
+                nodeKind: "array",
+                ...this.nodeMeta(typeText, path, identityParts),
+                elementTypeText: node.elementType.getText(),
+                element: this.resolveTypeNode(node.elementType, node.elementType.getText(), [...path, "Item"], stack, [...identityParts, "Item"]),
+                requiresCountMetadata: true,
+                reconstruction: "array"
+            };
+        }
+        if (typescript_1.default.isTupleTypeNode(node)) {
+            unsupported(path, typeText, "tuple transport is not supported by the whole-boundary planner");
+        }
+        if (typescript_1.default.isLiteralTypeNode(node)) {
+            if (typescript_1.default.isStringLiteral(node.literal)) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("string", [node.literal.text]));
+            }
+            if (typescript_1.default.isNumericLiteral(node.literal)) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("number", [Number(node.literal.text)]));
+            }
+            if (node.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword || node.literal.kind === typescript_1.default.SyntaxKind.FalseKeyword) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("boolean", [node.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword]));
+            }
+        }
+        if (typescript_1.default.isUnionTypeNode(node)) {
+            const filtered = filterNullishUnionParts(node.types);
+            if (filtered.length !== node.types.length) {
+                unsupported(path, typeText, "nullish unions are not supported; use explicit optional members instead");
+            }
+            const finiteStringVariants = collectFiniteStringLiterals(node);
+            if (finiteStringVariants) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("string", finiteStringVariants));
+            }
+            const finiteBooleanVariants = collectFiniteBooleanLiterals(node);
+            if (finiteBooleanVariants) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("boolean", finiteBooleanVariants));
+            }
+            const finiteNumberVariants = collectFiniteNumberLiterals(node);
+            if (finiteNumberVariants) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("number", finiteNumberVariants));
+            }
+            if (isStringLikeUnion(node)) {
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("string", "string"),
+                    fixedWidth: false
+                };
+            }
+            if (isBooleanLikeUnion(node)) {
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("boolean", "boolean"),
+                    fixedWidth: true
+                };
+            }
+            if (isNumberLikeUnion(node)) {
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("number", "number"),
+                    fixedWidth: true
+                };
+            }
+            unsupported(path, typeText, "union transport is only supported for string, boolean, or number-like unions");
+        }
+        if (typescript_1.default.isTypeReferenceNode(node)) {
+            const name = (0, boundary_codec_model_1.qNameText)(node.typeName);
+            const rawText = node.getText();
+            if (name === "Array" || name === "ReadonlyArray") {
+                const arg = node.typeArguments?.[0];
+                if (!arg) {
+                    unsupported(path, rawText, "array type is missing its element type");
+                }
+                return {
+                    nodeKind: "array",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    elementTypeText: arg.getText(),
+                    element: this.resolveTypeNode(arg, arg.getText(), [...path, "Item"], stack, [...identityParts, "Item"]),
+                    requiresCountMetadata: true,
+                    reconstruction: "array"
+                };
+            }
+            if (name === "Record" || name === "Map") {
+                const leaf = (0, boundary_codec_leaves_1.resolveLeafCapability)("object", "object");
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: leaf,
+                    fixedWidth: false
+                };
+            }
+            if (name === "Partial") {
+                unsupported(path, rawText, "generic Partial<T> transport is not supported");
+            }
+            if (name === "Promise") {
+                unsupported(path, rawText, "Promise transport is not supported");
+            }
+            if (rawText.trim() === "AnQst.Type.stringArray") {
+                const leaf = (0, boundary_codec_leaves_1.resolveLeafCapability)("string", "string");
+                return {
+                    nodeKind: "array",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    elementTypeText: "string",
+                    element: {
+                        nodeKind: "leaf",
+                        ...this.nodeMeta("string", [...path, "Item"], [...identityParts, "Item"]),
+                        leaf: leaf,
+                        fixedWidth: false
+                    },
+                    requiresCountMetadata: true,
+                    reconstruction: "array"
+                };
+            }
+            const leaf = (0, boundary_codec_leaves_1.resolveLeafCapability)(rawText, name);
+            if (leaf) {
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf,
+                    fixedWidth: leaf.fixedByteWidth !== null
+                };
+            }
+            const decl = this.declNodes.get(name);
+            if (decl) {
+                return this.resolveNamedReference(name, decl);
+            }
+        }
+        switch (node.kind) {
+            case typescript_1.default.SyntaxKind.StringKeyword:
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("string", "string"),
+                    fixedWidth: false
+                };
+            case typescript_1.default.SyntaxKind.BooleanKeyword:
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("boolean", "boolean"),
+                    fixedWidth: true
+                };
+            case typescript_1.default.SyntaxKind.NumberKeyword:
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("number", "number"),
+                    fixedWidth: true
+                };
+            case typescript_1.default.SyntaxKind.BigIntKeyword:
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("bigint", "bigint"),
+                    fixedWidth: true
+                };
+            case typescript_1.default.SyntaxKind.ObjectKeyword:
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("object", "object"),
+                    fixedWidth: false
+                };
+            default:
+                unsupported(path, typeText, "no transport analysis rule exists for this type");
+        }
+    }
+}
+exports.BoundaryTransportAnalyzer = BoundaryTransportAnalyzer;
+function summarizeAnalysis(node) {
+    const used = new Set();
+    const visitedNamed = new Set();
+    const visit = (current) => {
+        switch (current.nodeKind) {
+            case "leaf":
+                used.add(current.leaf.key);
+                return {
+                    hasBlobLeaves: current.leaf.region === "blob",
+                    hasStringLeaves: current.leaf.region === "string",
+                    hasBinaryLeaves: current.leaf.region === "binary",
+                    hasDynamicLeaves: current.leaf.region === "dynamic",
+                    hasRepeatedStructures: false,
+                    hasOptionalPresence: false,
+                    hasFiniteDomains: false,
+                    usedLeafCapabilities: []
+                };
+            case "named":
+                if (visitedNamed.has(current.name)) {
+                    return {
+                        hasBlobLeaves: false,
+                        hasStringLeaves: false,
+                        hasBinaryLeaves: false,
+                        hasDynamicLeaves: false,
+                        hasRepeatedStructures: false,
+                        hasOptionalPresence: false,
+                        hasFiniteDomains: false,
+                        usedLeafCapabilities: []
+                    };
+                }
+                visitedNamed.add(current.name);
+                return visit(current.target);
+            case "finite-domain":
+                return {
+                    hasBlobLeaves: false,
+                    hasStringLeaves: false,
+                    hasBinaryLeaves: false,
+                    hasDynamicLeaves: false,
+                    hasRepeatedStructures: false,
+                    hasOptionalPresence: false,
+                    hasFiniteDomains: true,
+                    usedLeafCapabilities: []
+                };
+            case "array": {
+                const inner = visit(current.element);
+                return {
+                    hasBlobLeaves: inner.hasBlobLeaves,
+                    hasStringLeaves: inner.hasStringLeaves,
+                    hasBinaryLeaves: inner.hasBinaryLeaves,
+                    hasDynamicLeaves: inner.hasDynamicLeaves,
+                    hasRepeatedStructures: true,
+                    hasOptionalPresence: inner.hasOptionalPresence,
+                    hasFiniteDomains: inner.hasFiniteDomains,
+                    usedLeafCapabilities: []
+                };
+            }
+            case "struct":
+                return current.fields.reduce((acc, field) => {
+                    const next = visit(field.node);
+                    return {
+                        hasBlobLeaves: acc.hasBlobLeaves || next.hasBlobLeaves,
+                        hasStringLeaves: acc.hasStringLeaves || next.hasStringLeaves,
+                        hasBinaryLeaves: acc.hasBinaryLeaves || next.hasBinaryLeaves,
+                        hasDynamicLeaves: acc.hasDynamicLeaves || next.hasDynamicLeaves,
+                        hasRepeatedStructures: acc.hasRepeatedStructures || next.hasRepeatedStructures,
+                        hasOptionalPresence: acc.hasOptionalPresence || field.optional || next.hasOptionalPresence,
+                        hasFiniteDomains: acc.hasFiniteDomains || next.hasFiniteDomains,
+                        usedLeafCapabilities: []
+                    };
+                }, {
+                    hasBlobLeaves: false,
+                    hasStringLeaves: false,
+                    hasBinaryLeaves: false,
+                    hasDynamicLeaves: false,
+                    hasRepeatedStructures: false,
+                    hasOptionalPresence: false,
+                    hasFiniteDomains: false,
+                    usedLeafCapabilities: []
+                });
+        }
+    };
+    const summary = visit(node);
+    return {
+        ...summary,
+        usedLeafCapabilities: [...used]
+    };
+}