@webda/core 4.0.0-beta.2 → 4.0.0-beta.4

package/lib/application/application.js

@@ -0,0 +1,845 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { WorkerOutput } from "@webda/workout";
+import { setLogContext } from "../loggers/hooks.js";
+import { FileUtils, State } from "@webda/utils";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { join, resolve, dirname, isAbsolute } from "node:path";
+import * as WebdaError from "../errors/errors.js";
+import { ServiceParameters } from "../services/serviceparameters.js";
+import { isModelClass } from "@webda/models";
+import { InstanceCache } from "../cache/cache.js";
+import { applyDeployment, getDeploymentFile, loadDeployment } from "./deployment.js";
+/**
+ * Define a static member that only belongs to `target`
+ *
+ * Static members are inherited by subclasses, so a factory installed on a modda would be used
+ * by any subclass of it. The accessor returns `value` for `target` and `fallback` for any
+ * subclass, and lets a subclass assign its own value.
+ * @param target - the class owning the member
+ * @param property - the static member name
+ * @param value - the value for `target`
+ * @param fallback - the value for subclasses of `target`
+ */
+function defineOwnStatic(target, property, value, fallback) {
+    Object.defineProperty(target, property, {
+        configurable: true,
+        enumerable: false,
+        get() {
+            return this === target ? value : fallback;
+        },
+        set(newValue) {
+            Object.defineProperty(this, property, { value: newValue, writable: true, configurable: true, enumerable: true });
+        }
+    });
+}
+/**
+ * Install `filterParameters` and `createConfiguration` on a modda or bean class
+ *
+ * Both are bound to `target`: a subclass that is not registered itself would otherwise inherit them and
+ * have its own parameters filtered out by the parent schema. Such a subclass gets the parent configuration
+ * class without filtering.
+ * @param target - the modda or bean class
+ * @param configurationClass - the parameters class to instantiate
+ * @param schema - the parameters JSON schema, used to filter the parameters
+ */
+export function installConfigurationFactories(target, configurationClass = ServiceParameters, schema) {
+    const filterParameters = (params = {}) => {
+        if (!schema?.properties) {
+            return params;
+        }
+        const filteredParams = {};
+        for (const field of Object.keys(schema.properties)) {
+            if (params[field] !== undefined) {
+                filteredParams[field] = params[field];
+            }
+        }
+        return filteredParams;
+    };
+    defineOwnStatic(target, "filterParameters", filterParameters, (params = {}) => params);
+    defineOwnStatic(target, "createConfiguration", (params = {}) => new configurationClass().load(filterParameters(params)), (params = {}) => new configurationClass().load(params));
+}
+// We should not be able to set initial from outside
+const ApplicationState = State;
+/**
+ * Map a Webda Application
+ *
+ * It allows to:
+ *  - Analyse imported modules
+ *  - Scan code for Modda and generate the webda.config.json
+ *  - Compile and Watch
+ *  - Migrate from old configuration
+ *  - List deployments
+ *
+ *
+ * @category CoreFeatures
+ */
+let Application = (() => {
+    let _instanceExtraInitializers = [];
+    let _load_decorators;
+    return class Application {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _load_decorators = [ApplicationState({ start: "loading", end: "ready" }), InstanceCache()];
+            __esDecorate(this, null, _load_decorators, { kind: "method", name: "load", static: false, private: false, access: { has: obj => "load" in obj, get: obj => obj.load }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        /**
+         * Get Application root path
+         */
+        applicationPath = __runInitializers(this, _instanceExtraInitializers);
+        /**
+         * Base configuration loaded from webda.config.json
+         */
+        baseConfiguration;
+        /**
+         * Current deployment
+         *
+         * Defaults to the `WEBDA_DEPLOYMENT` environment variable
+         */
+        currentDeployment = process.env.WEBDA_DEPLOYMENT || undefined;
+        /**
+         * Definition of the current deployment, once loaded
+         */
+        deployment;
+        /**
+         * Contains definitions of current application
+         */
+        appModule = {
+            moddas: {},
+            models: {},
+            schemas: {}
+        };
+        /**
+         * Deployers type registry
+         */
+        deployers = {};
+        /**
+         * Moddas registry
+         */
+        moddas = {};
+        /**
+         * Models type registry
+         */
+        models = {};
+        /**
+         * Beans registry
+         */
+        beans = {};
+        /**
+         * Behaviors registry
+         *
+         * Populated by `loadModule` from the top-level `behaviors` map of every
+         * loaded `webda.module.json`. Each entry holds the metadata blob emitted by
+         * the compiler so downstream consumers (DomainService, REST transport, etc.)
+         * can introspect the Behavior's declared actions and shape.
+         *
+         * The Behavior class itself is NOT loaded at runtime: the per-model
+         * `__hydrateBehaviors` method emitted at compile time by
+         * `@webda/content-mapper` holds a static import to the class, so the runtime
+         * never needs to look it up by identifier.
+         */
+        behaviors = {};
+        /**
+         * Class Logger
+         */
+        logger;
+        /**
+         * Detect if running as workspace
+         */
+        workspacesPath = "";
+        /**
+         * Configuration file
+         */
+        configurationFile;
+        /**
+         * Current deployment file
+         */
+        deploymentFile;
+        /**
+         * Create a new Application
+         * @param file - file path or unpacked configuration to load from
+         * @param logger - the logger instance
+         */
+        constructor(file, logger = undefined) {
+            this.logger = logger || new WorkerOutput();
+            setLogContext(this.logger);
+            // If configuration is a programmatic object (usually for tests)
+            if (typeof file !== "string") {
+                this.baseConfiguration = { parameters: {}, ...file };
+                // Still want to ensure default configuration
+                this.applicationPath = process.cwd();
+                return;
+            }
+            if (!existsSync(file)) {
+                throw new WebdaError.CodeError("NO_WEBDA_FOLDER", `Not a webda application folder or webda.config.(ya?ml|jsonc?) file: unexisting ${file}`);
+            }
+            // Check if file is a file or folder
+            if (lstatSync(file).isDirectory()) {
+                file = FileUtils.getConfigurationFile(join(file, "webda.config"));
+            }
+            this.configurationFile = file;
+            this.applicationPath = resolve(dirname(file));
+        }
+        /**
+         * Run the application
+         * @returns the result
+         */
+        async run() {
+            return Application._runner(this);
+        }
+        /**
+         * Pluggable runner — set by runner.ts to avoid circular dependency with Core.
+         * @internal
+         */
+        static _runner;
+        /**
+         * Import all required modules
+         * @returns the result
+         */
+        async load() {
+            await this.loadConfiguration(this.configurationFile);
+            this.applyCurrentDeployment();
+            await this.loadModule(this.baseConfiguration.cachedModules);
+            return this;
+        }
+        /**
+         * Select the deployment to apply on the configuration
+         *
+         * Must be called before {@link load}
+         *
+         * @param name - deployment name, a `deployments/<name>` file of the application
+         * @returns this
+         */
+        setCurrentDeployment(name) {
+            this.currentDeployment = name;
+            return this;
+        }
+        /**
+         * Get the definition of the current deployment
+         *
+         * It includes the `units` and `resources` that are not part of the application configuration
+         *
+         * @returns the deployment or undefined if no deployment is selected
+         */
+        getDeployment() {
+            return this.deployment;
+        }
+        /**
+         * Apply the current deployment parameters and services on the configuration
+         *
+         * A packaged application already contains its deployment: the file is only required
+         * when the deployment differs from the packaged one
+         */
+        applyCurrentDeployment() {
+            const name = this.currentDeployment;
+            if (!name) {
+                return;
+            }
+            const project = this.baseConfiguration.cachedModules?.project;
+            const packaged = project?.deployment?.name === name;
+            if (packaged && !existsSync(join(this.applicationPath, "deployments"))) {
+                return;
+            }
+            this.deploymentFile = getDeploymentFile(this.applicationPath, name);
+            this.deployment = loadDeployment(this.applicationPath, name);
+            applyDeployment(this.baseConfiguration, this.deployment);
+            if (project) {
+                project.deployment = { ...project.deployment, name };
+            }
+        }
+        /**
+         * Allow subclass to implement migration
+         *
+         * @param file - the file path
+         * @returns the result
+         */
+        async loadConfiguration(file) {
+            // Check if file is a file or folder
+            if (file && !existsSync(file)) {
+                throw new WebdaError.CodeError("NO_WEBDA_FOLDER", `Not a webda application folder or webda.config.jsonc or webda.config.json file: ${file}`);
+            }
+            try {
+                this.baseConfiguration ??= file ? FileUtils.load(file) : {};
+                if (this.baseConfiguration.version !== 4) {
+                    this.log("ERROR", "Your configuration file should use version 4, see https://docs.webda.io/");
+                }
+            }
+            catch (err) {
+                throw new WebdaError.CodeError("INVALID_WEBDA_CONFIG", `Cannot parse JSON of: ${file}`);
+            }
+        }
+        /**
+         * Get a schema from a type
+         *
+         * Schema should be precomputed in the default app
+         * @param type - the type to look up
+         * @returns the result
+         */
+        getSchema(type) {
+            // "?" suffix means optional input — return the same schema without required fields
+            if (type.endsWith("?")) {
+                const base = this.getSchema(type.slice(0, -1));
+                if (!base)
+                    return undefined;
+                const copy = { ...base };
+                delete copy.required;
+                return copy;
+            }
+            const cm = this.baseConfiguration.cachedModules;
+            return (cm.schemas[type] || cm.models?.[type]?.Schemas?.Input || cm.moddas?.[type]?.Schema || cm.beans?.[type]?.Schema);
+        }
+        /**
+         * Get schemas
+         * @returns the result
+         */
+        getSchemas() {
+            return this.baseConfiguration.cachedModules.schemas;
+        }
+        /**
+         * Check if application has cached modules
+         *
+         * When deployed the application contains cachedModules in the `webda.config.json`
+         * It allows to avoid the search for `webda.module.json` inside node_modules and
+         * take the schema from the cached modules also
+         * @returns true if the condition is met
+         */
+        isCached() {
+            return true;
+        }
+        /**
+         * Retrieve specific webda conf from package.json
+         *
+         * In case of workspaces the object is combined
+         * @returns the result
+         */
+        getPackageWebda() {
+            return (this.baseConfiguration.cachedModules.project?.webda || {
+                namespace: "Webda"
+            });
+        }
+        /**
+         * Retrieve content of package.json
+         * @returns the result
+         */
+        getPackageDescription() {
+            return this.baseConfiguration.cachedModules?.project?.package || {};
+        }
+        /**
+         * Log information
+         *
+         * @param level to log for
+         * @param args anything to display same as console.log
+         */
+        log(level, ...args) {
+            this.logger?.log(level, ...args);
+        }
+        /**
+         * Get current logger
+         * @returns the result
+         */
+        getWorkerOutput() {
+            return this.logger;
+        }
+        /**
+         * Return the current app path
+         *
+         * @param subpath to append to
+         * @returns the result string
+         */
+        getPath(subpath = undefined) {
+            if (subpath && subpath !== "") {
+                if (isAbsolute(subpath)) {
+                    return subpath;
+                }
+                return join(this.applicationPath, subpath);
+            }
+            return this.applicationPath;
+        }
+        /**
+         * Add a new service
+         *
+         * @param name - the name to use
+         * @param service - the service instance
+         * @returns this for chaining
+         */
+        addModda(name, service) {
+            this.log("TRACE", "Registering service", name);
+            this.moddas[name] = service;
+            return this;
+        }
+        /**
+         *
+         * @param section - the section name
+         * @param name - the name to use
+         * @param caseSensitive - whether matching is case sensitive
+         * @returns true if the condition is met
+         */
+        hasWebdaObject(section, name) {
+            let objectName = this.completeNamespace(name);
+            this.log("TRACE", `Search for ${section} ${objectName}`);
+            if (!this[section][objectName] && name.indexOf("/") === -1) {
+                objectName = `Webda/${name}`;
+            }
+            return this[section][objectName] !== undefined;
+        }
+        /**
+         * Return true if `model` is the one that wins when consumers look up the
+         * short name in the current namespace. Used by transports (REST, GraphQL,
+         * gRPC) so only one model gets exposed at a given URL / type when the app
+         * overrides a framework-provided class — e.g. WebdaSample/User shadowing
+         * Webda/User at `/users`.
+         *
+         * A model is "final" when either:
+         *  - it is the one resolved by `completeNamespace(shortName)`, or
+         *  - no other model exists with the same short name in the current namespace.
+         * @param model - the fully-qualified model identifier (e.g. "Webda/User")
+         * @returns true when `model` should be treated as the canonical version
+         */
+        isFinalModel(model) {
+            if (!this.models[model]) {
+                return false;
+            }
+            const name = model.split("/").pop();
+            const resolved = this.completeNamespace(name);
+            // Only a model that the current namespace resolves to is exposed. If the
+            // app defines its own version (e.g. WebdaSample/User shadowing Webda/User)
+            // just that one wins; otherwise the framework-provided model stays internal.
+            return resolved === model;
+        }
+        /**
+         *
+         * @param section - the section name
+         * @param name - the name to use
+         * @returns the result
+         */
+        getWebdaObject(section, name) {
+            let objectName = this.completeNamespace(name);
+            this.log("TRACE", `Search for ${section} ${objectName}`);
+            if (!this[section][objectName] && name.indexOf("/") === -1) {
+                const namespaced = this.completeNamespace(name);
+                objectName = this[section][namespaced] ? `${namespaced}/${name}` : `Webda/${name}`;
+            }
+            if (!this[section][objectName]) {
+                if (Object.keys(this[section]).includes(objectName)) {
+                    throw Error(`Null ${section.substring(0, section.length - 1)} ${objectName}`);
+                }
+                throw Error(`Undefined ${section.substring(0, section.length - 1)} ${objectName} (${Object.keys(this[section]).join(", ")})`);
+            }
+            return this[section][objectName];
+        }
+        /**
+         * Get a service based on name
+         *
+         * @param name - the name to use
+         * @returns the result
+         */
+        getModda(name) {
+            return this.getWebdaObject("moddas", name);
+        }
+        /**
+         * Return all services of the application
+         * @returns the result
+         */
+        getModdas() {
+            return this.moddas;
+        }
+        /**
+         * Retrieve the model implementation
+         *
+         * @param name model to retrieve
+         * @returns the result
+         */
+        getModel(name) {
+            return this.getWebdaObject("models", name);
+        }
+        /**
+         * Get all models definitions
+         * @returns the result
+         */
+        getModels() {
+            return this.models;
+        }
+        /**
+         * Return the metadata blob (Identifier, Actions, etc.) for a Behavior
+         * loaded from `webda.module.json`.
+         *
+         * @param identifier - fully qualified Behavior id (e.g. `Webda/MFA`)
+         * @returns the metadata, or undefined if no Behavior with that id is registered
+         */
+        getBehaviorMetadata(identifier) {
+            return this.behaviors[identifier]?.metadata;
+        }
+        /**
+         * Return all loaded Behaviors keyed by identifier.
+         *
+         * Each entry exposes the original metadata blob emitted by the compiler.
+         * @returns the result
+         */
+        getBehaviors() {
+            return this.behaviors;
+        }
+        /**
+         * Return the model name for a object
+         * @param object - the target object
+         * @returns the result
+         */
+        getModelFromInstance(object) {
+            return Object.keys(this.models).find(k => this.models[k] === object.constructor);
+        }
+        /**
+         * Return the model name for a object
+         * @param object - the target object
+         * @param model - the model to use
+         * @returns the result
+         */
+        getModelFromConstructor(model) {
+            // @ts-ignore
+            return Object.keys(this.models).find(k => this.models[k] === model);
+        }
+        /**
+         * Get the model name from a model or a constructor
+         *
+         * @param model - the model to use
+         * @paramn full if true always include the namespace, default is false e.g Webda/
+         * @returns longId for a model
+         */
+        getModelId(model) {
+            if (isModelClass(model)) {
+                return this.getModelFromConstructor(model);
+            }
+            return this.getModelFromInstance(model);
+        }
+        /**
+         * Return all deployers
+         * @returns the result
+         */
+        getDeployers() {
+            return this.deployers;
+        }
+        /**
+         * Add a new model
+         *
+         * @param name - the name to use
+         * @param model - the model to use
+         * @param dynamic class is dynamic so recompute the hierarchy
+         * @param metadata - the model metadata
+         * @returns this for chaining
+         */
+        addModel(name, model, metadata = {
+            Identifier: name,
+            Ancestors: [],
+            Subclasses: [],
+            Relations: {},
+            PrimaryKey: ["id"],
+            Events: [],
+            Schemas: {},
+            Actions: {},
+            Import: "",
+            Plural: name + "s",
+            Reflection: {}
+        }) {
+            name = this.completeNamespace(name);
+            this.log("TRACE", "Registering model", name);
+            if (!model) {
+                this.log("ERROR", "Model is undefined", name);
+                return this;
+            }
+            this.models[name] = model;
+            if (metadata) {
+                // Get ancestor?
+                const superClass = Object.getPrototypeOf(model);
+                model.Metadata = Object.freeze(metadata);
+            }
+            return this;
+        }
+        /* SERIALIZATION */
+        /**
+         *
+         * @param this - the constructor
+         * @param json - the JSON data
+         * @returns the result
+         */
+        static deserialize(json) {
+            const instance = new this();
+            instance.baseConfiguration = json.baseConfiguration;
+            instance.currentDeployment = json.currentDeployment;
+            instance.appModule = json.appModule;
+            return instance;
+        }
+        /**
+         * Serialize the application state to a plain object
+         * @returns the result
+         */
+        toJSON() {
+            return {
+                baseConfiguration: this.baseConfiguration,
+                currentDeployment: this.currentDeployment,
+                appModule: this.appModule
+            };
+        }
+        /**
+         * Return webda current version
+         *
+         * @returns package version
+         * @since 0.4.0
+         */
+        getWebdaVersion() {
+            return JSON.parse(readFileSync(__dirname + "/../../package.json").toString()).version;
+        }
+        /**
+         * Retrieve Git Repository information
+         *
+         * {@link GitInformation} for more details on how the information is gathered
+         * @return the git information
+         * @param _packageName - the package name
+         * @param _version - the version string
+         * @returns the result
+         */
+        getGitInformation(_packageName, _version) {
+            return this.baseConfiguration.cachedModules.project?.git;
+        }
+        /**
+         * Retrieve the project information
+         * @returns the result
+         */
+        getProjectInfo() {
+            return this.baseConfiguration.cachedModules.project;
+        }
+        /**
+         * Get current deployment name
+         * @returns the result string
+         */
+        getCurrentDeployment() {
+            return this.baseConfiguration.cachedModules?.project?.deployment?.name ?? this.currentDeployment;
+        }
+        /**
+         * Return all application modules merged as one
+         *
+         * Used when deployed
+         * @returns the result
+         */
+        getModules() {
+            return this.baseConfiguration.cachedModules;
+        }
+        /**
+         * Get application configuration
+         * @param _deployment - the deployment name
+         * @returns the result
+         */
+        getConfiguration(_deployment = undefined) {
+            return this.baseConfiguration;
+        }
+        /**
+         * Return current Configuration of the Application
+         *
+         * Same as calling
+         *
+         * ```js
+         * getConfiguration(this.currentDeployment);
+         * ```
+         * @returns the result
+         */
+        getCurrentConfiguration() {
+            return this.getConfiguration();
+        }
+        /**
+         * Import a file
+         *
+         * If the `default` is set take this or use old format
+         *
+         * @param info - the information object
+         * @param withExport - whether to include exports
+         * @returns the result
+         */
+        async importFile(info, withExport = true) {
+            if (info.startsWith(".")) {
+                info = this.getPath(info);
+            }
+            try {
+                this.log("TRACE", "Load file", info);
+                // eslint-disable-next-line prefer-const
+                let [importFilename, importName = "default"] = info.split(":");
+                if (!importFilename.endsWith(".js") && !importFilename.endsWith(".ts")) {
+                    importFilename += ".js";
+                }
+                const importedFile = await import(importFilename);
+                if (!withExport) {
+                    return;
+                }
+                const importObject = importedFile[importName];
+                if (!importObject) {
+                    this.log("WARN", `Module ${importFilename} does not have export named ${importName}`);
+                }
+                return importObject;
+            }
+            catch (err) {
+                this.log("ERROR", "Cannot resolve require", info, err.message);
+            }
+        }
+        /**
+         * Load local module
+         */
+        async loadLocalModule() {
+            const moduleFile = join(process.cwd(), "webda.module.json");
+            if (existsSync(moduleFile)) {
+                await this.loadModule(FileUtils.load(moduleFile), process.cwd());
+            }
+        }
+        /**
+         * Get implementations of a class
+         * @param object - the target object
+         * @returns the result
+         */
+        getImplementations(object) {
+            const res = {};
+            for (const key in this.moddas) {
+                if (this.moddas[key] && object instanceof this.moddas[key]) {
+                    res[key] = this.moddas[key];
+                }
+            }
+            return res;
+        }
+        /**
+         * Load the module,
+         *
+         * @protected
+         * @ignore Useless for documentation
+         */
+        async loadModule(module, parent = this.applicationPath) {
+            if (!module) {
+                return;
+            }
+            const info = module;
+            const sectionLoader = async (section) => {
+                for (const key in info[section]) {
+                    this[section][key] ??= await this.importFile(join(parent, info[section][key].Import));
+                    if (!this[section][key]) {
+                        this.log("ERROR", `Cannot load ${section.substring(0, section.length - 1)} ${key} from ${join(parent, info[section][key].Import)}`);
+                        continue;
+                    }
+                    if (section === "beans" || section === "moddas") {
+                        // Load the parameters automatically
+                        const configurationClass = info[section][key].Configuration
+                            ? await this.importFile(join(parent, info[section][key].Configuration))
+                            : ServiceParameters;
+                        if (!configurationClass) {
+                            this.log("ERROR", `Cannot load configuration for ${section.substring(0, section.length - 1)} ${key} from ${join(parent, info[section][key].Configuration)}`);
+                            continue;
+                        }
+                        installConfigurationFactories(this[section][key], configurationClass, info[section][key].Schema);
+                    }
+                }
+            };
+            // Filter beans based on ignoreBeans configuration
+            if (info.beans) {
+                const ignoreBeans = this.baseConfiguration?.parameters?.ignoreBeans;
+                for (const f of Object.keys(info.beans)) {
+                    if (ignoreBeans === true)
+                        continue;
+                    if (Array.isArray(ignoreBeans) && ignoreBeans.includes(f))
+                        continue;
+                    this.baseConfiguration.cachedModules.beans[f] = info.beans[f];
+                }
+            }
+            // Behaviors are registered by metadata only — the runtime never imports
+            // the Behavior class. The per-model `__hydrateBehaviors(rawData)` method
+            // emitted at compile time by `@webda/content-mapper` holds the static
+            // imports needed to coerce raw values into Behavior instances, so the
+            // application registry just needs to retain the metadata blob (action
+            // shapes, identifier, etc.) for `DomainService` operation registration
+            // and the REST transport routing.
+            if (info.behaviors) {
+                for (const id in info.behaviors) {
+                    this.behaviors[id] ??= { metadata: info.behaviors[id] };
+                }
+            }
+            // TODO Merging tree from different modules
+            await Promise.all([sectionLoader("moddas"), sectionLoader("models"), sectionLoader("beans")]);
+            // Set metadata on models - need to be done after all models are loaded
+            this.setModelMetadata(info.models);
+        }
+        /**
+         * Set object Metadata
+         * Need to be done after all models are loaded to resolve Ancestors and Subclasses
+         * @param info - the information object
+         */
+        setModelMetadata(info) {
+            // Might want to move this to specific methods
+            for (const m in this.models) {
+                if (!this.models[m]) {
+                    continue;
+                }
+                // Register serializer under the full model identifier so app-specific
+                // classes (e.g. WebdaSample/User) don't collide with framework ones that
+                // share the same JS constructor name (Webda/User).
+                this.models[m].registerSerializer(true, m);
+                this.models[m].Metadata = Object.freeze({
+                    ...info[m],
+                    // Runtime: resolve strings to model classes for backward compat
+                    // ModelMetadata types these as string[] but core resolves them to classes
+                    Ancestors: info[m].Ancestors.map(s => this.models[s]),
+                    Subclasses: info[m].Subclasses.map(s => this.models[s])
+                });
+            }
+        }
+        /**
+         * Return the full name including namespace
+         *
+         * In Webda the ServiceType include namespace `Webda/Store` or `Webda/Test`
+         * This method will make sure the namespace is present, adding it if no '/'
+         * is found in the name
+         *
+         * @param name - the name to use
+         * @returns the result string
+         */
+        completeNamespace(name = "") {
+            // Do not add a namespace if already present
+            if (name.includes("/")) {
+                return name;
+            }
+            return `${this.getNamespace()}/${name}`;
+        }
+        /**
+         * Return current namespace
+         * @returns the result string
+         */
+        getNamespace() {
+            return this.baseConfiguration?.cachedModules?.project?.webda?.namespace || "Webda";
+        }
+    };
+})();
+export { Application };
+//# sourceMappingURL=application.js.map