@dusted/anqst 0.1.1 → 0.1.3

package/dist/src/layout.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANQST_LAYOUT_VERSION = exports.ANQST_GENERATED_DIRNAME = exports.ANQST_ROOT_DIRNAME = void 0;
+exports.normalizeSlashes = normalizeSlashes;
+exports.anqstRootDir = anqstRootDir;
+exports.anqstGeneratedRootDir = anqstGeneratedRootDir;
+exports.anqstDebugIntermediateRootDir = anqstDebugIntermediateRootDir;
+exports.anqstSpecFileName = anqstSpecFileName;
+exports.anqstSettingsFileName = anqstSettingsFileName;
+exports.anqstSettingsRelativePath = anqstSettingsRelativePath;
+exports.generatedFrontendDirName = generatedFrontendDirName;
+exports.generatedNodeExpressDirName = generatedNodeExpressDirName;
+exports.generatedQtWidgetDirName = generatedQtWidgetDirName;
+exports.resolveGeneratedLayoutPaths = resolveGeneratedLayoutPaths;
+exports.toProjectRelative = toProjectRelative;
+const node_path_1 = __importDefault(require("node:path"));
+exports.ANQST_ROOT_DIRNAME = "AnQst";
+exports.ANQST_GENERATED_DIRNAME = "generated";
+exports.ANQST_LAYOUT_VERSION = 2;
+function normalizeSlashes(inputPath) {
+    return inputPath.split(node_path_1.default.sep).join("/");
+}
+function anqstRootDir(cwd) {
+    return node_path_1.default.join(cwd, exports.ANQST_ROOT_DIRNAME);
+}
+function anqstGeneratedRootDir(cwd) {
+    return node_path_1.default.join(anqstRootDir(cwd), exports.ANQST_GENERATED_DIRNAME);
+}
+function anqstDebugIntermediateRootDir(cwd) {
+    return node_path_1.default.join(anqstGeneratedRootDir(cwd), "debug", "intermediate");
+}
+function anqstSpecFileName(widgetName) {
+    return `${widgetName}.AnQst.d.ts`;
+}
+function anqstSettingsFileName(widgetName) {
+    return `${widgetName}.settings.json`;
+}
+function anqstSettingsRelativePath(widgetName) {
+    return `./${exports.ANQST_ROOT_DIRNAME}/${anqstSettingsFileName(widgetName)}`;
+}
+function generatedFrontendDirName(widgetName) {
+    return `${widgetName}_Angular`;
+}
+function generatedNodeExpressDirName(widgetName) {
+    return `${widgetName}_anQst`;
+}
+function generatedQtWidgetDirName(widgetName) {
+    return `${widgetName}_widget`;
+}
+function resolveGeneratedLayoutPaths(cwd, widgetName) {
+    const generatedRoot = anqstGeneratedRootDir(cwd);
+    const cppQtWidgetRoot = node_path_1.default.join(generatedRoot, "backend", "cpp", "qt", generatedQtWidgetDirName(widgetName));
+    const designerPluginRoot = node_path_1.default.join(cppQtWidgetRoot, "designerPlugin");
+    return {
+        generatedRoot,
+        frontendRoot: node_path_1.default.join(generatedRoot, "frontend", generatedFrontendDirName(widgetName)),
+        nodeExpressRoot: node_path_1.default.join(generatedRoot, "backend", "node", "express", generatedNodeExpressDirName(widgetName)),
+        cppCmakeRoot: node_path_1.default.join(generatedRoot, "backend", "cpp", "cmake"),
+        cppQtWidgetRoot,
+        designerPluginRoot,
+        designerPluginBuildRoot: node_path_1.default.join(designerPluginRoot, "build"),
+        debugIntermediateRoot: anqstDebugIntermediateRootDir(cwd)
+    };
+}
+function toProjectRelative(cwd, absolutePath) {
+    return normalizeSlashes(node_path_1.default.relative(cwd, absolutePath));
+}

package/dist/src/parser.js

@@ -8,6 +8,9 @@ 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 program_1 = require("./program");
+const typegraph_1 = require("./typegraph");
+const debug_dump_1 = require("./debug-dump");
 function locFromNode(source, node) {
     const lc = source.getLineAndCharacterOfPosition(node.getStart(source));
     return {
@@ -59,19 +62,116 @@ function parseMemberKindFromAnQstType(typeNode) {
     const arg = typeNode.typeArguments?.[0];
     return { kind, payload: arg ? arg.getText() : null };
 }
-function parseServiceMember(source, member) {
+const DEFAULT_MEMBER_TIMEOUT_MS = 120000;
+const MAX_MEMBER_TIMEOUT_MS = 2147483647;
+function parseMemberKindWithConfig(typeNode) {
+    if (!typescript_1.default.isTypeReferenceNode(typeNode))
+        return null;
+    const typeName = qNameToText(typeNode.typeName);
+    if (!typeName.startsWith("AnQst."))
+        return null;
+    const kind = typeName.slice("AnQst.".length);
+    if (!["Call", "Slot", "Emitter", "Output", "Input"].includes(kind))
+        return null;
+    const typeArgs = typeNode.typeArguments ?? [];
+    if (kind === "Emitter") {
+        return {
+            kind,
+            payload: null,
+            configTypeNode: typeArgs[0] ?? null
+        };
+    }
+    return {
+        kind,
+        payload: typeArgs[0] ? typeArgs[0].getText() : null,
+        configTypeNode: kind === "Call" ? (typeArgs[1] ?? null) : null
+    };
+}
+function parseNumericLiteralType(node) {
+    if (!typescript_1.default.isLiteralTypeNode(node))
+        return null;
+    if (typescript_1.default.isNumericLiteral(node.literal)) {
+        return Number(node.literal.text);
+    }
+    if (typescript_1.default.isPrefixUnaryExpression(node.literal)
+        && node.literal.operator === typescript_1.default.SyntaxKind.MinusToken
+        && typescript_1.default.isNumericLiteral(node.literal.operand)) {
+        return -Number(node.literal.operand.text);
+    }
+    return null;
+}
+function resolveMemberTimeoutMs(source, serviceName, memberName, kind, configTypeNode, warnings, memberLoc) {
+    if (kind !== "Call")
+        return DEFAULT_MEMBER_TIMEOUT_MS;
+    if (!configTypeNode)
+        return DEFAULT_MEMBER_TIMEOUT_MS;
+    if (!typescript_1.default.isTypeLiteralNode(configTypeNode)) {
+        throw new errors_1.VerifyError(`${kind} config for '${memberName}' must be an inline object literal type.`, locFromNode(source, configTypeNode));
+    }
+    let timeoutSeconds = null;
+    let timeoutMilliseconds = null;
+    const memberPath = `${serviceName}.${memberName}`;
+    for (const prop of configTypeNode.members) {
+        if (!typescript_1.default.isPropertySignature(prop) || !prop.name) {
+            throw new errors_1.VerifyError(`${kind} config for '${memberName}' only supports named properties.`, locFromNode(source, prop));
+        }
+        if (!typescript_1.default.isIdentifier(prop.name)) {
+            throw new errors_1.VerifyError(`${kind} config for '${memberName}' only supports identifier keys.`, locFromNode(source, prop.name));
+        }
+        const key = prop.name.text;
+        if (!prop.type) {
+            throw new errors_1.VerifyError(`${kind} config key '${key}' in '${memberName}' must declare a numeric literal value.`, locFromNode(source, prop));
+        }
+        if (key !== "timeoutSeconds" && key !== "timeoutMilliseconds") {
+            warnings.push({
+                severity: "warn",
+                message: `Unknown ${kind} config key '${key}' ignored for '${memberPath}'.`,
+                loc: locFromNode(source, prop.name),
+                memberPath
+            });
+            continue;
+        }
+        const numericValue = parseNumericLiteralType(prop.type);
+        if (numericValue === null || !Number.isInteger(numericValue)) {
+            throw new errors_1.VerifyError(`${kind} config key '${key}' in '${memberName}' must be an integer literal >= 0.`, locFromNode(source, prop.type));
+        }
+        if (numericValue < 0) {
+            throw new errors_1.VerifyError(`${kind} config key '${key}' in '${memberName}' must be >= 0.`, locFromNode(source, prop.type));
+        }
+        if (key === "timeoutSeconds")
+            timeoutSeconds = numericValue;
+        if (key === "timeoutMilliseconds")
+            timeoutMilliseconds = numericValue;
+    }
+    if (timeoutSeconds !== null && timeoutMilliseconds !== null) {
+        throw new errors_1.VerifyError(`${kind} config for '${memberName}' must specify only one of 'timeoutSeconds' or 'timeoutMilliseconds'.`, memberLoc);
+    }
+    const effectiveMs = timeoutMilliseconds !== null
+        ? timeoutMilliseconds
+        : timeoutSeconds !== null
+            ? timeoutSeconds * 1000
+            : DEFAULT_MEMBER_TIMEOUT_MS;
+    if (effectiveMs > MAX_MEMBER_TIMEOUT_MS) {
+        throw new errors_1.VerifyError(`${kind} timeout for '${memberName}' exceeds max supported value (${MAX_MEMBER_TIMEOUT_MS} ms).`, memberLoc);
+    }
+    return effectiveMs;
+}
+function parseServiceMember(source, serviceName, member, warnings) {
     if (typescript_1.default.isMethodSignature(member)) {
         if (member.questionToken)
             throw new errors_1.VerifyError("Optional service methods are not allowed.", locFromNode(source, member));
         const returnType = member.type;
         if (!returnType)
             throw new errors_1.VerifyError("Service method must declare return type.", locFromNode(source, member));
-        const parsed = parseMemberKindFromAnQstType(returnType);
+        const parsed = parseMemberKindWithConfig(returnType);
         if (!parsed)
             throw new errors_1.VerifyError(`Unsupported service method return type '${returnType.getText()}'.`, locFromNode(source, member));
         if (parsed.kind === "Input" || parsed.kind === "Output") {
             throw new errors_1.VerifyError(`${parsed.kind} must be declared as property, not method.`, locFromNode(source, member));
         }
+        if (parsed.kind === "Emitter" && parsed.configTypeNode !== null) {
+            throw new errors_1.VerifyError(`Emitter '${member.name.getText(source)}' does not support config parameters; use plain AnQst.Emitter.`, locFromNode(source, parsed.configTypeNode));
+        }
         if (!member.name || !typescript_1.default.isIdentifier(member.name)) {
             throw new errors_1.VerifyError("Only identifier service method names are supported.", locFromNode(source, member));
         }
@@ -84,11 +184,13 @@ function parseServiceMember(source, member) {
                 throw new errors_1.VerifyError("Service parameters must declare type.", locFromNode(source, param));
             return { name: param.name.text, typeText: param.type.getText() };
         });
+        const timeoutMs = resolveMemberTimeoutMs(source, serviceName, member.name.text, parsed.kind, parsed.configTypeNode, warnings, locFromNode(source, member));
         return {
             kind: parsed.kind,
             name: member.name.text,
             payloadTypeText: parsed.payload,
             parameters,
+            timeoutMs,
             loc: locFromNode(source, member)
         };
     }
@@ -97,7 +199,7 @@ function parseServiceMember(source, member) {
             throw new errors_1.VerifyError("Service property must declare type.", locFromNode(source, member));
         if (member.questionToken)
             throw new errors_1.VerifyError("Optional service properties are not allowed.", locFromNode(source, member));
-        const parsed = parseMemberKindFromAnQstType(member.type);
+        const parsed = parseMemberKindWithConfig(member.type);
         if (!parsed)
             throw new errors_1.VerifyError(`Unsupported service property type '${member.type.getText()}'.`, locFromNode(source, member));
         if (parsed.kind !== "Input" && parsed.kind !== "Output") {
@@ -106,11 +208,13 @@ function parseServiceMember(source, member) {
         if (!member.name || !typescript_1.default.isIdentifier(member.name)) {
             throw new errors_1.VerifyError("Only identifier service property names are supported.", locFromNode(source, member));
         }
+        const timeoutMs = resolveMemberTimeoutMs(source, serviceName, member.name.text, parsed.kind, parsed.configTypeNode, warnings, locFromNode(source, member));
         return {
             kind: parsed.kind,
             name: member.name.text,
             payloadTypeText: parsed.payload,
             parameters: [],
+            timeoutMs,
             loc: locFromNode(source, member)
         };
     }
@@ -207,7 +311,7 @@ function serviceBaseType(iface) {
     }
     return null;
 }
-function parseSpecFile(specFilePath) {
+function parseSpecFileAst(specFilePath) {
     if (!node_fs_1.default.existsSync(specFilePath))
         throw new errors_1.VerifyError(`Spec file does not exist: ${specFilePath}`);
     const text = node_fs_1.default.readFileSync(specFilePath, "utf8");
@@ -225,12 +329,13 @@ function parseSpecFile(specFilePath) {
         throw new errors_1.VerifyError("Namespace body must be a block.", locFromNode(source, ns));
     const services = [];
     const namespaceTypeDecls = [];
+    const warnings = [];
     let supportsDevelopmentModeTransport = false;
     for (const stmt of ns.body.statements) {
         if (typescript_1.default.isInterfaceDeclaration(stmt)) {
             const baseType = serviceBaseType(stmt);
             if (baseType !== null) {
-                const members = stmt.members.map((member) => parseServiceMember(source, member));
+                const members = stmt.members.map((member) => parseServiceMember(source, stmt.name.text, member, warnings));
                 if (baseType === "AngularHTTPBaseServerClass") {
                     supportsDevelopmentModeTransport = true;
                 }
@@ -254,6 +359,19 @@ function parseSpecFile(specFilePath) {
         namespaceTypeDecls,
         importedTypeDecls: importInfo.importedTypeDecls,
         importedTypeSymbols: importInfo.importedTypeSymbols,
-        specImports: importInfo.specImports
+        specImports: importInfo.specImports,
+        warnings
     };
 }
+function parseSpecFile(specFilePath) {
+    (0, program_1.createTscProgramContext)(specFilePath);
+    const parsed = parseSpecFileAst(specFilePath);
+    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 → program.js}

@@ -9,7 +9,7 @@ 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 errors_1 = require("./errors");
 const debug_dump_1 = require("./debug-dump");
 const contextBySpecPath = new Map();
 function diagnosticText(diagnostic) {