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

package/lib/services/service.js

@@ -1,15 +1,62 @@
+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 { EventEmitterUtils } from "../events/asynceventemitter.js";
+import { createPropertyDecorator } from "@webda/tsc-esm";
+import { useMetric } from "../metrics/metrics.js";
+import { ServiceParameters } from "./serviceparameters.js";
+import { useDynamicService, useService } from "../core/hooks.js";
+import { registerOperation } from "../core/operations.js";
 import { deepmerge } from "deepmerge-ts";
-import * as events from "events";
-import { EventEmitterUtils } from "../index.js";
-import { Route } from "../rest/router.js";
+import { useApplication } from "../application/hooks.js";
+import { AbstractService } from "../core/icore.js";
+import { useLogger } from "../loggers/hooks.js";
+import { WEBDA_EVENTS } from "@webda/models";
+import { State } from "@webda/utils";
+import { ServiceState } from "./iservice.js";
+import { getMetadata } from "@webda/decorators";
 /**
  * Represent a Inject annotation
  *
  * @see Inject
  */
 class Injector {
+    parameter;
+    value;
+    property;
+    optional;
     /**
-     *
      * @param property annotated
      * @param parameterOrName to inject from
      * @param defaultValue in case of a parameter
@@ -41,7 +88,7 @@ class Injector {
         if (this.parameter) {
             name = service.getParameters()[this.parameter] || this.value;
         }
-        service[this.property] = service.getService(name);
+        service[this.property] = useService(name);
         if (!service[this.property] && !this.optional) {
             if (this.parameter) {
                 throw new Error(`Injector did not found bean '${name}'(parameter:${this.parameter}) for '${service.getName()}'`);
@@ -55,7 +102,9 @@ class Injector {
      * @param service to inject to
      */
     static resolveAll(service) {
-        (Object.getPrototypeOf(service).Injectors || []).forEach(injector => injector.resolve(service));
+        getMetadata(service.constructor)?.["webda.inject"]?.forEach((injector) => {
+            injector.resolve(service);
+        });
     }
 }
 /**
@@ -70,127 +119,29 @@ class Injector {
  * @param parameterOrName of the service to inject
  *
  * Might consider to split into two annotations
+ * TODO @webda/compiler could get all interfaces and ancestors classes to find the correct service
  */
