@dusted/anqst 0.1.0 → 0.1.1

package/dist/src/backend/tsc/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tscBackend = void 0;
+const emit_cpp_1 = require("./emit-cpp");
+const emit_node_1 = require("./emit-node");
+const parser_1 = require("./parser");
+const verify_1 = require("./verify");
+function mergeGeneratedFiles(...parts) {
+    const out = {};
+    for (const part of parts) {
+        for (const [key, value] of Object.entries(part)) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+function formatTargets(options) {
+    const enabled = [];
+    if (options.emitQWidget)
+        enabled.push("QWidget");
+    if (options.emitNodeExpressWs)
+        enabled.push("node_express_ws");
+    if (enabled.length === 0)
+        return "none";
+    return enabled.join(", ");
+}
+function logBackendInput(spec, options) {
+    console.log(`[AnQst][backend=tsc] parsed widget=${spec.widgetName}, services=${spec.services.length}, targets=${formatTargets(options)}`);
+}
+exports.tscBackend = {
+    id: "tsc",
+    parseSpecFile: parser_1.parseSpecFile,
+    verifySpec: verify_1.verifySpec,
+    generateOutputs(spec, options) {
+        logBackendInput(spec, options);
+        const cpp = (0, emit_cpp_1.emitCppQWidget)(spec, options);
+        const node = (0, emit_node_1.emitNodeExpressWs)(spec, options);
+        return mergeGeneratedFiles(cpp, node);
+    },
+    emitsArtifacts: true
+};

package/dist/src/backend/tsc/parser.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSpecFile = parseSpecFile;
+const parser_1 = require("../ast/parser");
+const debug_dump_1 = require("./debug-dump");
+const program_1 = require("./program");
+const typegraph_1 = require("./typegraph");
+function parseSpecFile(specPath) {
+    (0, program_1.createTscProgramContext)(specPath);
+    const parsed = (0, parser_1.parseSpecFile)(specPath);
+    if ((0, debug_dump_1.isDebugEnabled)()) {
+        (0, debug_dump_1.writeDebugFile)(process.cwd(), "anqstmodel/parsed-before-typegraph.txt", `${(0, debug_dump_1.inspectText)(parsed)}\n`);
+    }
+    const normalized = (0, typegraph_1.applyResolvedTypeGraph)(parsed);
+    if ((0, debug_dump_1.isDebugEnabled)()) {
+        (0, debug_dump_1.writeDebugFile)(process.cwd(), "anqstmodel/parsed-after-typegraph.txt", `${(0, debug_dump_1.inspectText)(normalized)}\n`);
+    }
+    return normalized;
+}

package/dist/src/backend/tsc/program.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTscProgramContext = createTscProgramContext;
+exports.getTscProgramContext = getTscProgramContext;
+exports.getProgramDiagnostics = getProgramDiagnostics;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const errors_1 = require("../../errors");
+const debug_dump_1 = require("./debug-dump");
+const contextBySpecPath = new Map();
+function diagnosticText(diagnostic) {
+    return typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+}
+function formatDiagnostic(diagnostic) {
+    if (!diagnostic.file || diagnostic.start === undefined) {
+        return diagnosticText(diagnostic);
+    }
+    const pos = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+    return `${diagnostic.file.fileName}:${pos.line + 1}:${pos.character + 1}: ${diagnosticText(diagnostic)}`;
+}
+function dumpSourceFileAst(sourceFile) {
+    const lines = [];
+    lines.push(`== SOURCE FILE ==`);
+    lines.push(sourceFile.fileName);
+    lines.push("");
+    lines.push("== FULL TEXT ==");
+    lines.push(sourceFile.getFullText());
+    lines.push("");
+    lines.push("== AST NODES ==");
+    const walk = (node, depth) => {
+        const indent = "  ".repeat(depth);
+        const kind = typescript_1.default.SyntaxKind[node.kind];
+        const start = node.getStart(sourceFile, false);
+        const end = node.getEnd();
+        const text = node.getText(sourceFile).replace(/\s+/g, " ").slice(0, 160);
+        lines.push(`${indent}${kind} [${start}, ${end}] ${text}`);
+        typescript_1.default.forEachChild(node, (child) => walk(child, depth + 1));
+    };
+    walk(sourceFile, 0);
+    return `${lines.join("\n")}\n`;
+}
+function dumpProgramArtifacts(specPath, rootNames, options, program, sourceFile) {
+    if (!(0, debug_dump_1.isDebugEnabled)())
+        return;
+    const cwd = process.cwd();
+    const diagnostics = typescript_1.default.getPreEmitDiagnostics(program, sourceFile).map(formatDiagnostic);
+    const sourceFiles = program.getSourceFiles().map((sf) => sf.fileName);
+    const contextLines = [
+        `specPath: ${specPath}`,
+        "",
+        "compilerOptions:",
+        (0, debug_dump_1.inspectText)(options),
+        "",
+        "rootNames:",
+        rootNames.join("\n"),
+        "",
+        "diagnostics:",
+        diagnostics.length > 0 ? diagnostics.join("\n") : "(none)"
+    ];
+    (0, debug_dump_1.writeDebugFile)(cwd, node_path_1.default.join("tsc", "program-context.txt"), `${contextLines.join("\n")}\n`);
+    (0, debug_dump_1.writeDebugFile)(cwd, node_path_1.default.join("tsc", "program-files.txt"), `${sourceFiles.join("\n")}\n`);
+    (0, debug_dump_1.writeDebugFile)(cwd, node_path_1.default.join("tsc", "sourcefile-ast.txt"), dumpSourceFileAst(sourceFile));
+}
+function readTsConfigFrom(specPath) {
+    const specDir = node_path_1.default.dirname(specPath);
+    const configPath = typescript_1.default.findConfigFile(specDir, typescript_1.default.sys.fileExists, "tsconfig.json");
+    if (!configPath || !node_fs_1.default.existsSync(configPath)) {
+        return null;
+    }
+    const config = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
+    if (config.error) {
+        throw new errors_1.VerifyError(`Unable to parse tsconfig.json: ${diagnosticText(config.error)}`);
+    }
+    const parsed = typescript_1.default.parseJsonConfigFileContent(config.config, typescript_1.default.sys, node_path_1.default.dirname(configPath), {}, configPath);
+    return { rootNames: parsed.fileNames, options: parsed.options };
+}
+function createTscProgramContext(specPath) {
+    const absoluteSpecPath = node_path_1.default.resolve(specPath);
+    const tsConfig = readTsConfigFrom(absoluteSpecPath);
+    const rootNames = tsConfig ? [...new Set([...tsConfig.rootNames, absoluteSpecPath])] : [absoluteSpecPath];
+    const options = tsConfig?.options ?? {
+        target: typescript_1.default.ScriptTarget.ES2022,
+        module: typescript_1.default.ModuleKind.CommonJS,
+        moduleResolution: typescript_1.default.ModuleResolutionKind.NodeJs,
+        skipLibCheck: true,
+        esModuleInterop: true,
+        strict: false,
+        allowJs: false
+    };
+    const program = typescript_1.default.createProgram({ rootNames, options });
+    const sourceFile = program.getSourceFile(absoluteSpecPath);
+    if (!sourceFile) {
+        throw new errors_1.VerifyError(`Unable to load spec source file into TypeScript program: ${absoluteSpecPath}`);
+    }
+    const context = {
+        specPath: absoluteSpecPath,
+        program,
+        checker: program.getTypeChecker(),
+        sourceFile
+    };
+    dumpProgramArtifacts(absoluteSpecPath, rootNames, options, program, sourceFile);
+    contextBySpecPath.set(absoluteSpecPath, context);
+    return context;
+}
+function getTscProgramContext(specPath) {
+    const absoluteSpecPath = node_path_1.default.resolve(specPath);
+    const existing = contextBySpecPath.get(absoluteSpecPath);
+    if (existing)
+        return existing;
+    return createTscProgramContext(absoluteSpecPath);
+}
+function getProgramDiagnostics(specPath) {
+    const context = getTscProgramContext(specPath);
+    const diagnostics = typescript_1.default.getPreEmitDiagnostics(context.program, context.sourceFile);
+    return diagnostics.map(formatDiagnostic);
+}

package/dist/src/backend/tsc/typegraph.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyResolvedTypeGraph = applyResolvedTypeGraph;
+const typescript_1 = __importDefault(require("typescript"));
+const debug_dump_1 = require("./debug-dump");
+const program_1 = require("./program");
+function qNameText(name) {
+    if (typescript_1.default.isIdentifier(name))
+        return name.text;
+    return `${qNameText(name.left)}.${name.right.text}`;
+}
+function serviceBaseType(iface) {
+    if (!iface.heritageClauses)
+        return null;
+    for (const clause of iface.heritageClauses) {
+        if (clause.token !== typescript_1.default.SyntaxKind.ExtendsKeyword)
+            continue;
+        for (const t of clause.types) {
+            const text = t.expression.getText();
+            if (text === "AnQst.Service")
+                return "Service";
+            if (text === "AnQst.AngularHTTPBaseServerClass")
+                return "AngularHTTPBaseServerClass";
+        }
+    }
+    return null;
+}
+function parseMemberKind(typeNode) {
+    if (!typescript_1.default.isTypeReferenceNode(typeNode))
+        return null;
+    const name = qNameText(typeNode.typeName);
+    if (!name.startsWith("AnQst."))
+        return null;
+    const kind = name.slice("AnQst.".length);
+    if (!["Call", "Slot", "Emitter", "Output", "Input"].includes(kind))
+        return null;
+    if (kind === "Emitter")
+        return { kind, payloadNode: null };
+    return { kind, payloadNode: typeNode.typeArguments?.[0] ?? null };
+}
+function typeToString(checker, node) {
+    const type = checker.getTypeFromTypeNode(node);
+    const flags = typescript_1.default.TypeFormatFlags.NoTruncation;
+    if (typescript_1.default.isTypeReferenceNode(node) && qNameText(node.typeName).endsWith(".infer") && node.typeArguments?.[0]) {
+        const schemaType = checker.getTypeFromTypeNode(node.typeArguments[0]);
+        const outputSymbol = schemaType.getProperty("_output") ?? schemaType.getProperty("_type");
+        if (outputSymbol) {
+            const outputType = checker.getTypeOfSymbolAtLocation(outputSymbol, node);
+            const outputText = checker.typeToString(outputType, node, flags);
+            if (outputText.trim().length > 0 && outputText !== "any" && outputText !== "unknown") {
+                return outputText;
+            }
+        }
+    }
+    const direct = checker.typeToString(type, node, flags);
+    if (!/(?:\bz\.infer<|typeof\s+)/.test(direct)) {
+        return direct;
+    }
+    const apparent = checker.getApparentType(type);
+    const apparentText = checker.typeToString(apparent, node, flags);
+    if (!/(?:\bz\.infer<|typeof\s+)/.test(apparentText)) {
+        return apparentText;
+    }
+    const structuralNode = checker.typeToTypeNode(apparent, node, typescript_1.default.NodeBuilderFlags.NoTruncation |
+        typescript_1.default.NodeBuilderFlags.UseStructuralFallback |
+        typescript_1.default.NodeBuilderFlags.IgnoreErrors);
+    if (structuralNode) {
+        const structuralText = structuralNode.getText();
+        if (structuralText.trim().length > 0) {
+            return structuralText;
+        }
+    }
+    return direct;
+}
+function collectServiceTypes(specPath) {
+    const { checker, sourceFile } = (0, program_1.getTscProgramContext)(specPath);
+    const services = new Map();
+    for (const stmt of sourceFile.statements) {
+        if (!typescript_1.default.isModuleDeclaration(stmt) || !stmt.body || !typescript_1.default.isModuleBlock(stmt.body))
+            continue;
+        for (const member of stmt.body.statements) {
+            if (!typescript_1.default.isInterfaceDeclaration(member))
+                continue;
+            if (serviceBaseType(member) === null)
+                continue;
+            const memberMap = new Map();
+            for (const typeMember of member.members) {
+                if (typescript_1.default.isMethodSignature(typeMember) && typeMember.name && typescript_1.default.isIdentifier(typeMember.name) && typeMember.type) {
+                    const parsed = parseMemberKind(typeMember.type);
+                    if (!parsed)
+                        continue;
+                    const payloadTypeText = parsed.payloadNode ? typeToString(checker, parsed.payloadNode) : null;
+                    const parameters = typeMember.parameters
+                        .filter((p) => !!p.type && typescript_1.default.isIdentifier(p.name))
+                        .map((p) => ({
+                        name: p.name.text,
+                        typeText: typeToString(checker, p.type)
+                    }));
+                    memberMap.set(typeMember.name.text, {
+                        payloadTypeText,
+                        parameters
+                    });
+                    continue;
+                }
+                if (typescript_1.default.isPropertySignature(typeMember) && typeMember.name && typescript_1.default.isIdentifier(typeMember.name) && typeMember.type) {
+                    const parsed = parseMemberKind(typeMember.type);
+                    if (!parsed)
+                        continue;
+                    const payloadTypeText = parsed.payloadNode ? typeToString(checker, parsed.payloadNode) : null;
+                    memberMap.set(typeMember.name.text, {
+                        payloadTypeText,
+                        parameters: []
+                    });
+                }
+            }
+            services.set(member.name.text, memberMap);
+        }
+    }
+    return services;
+}
+function renderServiceTypeMap(services) {
+    const lines = [];
+    for (const [serviceName, memberMap] of services.entries()) {
+        lines.push(`service ${serviceName}`);
+        for (const [memberName, memberTypes] of memberMap.entries()) {
+            lines.push(`  member ${memberName}`);
+            lines.push(`    payloadTypeText: ${memberTypes.payloadTypeText ?? "(none)"}`);
+            if (memberTypes.parameters.length === 0) {
+                lines.push("    parameters: (none)");
+            }
+            else {
+                lines.push("    parameters:");
+                for (const parameter of memberTypes.parameters) {
+                    lines.push(`      - ${parameter.name}: ${parameter.typeText}`);
+                }
+            }
+        }
+        lines.push("");
+    }
+    return `${lines.join("\n")}\n`;
+}
+function applyServiceMemberTypes(member, memberTypes) {
+    if (!memberTypes)
+        return member;
+    return {
+        ...member,
+        payloadTypeText: memberTypes.payloadTypeText,
+        parameters: member.parameters.map((param) => {
+            const next = memberTypes.parameters.find((p) => p.name === param.name);
+            return next ? { ...param, typeText: next.typeText } : param;
+        })
+    };
+}
+function applyServiceTypes(service, memberMap) {
+    if (!memberMap)
+        return service;
+    return {
+        ...service,
+        members: service.members.map((m) => applyServiceMemberTypes(m, memberMap.get(m.name)))
+    };
+}
+function applyResolvedTypeGraph(spec) {
+    const serviceTypes = collectServiceTypes(spec.filePath);
+    (0, debug_dump_1.writeDebugFile)(process.cwd(), "anqstmodel/typegraph-service-map.txt", renderServiceTypeMap(serviceTypes));
+    return {
+        ...spec,
+        services: spec.services.map((service) => applyServiceTypes(service, serviceTypes.get(service.name)))
+    };
+}

package/dist/src/backend/tsc/verify.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySpec = verifySpec;
+const errors_1 = require("../../errors");
+const verify_1 = require("../ast/verify");
+const program_1 = require("./program");
+function verifySpec(spec) {
+    const diagnostics = (0, program_1.getProgramDiagnostics)(spec.filePath);
+    if (diagnostics.length > 0) {
+        throw new errors_1.VerifyError(`TypeScript diagnostics in spec:\n    ${diagnostics.join("\n    ")}`);
+    }
+    return (0, verify_1.verifySpec)(spec);
+}

package/dist/src/backend/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });