@webda/core 4.0.0-beta.1 → 4.0.0-beta.3

package/README.md

@@ -0,0 +1,252 @@
+# @webda/core module
+
+This module is part of Webda Application Framework that allows you to quickly develop applications with all modern prerequisites: Security, Extensibility, GraphQL, REST, CloudNative [https://webda.io](https://webda.io)
+
+<img src="https://webda.io/images/webda.svg" width="128" />
+
+![CI](https://github.com/loopingz/webda.io/workflows/CI/badge.svg)
+
+[![Join the chat at https://gitter.im/loopingz/webda](https://badges.gitter.im/loopingz/webda.svg)](https://gitter.im/loopingz/webda?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![codecov](https://codecov.io/gh/loopingz/webda.io/branch/main/graph/badge.svg?token=8N9DNM3K3O)](https://codecov.io/gh/loopingz/webda.io)
+[![SonarCloud.io](https://sonarcloud.io/api/project_badges/measure?project=loopingz_webda.io&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=loopingz_webda.io)
+![CodeQL](https://github.com/loopingz/webda.io/workflows/CodeQL/badge.svg)
+
+<!-- README_HEADER -->
+
+The runtime engine of the [webda.io](https://webda.io) framework. It manages the full lifecycle of a Webda application: loading configuration, instantiating services, routing HTTP requests, managing sessions, and providing cross-cutting concerns like logging, metrics, and caching.
+
+## Architecture
+
+![Architecture](https://excalidraw.com/#json=ZknRJYOBPPNyJpoI-Ua_a,iPuhkC-OplOnesHiMJaY9A)
+
+The framework is organized into six layers:
+
+### Application Layer
+
+Responsible for discovering modules, loading configuration, and bootstrapping the runtime.
+
+- **Application** -- Scans the project, parses `webda.config.json`, discovers installed Moddas (service types) and Models, and caches everything for fast startup.
+- **UnpackedApplication** -- Development-oriented variant that auto-discovers `webda.module.json` files and creates default services (Router, Registry, CryptoService, SessionManager) when missing.
+- **Configuration** -- Defines the `UnpackedConfiguration` schema (version 4) with service definitions, global parameters, and application settings.
+- **Runner** -- Orchestrates startup: creates Core from Application, initializes all services, and registers SIGINT for graceful shutdown.
+- **Application Hooks** -- `useApplication()`, `useModel()`, `useModelId()`, `useParameters()` for accessing application state from anywhere in the call stack.
+
+### Core Runtime
+
+The central orchestrator that manages the service lifecycle and dependency graph.
+
+- **Core** -- Creates and initializes services with dependency tracking, maps Models to Stores and BinaryServices, manages the operation registry. Lifecycle: `initial` -> `loading` -> `initializing` -> `ready` -> `stopping` -> `stopped`.
+- **InstanceStorage** -- `AsyncLocalStorage`-based context that holds the current Core, Application, Router, and request context. Enables the hooks pattern without passing references through every function call.
+- **Core Hooks** -- `useCore()`, `useService()`, `useDynamicService()`, `useModelStore()`, `useModelRepository()`, `getMachineId()`.
+- **Events** -- Async event system with lifecycle events: `Webda.Init`, `Webda.Request`, `Webda.Result`, `Webda.404`, `Webda.OperationSuccess`, `Webda.Configuration.Applied`, etc.
+- **Errors** -- Typed HTTP errors: `Unauthorized` (401), `Forbidden` (403), `NotFound` (404), `BadRequest` (400), `Conflict` (409), `TooManyRequests` (429), `Redirect` (302), and more.
+
+### Services Layer
+
+All application logic lives in services. Every service extends `Service` which provides logging, metrics, dependency injection, and event emission.
+
+- **Service** -- Base class for all application services. Provides `@Inject` decorator for DI, `@Route` for HTTP endpoints, logger per instance, metrics support, and lifecycle hooks (`init()`, `resolve()`, `stop()`).
+- **ServiceParameters** -- Base configuration class with change watching support. Services declare their config shape by extending this class.
+- **CryptoService** -- Encryption, JWT signing/verification, key management with rotation support. Pluggable encrypters.
+- **BinaryService** -- Abstract file/binary storage with metadata, integrity challenges, and model-attribute mapping.
+- **ConfigurationService** -- Dynamic configuration with hot-reload from external sources (files, Kubernetes ConfigMaps, other services).
+
+### Data Layer
+
+Persistent storage abstraction with query support.
+
+- **Store** -- Abstract storage with CRUD, query (via WebdaQL), conditional updates, and event emission (`Created`, `Updated`, `Deleted`). Automatically maps to Models via scoring.
+- **MemoryStore** -- In-memory implementation with optional file persistence. Used as the default Registry.
+- **Registry** -- Key-value store for framework internals (crypto keys, service state). Backed by any Store implementation.
+
+### HTTP / Request Layer
+
+Handles incoming HTTP requests and manages user sessions.
+
+- **Router** -- Routes HTTP requests to service methods, manages OpenAPI spec generation, request/CORS filters, and model REST endpoints.
+- **OperationContext** -- Typed request/response context with generic `<Input, Parameters, Output>`. Provides session access, parameter parsing, header management, and streaming.
+- **SessionManager** -- Abstract session load/save. Default implementation uses JWT tokens in secure cookies with optional backend storage.
+
+### Cross-Cutting Concerns
+
+Shared infrastructure available to all services.
+
+- **Logger** -- Structured logging with per-service context. Backed by `@webda/workout`.
+- **Metrics** -- Prometheus integration via `prom-client`. `useMetric()` creates Counters, Gauges, and Histograms with automatic service labels.
+- **Cache** -- Decorator-based caching at four scopes: `@ProcessCache()` (global), `@InstanceCache()` (per Core), `@SessionCache()` (per user), `@ContextCache()` (per request).
+- **Queue** -- Message queue consumer pattern with configurable parallelism, retry backoff, and metrics. Extend for SQS, AMQP, etc.
+- **Models** -- Model registry with built-in types: `CoreModel`, `User`, `Ident`, `ACLModel`, `OwnerModel`, `RegistryEntry`.
+- **Execution Context** -- `AsyncLocalStorage`-based context for `useContext()`, `useCurrentUser()`, `runAsSystem()`, `runWithContext()`.
+
+## Request Flow
+
+```
+HTTP Request
+    |
+    v
+HttpContext (parse headers, cookies, body)
+    |
+    v
+OperationContext / WebContext (typed I/O)
+    |
+    v
+SessionManager.load() (JWT from cookie)
+    |
+    v
+Router.execute() (match route, run filters)
+    |
+    v
+Service method (business logic)
+    |
+    v
+SessionManager.save() (persist if dirty)
+    |
+    v
+HTTP Response
+```
+
+## Hooks API
+
+The hooks pattern provides access to framework singletons from any point in the call stack, powered by `AsyncLocalStorage`:
+
+| Hook | Returns | Use case |
+|------|---------|----------|
+| `useCore()` | `Core` | Access the runtime engine |
+| `useApplication()` | `Application` | Access project metadata and configuration |
+| `useService(name)` | Typed service | Get a named service (`"Registry"`, `"CryptoService"`, etc.) |
+| `useDynamicService(name)` | `Service` | Get a service by arbitrary name |
+| `useModel(name)` | `ModelDefinition` | Get a model class with metadata |
+| `useModelId(object)` | `string` | Get the model identifier for an instance |
+| `useModelStore(name)` | `IStore` | Get the store assigned to a model |
+| `useModelRepository(name)` | `Repository` | Get the repository for a model |
+| `useContext()` | `Context` | Get the current request context |
+| `useCurrentUser()` | `User` | Get the authenticated user |
+| `useCurrentUserId()` | `string` | Get the user ID or `"system"` |
+| `useLogger(class)` | `Logger` | Get a logger with class context |
+| `useMetric(type, config)` | Counter/Gauge/Histogram | Create a prometheus metric |
+| `useParameters()` | `Configuration["parameters"]` | Get global configuration parameters |
+| `getMachineId()` | `string` | Get a stable machine identifier |
+
+## Dependency Injection
+
+Services declare dependencies with the `@Inject` decorator:
+
+```typescript
+import { Service, Inject } from "@webda/core";
+
+class MyService extends Service {
+  // Inject by service name
+  @Inject("CryptoService")
+  crypto: CryptoService;
+
+  // Inject from a parameter value
+  @Inject("params:storeName", "Registry")
+  store: Store;
+
+  // Optional injection
+  @Inject("NotificationService", undefined, true)
+  notifications?: NotificationService;
+}
+```
+
+## Configuration
+
+Applications are configured via `webda.config.json` (version 4):
+
+```json
+{
+  "version": 4,
+  "parameters": {
+    "routePrefix": "/api",
+    "metrics": { "prefix": "myapp_" }
+  },
+  "services": {
+    "MyStore": {
+      "type": "MemoryStore",
+      "model": "MyApp/MyModel"
+    },
+    "MyService": {
+      "type": "MyApp/MyService",
+      "storeName": "MyStore"
+    }
+  }
+}
+```
+
+## Events
+
+Services emit typed async events. Subscribe with `on()`:
+
+```typescript
+// Core lifecycle events
+useCoreEvents("Webda.Init", () => { /* framework ready */ });
+useCoreEvents("Webda.Request", ({ context }) => { /* new request */ });
+
+// Store events
+myStore.on("Store.Created", ({ object }) => { /* model created */ });
+myStore.on("Store.Updated", ({ object }) => { /* model updated */ });
+myStore.on("Store.Deleted", ({ object }) => { /* model deleted */ });
+```
+
+## Error Handling
+
+Throw typed HTTP errors from services:
+
+```typescript
+import * as WebdaError from "@webda/core";
+
+throw new WebdaError.NotFound("User not found");
+throw new WebdaError.Forbidden("Insufficient permissions");
+throw new WebdaError.BadRequest("Invalid input", "VALIDATION_ERROR");
+throw new WebdaError.Redirect("https://example.com/new-location");
+```
+
+## Ecosystem
+
+`@webda/core` is the foundation. The full framework includes:
+
+| Package | Purpose |
+|---------|---------|
+| `@webda/models` | Model base classes, relations, repositories |
+| `@webda/compiler` | TypeScript compiler with schema generation |
+| `@webda/tsc-esm` | ESM-aware TypeScript compiler, decorators |
+| `@webda/utils` | Utilities (debounce, dirty tracking, state machines) |
+| `@webda/workout` | Logging infrastructure |
+| `@webda/test` | Multi-framework test decorators (vitest, jest, mocha, bun) |
+| `@webda/ql` | WebdaQL query language |
+| `@webda/cloudevents` | CloudEvents filtering |
+| `@webda/cache` | Caching decorators |
+| `@webda/serialize` | Serialization framework |
+| `@webda/content-mapper` | JSON Schema generator |
+
+## Deep-dive sub-pages
+
+- [Architecture](../../docs/pages/Modules/core/Architecture.md) — 6-layer overview with diagram
+- [Service Lifecycle](../../docs/pages/Modules/core/Lifecycle.md) — resolve → init → run → stop
+- [Services](../../docs/pages/Modules/core/Services.md) — `Service`, `@Bean`, `@Inject`, `ServiceParameters`
+- [Stores](../../docs/pages/Modules/core/Stores.md) — Store contract, query interface, events
+- [Context](../../docs/pages/Modules/core/Context.md) — `WebContext`, sessions, request lifecycle
+- [Routing](../../docs/pages/Modules/core/Routing.md) — `@Route`, `@Operation`, REST auto-generation
+- [Events](../../docs/pages/Modules/core/Events.md) — `Core.on`, store events, `@On` decorator
+- [Errors](../../docs/pages/Modules/core/Errors.md) — WebdaError hierarchy and HTTP status mapping
+- [Logging](../../docs/pages/Modules/core/Logging.md) — `useLog` + `@webda/workout` integration
+- [CLI](../../docs/pages/Modules/core/CLI.md) — `webda` runtime commands
+
+<!-- README_FOOTER -->
+## Sponsors
+
+<!--
+Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [Become a sponsor](mailto:sponsor@webda.io)
+-->
+
+Arize AI is a machine learning observability and model monitoring platform. It helps you visualize, monitor, and explain your machine learning models. [Learn more](https://arize.com)
+
+[<img src="https://arize.com/hubfs/arize/brand/arize-logomark-1.png" width="200">](https://arize.com)
+
+Loopingz is a software development company that provides consulting and development services. [Learn more](https://loopingz.com)
+
+[<img src="https://loopingz.com/images/logo.png" width="200">](https://loopingz.com)
+
+Tellae is an innovative consulting firm specialized in cities transportation issues. We provide our clients, both public and private, with solutions to support your strategic and operational decisions. [Learn more](https://tellae.fr)
+
+[<img src="https://tellae.fr/" width="200">](https://tellae.fr)

package/lib/application/application.d.ts

@@ -0,0 +1,437 @@
+import { WorkerLogLevel, WorkerOutput } from "@webda/workout";
+import type { CachedModule, Configuration, GitInformation, PackageDescriptor, ProjectInformation, Section, UnpackedConfiguration, WebdaModule, WebdaPackageDescriptor } from "./iconfiguration.js";
+import type { Modda } from "../services/iservice.js";
+import type { ModelDefinition } from "../models/types.js";
+import { ServiceParameters } from "../services/serviceparameters.js";
+import { type Model, type ModelClass, type Storable } from "@webda/models";
+import { JSONSchema7 } from "json-schema";
+import type { Service } from "../services/service.js";
+import { ModelMetadata } from "@webda/compiler";
+import type { BehaviorMetadata } from "@webda/compiler";
+/**
+ * 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 declare function installConfigurationFactories(target: any, configurationClass?: new () => ServiceParameters, schema?: JSONSchema7): void;
+export type ApplicationState = "initial" | "loading" | "ready";
+/**
+ * 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
+ */
+export declare class Application {
+    /**
+     * Get Application root path
+     */
+    readonly applicationPath: string;
+    /**
+     * Base configuration loaded from webda.config.json
+     */
+    protected baseConfiguration: Configuration;
+    /**
+     * Current deployment
+     */
+    protected currentDeployment: string;
+    /**
+     * Contains definitions of current application
+     */
+    protected appModule: WebdaModule;
+    /**
+     * Deployers type registry
+     */
+    protected deployers: {
+        [key: string]: any;
+    };
+    /**
+     * Moddas registry
+     */
+    protected moddas: {
+        [key: string]: Modda;
+    };
+    /**
+     * Models type registry
+     */
+    protected models: {
+        [key: string]: ModelDefinition;
+    };
+    /**
+     * Beans registry
+     */
+    protected beans: {
+        [key: string]: Modda;
+    };
+    /**
+     * 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.
+     */
+    protected behaviors: {
+        [key: string]: {
+            metadata: BehaviorMetadata;
+        };
+    };
+    /**
+     * Class Logger
+     */
+    protected logger: WorkerOutput;
+    /**
+     * Detect if running as workspace
+     */
+    protected workspacesPath: string;
+    /**
+     * Configuration file
+     */
+    readonly configurationFile: string;
+    /**
+     * Current deployment file
+     */
+    deploymentFile: string;
+    /**
+     * Create a new Application
+     * @param file - file path or unpacked configuration to load from
+     * @param logger - the logger instance
+     */
+    constructor(file: string | UnpackedConfiguration, logger?: WorkerOutput);
+    /**
+     * Run the application
+     * @returns the result
+     */
+    run(): Promise<void>;
+    /**
+     * Pluggable runner — set by runner.ts to avoid circular dependency with Core.
+     * @internal
+     */
+    static _runner: (app: Application) => Promise<void>;
+    /**
+     * Import all required modules
+     * @returns the result
+     */
+    load(): Promise<this>;
+    /**
+     * Allow subclass to implement migration
+     *
+     * @param file - the file path
+     * @returns the result
+     */
+    loadConfiguration(file: string): Promise<void>;
+    /**
+     * 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: string): JSONSchema7;
+    /**
+     * Get schemas
+     * @returns the result
+     */
+    getSchemas(): {
+        [key: string]: JSONSchema7;
+    };
+    /**
+     * 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(): boolean;
+    /**
+     * Retrieve specific webda conf from package.json
+     *
+     * In case of workspaces the object is combined
+     * @returns the result
+     */
+    getPackageWebda(): WebdaPackageDescriptor;
+    /**
+     * Retrieve content of package.json
+     * @returns the result
+     */
+    getPackageDescription(): PackageDescriptor;
+    /**
+     * Log information
+     *
+     * @param level to log for
+     * @param args anything to display same as console.log
+     */
+    log(level: WorkerLogLevel, ...args: any[]): void;
+    /**
+     * Get current logger
+     * @returns the result
+     */
+    getWorkerOutput(): WorkerOutput;
+    /**
+     * Return the current app path
+     *
+     * @param subpath to append to
+     * @returns the result string
+     */
+    getPath(subpath?: string): string;
+    /**
+     * Add a new service
+     *
+     * @param name - the name to use
+     * @param service - the service instance
+     * @returns this for chaining
+     */
+    addModda(name: string, service: Modda): 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: Section, name: string): boolean;
+    /**
+     * 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: string): boolean;
+    /**
+     *
+     * @param section - the section name
+     * @param name - the name to use
+     * @returns the result
+     */
+    getWebdaObject(section: Section, name: string): any;
+    /**
+     * Get a service based on name
+     *
+     * @param name - the name to use
+     * @returns the result
+     */
+    getModda(name: string): Modda;
+    /**
+     * Return all services of the application
+     * @returns the result
+     */
+    getModdas(): {
+        [key: string]: Modda;
+    };
+    /**
+     * Retrieve the model implementation
+     *
+     * @param name model to retrieve
+     * @returns the result
+     */
+    getModel<T extends Model = Model>(name: string): ModelDefinition<T>;
+    /**
+     * Get all models definitions
+     * @returns the result
+     */
+    getModels(): {
+        [key: string]: ModelDefinition<any>;
+    };
+    /**
+     * 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: string): BehaviorMetadata | undefined;
+    /**
+     * Return all loaded Behaviors keyed by identifier.
+     *
+     * Each entry exposes the original metadata blob emitted by the compiler.
+     * @returns the result
+     */
+    getBehaviors(): {
+        [key: string]: {
+            metadata: BehaviorMetadata;
+        };
+    };
+    /**
+     * Return the model name for a object
+     * @param object - the target object
+     * @returns the result
+     */
+    getModelFromInstance(object: Storable): string | undefined;
+    /**
+     * Return the model name for a object
+     * @param object - the target object
+     * @param model - the model to use
+     * @returns the result
+     */
+    getModelFromConstructor(model: ModelClass): string | undefined;
+    /**
+     * 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: ModelClass | Storable): string | undefined;
+    /**
+     * Return all deployers
+     * @returns the result
+     */
+    getDeployers(): {
+        [key: string]: Modda;
+    };
+    /**
+     * 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: string, model: any, metadata?: ModelMetadata): this;
+    /**
+     *
+     * @param this - the constructor
+     * @param json - the JSON data
+     * @returns the result
+     */
+    static deserialize<T extends Application>(this: new (...args: any[]) => T, json: any): T;
+    /**
+     * Serialize the application state to a plain object
+     * @returns the result
+     */
+    toJSON(): {
+        baseConfiguration: Configuration;
+        currentDeployment: string;
+        appModule: WebdaModule;
+    };
+    /**
+     * Return webda current version
+     *
+     * @returns package version
+     * @since 0.4.0
+     */
+    getWebdaVersion(): string;
+    /**
+     * 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?: string, _version?: string): GitInformation;
+    /**
+     * Retrieve the project information
+     * @returns the result
+     */
+    getProjectInfo(): ProjectInformation | undefined;
+    /**
+     * Get current deployment name
+     * @returns the result string
+     */
+    getCurrentDeployment(): string;
+    /**
+     * Return all application modules merged as one
+     *
+     * Used when deployed
+     * @returns the result
+     */
+    getModules(): CachedModule;
+    /**
+     * Get application configuration
+     * @param _deployment - the deployment name
+     * @returns the result
+     */
+    getConfiguration(_deployment?: string): Configuration;
+    /**
+     * Return current Configuration of the Application
+     *
+     * Same as calling
+     *
+     * ```js
+     * getConfiguration(this.currentDeployment);
+     * ```
+     * @returns the result
+     */
+    getCurrentConfiguration(): Configuration;
+    /**
+     * 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
+     */
+    protected importFile(info: string, withExport?: boolean): Promise<any>;
+    /**
+     * Load local module
+     */
+    loadLocalModule(): Promise<void>;
+    /**
+     * Get implementations of a class
+     * @param object - the target object
+     * @returns the result
+     */
+    getImplementations<T extends Service>(object: T): {
+        [key: string]: Modda<T>;
+    };
+    /**
+     * Load the module,
+     *
+     * @protected
+     * @ignore Useless for documentation
+     */
+    loadModule(module: WebdaModule, parent?: string): Promise<void>;
+    /**
+     * Set object Metadata
+     * Need to be done after all models are loaded to resolve Ancestors and Subclasses
+     * @param info - the information object
+     */
+    protected setModelMetadata(info: {
+        [key: string]: ModelMetadata;
+    }): void;
+    /**
+     * 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?: string): string;
+    /**
+     * Return current namespace
+     * @returns the result string
+     */
+    getNamespace(): string;
+}
+//# sourceMappingURL=application.d.ts.map