-export function Inject(parameterOrName, defaultValue, optional) {
-    return (target, propertyName) => {
-        target.Injectors = target.Injectors || [];
-        if (typeof defaultValue === "boolean") {
-            target.Injectors.push(new Injector(propertyName, parameterOrName || propertyName, undefined, defaultValue));
-        }
-        else {
-            target.Injectors.push(new Injector(propertyName, parameterOrName || propertyName, defaultValue, optional));
-        }
-    };
-}
-/**
- * Register an Operation within the framework
- *
- * An operation is a callable method with an input and output
- * The method will receive a Context from where it can execute
- *
- * @param id
- * @param input
- * @param output
- */
-export function Operation(properties, route) {
-    return (target, executor) => {
-        var _a, _b, _c, _d, _e, _f;
-        (_a = target.constructor).operations ?? (_a.operations = {});
-        properties ?? (properties = {});
-        properties.id ?? (properties.id = executor.substring(0, 1).toUpperCase() + executor.substring(1));
-        const id = properties.id;
-        if (target.constructor.operations[id]) {
-            console.error("Operation already exists", id);
-            return;
-        }
-        (_b = target.constructor.operations)[id] ?? (_b[id] = {
-            method: executor,
-            ...properties
-        });
-        // If url is specified define the openapi
-        if (route) {
-            route.method ?? (route.method = "GET");
-            route.openapi ?? (route.openapi = {});
-            (_c = route.openapi)[_d = route.method.toLowerCase()] ?? (_c[_d] = {});
-            const def = route.openapi[route.method.toLowerCase()];
-            def.operationId = id;
-            def.schemas ?? (def.schemas = {});
-            (_e = def.schemas).input ?? (_e.input = properties.id.toLowerCase() + ".input");
-            (_f = def.schemas).output ?? (_f.output = properties.id.toLowerCase() + ".output");
-            Route(route.url, route.method, route.openapi)(target, executor);
-        }
-    };
-}
-/**
- * A utility class that takes a array of string or string transformed into regex that includes
- * a start line and end line
- */
-export class RegExpValidator {
-    constructor(info) {
-        info = Array.isArray(info) ? info : [info];
-        this.validators = info.map(i => RegExpValidator.getRegExp(i));
-    }
-    static getRegExp(reg) {
-        if (!reg.startsWith("^")) {
-            reg = "^" + reg;
-        }
-        if (!reg.endsWith("$")) {
-            reg += "$";
-        }
-        return new RegExp(reg);
-    }
-    validate(value) {
-        return this.validators.some(p => p.test(value));
-    }
-}
-/**
- * Standardized way to allow string/regex validation within configuration
- *
- * If url is prefixed with `regex:` it is considered a regex
- *
- * @example
- * ```typescript
- * class MyServiceParameters extends ServiceParameters {
- *    urls: string[];
- * }
- *
- * class MyService extends Service {
- *    loadParameters(params:any) {
- *      const parameters = new MyServiceParameters(params);
- *      this.urlsValidator = new RegExpStringValidator(parameters.urls);
- *      return parameters;
- *    }
- * }
- * ```
- */
-export class RegExpStringValidator extends RegExpValidator {
-    constructor(info) {
-        info = Array.isArray(info) ? info : [info];
-        super(info.filter(i => i.startsWith("regex:")).map(i => i.substring(6)));
-        this.stringValidators = info.filter(i => !i.startsWith("regex:"));
-    }
-    /**
-     * Add string validation
-     * @param value
-     * @returns
-     */
-    validate(value) {
-        return this.stringValidators.find(p => p === value) !== undefined || super.validate(value);
-    }
-}
-/**
- * Interface to specify the Service parameters
- */
-export class ServiceParameters {
-    /**
-     * Copy all parameters into the object by default
-     *
-     * @param params from webda.config.json
-     */
-    constructor(params) {
-        Object.assign(this, params);
-    }
+export const Inject = createPropertyDecorator((context, parameterOrName, defaultValue, optional) => {
+    context.metadata["webda.inject"] ??= [];
+    context.metadata["webda.inject"].push(new Injector(context.name, (parameterOrName || context.name), typeof defaultValue === "boolean" ? undefined : defaultValue, typeof defaultValue === "boolean" ? defaultValue : optional));
+});
+/*
+export function Inject(parameterOrName?: string, defaultValue?: string | boolean, optional?: boolean) {
+  return (target: Service, context: ClassFieldDecoratorContext): void => {
+    context.metadata["webda.inject"] ??= {};
+    context.metadata["webda.inject"][context.name] = { parameterOrName, defaultValue, optional };
+
+    /*
+    target.Injectors = target.Injectors || [];
+    if (typeof defaultValue === "boolean") {
+      target.Injectors.push(new Injector(propertyName, parameterOrName || propertyName, undefined, defaultValue));
+    } else {
+      target.Injectors.push(new Injector(propertyName, parameterOrName || propertyName, defaultValue, optional));
+    }
+      /
+  };
 }
+  */
 /**
  * Use this object for representing a service in the application
  * A Service is a singleton in the application, that is init after all others services are created
@@ -201,310 +152,344 @@ export class ServiceParameters {
  * @abstract
  * @class Service
  */
-class Service extends events.EventEmitter {
-    /**
-     *
-     *
-     * @class Service
-     * @param {Webda} webda - The main instance of Webda
-     * @param {String} name - The name of the service
-     * @param {Object} params - The parameters block define in the configuration file
-     */
-    constructor(webda, name, params = {}) {
-        super();
-        this._initException = undefined;
-        this.logger = webda ? webda.getLogger(this) : undefined;
-        this._webda = webda;
-        this._name = name;
-        this.parameters = this.loadParameters(params);
-    }
-    /**
-     * Load the parameters for a service
-     */
-    loadParameters(params) {
-        return new ServiceParameters(params);
-    }
-    /**
-     * Used to compute or derivate input parameter to attribute
-     */
-    computeParameters() {
-        // Can be overriden by subclasses if needed
-    }
-    /**
-     * Get the service parameters
-     */
-    getParameters() {
-        return this.parameters;
-    }
-    /**
-     * Return WebdaCore
-     */
-    getWebda() {
-        return this._webda;
-    }
-    /**
-     * Shutdown the current service if action need to be taken
-     */
-    async stop() {
-        // Nothing to do
-    }
-    /**
-     * Return service representation
-     */
-    toString() {
-        return this.parameters.type + "[" + this._name + "]";
-    }
-    /**
-     * Resolve parameters
-     * Call initRoutes and initBeanRoutes
-     */
-    resolve() {
-        this.initMetrics();
-        // Inject dependencies
-        Injector.resolveAll(this);
-        // We wait for all services to be created before calling computeParameters
-        this.computeParameters();
-        this.initRoutes();
-        this.initOperations();
-        return this;
-    }
-    /**
-     * Init the metrics
-     */
-    initMetrics() {
-        this.metrics = {};
-    }
-    /**
-     * Add service name label
-     * @param type
-     * @param configuration
-     * @returns
-     */
-    getMetric(type, configuration) {
-        configuration.labelNames ?? (configuration.labelNames = []);
-        configuration.labelNames = [...configuration.labelNames, "service"];
-        configuration.name = `${this.getName().toLowerCase()}_${configuration.name}`;
-        return this.getWebda().getMetric(type, configuration);
-    }
-    /**
-     * Return the events that an external system can subscribe to
-     *
-     * @returns
-     */
-    getClientEvents() {
-        return [];
-    }
-    /**
-     * Authorize a public event subscription
-     * @param event
-     * @param context
-     */
-    authorizeClientEvent(_event, _context) {
-        return false;
-    }
-    /**
-     * Return the full path url based on parameters
-     *
-     * @param url relative url to service
-     * @param _methods in case we need filtering (like Store)
-     * @returns absolute url or undefined if need to skip the Route
-     */
-    getUrl(url, _methods) {
-        // If url is absolute
-        if (url.startsWith("/")) {
-            return url;
+let Service = (() => {
+    let _classSuper = AbstractService;
+    let _instanceExtraInitializers = [];
+    let _stop_decorators;
+    let _resolve_decorators;
+    let _init_decorators;
+    return class Service extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _stop_decorators = [ServiceState({ start: "stopping", end: "stopped" })];
+            _resolve_decorators = [ServiceState({ start: "resolving", end: "resolved" })];
+            _init_decorators = [ServiceState({ start: "initializing", end: "running" })];
+            __esDecorate(this, null, _stop_decorators, { kind: "method", name: "stop", static: false, private: false, access: { has: obj => "stop" in obj, get: obj => obj.stop }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _resolve_decorators, { kind: "method", name: "resolve", static: false, private: false, access: { has: obj => "resolve" in obj, get: obj => obj.resolve }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _init_decorators, { kind: "method", name: "init", static: false, private: false, access: { has: obj => "init" in obj, get: obj => obj.init }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        /**
+         * Service parameters
+         */
+        static Parameters = ServiceParameters;
+        /**
+         * Set the Webda events here
+         */
+        [WEBDA_EVENTS] = __runInitializers(this, _instanceExtraInitializers);
+        /**
+         * Get the current state
+         * @returns the result
+         */
+        getState() {
+            return State.getCurrentState(this);
+        }
+        /**
+         * Logger with class context
+         */
+        logger;
+        /**
+         * Get metrics
+         */
+        metrics;
+        /**
+         *
+         *
+         * @class Service
+         * @param {Webda} webda - The main instance of Webda
+         * @param {String} name - The name of the service
+         * @param {Object} params - The parameters block define in the configuration file
+         */
+        constructor(name, params) {
+            super(name, params);
+            this.logger = useLogger(this);
+        }
+        /**
+         * Used to compute or derivate input parameter to attribute
+         * @deprecated
+         */
+        computeParameters() {
+            // Can be overriden by subclasses if needed
+        }
+        /**
+         * Get the service parameters
+         * @returns the result
+         */
+        getParameters() {
+            return this.parameters;
+        }
+        /**
+         * Shutdown the current service if action need to be taken
+         */
+        async stop() {
+            // Nothing to do
         }
-        if (!this.parameters.url) {
-            return undefined;
+        /**
+         * Return service representation
+         * @returns the result
+         */
+        toString() {
+            return this.parameters.type + "[" + this.name + "]";
         }
-        if (url.startsWith(".")) {
-            if (this.parameters.url.endsWith("/") && url.startsWith("./")) {
-                return this.parameters.url + url.substring(2);
+        /**
+         * Resolve parameters and load metadata. `@Route`-declared routes are scanned
+         * and registered by `Router.discoverRoutes(services)` from `Core.init()`
+         * once every service has resolved — nothing to do per-service here.
+         * @returns the result
+         */
+        resolve() {
+            this.initMetrics();
+            // Inject dependencies
+            Injector.resolveAll(this);
+            // We wait for all services to be created before calling computeParameters
+            this.computeParameters();
+            this.loadCapabilities();
+            this.initOperations();
+            return this;
+        }
+        /**
+         * Load capabilities from webda.module.json metadata into {@link _compiledCapabilities}.
+         *
+         * Called during {@link resolve} after dependency injection. Reads the service's
+         * type name from parameters, looks it up in the application's module metadata
+         * (moddas or beans section), and populates `_compiledCapabilities` with an
+         * empty object for each declared capability name.
+         *
+         * Fails silently if the application is not available (e.g., in unit tests
+         * where services are instantiated without a full application context).
+         *
+         * @example
+         * ```typescript
+         * // If webda.module.json contains:
+         * // { "moddas": { "MyApp/HawkService": { "capabilities": ["request-filter", "cors-filter"] } } }
+         * // Then after resolve(), this.getCapabilities() returns:
+         * // { "request-filter": {}, "cors-filter": {} }
+         * ```
+         *
+         * @see getCapabilities
+         */
+        loadCapabilities() {
+            try {
+                const app = useApplication();
+                const modules = app.getModules();
+                const type = this.parameters.type;
+                const metadata = modules.moddas?.[type] || modules.beans?.[type];
+                if (metadata?.capabilities) {
+                    this._compiledCapabilities = {};
+                    for (const cap of metadata.capabilities) {
+                        this._compiledCapabilities[cap] = {};
+                    }
+                }
+            }
+            catch {
+                // Application may not be available in tests
             }
-            return this.parameters.url + url.substring(1);
         }
-        return url;
-    }
-    /**
-     * If undefined is returned it cancel the operation registration
-     * @param id
-     * @returns
-     */
-    getOperationId(id) {
-        return id;
-    }
-    /**
-     * Add a route dynamicaly
-     *
-     * @param {String} url of the route can contains dynamic part like {uuid}
-     * @param {Array[]} methods
-     * @param {Function} executer Method to execute for this route
-     */
-    addRoute(url, methods, executer, openapi = {}, override = false) {
-        const finalUrl = this.getUrl(url, methods);
-        if (!finalUrl) {
-            return;
-        }
-        this._webda.addRoute(finalUrl, {
-            // Create bounded function to keep the context
-            _method: executer.bind(this),
-            executor: this._name,
-            openapi: deepmerge(openapi, this.parameters.openapi || {}),
-            methods,
-            override
-        });
-    }
-    /**
-     * Return variables for replacement in openapi
-     * @returns
-     */
-    getOpenApiReplacements() {
-        return {};
-    }
-    /**
-     * Init the routes
-     */
-    initRoutes() {
-        // @ts-ignore
-        const routes = this.constructor.routes || {};
-        for (const j in routes) {
-            this.log("TRACE", "Adding route", j, "for bean", this.getName());
-            routes[j].forEach(route => {
-                this.addRoute(j, route.methods, this[route.executor], route.openapi);
-            });
+        /**
+         * Init the metrics
+         */
+        initMetrics() {
+            this.metrics = {};
         }
-    }
-    /**
-     * Init the operations
-     */
-    initOperations() {
-        // @ts-ignore
-        const operations = this.constructor.operations || {};
-        for (const j in operations) {
-            const id = this.getOperationId(j);
-            if (!id)
-                continue;
-            this.log("TRACE", "Adding operation", id, "for bean", this.getName());
-            let name = this.getName();
-            name = name.substring(0, 1).toUpperCase() + name.substring(1);
-            this._webda.registerOperation(j.includes(".") ? j : `${name}.${j}`, {
-                ...operations[j],
-                service: this.getName(),
-                input: `${this.getName()}.${operations[j].method}.input`,
-                output: `${this.getName()}.${operations[j].method}.output`,
-                id
+        /**
+         * Get a service by name
+         * @param name - the name to use
+         * @returns the result map
+         * @deprecated Use useService, might reconsider
+         */
+        getService(name) {
+            return useService(name);
+        }
+        /**
+         * Add service name label
+         * @param type - the type to look up
+         * @param configuration - the configuration
+         * @returns the result
+         */
+        getMetric(type, configuration) {
+            configuration.labelNames ??= [];
+            configuration.labelNames = [...configuration.labelNames, "service"];
+            configuration.name = `${this.getName().toLowerCase()}_${configuration.name}`;
+            return useMetric(type, configuration);
+        }
+        /**
+         * Return the events that an external system can subscribe to
+         *
+         * @returns the list of results
+         */
+        getClientEvents() {
+            return [];
+        }
+        /**
+         * Authorize a public event subscription
+         * @param event - the event name
+         * @param context - the execution context
+         * @param _event - the event name
+         * @param _context - the execution context
+         * @returns true if the condition is met
+         */
+        authorizeClientEvent(_event, _context) {
+            return false;
+        }
+        /**
+         * Return the full path url based on parameters
+         *
+         * @param url relative url to service
+         * @param _methods in case we need filtering (like Store)
+         * @returns absolute url or undefined if need to skip the Route
+         */
+        getUrl(url, _methods) {
+            const { url: ServiceUrl } = this.parameters;
+            // If url is absolute
+            if (url.startsWith("/")) {
+                return url;
+            }
+            if (!ServiceUrl) {
+                return undefined;
+            }
+            if (url.startsWith(".")) {
+                if (ServiceUrl.endsWith("/") && url.startsWith("./")) {
+                    return ServiceUrl + url.substring(2);
+                }
+                return ServiceUrl + url.substring(1);
+            }
+            return url;
+        }
+        /**
+         * If undefined is returned it cancel the operation registration
+         * @param id - the identifier
+         * @returns the result
+         */
+        getOperationId(id) {
+            return id;
+        }
+        /**
+         * Add a route dynamicaly
+         *
+         * @param {String} url of the route can contains dynamic part like {uuid}
+         * @param {Array[]} methods - the HTTP methods
+         * @param {Function} executer Method to execute for this route
+         * @param openapi - the OpenAPI specification
+         * @param override - whether to override existing
+         */
+        addRoute(url, methods, executer, openapi = {}, override = false) {
+            const finalUrl = this.getUrl(url, methods);
+            if (!finalUrl) {
+                return;
+            }
+            const router = useDynamicService("Router");
+            if (!router) {
+                this.log("WARN", `No Router service available, skipping route ${finalUrl}`);
+                return;
+            }
+            router.addRouteToRouter(finalUrl, {
+                _method: executer.bind(this),
+                executor: this.getName(),
+                openapi: deepmerge(openapi, this.parameters.openapi || {}),
+                methods,
+                override
             });
         }
-    }
-    /**
-     * Convert an object to JSON using the Webda json filter
-     *
-     * @class Service
-     * @param {Object} object - The object to export
-     * @return {String} The export of the strip object ( removed all attribute with _ )
-     */
-    toPublicJSON(object) {
-        return this._webda.toPublicJSON(object);
-    }
-    /**
-     * Prevent service to be serialized
-     * @returns
-     */
-    toJSON() {
-        return this._name;
-    }
-    /**
-     * Will be called after all the Services are created
-     *
-     * @param config for the host so you can add your own route here
-     * @abstract
-     */
-    async init() {
-        // Can be overriden by subclasses if needed
-        return this;
-    }
-    /**
-     *
-     * @param config new parameters for the service
-     */
-    async reinit(config) {
-        this.parameters = this.loadParameters(config);
-        this.computeParameters();
-        return this.init();
-    }
-    /**
-     * Emit the event with data and wait for Promise to finish if listener returned a Promise
-     */
-    emitSync(event, data) {
-        return EventEmitterUtils.emitSync(this, event, data);
-    }
-    /**
-     * Override to allow capturing long listeners
-     * @override
-     */
-    emit(event, data) {
-        return EventEmitterUtils.emit(this, event, data);
-    }
-    /**
-     * Type the listener part
-     * @param event
-     * @param listener
-     * @param queue
-     * @returns
-     */
-    on(event, listener) {
-        super.on(event, listener);
-        return this;
-    }
-    /**
-     * Listen to an event as on(...) would do except that it will be asynchronous
-     * @param event
-     * @param callback
-     * @param queue Name of queue to use, can be undefined, queue name are used to define differents priorities
-     */
-    onAsync(event, listener, queue = undefined) {
-        this._webda.getService("AsyncEvents").bindAsyncListener(this, event, listener, queue);
-    }
-    /**
-     * Return a webda service
-     * @param service name to retrieve
-     */
-    getService(service) {
-        return this._webda.getService(service);
-    }
-    /**
-     * Get service name
-     */
-    getName() {
-        return this._name;
-    }
-    /**
-     * Clean the service data, can only be used in test mode
-     *
-     * @abstract
-     */
-    __clean() {
-        // @ts-ignore
-        if (typeof global.it !== "function") {
-            throw Error("Only for test purpose");
+        /**
+         * Return variables for replacement in openapi
+         * @returns the result
+         */
+        getOpenApiReplacements() {
+            return {};
         }
-        return this.___cleanData();
-    }
-    /**
-     * @private
-     */
-    ___cleanData() {
-        return Promise.resolve();
-    }
-    /**
-     *
-     * @param level to log
-     * @param args
-     */
-    log(level, ...args) {
-        // Add the service name to avoid confusion
-        this.logger.log(level, `[${this._name}]`, ...args);
-    }
-}
+        /**
+         * Init the operations from @Operation decorators on this service
+         */
+        initOperations() {
+            // Read @Operation decorator metadata from Symbol.metadata
+            const metadata = getMetadata(this.constructor);
+            const operations = metadata?.["webda.operations"] || [];
+            if (operations.length === 0)
+                return;
+            let serviceName = this.getName();
+            serviceName = serviceName.substring(0, 1).toUpperCase() + serviceName.substring(1);
+            for (const op of operations) {
+                // The decorator stores context.name first, then spreads options which may override id
+                // We need the actual method name (context.name) for execution
+                const actualMethod = op._methodName;
+                const opName = op.id;
+                const opId = opName.includes(".")
+                    ? opName
+                    : `${serviceName}.${opName.substring(0, 1).toUpperCase() + opName.substring(1)}`;
+                if (!this.getOperationId(opId))
+                    continue;
+                this.log("TRACE", "Adding operation", opId, "for service", this.getName());
+                registerOperation(opId, {
+                    ...op,
+                    service: this.getName(),
+                    method: actualMethod,
+                    input: op.input || `${this.getName()}.${actualMethod}.input`,
+                    output: op.output || `${this.getName()}.${actualMethod}.output`,
+                    id: opId
+                });
+            }
+        }
+        /**
+         * Prevent service to be serialized
+         * @returns the result
+         */
+        toJSON() {
+            return this.toString();
+        }
+        /**
+         * Will be called after all the Services are created
+         *
+         * @param config for the host so you can add your own route here
+         * @abstract
+         */
+        async init() {
+            // Can be overriden by subclasses if needed
+            return this;
+        }
+        /**
+         * Emit the event with data and wait for Promise to finish if listener returned a Promise
+         * @param event - the event name
+         * @param data - the data to process
+         */
+        async emit(event, data) {
+            await EventEmitterUtils.emit(this, event, data, (level, ...args) => this.log(level, ...args));
+        }
+        /**
+         * Get service name
+         * @returns the result string
+         */
+        getName() {
+            return this.name;
+        }
+        /**
+         * Clean the service data, can only be used in test mode
+         *
+         * @abstract
+         */
+        __clean() {
+            // @ts-ignore
+            if (typeof global.it !== "function") {
+                throw Error("Only for test purpose");
+            }
+            return this.___cleanData();
+        }
+        /**
+         * @private
+         * @returns the result
+         */
+        ___cleanData() {
+            return Promise.resolve();
+        }
+        /**
+         *
+         * @param level to log
+         * @param args - additional arguments
+         */
+        log(level, ...args) {
+            // Add the service name to avoid confusion
+            this.logger.log(level, `[${this.name}]`, ...args);
+        }
+    };
+})();
 export { Service };
 //# sourceMappingURL=service.js.map