@dusted/anqst 0.1.0 → 0.1.2

package/dist/src/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/verify.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifySpec = verifySpec;
 const typescript_1 = __importDefault(require("typescript"));
 const errors_1 = require("./errors");
+const program_1 = require("./program");
 function parseTypeNodeFromText(typeText) {
     const source = typescript_1.default.createSourceFile("__inline__.ts", `type __X = ${typeText};`, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
     const stmt = source.statements.find(typescript_1.default.isTypeAliasDeclaration);
@@ -170,7 +171,7 @@ function collectReachableTypeNames(spec) {
     }
     return seen;
 }
-function verifySpec(spec) {
+function verifySpecSemantics(spec) {
     checkServiceDuplicates(spec);
     for (const service of spec.services) {
         for (const member of service.members) {
@@ -198,3 +199,10 @@ function verifySpec(spec) {
         message: `AnQst spec valid:\n    ${stats.namespaceDeclaredTypes} types.\n    ${stats.serviceCount} services.`
     };
 }
+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 verifySpecSemantics(spec);
+}

package/index.d.ts

@@ -0,0 +1 @@
+export { AnQst } from "./spec/AnQst-Spec-DSL";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dusted/anqst",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Opinionated backend generator for webapps.",
   "keywords": [
     "nodejs",
@@ -21,14 +21,19 @@
   "author": "DusteD",
   "type": "commonjs",
   "main": "dist/src/app.js",
+  "types": "index.d.ts",
   "exports": {
-    ".": "./dist/src/app.js"
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./dist/src/app.js"
+    }
   },
   "bin": {
     "anqst": "dist/src/bin/anqst.js"
   },
   "files": [
     "dist/src",
+    "index.d.ts",
     "spec/AnQst-Spec-DSL.d.ts",
     "README.md",
     "LICENSE"
@@ -38,16 +43,19 @@
   },
   "scripts": {
     "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
-    "build": "npm run clean && tsc -p tsconfig.build.json",
-    "build:test": "npm run clean && tsc -p tsconfig.json",
+    "chmod:bin": "node -e \"require('node:fs').chmodSync('dist/src/bin/anqst.js', 0o755)\"",
+    "build": "node scripts/build-with-stamp.js",
+    "build:test": "npm run clean && tsc -p tsconfig.json && npm run chmod:bin",
     "prepare": "npm run build",
     "test": "npm run build:test && node --test dist/test/**/*.test.js",
     "start": "node dist/src/bin/anqst.js"
   },
   "dependencies": {
+    "pngjs": "^7.0.0",
     "typescript": "^5.9.2"
   },
   "devDependencies": {
-    "@types/node": "^24.3.0"
+    "@types/node": "^24.3.0",
+    "@types/pngjs": "^6.0.5"
   }
 }

package/spec/AnQst-Spec-DSL.d.ts

@@ -10,8 +10,8 @@
  * - This is not an input file to the generator, it is the description of the language that describes the widget.
  *   Not for use by TypeScript application implementation.
  * @example
- * package.json:
- * - "AnQst": { "WidgetSpec": "MyUserMgmtWidget.AnQstSpec.d.ts" }
+ * package.json:
+ * - "AnQst": "./AnQst/MyUserMgmtWidget.settings.json"
  */
 
 export namespace AnQst {