@webda/content-mapper 0.0.0-stage → 4.0.0-beta.4

package/lib/module.js

@@ -0,0 +1,1243 @@
+/**
+ * The whole `webda.module.json`, generated on the TypeScript 7.1 API.
+ *
+ * A port of `@webda/compiler`'s `ModuleGenerator.generate()` and its metadata
+ * plugins (`metadata/*.ts`). The target is byte identity with the artefact the
+ * TypeScript 6 generator writes, so key order is reproduced as carefully as
+ * the values: `beans`, `deployers`, `moddas` and `models` are key-sorted with
+ * the default code-unit sort (`JSONUtils.sortObject`), every other map keeps
+ * insertion order, and insertion order follows the TypeScript 6 program walk.
+ *
+ * Discovery, reflection and the schemas are not reimplemented here — they
+ * come from `module-discovery.ts` and `schema/*.ts`. What this file adds is
+ * the remaining metadata (Relations, Ancestors, Subclasses, Actions, Events,
+ * PrimaryKey, Plural, behaviours, commands, capabilities, Configuration) and
+ * the assembly.
+ *
+ * The module holds no source digest: the compiler keeps it in `.webda/cache`
+ * so the committed file only changes when its content does.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { getJSDocTags, getTextOfJSDocComment, SyntaxKind } from "typescript/unstable/ast";
+import * as is from "typescript/unstable/ast/is";
+import { SymbolFlags } from "typescript/unstable/sync";
+import { classTree, dependencyModelName, discoverWebdaObjects, exportedName, outputTarget, packageOf, reflectAttributes } from "./module-discovery.js";
+import { classPropertiesInTs6Order, ts6PropertyOrder } from "./property-order.js";
+import { generateModelSchemas } from "./schema/model.js";
+import { generateTopLevelSchemas } from "./schema/project.js";
+import { findParametersNode, generateServiceSchema } from "./schema/service.js";
+/** Value of `$schema` in every generated module. */
+export const WEBDA_MODULE_SCHEMA = "https://webda.io/schemas/webda.module.v4.json";
+/** Suffixes the content mapper is registered for. */
+const MAPPED_SUFFIXES = [".model.ts", ".service.ts"];
+/** Suffix suggested for a section when a file has none of {@link MAPPED_SUFFIXES}. */
+const SECTION_SUFFIX = {
+    models: ".model.ts",
+    moddas: ".service.ts",
+    beans: ".service.ts",
+    deployers: ".service.ts"
+};
+/**
+ * Plural of an English noun, as `@webda/compiler`'s `getPlural`.
+ *
+ * https://www.teflcourse.net/english-grammar-corner/changing-nouns-from-singular-to-plural/
+ * @param name - the singular noun
+ * @returns the pluralized form
+ */
+export function getPlural(name) {
+    const isVowel = (char) => "aeiouy".includes(char.toLowerCase());
+    if (name.endsWith("y")) {
+        if (isVowel(name.charAt(name.length - 2)))
+            return name + "s";
+        return name.substring(0, name.length - 1) + "ies";
+    }
+    if (name.endsWith("fe"))
+        return name.substring(0, name.length - 2) + "ves";
+    if (name.endsWith("f"))
+        return name.substring(0, name.length - 1) + "ves";
+    if (name.endsWith("on"))
+        return name.substring(0, name.length - 2) + "a";
+    if (name.endsWith("is"))
+        return name.substring(0, name.length - 2) + "es";
+    if (name.endsWith("man"))
+        return name.substring(0, name.length - 3) + "men";
+    if (name.endsWith("s") ||
+        name.endsWith("ss") ||
+        name.endsWith("sh") ||
+        name.endsWith("ch") ||
+        name.endsWith("x") ||
+        name.endsWith("z") ||
+        name.endsWith("o")) {
+        return name + "es";
+    }
+    return name + "s";
+}
+/**
+ * `JSONUtils.sortObject`: keys in default (code unit) order, entries the
+ * transformer maps to a falsy value dropped.
+ * @param unordered - the map
+ * @param transformer - value mapper
+ * @returns the sorted map
+ */
+export function sortObject(unordered, transformer = v => v) {
+    const sorted = {};
+    for (const key of Object.keys(unordered).sort()) {
+        const value = transformer(unordered[key]);
+        if (!value)
+            continue;
+        sorted[key] = value;
+    }
+    return sorted;
+}
+/**
+ * Text of a node, as `Node.getText()`.
+ * @param ctx - analysis context
+ * @param node - the node
+ * @returns the source text
+ */
+function text(ctx, node) {
+    return ctx.textOf(sourceFileOf(node), node);
+}
+/**
+ * The source file a node belongs to.
+ * @param node - the node
+ * @returns its file
+ */
+function sourceFileOf(node) {
+    const direct = node.getSourceFile?.() ?? node._sourceFile;
+    if (direct)
+        return direct;
+    let current = node;
+    while (current && current.kind !== SyntaxKind.SourceFile)
+        current = current.parent;
+    return current;
+}
+/**
+ * Decorators on a node, from its `modifiers`.
+ * @param node - a class element or class
+ * @returns the decorator nodes
+ */
+function decoratorsOf(node) {
+    return (node.modifiers ?? []).filter((modifier) => modifier.kind === SyntaxKind.Decorator);
+}
+/**
+ * Decorator name, for both `@Name` and `@Name()`, as `getDecoratorName`.
+ * @param ctx - analysis context
+ * @param decorator - the decorator
+ * @returns the name, when the expression is an identifier or a call on one
+ */
+function decoratorName(ctx, decorator) {
+    const expression = decorator.expression;
+    if (is.isCallExpression(expression) && is.isIdentifier(expression.expression)) {
+        return text(ctx, expression.expression);
+    }
+    if (is.isIdentifier(expression))
+        return text(ctx, expression);
+    return undefined;
+}
+/**
+ * Whether a method carries `@Action` or `@Operation`.
+ * @param ctx - analysis context
+ * @param method - the method
+ * @returns true when decorated
+ */
+function hasOperationDecorator(ctx, method) {
+    return decoratorsOf(method).some(decorator => {
+        const name = decoratorName(ctx, decorator);
+        return name === "Action" || name === "Operation";
+    });
+}
+/**
+ * Whether a node carries the `static` keyword.
+ * @param node - the node
+ * @returns true when static
+ */
+function isStaticMember(node) {
+    return (node.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.StaticKeyword);
+}
+/**
+ * The first `@tagName` JSDoc tag on a node.
+ * @param node - the declaration
+ * @param tagName - tag to find
+ * @returns the tag
+ */
+function findTag(node, tagName) {
+    try {
+        return getJSDocTags(node).find(tag => tag.tagName.text === tagName);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * `getTagsName`: every `Webda*` tag, valued by the first token of its payload
+ * or the class name.
+ * @param node - the declaration
+ * @returns tag name to value
+ */
+function webdaTags(node) {
+    const tags = {};
+    let found = [];
+    try {
+        found = getJSDocTags(node);
+    }
+    catch {
+        found = [];
+    }
+    for (const tag of found) {
+        const name = tag.tagName.text;
+        if (name.startsWith("Webda")) {
+            tags[name] =
+                (getTextOfJSDocComment(tag.comment) ?? "").trim().replace("\n", " ").split(" ").shift() ||
+                    node.name?.text;
+        }
+        else if (name.startsWith("Schema")) {
+            tags[name] = (getTextOfJSDocComment(tag.comment) ?? "").trim();
+        }
+    }
+    return tags;
+}
+/**
+ * Follow an alias to its target.
+ * @param ctx - analysis context
+ * @param symbol - the symbol
+ * @returns the resolved symbol
+ */
+function resolveAlias(ctx, symbol) {
+    if (!symbol)
+        return symbol;
+    if (!(symbol.flags & SymbolFlags.Alias))
+        return symbol;
+    try {
+        return ctx.checker.getAliasedSymbol(symbol);
+    }
+    catch {
+        return symbol;
+    }
+}
+/**
+ * Resolved declaration nodes of a symbol.
+ * @param ctx - analysis context
+ * @param symbol - the symbol
+ * @returns the declarations
+ */
+function declarationsOf(ctx, symbol) {
+    const nodes = [];
+    for (const handle of symbol?.declarations ?? []) {
+        const node = handle.resolve(ctx.project);
+        if (node)
+            nodes.push(node);
+    }
+    return nodes;
+}
+/**
+ * Resolved value declaration of a symbol.
+ * @param ctx - analysis context
+ * @param symbol - the symbol
+ * @returns the declaration
+ */
+function valueDeclarationOf(ctx, symbol) {
+    return symbol?.valueDeclaration?.resolve(ctx.project) ?? undefined;
+}
+/**
+ * `propertyIsKeyedBySymbol`: whether a property is declared `[key]` with
+ * `key` the named `unique symbol` exported by `packageName`.
+ * @param ctx - analysis context
+ * @param property - the property symbol
+ * @param packageName - package declaring the key
+ * @param symbolName - name of the key
+ * @returns true on a match
+ */
+function propertyIsKeyedBySymbol(ctx, property, packageName, symbolName) {
+    // Cheap pre-filter: symbol-keyed members are named `__@<name>@<id>`.
+    if (!property.name.startsWith(`__@${symbolName}@`))
+        return false;
+    for (const declaration of declarationsOf(ctx, property)) {
+        const name = declaration.name;
+        if (!name || !is.isComputedPropertyName(name))
+            continue;
+        const key = resolveAlias(ctx, ctx.checker.getSymbolAtLocation(name.expression));
+        if (!key || key.name !== symbolName)
+            continue;
+        const keyDeclaration = valueDeclarationOf(ctx, key);
+        const file = keyDeclaration ? sourceFileOf(keyDeclaration)?.fileName : undefined;
+        if (file && packageOf(file) === packageName)
+            return true;
+    }
+    return false;
+}
+/**
+ * Declared (instance) type of a class.
+ * @param ctx - analysis context
+ * @param cls - the class declaration
+ * @returns the type
+ */
+function declaredTypeOf(ctx, cls) {
+    const symbol = cls.name ? ctx.checker.getSymbolAtLocation(cls.name) : undefined;
+    return symbol ? ctx.checker.getDeclaredTypeOfSymbol(symbol) : undefined;
+}
+/**
+ * Properties of a class's instance type, inherited ones included.
+ * @param ctx - analysis context
+ * @param cls - the class declaration
+ * @returns the property symbols
+ */
+function propertiesOf(ctx, cls) {
+    return classPropertiesInTs6Order(ctx, cls);
+}
+/**
+ * Names of the properties of a symbol-keyed member's type — the `Events` of
+ * `[WEBDA_EVENTS]` or the declarative `Actions` of `[WEBDA_ACTIONS]`.
+ * @param ctx - analysis context
+ * @param property - the member
+ * @returns property names in declaration order
+ */
+function memberTypeKeys(ctx, property) {
+    const location = valueDeclarationOf(ctx, property);
+    const type = location
+        ? ctx.checker.getTypeOfSymbolAtLocation(property, location)
+        : ctx.checker.getTypeOfSymbol(property);
+    const keys = {};
+    for (const member of ts6PropertyOrder(ctx, type, ctx.checker.getPropertiesOfType(type)))
+        keys[member.name] = true;
+    return Object.keys(keys);
+}
+/**
+ * Read the string-literal options of an `@Action`/`@Operation` decorator.
+ * @param ctx - analysis context
+ * @param method - the method
+ * @param onProperty - receives each `key: value` property assignment
+ */
+function forEachOperationOption(ctx, method, onProperty) {
+    const decorator = decoratorsOf(method).find(candidate => {
+        const name = decoratorName(ctx, candidate);
+        return name === "Action" || name === "Operation";
+    });
+    if (!decorator || !is.isCallExpression(decorator.expression))
+        return;
+    const argument = decorator.expression.arguments?.[0];
+    if (!argument || !is.isObjectLiteralExpression(argument))
+        return;
+    for (const property of argument.properties) {
+        if (!is.isPropertyAssignment(property) || !is.isIdentifier(property.name))
+            continue;
+        onProperty(property.name.text, property.initializer);
+    }
+}
+/**
+ * Decorated instance methods, via the type so inherited ones are included.
+ * @param ctx - analysis context
+ * @param cls - the class
+ * @returns the method declarations, in property order
+ */
+function decoratedInstanceMethods(ctx, cls) {
+    const methods = [];
+    for (const property of propertiesOf(ctx, cls)) {
+        const node = valueDeclarationOf(ctx, property);
+        if (!node || node.kind !== SyntaxKind.MethodDeclaration)
+            continue;
+        if (hasOperationDecorator(ctx, node))
+            methods.push(node);
+    }
+    return methods;
+}
+/**
+ * Decorated static methods declared on the class itself.
+ * @param ctx - analysis context
+ * @param cls - the class
+ * @returns the method declarations, in member order
+ */
+function decoratedStaticMethods(ctx, cls) {
+    return (cls.members ?? []).filter((member) => is.isMethodDeclaration(member) && isStaticMember(member) && hasOperationDecorator(ctx, member));
+}
+/**
+ * A model's `Actions`, as `ActionsMetadata`.
+ * @param ctx - analysis context
+ * @param cls - the model class
+ * @returns action name to metadata
+ */
+export function buildModelActions(ctx, cls) {
+    let actions = {};
+    // Source 1: the declarative `[WEBDA_ACTIONS]` member.
+    const declared = propertiesOf(ctx, cls).find(p => propertyIsKeyedBySymbol(ctx, p, "@webda/models", "WEBDA_ACTIONS"));
+    if (declared) {
+        actions = {};
+        for (const key of memberTypeKeys(ctx, declared))
+            actions[key] = {};
+    }
+    // Source 2: decorated methods, instance then static.
+    const processMethod = (method) => {
+        const meta = {};
+        if (isStaticMember(method))
+            meta.global = true;
+        const methodName = text(ctx, method.name);
+        let name = methodName;
+        forEachOperationOption(ctx, method, (key, initializer) => {
+            if ((key === "description" || key === "summary") && is.isStringLiteral(initializer)) {
+                meta[key] = initializer.text;
+            }
+            // `@Action({ name })` exposes the action under another name than the method
+            if (key === "name" && is.isStringLiteral(initializer) && initializer.text) {
+                name = initializer.text;
+            }
+        });
+        if (name !== methodName)
+            meta.handler = methodName;
+        actions[name] = meta;
+    };
+    decoratedInstanceMethods(ctx, cls).forEach(processMethod);
+    decoratedStaticMethods(ctx, cls).forEach(processMethod);
+    return actions;
+}
+/**
+ * A model's `Events`, as `EventsMetadata`.
+ * @param ctx - analysis context
+ * @param cls - the model class
+ * @returns event names, or undefined when the model declares no events member
+ */
+export function buildModelEvents(ctx, cls) {
+    const events = propertiesOf(ctx, cls).find(p => propertyIsKeyedBySymbol(ctx, p, "@webda/models", "WEBDA_EVENTS"));
+    return events ? memberTypeKeys(ctx, events) : undefined;
+}
+/**
+ * A model's `PrimaryKey`, as `PrimaryKeyMetadata`.
+ *
+ * Two forms: a `readonly ["a", "b"]` tuple annotation, and an
+ * `= ["a", "b"] as const` initialiser. A `readonly X[]` annotation — the
+ * abstract `keyof this` form — records nothing, even when an initialiser
+ * follows it.
+ * @param ctx - analysis context
+ * @param cls - the model class
+ * @returns key attributes, or undefined when the model has no key member
+ */
+export function buildModelPrimaryKey(ctx, cls) {
+    const symbol = propertiesOf(ctx, cls).find(p => propertyIsKeyedBySymbol(ctx, p, "@webda/models", "WEBDA_PRIMARY_KEY"));
+    if (!symbol)
+        return undefined;
+    const keys = [];
+    const declaration = valueDeclarationOf(ctx, symbol);
+    if (!declaration)
+        return keys;
+    const typeNode = declaration.type;
+    if (typeNode && is.isTypeOperatorNode(typeNode) && typeNode.operator === SyntaxKind.ReadonlyKeyword) {
+        const inner = typeNode.type;
+        if (is.isTupleTypeNode(inner)) {
+            for (const element of inner.elements) {
+                if (is.isLiteralTypeNode(element))
+                    keys.push(text(ctx, element.literal).replace(/"/g, ""));
+            }
+            return keys;
+        }
+        if (is.isArrayTypeNode(inner))
+            return keys;
+    }
+    const initializer = declaration.initializer;
+    if (initializer && is.isAsExpression(initializer)) {
+        const array = initializer.expression;
+        if (is.isArrayLiteralExpression(array)) {
+            for (const element of array.elements) {
+                if (is.isStringLiteral(element))
+                    keys.push(element.text);
+            }
+        }
+    }
+    return keys;
+}
+/**
+ * A model's `PrimaryKeySeparator`, from a `[WEBDA_PRIMARY_KEY_SEPARATOR] = ":"` initialiser.
+ * @param ctx - analysis context
+ * @param cls - the model class
+ * @returns the separator, or undefined when the model declares none
+ */
+export function buildModelPrimaryKeySeparator(ctx, cls) {
+    const symbol = propertiesOf(ctx, cls).find(p => propertyIsKeyedBySymbol(ctx, p, "@webda/models", "WEBDA_PRIMARY_KEY_SEPARATOR"));
+    const initializer = symbol ? valueDeclarationOf(ctx, symbol)?.initializer : undefined;
+    return initializer && is.isStringLiteral(initializer) ? initializer.text : undefined;
+}
+/**
+ * Leading comments of a parameter, one string per comment.
+ * @param ctx - analysis context
+ * @param param - the parameter
+ * @returns comment texts
+ */
+function leadingComments(ctx, param) {
+    const trivia = ctx.triviaOf(sourceFileOf(param), param);
+    return trivia.match(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g) ?? [];
+}
+/**
+ * One `@Command` argument, as `extractParamDefinition`.
+ * @param ctx - analysis context
+ * @param param - the parameter declaration
+ * @returns the argument definition
+ */
+function commandArg(ctx, param) {
+    let type = "string";
+    if (param.type) {
+        const typeText = text(ctx, param.type).toLowerCase().trim();
+        type = typeText === "number" ? "number" : typeText === "boolean" ? "boolean" : "string";
+    }
+    const def = { type };
+    if (!param.initializer && !param.questionToken)
+        def.required = true;
+    const initializer = param.initializer;
+    if (initializer) {
+        if (is.isStringLiteral(initializer))
+            def.default = initializer.text;
+        else if (is.isNumericLiteral(initializer))
+            def.default = Number(initializer.text);
+        else if (initializer.kind === SyntaxKind.TrueKeyword)
+            def.default = true;
+        else if (initializer.kind === SyntaxKind.FalseKeyword)
+            def.default = false;
+    }
+    const docs = {};
+    for (const comment of leadingComments(ctx, param)) {
+        const alias = comment.match(/@alias\s+(\S+)/);
+        if (alias)
+            docs.alias = alias[1];
+        const description = comment.match(/@description\s+(.+?)(?:\n|$|\*\/)/);
+        if (description)
+            docs.description = description[1]
+                .trim()
+                .replace(/\s*\*\s*/g, " ")
+                .trim();
+        const deprecated = comment.match(/@deprecated\s*(.*?)(?:\n|$|\*\/)/);
+        if (deprecated)
+            docs.deprecated =
+                deprecated[1]
+                    .trim()
+                    .replace(/\s*\*\s*/g, " ")
+                    .trim() || "";
+    }
+    if (docs.alias)
+        def.alias = docs.alias;
+    if (docs.description)
+        def.description = docs.description;
+    if (docs.deprecated !== undefined)
+        def.deprecated = docs.deprecated;
+    return def;
+}
+/**
+ * A service's `commands`, as `CommandsMetadata`: every `@Command` or
+ * `@BuildCommand` method declared on the class itself.
+ * @param ctx - analysis context
+ * @param cls - the service class
+ * @returns command name to definition
+ */
+export function buildCommands(ctx, cls) {
+    const commands = {};
+    for (const member of cls.members ?? []) {
+        if (!is.isMethodDeclaration(member))
+            continue;
+        const decorator = decoratorsOf(member).find(candidate => {
+            const name = decoratorName(ctx, candidate);
+            return name === "Command" || name === "BuildCommand";
+        });
+        if (!decorator || !is.isCallExpression(decorator.expression))
+            continue;
+        const isBuild = decoratorName(ctx, decorator) === "BuildCommand";
+        const args = decorator.expression.arguments ?? [];
+        let commandName;
+        let options;
+        if (isBuild) {
+            commandName = "build";
+            options = args[0];
+        }
+        else {
+            if (args.length === 0 || !is.isStringLiteral(args[0]))
+                continue;
+            commandName = args[0].text;
+            options = args[1];
+        }
+        let description = "";
+        let requires;
+        let phase = isBuild ? "resolved" : undefined;
+        if (options && is.isObjectLiteralExpression(options)) {
+            for (const property of options.properties) {
+                if (!is.isPropertyAssignment(property) || !is.isIdentifier(property.name))
+                    continue;
+                const key = property.name.text;
+                const initializer = property.initializer;
+                if (key === "description" && is.isStringLiteral(initializer)) {
+                    description = initializer.text;
+                }
+                else if (key === "requires" && is.isArrayLiteralExpression(initializer)) {
+                    requires = initializer.elements.filter((e) => is.isStringLiteral(e)).map((e) => e.text);
+                }
+                else if (!isBuild && key === "phase" && is.isStringLiteral(initializer)) {
+                    const value = initializer.text;
+                    if (value === "resolved" || value === "initialized")
+                        phase = value;
+                }
+            }
+        }
+        const methodArgs = {};
+        for (const param of member.parameters)
+            methodArgs[text(ctx, param.name)] = commandArg(ctx, param);
+        commands[commandName] = { description, method: text(ctx, member.name), args: methodArgs, requires, phase };
+    }
+    return commands;
+}
+/**
+ * A service's `capabilities`, as `CapabilitiesMetadata`: the
+ * `@WebdaCapability` of every type named in the class's own heritage clauses.
+ * @param ctx - analysis context
+ * @param cls - the service class
+ * @returns sorted capability names
+ */
+export function buildCapabilities(ctx, cls) {
+    const capabilities = [];
+    const type = declaredTypeOf(ctx, cls);
+    const declarations = declarationsOf(ctx, type?.getSymbol());
+    for (const declaration of declarations) {
+        if (!is.isClassDeclaration(declaration))
+            continue;
+        for (const clause of declaration.heritageClauses ?? []) {
+            for (const expression of clause.types) {
+                const target = ctx.checker.getTypeAtLocation(expression);
+                for (const targetDeclaration of declarationsOf(ctx, target?.getSymbol())) {
+                    const tag = findTag(targetDeclaration, "WebdaCapability");
+                    if (!tag)
+                        continue;
+                    const name = (getTextOfJSDocComment(tag.comment) ?? "").trim().split(" ").shift() || undefined;
+                    if (name && !capabilities.includes(name))
+                        capabilities.push(name);
+                }
+            }
+        }
+    }
+    return capabilities.sort();
+}
+/**
+ * The Behavior identifier of a `@WebdaBehavior` class: the tag's first token,
+ * else the namespaced class name.
+ * @param cls - the class
+ * @param namespace - project namespace
+ * @returns the identifier, or undefined when the class is not a Behavior
+ */
+function behaviorIdentifier(cls, namespace) {
+    const tag = findTag(cls, "WebdaBehavior");
+    if (!tag)
+        return undefined;
+    const override = getTextOfJSDocComment(tag.comment)?.trim();
+    if (override) {
+        const first = override.split(/\s+/).shift();
+        if (first)
+            return first;
+    }
+    const className = cls.name?.text ?? "";
+    if (!className)
+        return undefined;
+    return completeNamespace(className, namespace);
+}
+/**
+ * `WebdaProject.completeNamespace`.
+ * @param name - a bare or qualified name
+ * @param namespace - project namespace
+ * @returns the qualified name
+ */
+function completeNamespace(name, namespace) {
+    if (name.includes("/"))
+        return name;
+    return `${namespace ?? "Webda"}/${name}`;
+}
+/**
+ * A Behavior's `Actions`, as `BehaviorsMetadata`.
+ * @param ctx - analysis context
+ * @param cls - the Behavior class
+ * @param identifier - its identifier, for error messages
+ * @returns action name to metadata
+ * @throws on a static action or `global: true`, both of which Behaviors forbid
+ */
+export function buildBehaviorActions(ctx, cls, identifier) {
+    const actions = {};
+    const processMethod = (method) => {
+        const methodName = text(ctx, method.name);
+        if (isStaticMember(method)) {
+            throw new Error(`Behavior ${identifier}: static @Action methods are not allowed (method "${methodName}").`);
+        }
+        const meta = {};
+        forEachOperationOption(ctx, method, (key, initializer) => {
+            if (key === "global") {
+                throw new Error(`Behavior ${identifier}: @Action({ global: true }) is not allowed (method "${methodName}").`);
+            }
+            if ((key === "description" || key === "summary") && is.isStringLiteral(initializer)) {
+                meta[key] = initializer.text;
+            }
+            if (key === "rest" && is.isObjectLiteralExpression(initializer)) {
+                const rest = {};
+                for (const restProperty of initializer.properties) {
+                    if (is.isPropertyAssignment(restProperty) &&
+                        is.isIdentifier(restProperty.name) &&
+                        is.isStringLiteral(restProperty.initializer)) {
+                        const restKey = restProperty.name.text;
+                        if (restKey === "route" || restKey === "method")
+                            rest[restKey] = restProperty.initializer.text;
+                    }
+                }
+                if (Object.keys(rest).length > 0)
+                    meta.rest = rest;
+            }
+        });
+        actions[methodName] = meta;
+    };
+    decoratedInstanceMethods(ctx, cls).forEach(processMethod);
+    decoratedStaticMethods(ctx, cls).forEach(processMethod);
+    return actions;
+}
+/**
+ * The Behavior identifier of an attribute's written type, when that type is a
+ * `@WebdaBehavior` class — `resolveBehaviorIdentifierFromType`.
+ * @param ctx - analysis context
+ * @param typeRef - the attribute's type reference
+ * @param namespace - project namespace
+ * @returns the identifier
+ */
+function behaviorOfTypeReference(ctx, typeRef, namespace) {
+    if (!typeRef?.typeName)
+        return undefined;
+    // `getTypeAtLocation(typeName)` answers with a symbol-less type on 7.1; the
+    // type of the reference itself carries the class symbol.
+    let symbol;
+    try {
+        symbol = ctx.checker.getTypeFromTypeNode(typeRef).getSymbol();
+    }
+    catch {
+        symbol = undefined;
+    }
+    symbol ??= resolveAlias(ctx, ctx.checker.getSymbolAtLocation(typeRef.typeName));
+    const declaration = declarationsOf(ctx, symbol).find(d => is.isClassDeclaration(d) || is.isClassExpression(d));
+    if (!declaration)
+        return undefined;
+    return behaviorIdentifier(declaration, namespace);
+}
+/**
+ * Whether a property should be skipped entirely: `@NotEnumerable` (the bare
+ * decorator only) or an `@ignore` JSDoc tag.
+ * @param ctx - analysis context
+ * @param member - the property declaration
+ * @returns true to skip
+ */
+function isSkippedProperty(ctx, member) {
+    for (const decorator of decoratorsOf(member)) {
+        if (is.isIdentifier(decorator.expression) && decorator.expression.text === "NotEnumerable")
+            return true;
+    }
+    return findTag(member, "ignore") !== undefined;
+}
+/**
+ * `processModels`: Relations, Ancestors and Subclasses for every local model,
+ * plus the fields the plugins fill in later.
+ * @param ctx - analysis context
+ * @param models - local models, in program-walk order
+ * @param namespace - project namespace
+ * @param errors - accumulator for conditions TypeScript 6 throws on
+ * @param appPath - project directory, to tell dependency models from local ones
+ * @returns model entries, in walk order (sorted by the caller)
+ */
+function processModels(ctx, models, namespace, errors, appPath) {
+    const byTypeId = new Map();
+    for (const model of models)
+        byTypeId.set(model.type.id, model.object.name);
+    const modelOf = (typeNode) => {
+        if (!typeNode)
+            return undefined;
+        try {
+            return byTypeId.get(ctx.checker.getTypeFromTypeNode(typeNode).id);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const entries = {};
+    for (const { object, declaration } of models) {
+        const name = object.name;
+        const sf = sourceFileOf(declaration);
+        const relations = {};
+        let hasProperty = false;
+        for (const property of propertiesOf(ctx, declaration)) {
+            let member = valueDeclarationOf(ctx, property);
+            if (!member)
+                continue;
+            if (is.isPropertyDeclaration(member)) {
+                hasProperty = true;
+            }
+            else {
+                // A property inherited from a dependency's model is read from its
+                // declaration file, where relation properties are emitted as accessors.
+                member = declarationFileGetter(ctx, property, member);
+                if (!member)
+                    continue;
+            }
+            if (isSkippedProperty(ctx, member))
+                continue;
+            const typeNode = member.type;
+            if (!typeNode || !is.isTypeReferenceNode(typeNode))
+                continue;
+            const attribute = property.name;
+            const typeArguments = typeNode.typeArguments ?? [];
+            const typeName = text(ctx, typeNode.typeName);
+            const addLink = (type) => {
+                relations.links ??= [];
+                relations.links.push({ attribute, model: modelOf(typeArguments[0]), type });
+            };
+            switch (typeName) {
+                case "ModelParent": {
+                    const model = modelOf(typeArguments[0]);
+                    if (!model)
+                        errors.push(`Cannot find parent model ${text(ctx, typeArguments[0])} for ${name}.${attribute}`);
+                    relations.parent = { attribute, model };
+                    break;
+                }
+                case "ModelRelated": {
+                    relations.queries ??= [];
+                    const model = modelOf(typeArguments[0]);
+                    if (!model)
+                        errors.push(`Cannot find query model ${text(ctx, typeArguments[0])} for ${name}.${attribute}`);
+                    relations.queries.push({
+                        attribute,
+                        model,
+                        targetAttribute: typeArguments[1] ? text(ctx, typeArguments[1]).replace(/"/g, "") : undefined
+                    });
+                    break;
+                }
+                case "ModelsMapped": {
+                    relations.maps ??= [];
+                    const model = modelOf(typeArguments[0]);
+                    if (!model)
+                        errors.push(`Cannot find map model ${text(ctx, typeArguments[0])} for ${name}.${attribute}`);
+                    const map = {
+                        attribute,
+                        cascadeDelete: findTag(member, "CascadeDelete") !== undefined,
+                        model,
+                        targetLink: text(ctx, typeArguments[1]).replace(/"/g, ""),
+                        targetAttributes: text(ctx, typeArguments[2])
+                            .replace(/"/g, "")
+                            .split("|")
+                            .map(t => t.trim())
+                    };
+                    if (!map.targetAttributes.includes("uuid"))
+                        map.targetAttributes.push("uuid");
+                    relations.maps.push(map);
+                    break;
+                }
+                case "ModelLink":
+                    addLink("LINK");
+                    break;
+                case "ModelLinksMap":
+                    addLink("LINKS_MAP");
+                    break;
+                case "ModelLinksArray":
+                    addLink("LINKS_ARRAY");
+                    break;
+                case "ModelLinksSimpleArray":
+                    addLink("LINKS_SIMPLE_ARRAY");
+                    break;
+                default: {
+                    const behavior = behaviorOfTypeReference(ctx, typeNode, namespace);
+                    if (behavior) {
+                        relations.behaviors ??= [];
+                        relations.behaviors.push({ attribute, behavior });
+                    }
+                }
+            }
+        }
+        // TypeScript 6 records the entry from inside the property loop, so a model
+        // with no property declarations at all has no entry.
+        if (!hasProperty)
+            continue;
+        entries[name] = {
+            Plural: "",
+            Import: object.importTarget,
+            Relations: relations,
+            Ancestors: [],
+            Subclasses: [],
+            Reflection: reflectAttributes(ctx, sf, declaration),
+            Schemas: {},
+            Actions: {},
+            Events: [],
+            PrimaryKey: [],
+            Identifier: name
+        };
+    }
+    // Ancestors: the class tree mapped to local models, nearest first, without
+    // the model itself and — as in TypeScript 6 — without `Webda/CoreModel`.
+    for (const { object, declaration } of models) {
+        const entry = entries[object.name];
+        if (!entry)
+            continue;
+        entry.Ancestors = classTree(ctx, declaration)
+            .map((type) => byTypeId.get(declaredId(ctx, type)) ?? dependencyModelOf(ctx, type, appPath))
+            .filter((ancestor) => ancestor !== undefined && ancestor !== "Webda/CoreModel" && ancestor !== object.name);
+    }
+    for (const name of Object.keys(entries)) {
+        const ancestors = entries[name].Ancestors;
+        if (ancestors.length)
+            entries[ancestors[0]]?.Subclasses.push(name);
+    }
+    return entries;
+}
+/**
+ * Getter declaring a property in a declaration file.
+ *
+ * Declaration emit turns a relation property (`_user: ModelLink<T>`) into a
+ * `get`/`set` pair; the getter's return type is the property's type.
+ * @param ctx - analysis context
+ * @param property - the property symbol
+ * @param member - its value declaration
+ * @returns the getter, or undefined outside a declaration file
+ */
+function declarationFileGetter(ctx, property, member) {
+    if (!sourceFileOf(member)?.isDeclarationFile)
+        return undefined;
+    if (is.isGetAccessorDeclaration(member))
+        return member;
+    for (const declaration of property.declarations ?? []) {
+        const node = declaration?.resolve(ctx.project);
+        if (node && is.isGetAccessorDeclaration(node))
+            return node;
+    }
+    return undefined;
+}
+/**
+ * Framework base classes from `@webda/models`. Like `Webda/CoreModel`, they are
+ * the root every model derives from, not a domain ancestor, and are not
+ * recorded.
+ */
+const FRAMEWORK_BASE_MODELS = new Set(["Webda/Model", "Webda/UuidModel"]);
+/**
+ * Namespaced name of a class declared as a model by a dependency package.
+ * @param ctx - analysis context
+ * @param type - a class in a model's class tree
+ * @param appPath - project directory
+ * @returns the model name, when the class is a dependency's domain model
+ */
+function dependencyModelOf(ctx, type, appPath) {
+    const symbol = type.getSymbol?.() ?? type.symbol;
+    const declaration = valueDeclarationOf(ctx, symbol);
+    const fileName = declaration ? sourceFileOf(declaration)?.fileName : undefined;
+    if (!fileName || !symbol?.name)
+        return undefined;
+    const name = dependencyModelName(fileName, symbol.name, appPath);
+    return name && !FRAMEWORK_BASE_MODELS.has(name) ? name : undefined;
+}
+/**
+ * Id of the declared type behind a (possibly instantiated) type — what
+ * TypeScript 6's `getClassTree` records, as it re-reads each base through
+ * `getTypeAtLocation(valueDeclaration)`.
+ * @param ctx - analysis context
+ * @param type - the type
+ * @returns the declared type's id
+ */
+function declaredId(ctx, type) {
+    const symbol = type.getSymbol?.();
+    if (!symbol)
+        return type.id;
+    try {
+        return ctx.checker.getDeclaredTypeOfSymbol(symbol).id;
+    }
+    catch {
+        return type.id;
+    }
+}
+/**
+ * Find a class declaration by file and written name.
+ * @param ctx - analysis context
+ * @param fileName - declaring file
+ * @param className - class name
+ * @returns the declaration
+ */
+function findClass(ctx, fileName, className) {
+    const sf = ctx.program.getSourceFile(fileName);
+    return sf?.statements.find((statement) => is.isClassDeclaration(statement) && statement.name?.text === className);
+}
+/**
+ * `getJSTargetFile` without extension: the output path for a project file, or
+ * `node_modules/<package>/<path>` for a dependency's declaration file.
+ * @param fileName - the source file
+ * @param options - discovery options
+ * @returns the import path
+ */
+function jsTarget(fileName, options) {
+    if (!fileName.startsWith(options.appPath)) {
+        let folder = fileName;
+        let libPath = "node_modules/";
+        for (;;) {
+            const parent = join(folder, "..");
+            if (parent === folder || parent.length <= 2)
+                break;
+            folder = parent;
+            const manifest = join(folder, "package.json");
+            if (!existsSync(manifest))
+                continue;
+            const name = JSON.parse(readFileSync(manifest, "utf8")).name;
+            if (name) {
+                libPath += name + "/";
+                break;
+            }
+        }
+        return (libPath + relative(folder, fileName)).replace(/\.d\.ts$/, ".js").replace(/\.js$/, "");
+    }
+    return outputTarget(fileName, options);
+}
+/**
+ * The `Configuration` of a service: where its parameters class is exported.
+ * @param ctx - analysis context
+ * @param declaration - the service class
+ * @param base - parameters base type
+ * @param options - discovery options
+ * @returns `path:export`, or undefined when there is no parameters type
+ * @throws when the parameters class is not exported
+ */
+function configurationOf(ctx, declaration, base, options) {
+    const node = findParametersNode(declaration, ctx.checker, ctx.project, base);
+    if (!node)
+        return undefined;
+    const type = ctx.checker.getTypeAtLocation(node);
+    const target = valueDeclarationOf(ctx, type.getSymbol());
+    if (!target)
+        throw new Error(`Cannot find the declaration of ${text(ctx, node)}`);
+    const sf = sourceFileOf(target);
+    const exportName = exportedName(ctx, sf, target);
+    if (!exportName) {
+        throw new Error(`Cannot find exported name for ${target.name?.text}, check that the class is exported`);
+    }
+    return `${jsTarget(sf.fileName, options)}:${exportName}`;
+}
+/**
+ * Read the application's `package.json`.
+ * @param appPath - application root
+ * @returns the manifest, or an empty object
+ */
+function manifestOf(appPath) {
+    try {
+        return JSON.parse(readFileSync(join(appPath, "package.json"), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Generate the complete `webda.module.json` for a project.
+ * @param ctx - analysis context over the project
+ * @param options - roots, namespace and capabilities
+ * @returns the module, naming violations and errors
+ */
+export function generateWebdaModule(ctx, options) {
+    const compilerOptions = ctx.program.getCompilerOptions?.() ?? {};
+    const discovery = {
+        appPath: options.appPath,
+        rootDir: options.rootDir ?? compilerOptions.rootDir ?? join(options.appPath, "src"),
+        outDir: options.outDir ?? compilerOptions.outDir ?? join(options.appPath, "lib"),
+        namespace: options.namespace
+    };
+    const namespace = options.namespace;
+    const errors = [];
+    // TypeScript 6 walks `program.getSourceFiles()` in program order; several
+    // maps below keep that insertion order, so reproduce it.
+    const fileOrder = new Map();
+    ctx.program.getSourceFileNames().forEach((fileName, index) => fileOrder.set(fileName, index));
+    const walkOrder = (a, b) => (fileOrder.get(a.fileName) ?? 0) - (fileOrder.get(b.fileName) ?? 0) || a.pos - b.pos;
+    const classified = discoverWebdaObjects(ctx, { ...discovery, keepDuplicates: true })
+        .map(object => ({ object, declaration: findClass(ctx, object.fileName, object.className) }))
+        .filter((item) => !!item.declaration)
+        // A `@WebdaSchema` class is a top-level schema and nothing else: the
+        // TypeScript 6 walk returns before classifying it.
+        .filter(item => webdaTags(item.declaration).WebdaSchema === undefined)
+        .sort((a, b) => walkOrder({ fileName: a.object.fileName, pos: a.declaration.pos }, { fileName: b.object.fileName, pos: b.declaration.pos }));
+    // Two classes can share a namespaced name. TypeScript 6 let the last class
+    // in program order win silently, which registered one class while code
+    // saved the other (`@webda/core` shipped two AuditEntry models). Keep that
+    // choice so the module stays inspectable, but report it: the build fails.
+    const slots = new Map();
+    const discovered = [];
+    for (const item of classified) {
+        const key = `${item.object.section}:${item.object.name}`;
+        const slot = slots.get(key);
+        if (slot === undefined) {
+            slots.set(key, discovered.length);
+            discovered.push(item);
+        }
+        else {
+            const previous = discovered[slot].object;
+            errors.push(`${item.object.name} is declared twice: ${previous.className} in ${previous.fileName} and ` +
+                `${item.object.className} in ${item.object.fileName}; rename one`);
+            discovered[slot] = item;
+        }
+    }
+    // Naming guard, in walk order, one report per file — every classified
+    // class counts, including a duplicate that loses its slot.
+    const namingViolations = [];
+    for (const { object } of classified) {
+        const expectedSuffix = SECTION_SUFFIX[object.section];
+        if (!expectedSuffix)
+            continue;
+        if (MAPPED_SUFFIXES.some(suffix => object.fileName.endsWith(suffix)))
+            continue;
+        if (namingViolations.some(v => v.fileName === object.fileName))
+            continue;
+        namingViolations.push({
+            fileName: object.fileName,
+            className: object.className,
+            section: object.section,
+            expectedSuffix
+        });
+    }
+    const services = {
+        beans: {},
+        deployers: {},
+        moddas: {}
+    };
+    const models = [];
+    for (const { object, declaration } of discovered) {
+        if (object.section === "models") {
+            const type = declaredTypeOf(ctx, declaration);
+            if (type)
+                models.push({ object, declaration, type, tags: webdaTags(declaration) });
+            continue;
+        }
+        services[object.section][object.name] = { Import: object.importTarget, Schema: {} };
+    }
+    const module = {
+        $schema: WEBDA_MODULE_SCHEMA,
+        beans: sortObject(services.beans),
+        deployers: sortObject(services.deployers),
+        moddas: sortObject(services.moddas),
+        models: sortObject(processModels(ctx, models, namespace, errors, options.appPath)),
+        schemas: {},
+        behaviors: {},
+        capabilities: options.capabilities ?? manifestOf(options.appPath).webda?.capabilities
+    };
+    // Schemas and Configuration — `WebdaSchemaResults.generateSchemas`.
+    for (const { object, declaration } of discovered) {
+        if (object.section === "models") {
+            const entry = module.models[object.name];
+            if (!entry)
+                continue;
+            try {
+                entry.Schemas = generateModelSchemas(declaration, { project: ctx.project, checker: ctx.checker });
+            }
+            catch (error) {
+                errors.push(`${object.name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            continue;
+        }
+        const entry = module[object.section][object.name];
+        const base = object.section === "deployers" ? "DeployerResources" : "ServiceParameters";
+        try {
+            const schema = generateServiceSchema(declaration, {
+                project: ctx.project,
+                checker: ctx.checker,
+                addOpenApi: object.section !== "deployers",
+                parametersBase: object.section === "deployers" ? base : undefined,
+                title: declaration.name?.text ?? object.className
+            });
+            if (schema)
+                entry.Schema = schema;
+        }
+        catch (error) {
+            errors.push(`${object.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        try {
+            const configuration = configurationOf(ctx, declaration, base, discovery);
+            if (configuration)
+                entry.Configuration = configuration;
+        }
+        catch (error) {
+            errors.push(`${object.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    try {
+        Object.assign(module.schemas, generateTopLevelSchemas(ctx, discovery));
+    }
+    catch (error) {
+        errors.push(`schemas: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // Plugins, in the TypeScript 6 order: Actions, Behaviors, Capabilities,
+    // Commands, Events, PrimaryKey, Plural.
+    for (const { object, declaration } of models) {
+        const entry = module.models[object.name];
+        if (entry)
+            entry.Actions = buildModelActions(ctx, declaration);
+    }
+    for (const { sf, declaration } of behaviorClasses(ctx)) {
+        const identifier = behaviorIdentifier(declaration, namespace);
+        const exportName = exportedName(ctx, sf, declaration);
+        try {
+            module.behaviors[identifier] = {
+                Identifier: identifier,
+                Import: `${outputTarget(sf.fileName, discovery)}:${exportName}`,
+                Actions: buildBehaviorActions(ctx, declaration, identifier)
+            };
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error.message : String(error));
+        }
+    }
+    for (const { object, declaration } of discovered) {
+        if (object.section !== "moddas" && object.section !== "beans")
+            continue;
+        const capabilities = buildCapabilities(ctx, declaration);
+        if (capabilities.length > 0)
+            module[object.section][object.name].capabilities = capabilities;
+    }
+    for (const { object, declaration } of discovered) {
+        if (object.section !== "moddas" && object.section !== "beans")
+            continue;
+        const commands = buildCommands(ctx, declaration);
+        if (Object.keys(commands).length > 0)
+            module[object.section][object.name].commands = commands;
+    }
+    for (const { object, declaration, tags } of models) {
+        const entry = module.models[object.name];
+        if (!entry)
+            continue;
+        const events = buildModelEvents(ctx, declaration);
+        if (events)
+            entry.Events = events;
+        const primaryKey = buildModelPrimaryKey(ctx, declaration);
+        if (primaryKey)
+            entry.PrimaryKey = primaryKey;
+        const primaryKeySeparator = buildModelPrimaryKeySeparator(ctx, declaration);
+        if (primaryKeySeparator)
+            entry.PrimaryKeySeparator = primaryKeySeparator;
+        entry.Plural = tags.WebdaPlural || getPlural(object.name.split("/").pop());
+    }
+    return { module, namingViolations, errors };
+}
+/**
+ * Exported `@WebdaBehavior` classes of the project, in walk order.
+ *
+ * The same filter as `searchForWebdaObjects`' `allClasses` for root files:
+ * not a spec, not `@WebdaSchema`, not `@WebdaIgnore`, exported.
+ * @param ctx - analysis context
+ * @returns the behaviour classes
+ */
+function behaviorClasses(ctx) {
+    const found = [];
+    const own = new Set(ctx.sourceFiles.map(sf => sf.fileName));
+    for (const fileName of ctx.program.getSourceFileNames()) {
+        if (!own.has(fileName) || fileName.endsWith(".spec.ts"))
+            continue;
+        const sf = ctx.program.getSourceFile(fileName);
+        if (!sf)
+            continue;
+        for (const statement of sf.statements) {
+            const tags = webdaTags(statement);
+            if (tags.WebdaSchema !== undefined)
+                continue;
+            if (!is.isClassDeclaration(statement) || !statement.name)
+                continue;
+            if (tags.WebdaIgnore !== undefined)
+                continue;
+            if (!findTag(statement, "WebdaBehavior"))
+                continue;
+            if (!exportedName(ctx, sf, statement))
+                continue;
+            found.push({ sf, declaration: statement });
+        }
+    }
+    return found;
+}
+//# sourceMappingURL=module.js.map